diff --git a/.gitignore b/.gitignore
index 670f1e87..dc68a226 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,3 +7,4 @@
 /Debug/
 /Release/
 /de4dot.snk
+/cecil/
diff --git a/.gitmodules b/.gitmodules
index af49613a..2be6a574 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,3 +1,3 @@
-[submodule "cecil"]
-	path = cecil
-	url = git@github.com:0xd4d/cecil.git
+[submodule "dot10"]
+	path = dot10
+	url = e:/work/dot10.git
diff --git a/AssemblyData/AssemblyData.csproj b/AssemblyData/AssemblyData.csproj
index 0a917298..61d56a35 100644
--- a/AssemblyData/AssemblyData.csproj
+++ b/AssemblyData/AssemblyData.csproj
@@ -70,14 +70,14 @@
       <Project>{045B96F2-AF80-4C4C-8D27-E38635AC705E}</Project>
       <Name>blocks</Name>
     </ProjectReference>
-    <ProjectReference Include="..\cecil\Mono.Cecil.csproj">
-      <Project>{D68133BD-1E63-496E-9EDE-4FBDBF77B486}</Project>
-      <Name>Mono.Cecil</Name>
-    </ProjectReference>
     <ProjectReference Include="..\de4dot.mdecrypt\de4dot.mdecrypt.csproj">
       <Project>{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}</Project>
       <Name>de4dot.mdecrypt</Name>
     </ProjectReference>
+    <ProjectReference Include="..\dot10\src\dot10.csproj">
+      <Project>{FDFC1237-143F-4919-8318-4926901F4639}</Project>
+      <Name>dot10</Name>
+    </ProjectReference>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/AssemblyData/AssemblyService.cs b/AssemblyData/AssemblyService.cs
index 2a784303..421a0331 100644
--- a/AssemblyData/AssemblyService.cs
+++ b/AssemblyData/AssemblyService.cs
@@ -21,7 +21,8 @@ using System;
 using System.Collections.Generic;
 using System.Reflection;
 using System.Threading;
-using Mono.MyStuff;
+using dot10.DotNet;
+using de4dot.blocks;
 using de4dot.mdecrypt;
 
 namespace AssemblyData {
diff --git a/AssemblyData/IAssemblyService.cs b/AssemblyData/IAssemblyService.cs
index 809db321..41d01fc6 100644
--- a/AssemblyData/IAssemblyService.cs
+++ b/AssemblyData/IAssemblyService.cs
@@ -17,7 +17,8 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.MyStuff;
+using dot10.DotNet;
+using de4dot.blocks;
 using de4dot.mdecrypt;
 
 namespace AssemblyData {
diff --git a/AssemblyData/Utils.cs b/AssemblyData/Utils.cs
index 3dc2bc20..4f8fe446 100644
--- a/AssemblyData/Utils.cs
+++ b/AssemblyData/Utils.cs
@@ -24,7 +24,6 @@ using System.Reflection.Emit;
 using System.Text;
 
 namespace AssemblyData {
-	// Yes, I did type this by hand.
 	internal delegate void Action();
 	internal delegate void Action<T1>(T1 arg1);
 	internal delegate void Action<T1, T2>(T1 arg1, T2 arg2);
@@ -45,7 +44,6 @@ namespace AssemblyData {
 	internal delegate void Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16, T17 arg17);
 	internal delegate void Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16, T17 arg17, T18 arg18);
 	internal delegate void Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16, T17 arg17, T18 arg18, T19 arg19);
-	// No that was a lie.
 	internal delegate TResult Func<TResult>();
 	internal delegate TResult Func<T1, TResult>(T1 arg1);
 	internal delegate TResult Func<T1, T2, TResult>(T1 arg1, T2 arg2);
diff --git a/AssemblyData/methodsrewriter/AssemblyResolver.cs b/AssemblyData/methodsrewriter/AssemblyResolver.cs
index cd6395da..5295995b 100644
--- a/AssemblyData/methodsrewriter/AssemblyResolver.cs
+++ b/AssemblyData/methodsrewriter/AssemblyResolver.cs
@@ -20,7 +20,7 @@
 using System;
 using System.Collections.Generic;
 using System.Reflection;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace AssemblyData.methodsrewriter {
@@ -48,38 +48,41 @@ namespace AssemblyData.methodsrewriter {
 			}
 		}
 
-		TypeResolver getTypeResolver(TypeReference typeReference) {
-			var key = typeReference.Namespace + "." + typeReference.Name;
+		TypeResolver getTypeResolver(ITypeDefOrRef typeRef) {
+			if (typeRef == null)
+				return null;
+			var scopeType = typeRef.ScopeType;
+			var key = scopeType.Namespace + "." + scopeType.TypeName;
 			List<TypeResolver> list;
 			if (!types.TryGetValue(key, out list))
 				return null;
 
-			if (typeReference is TypeDefinition) {
+			if (scopeType is TypeDef) {
 				foreach (var resolver in list) {
-					if (resolver.type.MetadataToken == typeReference.MetadataToken.ToInt32())
+					if (resolver.type.MetadataToken == scopeType.MDToken.Raw)
 						return resolver;
 				}
 			}
 
 			foreach (var resolver in list) {
-				if (ResolverUtils.compareTypes(resolver.type, typeReference))
+				if (ResolverUtils.compareTypes(resolver.type, scopeType))
 					return resolver;
 			}
 
 			return null;
 		}
 
-		public FieldInfo resolve(FieldReference fieldReference) {
-			var resolver = getTypeResolver(fieldReference.DeclaringType);
+		public FieldInfo resolve(IField fieldRef) {
+			var resolver = getTypeResolver(fieldRef.DeclaringType);
 			if (resolver != null)
-				return resolver.resolve(fieldReference);
-			return resolveGlobalField(fieldReference);
+				return resolver.resolve(fieldRef);
+			return resolveGlobalField(fieldRef);
 		}
 
-		FieldInfo resolveGlobalField(FieldReference fieldReference) {
+		FieldInfo resolveGlobalField(IField fieldRef) {
 			initGlobalFields();
 			foreach (var globalField in globalFields) {
-				if (ResolverUtils.compareFields(globalField, fieldReference))
+				if (ResolverUtils.compareFields(globalField, fieldRef))
 					return globalField;
 			}
 			return null;
@@ -97,17 +100,17 @@ namespace AssemblyData.methodsrewriter {
 			}
 		}
 
-		public MethodBase resolve(MethodReference methodReference) {
-			var resolver = getTypeResolver(methodReference.DeclaringType);
+		public MethodBase resolve(IMethod methodRef) {
+			var resolver = getTypeResolver(methodRef.DeclaringType);
 			if (resolver != null)
-				return resolver.resolve(methodReference);
-			return resolveGlobalMethod(methodReference);
+				return resolver.resolve(methodRef);
+			return resolveGlobalMethod(methodRef);
 		}
 
-		MethodBase resolveGlobalMethod(MethodReference methodReference) {
+		MethodBase resolveGlobalMethod(IMethod methodRef) {
 			initGlobalMethods();
 			foreach (var globalMethod in globalMethods) {
-				if (ResolverUtils.compareMethods(globalMethod, methodReference))
+				if (ResolverUtils.compareMethods(globalMethod, methodRef))
 					return globalMethod;
 			}
 			return null;
@@ -125,12 +128,13 @@ namespace AssemblyData.methodsrewriter {
 			}
 		}
 
-		public Type resolve(TypeReference typeReference) {
-			var resolver = getTypeResolver(typeReference);
+		public Type resolve(ITypeDefOrRef typeRef) {
+			var resolver = getTypeResolver(typeRef);
 			if (resolver != null)
 				return resolver.type;
 
-			if (typeReference.IsGenericParameter)
+			var ts = typeRef as TypeSpec;
+			if (ts != null && ts.TypeSig is GenericSig)
 				return typeof(MGenericParameter);
 
 			return null;
diff --git a/AssemblyData/methodsrewriter/CodeGenerator.cs b/AssemblyData/methodsrewriter/CodeGenerator.cs
index fb15a971..2765e70a 100644
--- a/AssemblyData/methodsrewriter/CodeGenerator.cs
+++ b/AssemblyData/methodsrewriter/CodeGenerator.cs
@@ -22,13 +22,13 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.Reflection;
 using System.Reflection.Emit;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet.Emit;
+using dot10.DotNet;
 using de4dot.blocks;
 
-using OpCode = Mono.Cecil.Cil.OpCode;
-using OpCodes = Mono.Cecil.Cil.OpCodes;
-using OperandType = Mono.Cecil.Cil.OperandType;
+using OpCode = dot10.DotNet.Emit.OpCode;
+using OpCodes = dot10.DotNet.Emit.OpCodes;
+using OperandType = dot10.DotNet.Emit.OperandType;
 using ROpCode = System.Reflection.Emit.OpCode;
 using ROpCodes = System.Reflection.Emit.OpCodes;
 
@@ -94,7 +94,7 @@ namespace AssemblyData.methodsrewriter {
 
 			var dm = new DynamicMethod(methodName, methodReturnType, methodParameters, methodInfo.methodBase.Module, true);
 			var lastInstr = allInstructions[allInstructions.Count - 1];
-			ilg = dm.GetILGenerator(lastInstr.Offset + lastInstr.GetSize());
+			ilg = dm.GetILGenerator((int)lastInstr.Offset + lastInstr.GetSize());
 
 			initInstrToIndex();
 			initLocals();
@@ -178,8 +178,8 @@ namespace AssemblyData.methodsrewriter {
 
 		void initLocals() {
 			locals = new List<LocalBuilder>();
-			foreach (var local in methodInfo.methodDefinition.Body.Variables)
-				locals.Add(ilg.DeclareLocal(Resolver.getRtType(local.VariableType), local.IsPinned));
+			foreach (var local in methodInfo.methodDef.Body.LocalList)
+				locals.Add(ilg.DeclareLocal(Resolver.getRtType(local.Type), local.Type.RemoveModifiers().IsPinned));
 			tempObjLocal = ilg.DeclareLocal(typeof(object));
 			tempObjArrayLocal = ilg.DeclareLocal(typeof(object[]));
 		}
@@ -256,14 +256,6 @@ namespace AssemblyData.methodsrewriter {
 			return labels;
 		}
 
-		int getArgIndex(ParameterDefinition arg) {
-			return arg.Sequence;
-		}
-
-		int getLocalIndex(VariableDefinition local) {
-			return local.Index;
-		}
-
 		void writeInstr(Instruction instr) {
 			var opcode = convertOpCode(instr.OpCode);
 			switch (instr.OpCode.OperandType) {
@@ -311,7 +303,7 @@ namespace AssemblyData.methodsrewriter {
 			case OperandType.InlineType:
 			case OperandType.InlineMethod:
 			case OperandType.InlineField:
-				var obj = Resolver.getRtObject((MemberReference)instr.Operand);
+				var obj = Resolver.getRtObject((ITokenOperand)instr.Operand);
 				if (obj is ConstructorInfo)
 					ilg.Emit(opcode, (ConstructorInfo)obj);
 				else if (obj is MethodInfo)
@@ -324,20 +316,12 @@ namespace AssemblyData.methodsrewriter {
 					throw new ApplicationException(string.Format("Unknown type: {0}", (obj == null ? obj : obj.GetType())));
 				break;
 
-			case OperandType.InlineArg:
-				ilg.Emit(opcode, checked((short)getArgIndex((ParameterDefinition)instr.Operand)));
-				break;
-
-			case OperandType.ShortInlineArg:
-				ilg.Emit(opcode, checked((byte)getArgIndex((ParameterDefinition)instr.Operand)));
-				break;
-
 			case OperandType.InlineVar:
-				ilg.Emit(opcode, checked((short)getLocalIndex((VariableDefinition)instr.Operand)));
+				ilg.Emit(opcode, checked((short)((IVariable)instr.Operand).Index));
 				break;
 
 			case OperandType.ShortInlineVar:
-				ilg.Emit(opcode, checked((byte)getLocalIndex((VariableDefinition)instr.Operand)));
+				ilg.Emit(opcode, checked((byte)((IVariable)instr.Operand).Index));
 				break;
 
 			case OperandType.InlineSig:	//TODO:
diff --git a/AssemblyData/methodsrewriter/IMethodsRewriter.cs b/AssemblyData/methodsrewriter/IMethodsRewriter.cs
index dc818009..44761145 100644
--- a/AssemblyData/methodsrewriter/IMethodsRewriter.cs
+++ b/AssemblyData/methodsrewriter/IMethodsRewriter.cs
@@ -19,7 +19,6 @@
 
 using System;
 using System.Reflection;
-using Mono.Cecil;
 
 namespace AssemblyData.methodsrewriter {
 	interface IMethodsRewriter {
diff --git a/AssemblyData/methodsrewriter/MField.cs b/AssemblyData/methodsrewriter/MField.cs
index 4cd74c8e..75cf53ba 100644
--- a/AssemblyData/methodsrewriter/MField.cs
+++ b/AssemblyData/methodsrewriter/MField.cs
@@ -18,20 +18,20 @@
 */
 
 using System.Reflection;
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace AssemblyData.methodsrewriter {
 	class MField {
 		public FieldInfo fieldInfo;
-		public FieldDefinition fieldDefinition;
+		public FieldDef fieldDef;
 
-		public MField(FieldInfo fieldInfo, FieldDefinition fieldDefinition) {
+		public MField(FieldInfo fieldInfo, FieldDef fieldDef) {
 			this.fieldInfo = fieldInfo;
-			this.fieldDefinition = fieldDefinition;
+			this.fieldDef = fieldDef;
 		}
 
 		public override string ToString() {
-			return fieldDefinition.ToString();
+			return fieldDef.ToString();
 		}
 	}
 }
diff --git a/AssemblyData/methodsrewriter/MMethod.cs b/AssemblyData/methodsrewriter/MMethod.cs
index 4bb3677b..dfd3be0e 100644
--- a/AssemblyData/methodsrewriter/MMethod.cs
+++ b/AssemblyData/methodsrewriter/MMethod.cs
@@ -18,23 +18,23 @@
 */
 
 using System.Reflection;
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace AssemblyData.methodsrewriter {
 	class MMethod {
 		public MethodBase methodBase;
-		public MethodDefinition methodDefinition;
-		public MMethod(MethodBase methodBase, MethodDefinition methodDefinition) {
+		public MethodDef methodDef;
+		public MMethod(MethodBase methodBase, MethodDef methodDefinition) {
 			this.methodBase = methodBase;
-			this.methodDefinition = methodDefinition;
+			this.methodDef = methodDefinition;
 		}
 
 		public bool hasInstructions() {
-			return methodDefinition.Body != null && methodDefinition.Body.Instructions.Count != 0;
+			return methodDef.Body != null && methodDef.Body.Instructions.Count != 0;
 		}
 
 		public override string ToString() {
-			return methodDefinition.ToString();
+			return methodDef.ToString();
 		}
 	}
 }
diff --git a/AssemblyData/methodsrewriter/MModule.cs b/AssemblyData/methodsrewriter/MModule.cs
index 8041bba3..e003bfcf 100644
--- a/AssemblyData/methodsrewriter/MModule.cs
+++ b/AssemblyData/methodsrewriter/MModule.cs
@@ -20,74 +20,74 @@
 using System;
 using System.Collections.Generic;
 using System.Reflection;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace AssemblyData.methodsrewriter {
 	class MModule {
 		public Module module;
-		public ModuleDefinition moduleDefinition;
+		public ModuleDefMD moduleDef;
 		TypeDefinitionDict<MType> typeReferenceToType = new TypeDefinitionDict<MType>();
 		Dictionary<int, MType> tokenToType = new Dictionary<int, MType>();
 		Dictionary<int, MMethod> tokenToGlobalMethod;
 		Dictionary<int, MField> tokenToGlobalField;
-		TypeDefinition moduleType;
+		TypeDef moduleType;
 
-		public MModule(Module module, ModuleDefinition moduleDefinition) {
+		public MModule(Module module, ModuleDefMD moduleDefinition) {
 			this.module = module;
-			this.moduleDefinition = moduleDefinition;
+			this.moduleDef = moduleDefinition;
 			initTokenToType();
 		}
 
 		void initTokenToType() {
-			moduleType = DotNetUtils.getModuleType(moduleDefinition);
-			foreach (var typeDefinition in moduleDefinition.GetTypes()) {
-				int token = typeDefinition.MetadataToken.ToInt32();
+			moduleType = moduleDef.Types[0];
+			foreach (var typeDef in moduleDef.GetTypes()) {
+				int token = (int)typeDef.MDToken.Raw;
 				Type type;
 				try {
 					type = module.ResolveType(token);
 				}
 				catch {
 					tokenToType[token] = null;
-					typeReferenceToType.add(typeDefinition, null);
+					typeReferenceToType.add(typeDef, null);
 					continue;
 				}
-				var mtype = new MType(type, typeDefinition);
+				var mtype = new MType(type, typeDef);
 				tokenToType[token] = mtype;
-				typeReferenceToType.add(typeDefinition, mtype);
+				typeReferenceToType.add(typeDef, mtype);
 			}
 		}
 
-		public MType getType(TypeReference typeReference) {
-			return typeReferenceToType.find(typeReference);
+		public MType getType(IType typeRef) {
+			return typeReferenceToType.find(typeRef);
 		}
 
-		public MMethod getMethod(MethodReference methodReference) {
-			var type = getType(methodReference.DeclaringType);
+		public MMethod getMethod(IMethod methodRef) {
+			var type = getType(methodRef.DeclaringType);
 			if (type != null)
-				return type.getMethod(methodReference);
-			if (!MemberReferenceHelper.compareTypes(moduleType, methodReference.DeclaringType))
+				return type.getMethod(methodRef);
+			if (!new SigComparer().Equals(moduleType, methodRef.DeclaringType))
 				return null;
 
 			initGlobalMethods();
 			foreach (var method in tokenToGlobalMethod.Values) {
-				if (MemberReferenceHelper.compareMethodReference(methodReference, method.methodDefinition))
+				if (new SigComparer().Equals(methodRef, method.methodDef))
 					return method;
 			}
 
 			return null;
 		}
 
-		public MField getField(FieldReference fieldReference) {
-			var type = getType(fieldReference.DeclaringType);
+		public MField getField(IField fieldRef) {
+			var type = getType(fieldRef.DeclaringType);
 			if (type != null)
-				return type.getField(fieldReference);
-			if (!MemberReferenceHelper.compareTypes(moduleType, fieldReference.DeclaringType))
+				return type.getField(fieldRef);
+			if (!new SigComparer().Equals(moduleType, fieldRef.DeclaringType))
 				return null;
 
 			initGlobalFields();
 			foreach (var field in tokenToGlobalField.Values) {
-				if (MemberReferenceHelper.compareFieldReference(fieldReference, field.fieldDefinition))
+				if (new SigComparer().Equals(fieldRef, field.fieldDef))
 					return field;
 			}
 
@@ -120,7 +120,7 @@ namespace AssemblyData.methodsrewriter {
 			foreach (var m in moduleType.Methods) {
 				if (m.Name == ".cctor")	//TODO: Use module.GetMethod(token) to get .cctor method
 					continue;
-				var token = m.MetadataToken.ToInt32();
+				var token = (int)m.MDToken.Raw;
 				tokenToGlobalMethod[token] = new MMethod(tmpTokenToGlobalMethod[token], m);
 			}
 		}
@@ -135,13 +135,13 @@ namespace AssemblyData.methodsrewriter {
 			foreach (var f in module.GetFields(flags))
 				tmpTokenToGlobalField[f.MetadataToken] = f;
 			foreach (var f in moduleType.Fields) {
-				var token = f.MetadataToken.ToInt32();
+				var token = (int)f.MDToken.Raw;
 				tokenToGlobalField[token] = new MField(tmpTokenToGlobalField[token], f);
 			}
 		}
 
 		public override string ToString() {
-			return moduleDefinition.FullyQualifiedName;
+			return moduleDef.Location;
 		}
 	}
 }
diff --git a/AssemblyData/methodsrewriter/MType.cs b/AssemblyData/methodsrewriter/MType.cs
index ad4f5f07..00d42751 100644
--- a/AssemblyData/methodsrewriter/MType.cs
+++ b/AssemblyData/methodsrewriter/MType.cs
@@ -20,31 +20,31 @@
 using System;
 using System.Collections.Generic;
 using System.Reflection;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace AssemblyData.methodsrewriter {
 	class MType {
 		public Type type;
-		public TypeDefinition typeDefinition;
+		public TypeDef typeDef;
 		Dictionary<int, MMethod> tokenToMethod;
 		MethodDefinitionDict<MMethod> methodReferenceToMethod;
 		Dictionary<int, MField> tokenToField;
 		FieldDefinitionDict<MField> fieldReferenceToField;
 
-		public MType(Type type, TypeDefinition typeDefinition) {
+		public MType(Type type, TypeDef typeDefinition) {
 			this.type = type;
-			this.typeDefinition = typeDefinition;
+			this.typeDef = typeDefinition;
 		}
 
-		public MMethod getMethod(MethodReference methodReference) {
+		public MMethod getMethod(IMethod methodRef) {
 			initMethods();
-			return methodReferenceToMethod.find(methodReference);
+			return methodReferenceToMethod.find(methodRef);
 		}
 
-		public MField getField(FieldReference fieldReference) {
+		public MField getField(IField fieldRef) {
 			initFields();
-			return fieldReferenceToField.find(fieldReference);
+			return fieldReferenceToField.find(fieldRef);
 		}
 
 		public MMethod getMethod(int token) {
@@ -60,41 +60,41 @@ namespace AssemblyData.methodsrewriter {
 		void initMethods() {
 			if (tokenToMethod != null)
 				return;
-			tokenToMethod = new Dictionary<int, MMethod>(typeDefinition.Methods.Count);
+			tokenToMethod = new Dictionary<int, MMethod>(typeDef.Methods.Count);
 			methodReferenceToMethod = new MethodDefinitionDict<MMethod>();
 
 			var tmpTokenToMethod = new Dictionary<int, MethodBase>();
 			var flags = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
 			foreach (var m in ResolverUtils.getMethodBases(type, flags))
 				tmpTokenToMethod[m.MetadataToken] = m;
-			foreach (var m in typeDefinition.Methods) {
-				var token = m.MetadataToken.ToInt32();
+			foreach (var m in typeDef.Methods) {
+				var token = (int)m.MDToken.Raw;
 				var method = new MMethod(tmpTokenToMethod[token], m);
 				tokenToMethod[token] = method;
-				methodReferenceToMethod.add(method.methodDefinition, method);
+				methodReferenceToMethod.add(method.methodDef, method);
 			}
 		}
 
 		void initFields() {
 			if (tokenToField != null)
 				return;
-			tokenToField = new Dictionary<int, MField>(typeDefinition.Fields.Count);
+			tokenToField = new Dictionary<int, MField>(typeDef.Fields.Count);
 			fieldReferenceToField = new FieldDefinitionDict<MField>();
 
 			var tmpTokenToField = new Dictionary<int, FieldInfo>();
 			var flags = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
 			foreach (var f in type.GetFields(flags))
 				tmpTokenToField[f.MetadataToken] = f;
-			foreach (var f in typeDefinition.Fields) {
-				var token = f.MetadataToken.ToInt32();
+			foreach (var f in typeDef.Fields) {
+				var token = (int)f.MDToken.Raw;
 				var field = new MField(tmpTokenToField[token], f);
 				tokenToField[token] = field;
-				fieldReferenceToField.add(field.fieldDefinition, field);
+				fieldReferenceToField.add(field.fieldDef, field);
 			}
 		}
 
 		public override string ToString() {
-			return string.Format("{0:X8} - {1}", typeDefinition.MetadataToken.ToUInt32(), typeDefinition.FullName);
+			return string.Format("{0:X8} - {1}", typeDef.MDToken.Raw, typeDef.FullName);
 		}
 	}
 }
diff --git a/AssemblyData/methodsrewriter/MethodsRewriter.cs b/AssemblyData/methodsrewriter/MethodsRewriter.cs
index c1b3e317..e57e16f7 100644
--- a/AssemblyData/methodsrewriter/MethodsRewriter.cs
+++ b/AssemblyData/methodsrewriter/MethodsRewriter.cs
@@ -22,12 +22,12 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.Reflection;
 using System.Reflection.Emit;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet.Emit;
+using dot10.DotNet;
 using de4dot.blocks;
 
-using OpCode = Mono.Cecil.Cil.OpCode;
-using OpCodes = Mono.Cecil.Cil.OpCodes;
+using OpCode = dot10.DotNet.Emit.OpCode;
+using OpCodes = dot10.DotNet.Emit.OpCodes;
 using ROpCode = System.Reflection.Emit.OpCode;
 using ROpCodes = System.Reflection.Emit.OpCodes;
 
@@ -191,13 +191,13 @@ namespace AssemblyData.methodsrewriter {
 			var moduleInfo = Resolver.loadAssembly(realMethod.Module);
 			var methodInfo = moduleInfo.getMethod(realMethod);
 			if (!methodInfo.hasInstructions())
-				throw new ApplicationException(string.Format("Method {0} ({1:X8}) has no body", methodInfo.methodDefinition, methodInfo.methodDefinition.MetadataToken.ToUInt32()));
+				throw new ApplicationException(string.Format("Method {0} ({1:X8}) has no body", methodInfo.methodDef, methodInfo.methodDef.MDToken.Raw));
 
 			var codeGenerator = new CodeGenerator(this, newMethodInfo.delegateMethodName);
 			codeGenerator.setMethodInfo(methodInfo);
 			newMethodInfo.delegateType = codeGenerator.DelegateType;
 
-			var blocks = new Blocks(methodInfo.methodDefinition);
+			var blocks = new Blocks(methodInfo.methodDef);
 			foreach (var block in blocks.MethodBlocks.getAllBlocks())
 				update(block, newMethodInfo);
 
@@ -230,14 +230,15 @@ namespace AssemblyData.methodsrewriter {
 			for (int i = 0; i < instrs.Count; i++) {
 				var instr = instrs[i];
 				if (instr.OpCode == OpCodes.Newobj) {
-					var ctor = (MethodReference)instr.Operand;
-					if (MemberReferenceHelper.verifyType(ctor.DeclaringType, "mscorlib", "System.Diagnostics.StackTrace")) {
+					var ctor = (IMethod)instr.Operand;
+					var ctorTypeFullName = ctor.DeclaringType.FullName;
+					if (ctorTypeFullName == "System.Diagnostics.StackTrace") {
 						insertLoadThis(block, i + 1);
 						insertCallOurMethod(block, i + 2, "static_rtFixStackTrace");
 						i += 2;
 						continue;
 					}
-					else if (MemberReferenceHelper.verifyType(ctor.DeclaringType, "mscorlib", "System.Diagnostics.StackFrame")) {
+					else if (ctorTypeFullName == "System.Diagnostics.StackFrame") {
 						insertLoadThis(block, i + 1);
 						insertCallOurMethod(block, i + 2, "static_rtFixStackFrame");
 						i += 2;
@@ -246,18 +247,19 @@ namespace AssemblyData.methodsrewriter {
 				}
 
 				if (instr.OpCode == OpCodes.Call || instr.OpCode == OpCodes.Callvirt) {
-					var calledMethod = (MethodReference)instr.Operand;
-					if (DotNetUtils.isSameAssembly(calledMethod.DeclaringType, "mscorlib")) {
-						if (calledMethod.ToString() == "System.Reflection.Assembly System.Reflection.Assembly::GetAssembly(System.Type)") {
+					var calledMethod = (IMethod)instr.Operand;
+					if (calledMethod.DeclaringType.DefinitionAssembly.IsCorLib()) {
+						var calledMethodFullName = calledMethod.FullName;
+						if (calledMethodFullName == "System.Reflection.Assembly System.Reflection.Assembly::GetAssembly(System.Type)") {
 							block.replace(i, 1, Instruction.Create(OpCodes.Nop));
 							insertLoadThis(block, i + 1);
 							insertCallOurMethod(block, i + 2, "static_rtGetAssembly_TypeArg");
 							i += 2;
 							continue;
 						}
-						else if (calledMethod.ToString() == "System.Reflection.Assembly System.Reflection.Assembly::GetCallingAssembly()" ||
-								calledMethod.ToString() == "System.Reflection.Assembly System.Reflection.Assembly::GetEntryAssembly()" ||
-								calledMethod.ToString() == "System.Reflection.Assembly System.Reflection.Assembly::GetExecutingAssembly()") {
+						else if (calledMethodFullName == "System.Reflection.Assembly System.Reflection.Assembly::GetCallingAssembly()" ||
+								calledMethodFullName == "System.Reflection.Assembly System.Reflection.Assembly::GetEntryAssembly()" ||
+								calledMethodFullName == "System.Reflection.Assembly System.Reflection.Assembly::GetExecutingAssembly()") {
 							block.replace(i, 1, Instruction.Create(OpCodes.Nop));
 							insertLoadThis(block, i + 1);
 							block.insert(i + 2, Instruction.Create(OpCodes.Ldc_I4, currentMethodInfo.delegateIndex));
@@ -267,7 +269,7 @@ namespace AssemblyData.methodsrewriter {
 						}
 					}
 
-					var method = Resolver.getMethod((MethodReference)instr.Operand);
+					var method = Resolver.getMethod((IMethod)instr.Operand);
 					if (method != null) {
 						createMethod(method.methodBase);
 						var newMethodInfo = realMethodToNewMethod[method.methodBase];
@@ -276,17 +278,17 @@ namespace AssemblyData.methodsrewriter {
 						int n = i + 1;
 
 						// Pop all pushed args to a temp array
-						var mparams = getParameters(method.methodDefinition);
+						var mparams = getParameters(method.methodDef);
 						if (mparams.Count > 0) {
 							block.insert(n++, Instruction.Create(OpCodes.Ldc_I4, mparams.Count));
-							var objectType = method.methodDefinition.Module.TypeSystem.Object;
+							var objectType = method.methodDef.DeclaringType.Module.CorLibTypes.Object;
 							block.insert(n++, Instruction.Create(OpCodes.Newarr, objectType));
 							block.insert(n++, create(OpCodes.Stloc, new Operand(Operand.Type.TempObjArray)));
 
 							for (int j = mparams.Count - 1; j >= 0; j--) {
 								var argType = mparams[j];
-								if (argType.IsValueType)
-									block.insert(n++, Instruction.Create(OpCodes.Box, argType));
+								if (argType.RemovePinnedAndModifiers().IsValueType)
+									block.insert(n++, Instruction.Create(OpCodes.Box, ((TypeDefOrRefSig)argType).TypeDefOrRef));
 								block.insert(n++, create(OpCodes.Stloc, new Operand(Operand.Type.TempObj)));
 								block.insert(n++, create(OpCodes.Ldloc, new Operand(Operand.Type.TempObjArray)));
 								block.insert(n++, Instruction.Create(OpCodes.Ldc_I4, j));
@@ -308,14 +310,14 @@ namespace AssemblyData.methodsrewriter {
 								block.insert(n++, Instruction.Create(OpCodes.Ldc_I4, j));
 								block.insert(n++, Instruction.Create(OpCodes.Ldelem_Ref));
 								var argType = mparams[j];
-								if (argType.IsValueType)
-									block.insert(n++, Instruction.Create(OpCodes.Unbox_Any, argType));
+								if (argType.RemovePinnedAndModifiers().IsValueType)
+									block.insert(n++, Instruction.Create(OpCodes.Unbox_Any, ((TypeDefOrRefSig)argType).TypeDefOrRef));
 								else {
 									// Don't cast it to its correct type. This will sometimes cause
 									// an exception in some EF obfuscated assembly since we'll be
 									// trying to cast a System.Reflection.AssemblyName type to some
 									// other type.
-									// block.insert(n++, Instruction.Create(OpCodes.Castclass, argType));
+									// block.insert(n++, Instruction.Create(OpCodes.Castclass, argType.ToTypeDefOrRef()));
 								}
 							}
 						}
@@ -329,13 +331,10 @@ namespace AssemblyData.methodsrewriter {
 			}
 		}
 
-		static List<TypeReference> getParameters(MethodDefinition method) {
-			int count = method.Parameters.Count + (method.HasImplicitThis ? 1 : 0);
-			var list = new List<TypeReference>(count);
-			if (method.HasImplicitThis)
-				list.Add(method.DeclaringType);
-			foreach (var argType in method.Parameters)
-				list.Add(argType.ParameterType);
+		static IList<TypeSig> getParameters(MethodDef method) {
+			var list = new List<TypeSig>(method.Parameters.Count);
+			for (int i = 0; i < method.Parameters.Count; i++)
+				list.Add(method.Parameters[i].Type);
 			return list;
 		}
 
diff --git a/AssemblyData/methodsrewriter/Resolver.cs b/AssemblyData/methodsrewriter/Resolver.cs
index a3c7ab6e..9d593089 100644
--- a/AssemblyData/methodsrewriter/Resolver.cs
+++ b/AssemblyData/methodsrewriter/Resolver.cs
@@ -20,7 +20,7 @@
 using System;
 using System.Collections.Generic;
 using System.Reflection;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace AssemblyData.methodsrewriter {
@@ -33,47 +33,47 @@ namespace AssemblyData.methodsrewriter {
 			if (modules.TryGetValue(module, out info))
 				return info;
 
-			info = new MModule(module, ModuleDefinition.ReadModule(module.FullyQualifiedName));
+			info = new MModule(module, ModuleDefMD.Load(module.FullyQualifiedName));
 			modules[module] = info;
 			return info;
 		}
 
-		static MModule getModule(ModuleDefinition moduleDefinition) {
+		static MModule getModule(ModuleDef moduleDef) {
 			foreach (var mm in modules.Values) {
-				if (mm.moduleDefinition == moduleDefinition)
+				if (mm.moduleDef == moduleDef)
 					return mm;
 			}
 			return null;
 		}
 
-		static MModule getModule(AssemblyNameReference assemblyRef) {
+		static MModule getModule(AssemblyRef asmRef) {
 			foreach (var mm in modules.Values) {
-				var asm = mm.moduleDefinition.Assembly;
-				if (asm != null && asm.Name.FullName == assemblyRef.FullName)
+				var asm = mm.moduleDef.Assembly;
+				if (asm != null && asm.FullName == asmRef.FullName)
 					return mm;
 			}
 			return null;
 		}
 
-		public static MModule getModule(IMetadataScope scope) {
-			if (scope is ModuleDefinition)
-				return getModule((ModuleDefinition)scope);
-			else if (scope is AssemblyNameReference)
-				return getModule((AssemblyNameReference)scope);
+		public static MModule getModule(IScope scope) {
+			if (scope.ScopeType == ScopeType.ModuleDef)
+				return getModule((ModuleDef)scope);
+			else if (scope.ScopeType == ScopeType.AssemblyRef)
+				return getModule((AssemblyRef)scope);
 
 			return null;
 		}
 
-		public static MType getType(TypeReference typeReference) {
-			if (typeReference == null)
+		public static MType getType(IType typeRef) {
+			if (typeRef == null)
 				return null;
-			var module = getModule(typeReference.Scope);
+			var module = getModule(typeRef.Scope);
 			if (module != null)
-				return module.getType(typeReference);
+				return module.getType(typeRef);
 			return null;
 		}
 
-		public static MMethod getMethod(MethodReference methodReference) {
+		public static MMethod getMethod(IMethod methodReference) {
 			if (methodReference == null)
 				return null;
 			var module = getModule(methodReference.DeclaringType.Scope);
@@ -82,7 +82,7 @@ namespace AssemblyData.methodsrewriter {
 			return null;
 		}
 
-		public static MField getField(FieldReference fieldReference) {
+		public static MField getField(IField fieldReference) {
 			if (fieldReference == null)
 				return null;
 			var module = getModule(fieldReference.DeclaringType.Scope);
@@ -91,114 +91,129 @@ namespace AssemblyData.methodsrewriter {
 			return null;
 		}
 
-		public static object getRtObject(MemberReference memberReference) {
-			if (memberReference == null)
+		public static object getRtObject(ITokenOperand memberRef) {
+			if (memberRef == null)
 				return null;
-			else if (memberReference is TypeReference)
-				return getRtType((TypeReference)memberReference);
-			else if (memberReference is FieldReference)
-				return getRtField((FieldReference)memberReference);
-			else if (memberReference is MethodReference)
-				return getRtMethod((MethodReference)memberReference);
+			var tdr = memberRef as ITypeDefOrRef;
+			if (tdr != null)
+				return getRtType(tdr);
+			var field = memberRef as IField;
+			if (field != null && field.FieldSig != null)
+				return getRtField(field);
+			var method = memberRef as IMethod;
+			if (method != null && method.MethodSig != null)
+				return getRtMethod(method);
 
-			throw new ApplicationException(string.Format("Unknown MemberReference: {0}", memberReference));
+			throw new ApplicationException(string.Format("Unknown MemberReference: {0}", memberRef));
 		}
 
-		public static Type getRtType(TypeReference typeReference) {
-			var mtype = getType(typeReference);
+		public static Type getRtType(IType typeRef) {
+			var mtype = getType(typeRef);
 			if (mtype != null)
 				return mtype.type;
 
-			return Resolver.resolve(typeReference);
+			return Resolver.resolve(typeRef);
 		}
 
-		public static FieldInfo getRtField(FieldReference fieldReference) {
-			var mfield = getField(fieldReference);
+		public static FieldInfo getRtField(IField fieldRef) {
+			var mfield = getField(fieldRef);
 			if (mfield != null)
 				return mfield.fieldInfo;
 
-			return Resolver.resolve(fieldReference);
+			return Resolver.resolve(fieldRef);
 		}
 
-		public static MethodBase getRtMethod(MethodReference methodReference) {
-			var mmethod = getMethod(methodReference);
+		public static MethodBase getRtMethod(IMethod methodRef) {
+			var mmethod = getMethod(methodRef);
 			if (mmethod != null)
 				return mmethod.methodBase;
 
-			return Resolver.resolve(methodReference);
+			return Resolver.resolve(methodRef);
 		}
 
-		static AssemblyResolver getAssemblyResolver(TypeReference type) {
-			var asmName = DotNetUtils.getFullAssemblyName(type);
+		static AssemblyResolver getAssemblyResolver(ITypeDefOrRef type) {
+			var asmName = type.DefinitionAssembly.FullName;
 			AssemblyResolver resolver;
 			if (!assemblyResolvers.TryGetValue(asmName, out resolver))
 				assemblyResolvers[asmName] = resolver = new AssemblyResolver(asmName);
 			return resolver;
 		}
 
-		static Type resolve(TypeReference typeReference) {
-			if (typeReference == null)
+		static Type resolve(IType typeRef) {
+			if (typeRef == null)
 				return null;
-			var elemType = typeReference.GetElementType();
-			var resolver = getAssemblyResolver(elemType);
-			var resolvedType = resolver.resolve(elemType);
+			var scopeType = typeRef.ScopeType;
+			var resolver = getAssemblyResolver(scopeType);
+			var resolvedType = resolver.resolve(scopeType);
 			if (resolvedType != null)
-				return fixType(typeReference, resolvedType);
-			throw new ApplicationException(string.Format("Could not resolve type {0} ({1:X8}) in assembly {2}", typeReference, typeReference.MetadataToken.ToUInt32(), resolver));
+				return fixType(typeRef, resolvedType);
+			throw new ApplicationException(string.Format("Could not resolve type {0} ({1:X8}) in assembly {2}", typeRef, typeRef.MDToken.Raw, resolver));
 		}
 
-		static FieldInfo resolve(FieldReference fieldReference) {
-			if (fieldReference == null)
+		static FieldInfo resolve(IField fieldRef) {
+			if (fieldRef == null)
 				return null;
-			var resolver = getAssemblyResolver(fieldReference.DeclaringType);
-			var fieldInfo = resolver.resolve(fieldReference);
+			var resolver = getAssemblyResolver(fieldRef.DeclaringType);
+			var fieldInfo = resolver.resolve(fieldRef);
 			if (fieldInfo != null)
 				return fieldInfo;
-			throw new ApplicationException(string.Format("Could not resolve field {0} ({1:X8}) in assembly {2}", fieldReference, fieldReference.MetadataToken.ToUInt32(), resolver));
+			throw new ApplicationException(string.Format("Could not resolve field {0} ({1:X8}) in assembly {2}", fieldRef, fieldRef.MDToken.Raw, resolver));
 		}
 
-		static MethodBase resolve(MethodReference methodReference) {
-			if (methodReference == null)
+		static MethodBase resolve(IMethod methodRef) {
+			if (methodRef == null)
 				return null;
-			var resolver = getAssemblyResolver(methodReference.DeclaringType);
-			var methodBase = resolver.resolve(methodReference);
+			var resolver = getAssemblyResolver(methodRef.DeclaringType);
+			var methodBase = resolver.resolve(methodRef);
 			if (methodBase != null)
 				return methodBase;
-			throw new ApplicationException(string.Format("Could not resolve method {0} ({1:X8}) in assembly {2}", methodReference, methodReference.MetadataToken.ToUInt32(), resolver));
+			throw new ApplicationException(string.Format("Could not resolve method {0} ({1:X8}) in assembly {2}", methodRef, methodRef.MDToken.Raw, resolver));
 		}
 
-		static Type fixType(TypeReference typeReference, Type type) {
-			while (typeReference is TypeSpecification) {
-				var ts = (TypeSpecification)typeReference;
+		static Type fixType(IType typeRef, Type type) {
+			var sig = typeRef as TypeSig;
+			if (sig == null) {
+				var ts = typeRef as TypeSpec;
+				if (ts != null)
+					sig = ts.TypeSig;
+			}
+			while (sig != null) {
+				switch (sig.ElementType) {
+				case ElementType.SZArray:
+					type = type.MakeArrayType();
+					break;
 
-				if (typeReference is ArrayType) {
-					var arrayType = (ArrayType)typeReference;
-					if (arrayType.IsVector)
-						type = type.MakeArrayType();
-					else
-						type = type.MakeArrayType(arrayType.Rank);
-				}
-				else if (typeReference is ByReferenceType) {
+				case ElementType.Array:
+					type = type.MakeArrayType((int)((ArraySig)sig).Rank);
+					break;
+
+				case ElementType.ByRef:
 					type = type.MakeByRefType();
-				}
-				else if (typeReference is PointerType) {
+					break;
+
+				case ElementType.Ptr:
 					type = type.MakePointerType();
-				}
-				else if (typeReference is GenericInstanceType) {
-					var git = (GenericInstanceType)typeReference;
+					break;
+
+				case ElementType.GenericInst:
+					var git = (GenericInstSig)sig;
 					var args = new Type[git.GenericArguments.Count];
 					bool isGenericTypeDef = true;
 					for (int i = 0; i < args.Length; i++) {
-						var typeRef = git.GenericArguments[i];
-						if (!(typeRef.GetElementType() is GenericParameter))
+						var arg = git.GenericArguments[i];
+						if (!(arg is GenericSig))
 							isGenericTypeDef = false;
-						args[i] = Resolver.resolve(typeRef);
+						args[i] = Resolver.resolve(arg);
 					}
 					if (!isGenericTypeDef)
 						type = type.MakeGenericType(args);
+					break;
+
+				default:
+					break;
 				}
 
-				typeReference = ts.ElementType;
+				sig = sig.Next;
 			}
 			return type;
 		}
diff --git a/AssemblyData/methodsrewriter/ResolverUtils.cs b/AssemblyData/methodsrewriter/ResolverUtils.cs
index 43659cf5..e820191b 100644
--- a/AssemblyData/methodsrewriter/ResolverUtils.cs
+++ b/AssemblyData/methodsrewriter/ResolverUtils.cs
@@ -20,146 +20,17 @@
 using System;
 using System.Collections.Generic;
 using System.Reflection;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace AssemblyData.methodsrewriter {
 	static class ResolverUtils {
-		public static bool compareTypes(Type a, TypeReference b) {
-			if (a == null && b == null)
-				return true;
-			if (a == null || b == null)
-				return false;
-
-			var type = MemberReferenceHelper.getMemberReferenceType(b);
-			switch (type) {
-			case CecilType.ArrayType:
-				return compareArrayTypes(a, (ArrayType)b);
-			case CecilType.ByReferenceType:
-				return compareByReferenceTypes(a, (ByReferenceType)b);
-			case CecilType.FunctionPointerType:
-				return compareFunctionPointerTypes(a, (FunctionPointerType)b);
-			case CecilType.GenericInstanceType:
-				return compareGenericInstanceTypes(a, (GenericInstanceType)b);
-			case CecilType.GenericParameter:
-				return compareGenericParameters(a, (GenericParameter)b);
-			case CecilType.OptionalModifierType:
-				return compareOptionalModifierTypes(a, (OptionalModifierType)b);
-			case CecilType.PinnedType:
-				return comparePinnedTypes(a, (PinnedType)b);
-			case CecilType.PointerType:
-				return comparePointerTypes(a, (PointerType)b);
-			case CecilType.RequiredModifierType:
-				return compareRequiredModifierTypes(a, (RequiredModifierType)b);
-			case CecilType.SentinelType:
-				return compareSentinelTypes(a, (SentinelType)b);
-			case CecilType.TypeDefinition:
-				return compareTypeDefinitions(a, (TypeDefinition)b);
-			case CecilType.TypeReference:
-				return compareTypeReferences(a, (TypeReference)b);
-			default:
-				throw new ApplicationException(string.Format("Unknown cecil type {0}", type));
-			}
+		public static bool compareTypes(Type a, IType b) {
+			return new SigComparer().Equals(a, b);
 		}
 
-		static bool compareArrayTypes(Type a, ArrayType b) {
-			if (!a.IsArray)
-				return false;
-			if (a.GetArrayRank() != b.Rank)
-				return false;
-			return compareTypes(a.GetElementType(), b.ElementType);
-		}
-
-		static bool compareByReferenceTypes(Type a, ByReferenceType b) {
-			if (!a.IsByRef)
-				return false;
-			return compareTypes(a.GetElementType(), b.ElementType);
-		}
-
-		static bool compareFunctionPointerTypes(Type a, FunctionPointerType b) {
-			return compareTypes(a, b.ElementType);
-		}
-
-		static bool compareGenericInstanceTypes(Type a, GenericInstanceType b) {
-			if (!a.IsGenericType)
-				return false;
-
-			var aGpargs = a.GetGenericArguments();
-			var bGpargs = b.GenericArguments;
-			if (aGpargs.Length != bGpargs.Count)
-				return false;
-
-			for (int i = 0; i < aGpargs.Length; i++) {
-				var aArg = aGpargs[i];
-				var bArg = bGpargs[i];
-				if (aArg.IsGenericParameter)
-					continue;
-				if (!compareTypes(aArg, bArg))
-					return false;
-			}
-
-			return compareTypes(a, b.ElementType);
-		}
-
-		static bool compareGenericParameters(Type a, GenericParameter b) {
-			if (!a.IsGenericParameter)
-				return false;
-			if (a.GenericParameterPosition != b.Position)
-				return false;
-			return true;
-		}
-
-		static bool compareOptionalModifierTypes(Type a, OptionalModifierType b) {
-			return compareTypes(a, b.ElementType);
-		}
-
-		static bool comparePinnedTypes(Type a, PinnedType b) {
-			return compareTypes(a, b.ElementType);
-		}
-
-		static bool comparePointerTypes(Type a, PointerType b) {
-			if (!a.IsPointer)
-				return false;
-			return compareTypes(a.GetElementType(), b.ElementType);
-		}
-
-		static bool compareRequiredModifierTypes(Type a, RequiredModifierType b) {
-			return compareTypes(a, b.ElementType);
-		}
-
-		static bool compareSentinelTypes(Type a, SentinelType b) {
-			return compareTypes(a, b.ElementType);
-		}
-
-		static bool compareTypeDefinitions(Type a, TypeDefinition b) {
-			return compareTypeReferences(a, b);
-		}
-
-		static bool compareTypeReferences(Type a, TypeReference b) {
-			if (a.IsGenericParameter || a.IsPointer || a.IsByRef || a.IsArray)
-				return false;
-
-			if (a.Name != b.Name)
-				return false;
-			if ((a.Namespace ?? "") != b.Namespace)
-				return false;
-
-			var asmRef = DotNetUtils.getAssemblyNameReference(b);
-			var asmName = a.Assembly.GetName();
-			if (asmRef == null || asmRef.Name != asmName.Name)
-				return false;
-
-			return compareTypes(a.DeclaringType, b.DeclaringType);
-		}
-
-		public static bool compareFields(FieldInfo a, FieldReference b) {
-			if (a == null && b == null)
-				return true;
-			if (a == null || b == null)
-				return false;
-
-			return a.Name == b.Name &&
-				compareTypes(a.FieldType, b.FieldType);
+		public static bool compareFields(FieldInfo a, IField b) {
+			return new SigComparer().Equals(a, b);
 		}
 
 		public static bool hasThis(MethodBase method) {
@@ -170,52 +41,8 @@ namespace AssemblyData.methodsrewriter {
 			return (method.CallingConvention & CallingConventions.ExplicitThis) != 0;
 		}
 
-		public static bool compareMethods(MethodBase a, MethodReference b) {
-			if (a == null && b == null)
-				return true;
-			if (a == null || b == null)
-				return false;
-
-			if (a.Name != b.Name)
-				return false;
-
-			if (hasThis(a) != b.HasThis || explicitThis(a) != b.ExplicitThis)
-				return false;
-
-			CallingConventions aCallingConvention = a.CallingConvention & (CallingConventions)7;
-			switch (b.CallingConvention) {
-			case MethodCallingConvention.Default:
-				if (aCallingConvention != CallingConventions.Standard && aCallingConvention != CallingConventions.Any)
-					return false;
-				break;
-
-			case MethodCallingConvention.VarArg:
-				if (aCallingConvention != CallingConventions.VarArgs && aCallingConvention != CallingConventions.Any)
-					return false;
-				break;
-
-			default:
-				return false;
-			}
-
-			if (!compareTypes(getReturnType(a), b.MethodReturnType.ReturnType))
-				return false;
-
-			var aParams = a.GetParameters();
-			var bParams = b.Parameters;
-			if (aParams.Length != bParams.Count)
-				return false;
-			for (int i = 0; i < aParams.Length; i++) {
-				if (!compareTypes(aParams[i].ParameterType, bParams[i].ParameterType))
-					return false;
-			}
-
-			var aGparams = getGenericArguments(a);
-			var bGparams = b.GenericParameters;
-			if (aGparams.Length != bGparams.Count)
-				return false;
-
-			return true;
+		public static bool compareMethods(MethodBase a, IMethod b) {
+			return new SigComparer().Equals(a, b);
 		}
 
 		public static Type getReturnType(MethodBase methodBase) {
@@ -300,15 +127,18 @@ namespace AssemblyData.methodsrewriter {
 			return list;
 		}
 
-		public static Type makeInstanceType(Type type, TypeReference typeReference) {
-			var git = typeReference as GenericInstanceType;
+		public static Type makeInstanceType(Type type, ITypeDefOrRef typeRef) {
+			var ts = typeRef as TypeSpec;
+			if (ts == null)
+				return type;
+			var git = ts.TypeSig as GenericInstSig;
 			if (git == null)
 				return type;
 			var types = new Type[git.GenericArguments.Count];
 			bool isTypeDef = true;
 			for (int i = 0; i < git.GenericArguments.Count; i++) {
 				var arg = git.GenericArguments[i];
-				if (!(arg is GenericParameter))
+				if (!(arg is GenericSig))
 					isTypeDef = false;
 				types[i] = Resolver.getRtType(arg);
 			}
diff --git a/AssemblyData/methodsrewriter/TypeInstanceResolver.cs b/AssemblyData/methodsrewriter/TypeInstanceResolver.cs
index bbd2b7c1..b9d1ec01 100644
--- a/AssemblyData/methodsrewriter/TypeInstanceResolver.cs
+++ b/AssemblyData/methodsrewriter/TypeInstanceResolver.cs
@@ -20,7 +20,7 @@
 using System;
 using System.Collections.Generic;
 using System.Reflection;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace AssemblyData.methodsrewriter {
@@ -29,23 +29,21 @@ namespace AssemblyData.methodsrewriter {
 		Dictionary<string, List<MethodBase>> methods;
 		Dictionary<string, List<FieldInfo>> fields;
 
-		public TypeInstanceResolver(Type type, TypeReference typeReference) {
-			this.type = ResolverUtils.makeInstanceType(type, typeReference);
+		public TypeInstanceResolver(Type type, ITypeDefOrRef typeRef) {
+			this.type = ResolverUtils.makeInstanceType(type, typeRef);
 		}
 
-		public FieldInfo resolve(FieldReference fieldReference) {
+		public FieldInfo resolve(IField fieldRef) {
 			initFields();
 
 			List<FieldInfo> list;
-			if (!fields.TryGetValue(fieldReference.Name, out list))
+			if (!fields.TryGetValue(fieldRef.Name.String, out list))
 				return null;
 
-			var git = fieldReference.DeclaringType as GenericInstanceType;
-			if (git != null)
-				fieldReference = FieldReferenceInstance.make(fieldReference, git);
+			fieldRef = GenericArgsSubstitutor.create(fieldRef, fieldRef.DeclaringType.ToGenericInstSig());
 
 			foreach (var field in list) {
-				if (ResolverUtils.compareFields(field, fieldReference))
+				if (ResolverUtils.compareFields(field, fieldRef))
 					return field;
 			}
 
@@ -66,19 +64,17 @@ namespace AssemblyData.methodsrewriter {
 			}
 		}
 
-		public MethodBase resolve(MethodReference methodReference) {
+		public MethodBase resolve(IMethod methodRef) {
 			initMethods();
 
 			List<MethodBase> list;
-			if (!methods.TryGetValue(methodReference.Name, out list))
+			if (!methods.TryGetValue(methodRef.Name.String, out list))
 				return null;
 
-			var git = methodReference.DeclaringType as GenericInstanceType;
-			var gim = methodReference as GenericInstanceMethod;
-			methodReference = MethodReferenceInstance.make(methodReference, git, gim);
+			methodRef = GenericArgsSubstitutor.create(methodRef, methodRef.DeclaringType.ToGenericInstSig());
 
 			foreach (var method in list) {
-				if (ResolverUtils.compareMethods(method, methodReference))
+				if (ResolverUtils.compareMethods(method, methodRef))
 					return method;
 			}
 
diff --git a/AssemblyData/methodsrewriter/TypeResolver.cs b/AssemblyData/methodsrewriter/TypeResolver.cs
index 3a35dc4f..59e23597 100644
--- a/AssemblyData/methodsrewriter/TypeResolver.cs
+++ b/AssemblyData/methodsrewriter/TypeResolver.cs
@@ -20,32 +20,31 @@
 using System;
 using System.Collections.Generic;
 using System.Reflection;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace AssemblyData.methodsrewriter {
 	class TypeResolver {
 		public Type type;
-		Dictionary<TypeReferenceKey, TypeInstanceResolver> typeRefToInstance = new Dictionary<TypeReferenceKey, TypeInstanceResolver>();
+		Dictionary<ITypeDefOrRef, TypeInstanceResolver> typeRefToInstance = new Dictionary<ITypeDefOrRef, TypeInstanceResolver>(TypeEqualityComparer.Instance);
 
 		public TypeResolver(Type type) {
 			this.type = type;
 		}
 
-		TypeInstanceResolver getTypeInstance(TypeReference typeReference) {
-			var key = new TypeReferenceKey(typeReference);
+		TypeInstanceResolver getTypeInstance(ITypeDefOrRef typeRef) {
 			TypeInstanceResolver instance;
-			if (!typeRefToInstance.TryGetValue(key, out instance))
-				typeRefToInstance[key] = instance = new TypeInstanceResolver(type, typeReference);
+			if (!typeRefToInstance.TryGetValue(typeRef, out instance))
+				typeRefToInstance[typeRef] = instance = new TypeInstanceResolver(type, typeRef);
 			return instance;
 		}
 
-		public FieldInfo resolve(FieldReference fieldReference) {
-			return getTypeInstance(fieldReference.DeclaringType).resolve(fieldReference);
+		public FieldInfo resolve(IField fieldRef) {
+			return getTypeInstance(fieldRef.DeclaringType).resolve(fieldRef);
 		}
 
-		public MethodBase resolve(MethodReference methodReference) {
-			return getTypeInstance(methodReference.DeclaringType).resolve(methodReference);
+		public MethodBase resolve(IMethod methodRef) {
+			return getTypeInstance(methodRef.DeclaringType).resolve(methodRef);
 		}
 	}
 }
diff --git a/LICENSE.Mono.Cecil.txt b/LICENSE.Mono.Cecil.txt
deleted file mode 100644
index 1f20e5b1..00000000
--- a/LICENSE.Mono.Cecil.txt
+++ /dev/null
@@ -1,34 +0,0 @@
-<LICENSE>
-//
-// Author:
-//   Jb Evain (jbevain@gmail.com)
-//
-// Copyright (c) 2008 - 2011 Jb Evain
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-</LICENSE>
-
-Official site: https://github.com/jbevain/cecil
-My fork: https://github.com/0xd4d/cecil
-
-This version of Mono.Cecil is not the official version. I have added code
-to read decrypted methods and other fixes, eg. making it more robust when
-processing obfuscated assemblies with invalid metadata.
diff --git a/README.md b/README.md
index 04979fe6..e69de29b 100644
--- a/README.md
+++ b/README.md
@@ -1,167 +0,0 @@
-
-de4dot - Deobfuscator for .NET
-==============================
-
-Features
---------
-
-* Supports some popular obfuscators
-* Deobfuscates control flow
-* Cross-assembly symbol renaming
-* Decrypts strings
-* Decrypts resources
-* Dumps embedded assemblies
-* Dumps encrypted methods
-* Deobfuscated files are runnable
-* Removes other obfuscator junk
-* Supports pure managed .NET files only
-* Fixes peverify errors created by the obfuscator
-* 100% Open Source
-
-Many features work even if it's an unsupported obfuscator but the result may
-or may not be runnable.
-
-Who would need a deobfuscator?
-------------------------------
-
-* Security experts who need to deobfuscate obfuscated .NET malware.
-* You lost your source code but have a copy of your obfuscated .NET
-  assemblies. You can then use ILSpy to decompile them.
-* You must verify that an obfuscated compiled .NET assembly contains the
-  claimed source code, and no backdoors.
-* Some obfuscators are not Mono-compatible. If you deobfuscate it, it may run
-  on Mono.
-* Some obfuscated programs crash on 64-bit Windows. Deobfuscating it and
-  removing the obfuscator code solves that problem.
-* You can only run verifiable .NET code, but the obfuscated program is
-  non-verifiable due to the obfuscated code.
-* You don't want string decryption and tons of useless CIL instructions to
-  slow down your favorite program.
-
-Features explained
-------------------
-
-### Supports some popular obfuscators
-
-I won't list the supported obfuscators since I'd forget to update it when I
-add support for another one. Run `de4dot -h` to get a list of the supported
-obfuscators. It's usually very easy to add support for another obfuscator.
-
-Other obfuscators are partially supported. Eg. control flow deobfuscation,
-symbol renaming, and dynamic string decryption could possibly work.
-
-### Deobfuscates control flow
-
-Most obfuscators can rearrange the control flow so the code is harder to
-understand. A simple method that is 10 lines long and easy to read, could
-become 30-40 lines and be very hard to read. Control flow deobfuscation will
-remove all of the obfuscated code, leaving just the original code. Dead code
-is also removed.
-
-### Cross-assembly symbol renaming
-
-Many obfuscators can rename public classes if they're part of a private
-assembly. This deobfuscator will properly rename not only the obfuscated class
-and all references within that assembly, but also all references in other
-assemblies. If you don't need symbol renaming, you should disable it.
-
-### Decrypts strings
-
-Most, if not all, obfuscators support encrypting the strings. They usually
-replace the original string with an encrypted string, or an integer. The
-encrypted string or integer is then handed over to the string decrypter which
-returns the original string. This deobfuscator supports static decryption and
-dynamic decryption. Dynamic decryption will load the assembly and then call
-the string decrypter and save the decrypted string. You can tell it which
-method is the string decrypter and it will do the rest. The default is to use
-static string decryption. Dynamic string decryption can be useful if you're
-deobfuscating an assembly obfuscated with an unsupported obfuscator.
-
-### Decrypts resources
-
-Resources are usually encrypted by the obfuscator. The deobfuscator supports
-static decryption only.
-
-### Dumps embedded assemblies
-
-Some obfuscators can embed assemblies. They usually encrypt and compress the
-assembly and put it in the resources section. These assemblies will be
-decypted and decompressed and then saved to disk.
-
-### Dumps encrypted methods
-
-Some obfuscators encrypt all methods and only decrypt each method when
-requested by the .NET runtime. The methods are statically decrypted and then
-deobfuscated.
-
-### Deobfuscated files are runnable
-
-If it's a supported obfuscator, the output is runnable. This is an important
-feature. If you can't run the resulting file, it's almost useless. Note that
-you may need to resign all modified assemblies that were signed. Some programs
-have internal checks for modifications that aren't part of the obfuscator.
-These kinds of protections usually cause a crash on purpose. Those aren't
-removed since they're part of the original assembly.
-
-### Removes other obfuscator junk
-
-Many obfuscation products add other junk to the file. Eg., they could add code
-to log every single exception, or detect deobfuscation, etc. Since that's not
-part of the original file, it's also removed. Some obfuscators add so many
-junk classes that it's difficult to find all of them, though. You have to
-remove those manually for now.
-
-### Supports pure managed .NET files only
-
-This is a limitation of the Mono.Cecil library. Most .NET assemblies, however,
-are pure managed .NET assemblies.
-
-### Fixes peverify errors created by the obfuscator
-
-Usually when an obfuscator adds control flow obfuscation, the resulting code
-doesn't pass all peverify tests, resulting in an unverifiable assembly. By
-removing that obfuscation, and making sure to re-arrange the code blocks in a
-certain order, those obfuscator created errors will be gone. If the assembly
-was verifiable before obfuscation, it must be verifiable after deobfuscation.
-
-### 100% Open Source
-
-Can't get any better than this!
-
-Examples
---------
-
-Show help:
-
-    de4dot -h
-
-Deobfuscate a few files:
-
-    de4dot file1.exe file2.dll file3.exe
-
-Deobfuscate all files found:
-
-    de4dot -r c:\path1 -ro c:\out
-
-Detect obfuscator recursively:
-
-    de4dot -d -r c:\path1
-
-Deobfuscate and get a detailed log of what was changed:
-
-    de4dot -v file1.exe file2.dll file3.exe > log.txt
-
-Deobfuscate and override string decrypter detection, finding and using all
-static methods with string and int args that return a string. A dynamic method
-is created and used to call the string decrypter method(s). Make sure you
-don't include any non-string decrypter methods or you will get an exception:
-
-    de4dot --default-strtyp delegate --default-strtok "(System.String, System.Int32)" file1.exe file2.dll
-
-Same as above but use a metadata token:
-
-    de4dot --default-strtyp delegate file1.exe --strtok 06000123 file2.dll --strtok 06004567 --strtok 06009ABC
-
-Don't remove obfuscator types, methods, etc:
-
-    de4dot --keep-types file1.exe
diff --git a/blocks/Block.cs b/blocks/Block.cs
index 1142e016..73e1d748 100644
--- a/blocks/Block.cs
+++ b/blocks/Block.cs
@@ -19,7 +19,7 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil.Cil;
+using dot10.DotNet.Emit;
 
 namespace de4dot.blocks {
 	public class Block : BaseBlock {
@@ -269,7 +269,7 @@ namespace de4dot.blocks {
 			for (int i = 0; i < instrs.Count; i++) {
 				var instr = instrs[i];
 				if (instr.OpCode != OpCodes.Nop)
-					dest.Add(clone ? new Instr(DotNetUtils.clone(instr.Instruction)) : instr);
+					dest.Add(clone ? new Instr(instr.Instruction.Clone()) : instr);
 			}
 		}
 
diff --git a/blocks/Blocks.cs b/blocks/Blocks.cs
index 8b7afb0d..70c2a3d6 100644
--- a/blocks/Blocks.cs
+++ b/blocks/Blocks.cs
@@ -19,35 +19,35 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 
 namespace de4dot.blocks {
 	public class Blocks {
-		MethodDefinition method;
-		IList<VariableDefinition> locals;
+		MethodDef method;
+		IList<Local> locals;
 		MethodBlocks methodBlocks;
 
 		public MethodBlocks MethodBlocks {
 			get { return methodBlocks; }
 		}
 
-		public IList<VariableDefinition> Locals {
+		public IList<Local> Locals {
 			get { return locals; }
 		}
 
-		public MethodDefinition Method {
+		public MethodDef Method {
 			get { return method; }
 		}
 
-		public Blocks(MethodDefinition method) {
+		public Blocks(MethodDef method) {
 			this.method = method;
 			updateBlocks();
 		}
 
 		public void updateBlocks() {
 			var body = method.Body;
-			locals = body.Variables;
+			locals = body.LocalList;
 			methodBlocks = new InstructionListParser(body.Instructions, body.ExceptionHandlers).parse();
 		}
 
@@ -79,11 +79,11 @@ namespace de4dot.blocks {
 			if (locals.Count == 0)
 				return 0;
 
-			var usedLocals = new Dictionary<VariableDefinition, List<LocalVariableInfo>>();
+			var usedLocals = new Dictionary<Local, List<LocalVariableInfo>>();
 			foreach (var block in methodBlocks.getAllBlocks()) {
 				for (int i = 0; i < block.Instructions.Count; i++) {
 					var instr = block.Instructions[i];
-					VariableDefinition local;
+					Local local;
 					switch (instr.OpCode.Code) {
 					case Code.Ldloc:
 					case Code.Ldloc_S:
@@ -102,7 +102,7 @@ namespace de4dot.blocks {
 
 					case Code.Ldloca_S:
 					case Code.Ldloca:
-						local = (VariableDefinition)instr.Operand;
+						local = (Local)instr.Operand;
 						break;
 
 					default:
@@ -122,14 +122,39 @@ namespace de4dot.blocks {
 			}
 
 			int newIndex = -1;
-			var newLocals = new List<VariableDefinition>(usedLocals.Count);
+			var newLocals = new List<Local>(usedLocals.Count);
+			var newLocalsDict = new Dictionary<Local, bool>(usedLocals.Count);
 			foreach (var local in usedLocals.Keys) {
 				newIndex++;
 				newLocals.Add(local);
+				newLocalsDict[local] = true;
 				foreach (var info in usedLocals[local])
 					info.block.Instructions[info.index] = new Instr(optimizeLocalInstr(info.block.Instructions[info.index], local, (uint)newIndex));
 			}
 
+			// We can't remove all locals. Locals that reference another assembly will
+			// cause the CLR to load that assembly before the method is executed if it
+			// hasn't been loaded yet. This is a side effect the program may depend on.
+			// At least one program has this dependency and will crash if we remove the
+			// unused local. This took a while to figure out...
+			var keptAssemblies = new Dictionary<string, bool>(StringComparer.Ordinal);
+			foreach (var local in locals) {
+				if (newLocalsDict.ContainsKey(local))
+					continue;
+				var defAsm = local.Type.DefinitionAssembly;
+				if (defAsm == null)
+					continue;	// eg. fnptr
+				if (defAsm == method.DeclaringType.Module.Assembly)
+					continue;	// this assembly is always loaded
+				if (defAsm.IsCorLib())
+					continue;	// mscorlib is always loaded
+				var asmName = defAsm.FullName;
+				if (keptAssemblies.ContainsKey(asmName))
+					continue;
+				keptAssemblies[asmName] = true;
+				newLocals.Add(local);
+			}
+
 			int numRemoved = locals.Count - newLocals.Count;
 			locals.Clear();
 			foreach (var local in newLocals)
@@ -137,7 +162,7 @@ namespace de4dot.blocks {
 			return numRemoved;
 		}
 
-		static Instruction optimizeLocalInstr(Instr instr, VariableDefinition local, uint newIndex) {
+		static Instruction optimizeLocalInstr(Instr instr, Local local, uint newIndex) {
 			switch (instr.OpCode.Code) {
 			case Code.Ldloc:
 			case Code.Ldloc_S:
@@ -194,7 +219,7 @@ namespace de4dot.blocks {
 				}
 				catch (NullReferenceException) {
 					//TODO: Send this message to the log
-					Console.WriteLine("Null ref exception! Invalid metadata token in code? Method: {0:X8}: {1}", method.MetadataToken.ToUInt32(), method.FullName);
+					Console.WriteLine("Null ref exception! Invalid metadata token in code? Method: {0:X8}: {1}", method.MDToken.Raw, method.FullName);
 					return;
 				}
 			}
diff --git a/blocks/CodeGenerator.cs b/blocks/CodeGenerator.cs
index 1db3d945..db0bcf6e 100644
--- a/blocks/CodeGenerator.cs
+++ b/blocks/CodeGenerator.cs
@@ -19,8 +19,8 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 
 namespace de4dot.blocks {
 	class CodeGenerator {
@@ -45,10 +45,10 @@ namespace de4dot.blocks {
 			public int filterStart;
 			public int handlerStart;
 			public int handlerEnd;
-			public TypeReference catchType;
+			public ITypeDefOrRef catchType;
 			public ExceptionHandlerType handlerType;
 			public ExceptionInfo(int tryStart, int tryEnd, int filterStart,
-				int handlerStart, int handlerEnd, TypeReference catchType,
+				int handlerStart, int handlerEnd, ITypeDefOrRef catchType,
 				ExceptionHandlerType handlerType) {
 				if (tryStart > tryEnd || filterStart > handlerStart ||
 					tryStart < 0 || tryEnd < 0 || filterStart < 0 || handlerStart < 0 || handlerEnd < 0)
@@ -99,10 +99,10 @@ namespace de4dot.blocks {
 		}
 
 		void recalculateInstructionOffsets(IList<Instruction> allInstructions) {
-			int offset = 0;
+			uint offset = 0;
 			foreach (var instr in allInstructions) {
 				instr.Offset = offset;
-				offset += instr.GetSize();
+				offset += (uint)instr.GetSize();
 			}
 		}
 
@@ -137,7 +137,7 @@ namespace de4dot.blocks {
 				if (getShortBranch(instruction, out opcode)) {
 					const int instrSize = 5;	// It's a long branch instruction
 					var target = (Instruction)instruction.Operand;
-					int distance = target == null ? int.MaxValue : target.Offset - (instruction.Offset + instrSize);
+					int distance = target == null ? int.MaxValue : (int)(target.Offset - (instruction.Offset + instrSize));
 					if (-0x80 <= distance && distance <= 0x7F) {
 						instruction.OpCode = opcode;
 						changed = true;
diff --git a/blocks/DotNetUtils.cs b/blocks/DotNetUtils.cs
index 0c310b86..7455a82e 100644
--- a/blocks/DotNetUtils.cs
+++ b/blocks/DotNetUtils.cs
@@ -19,9 +19,8 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.Cecil.Metadata;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 
 namespace de4dot.blocks {
 	public enum FrameworkType {
@@ -33,9 +32,10 @@ namespace de4dot.blocks {
 		Zune,
 	}
 
+#if PORT
 	class TypeCache {
 		ModuleDefinition module;
-		TypeDefinitionDict<TypeDefinition> typeRefToDef = new TypeDefinitionDict<TypeDefinition>();
+		de4dot.blocks.OLD_REMOVE.TypeDefinitionDict<TypeDefinition> typeRefToDef = new de4dot.blocks.OLD_REMOVE.TypeDefinitionDict<TypeDefinition>();
 
 		public TypeCache(ModuleDefinition module) {
 			this.module = module;
@@ -51,7 +51,9 @@ namespace de4dot.blocks {
 			return typeRefToDef.find(typeReference);
 		}
 	}
+#endif
 
+#if PORT
 	public class TypeCaches {
 		Dictionary<ModuleDefinition, TypeCache> typeCaches = new Dictionary<ModuleDefinition, TypeCache>();
 
@@ -77,29 +79,29 @@ namespace de4dot.blocks {
 			return typeCache.lookup(typeReference);
 		}
 	}
+#endif
 
 	public class CallCounter {
-		Dictionary<MethodReferenceAndDeclaringTypeKey, int> calls = new Dictionary<MethodReferenceAndDeclaringTypeKey, int>();
+		Dictionary<IMethod, int> calls = new Dictionary<IMethod, int>(MethodEqualityComparer.CompareDeclaringTypes);
 
-		public void add(MethodReference calledMethod) {
+		public void add(IMethod calledMethod) {
 			int count;
-			var key = new MethodReferenceAndDeclaringTypeKey(calledMethod);
-			calls.TryGetValue(key, out count);
-			calls[key] = count + 1;
+			calls.TryGetValue(calledMethod, out count);
+			calls[calledMethod] = count + 1;
 		}
 
-		public MethodReference most() {
+		public IMethod most() {
 			int numCalls;
 			return most(out numCalls);
 		}
 
-		public MethodReference most(out int numCalls) {
-			MethodReference method = null;
+		public IMethod most(out int numCalls) {
+			IMethod method = null;
 			int callCount = 0;
 			foreach (var key in calls.Keys) {
 				if (calls[key] > callCount) {
 					callCount = calls[key];
-					method = key.MethodReference;
+					method = key;
 				}
 			}
 			numCalls = callCount;
@@ -107,10 +109,11 @@ namespace de4dot.blocks {
 		}
 	}
 
+#if PORT
 	public class MethodCalls {
 		Dictionary<string, int> methodCalls = new Dictionary<string, int>(StringComparer.Ordinal);
 
-		public void addMethodCalls(MethodDefinition method) {
+		public void addMethodCalls(MethodDef method) {
 			if (!method.HasBody)
 				return;
 			foreach (var instr in method.Body.Instructions) {
@@ -137,200 +140,22 @@ namespace de4dot.blocks {
 			return count(methodFullName) != 0;
 		}
 	}
+#endif
 
 	public static class DotNetUtils {
+#if PORT
 		public static readonly TypeCaches typeCaches = new TypeCaches();
+#endif
 
-		public static bool isLeave(Instruction instr) {
-			return instr.OpCode == OpCodes.Leave || instr.OpCode == OpCodes.Leave_S;
+		public static TypeDef getModuleType(ModuleDef module) {
+			return module.GlobalType;
 		}
 
-		public static bool isBr(Instruction instr) {
-			return instr.OpCode == OpCodes.Br || instr.OpCode == OpCodes.Br_S;
+		public static MethodDef getModuleTypeCctor(ModuleDef module) {
+			return module.GlobalType.FindStaticConstructor();
 		}
 
-		public static bool isBrfalse(Instruction instr) {
-			return instr.OpCode == OpCodes.Brfalse || instr.OpCode == OpCodes.Brfalse_S;
-		}
-
-		public static bool isBrtrue(Instruction instr) {
-			return instr.OpCode == OpCodes.Brtrue || instr.OpCode == OpCodes.Brtrue_S;
-		}
-
-		public static bool isLdcI4(Instruction instruction) {
-			return isLdcI4(instruction.OpCode.Code);
-		}
-
-		public static bool isLdcI4(Code code) {
-			switch (code) {
-			case Code.Ldc_I4_M1:
-			case Code.Ldc_I4_0:
-			case Code.Ldc_I4_1:
-			case Code.Ldc_I4_2:
-			case Code.Ldc_I4_3:
-			case Code.Ldc_I4_4:
-			case Code.Ldc_I4_5:
-			case Code.Ldc_I4_6:
-			case Code.Ldc_I4_7:
-			case Code.Ldc_I4_8:
-			case Code.Ldc_I4_S:
-			case Code.Ldc_I4:
-				return true;
-			default:
-				return false;
-			}
-		}
-
-		public static int getLdcI4Value(Instruction instruction) {
-			switch (instruction.OpCode.Code) {
-			case Code.Ldc_I4_M1:return -1;
-			case Code.Ldc_I4_0: return 0;
-			case Code.Ldc_I4_1: return 1;
-			case Code.Ldc_I4_2: return 2;
-			case Code.Ldc_I4_3: return 3;
-			case Code.Ldc_I4_4: return 4;
-			case Code.Ldc_I4_5: return 5;
-			case Code.Ldc_I4_6: return 6;
-			case Code.Ldc_I4_7: return 7;
-			case Code.Ldc_I4_8: return 8;
-			case Code.Ldc_I4_S: return (sbyte)instruction.Operand;
-			case Code.Ldc_I4:	return (int)instruction.Operand;
-			default:
-				throw new ApplicationException(string.Format("Not an ldc.i4 instruction: {0}", instruction));
-			}
-		}
-
-		// Returns true if it's one of the ldarg instructions
-		public static bool isLdarg(Instruction instr) {
-			switch (instr.OpCode.Code) {
-			case Code.Ldarg:
-			case Code.Ldarg_S:
-			case Code.Ldarg_0:
-			case Code.Ldarg_1:
-			case Code.Ldarg_2:
-			case Code.Ldarg_3:
-				return true;
-			default:
-				return false;
-			}
-		}
-
-		// Return true if it's one of the stloc instructions
-		public static bool isStloc(Instruction instr) {
-			switch (instr.OpCode.Code) {
-			case Code.Stloc:
-			case Code.Stloc_0:
-			case Code.Stloc_1:
-			case Code.Stloc_2:
-			case Code.Stloc_3:
-			case Code.Stloc_S:
-				return true;
-			default:
-				return false;
-			}
-		}
-
-		// Returns true if it's one of the ldloc instructions
-		public static bool isLdloc(Instruction instr) {
-			switch (instr.OpCode.Code) {
-			case Code.Ldloc:
-			case Code.Ldloc_0:
-			case Code.Ldloc_1:
-			case Code.Ldloc_2:
-			case Code.Ldloc_3:
-			case Code.Ldloc_S:
-				return true;
-			default:
-				return false;
-			}
-		}
-
-		// Returns the variable or null if it's not a ldloc/stloc instruction. It does not return
-		// a local variable if it's a ldloca/ldloca.s instruction.
-		public static VariableDefinition getLocalVar(IList<VariableDefinition> locals, Instruction instr) {
-			int index;
-			switch (instr.OpCode.Code) {
-			case Code.Ldloc:
-			case Code.Ldloc_S:
-			case Code.Stloc:
-			case Code.Stloc_S:
-				return (VariableDefinition)instr.Operand;
-
-			case Code.Ldloc_0:
-			case Code.Ldloc_1:
-			case Code.Ldloc_2:
-			case Code.Ldloc_3:
-				index = instr.OpCode.Code - Code.Ldloc_0;
-				break;
-
-			case Code.Stloc_0:
-			case Code.Stloc_1:
-			case Code.Stloc_2:
-			case Code.Stloc_3:
-				index = instr.OpCode.Code - Code.Stloc_0;
-				break;
-
-			default:
-				return null;
-			}
-
-			if (index < locals.Count)
-				return locals[index];
-			return null;
-		}
-
-		public static bool isConditionalBranch(Code code) {
-			switch (code) {
-			case Code.Bge:
-			case Code.Bge_S:
-			case Code.Bge_Un:
-			case Code.Bge_Un_S:
-			case Code.Blt:
-			case Code.Blt_S:
-			case Code.Blt_Un:
-			case Code.Blt_Un_S:
-			case Code.Bgt:
-			case Code.Bgt_S:
-			case Code.Bgt_Un:
-			case Code.Bgt_Un_S:
-			case Code.Ble:
-			case Code.Ble_S:
-			case Code.Ble_Un:
-			case Code.Ble_Un_S:
-			case Code.Brfalse:
-			case Code.Brfalse_S:
-			case Code.Brtrue:
-			case Code.Brtrue_S:
-			case Code.Beq:
-			case Code.Beq_S:
-			case Code.Bne_Un:
-			case Code.Bne_Un_S:
-				return true;
-
-			default:
-				return false;
-			}
-		}
-
-		public static TypeDefinition getModuleType(ModuleDefinition module) {
-			if (module.Types.Count == 0)
-				return null;
-
-			if (module.Runtime == TargetRuntime.Net_1_0 || module.Runtime == TargetRuntime.Net_1_1) {
-				if (module.Types[0].FullName == "<Module>")
-					return module.Types[0];
-				return null;
-			}
-
-			// It's always the first one, no matter what it is named.
-			return module.Types[0];
-		}
-
-		public static MethodDefinition getModuleTypeCctor(ModuleDefinition module) {
-			return getMethod(getModuleType(module), ".cctor");
-		}
-
-		public static bool isEmpty(MethodDefinition method) {
+		public static bool isEmpty(MethodDef method) {
 			if (method.Body == null)
 				return false;
 			foreach (var instr in method.Body.Instructions) {
@@ -341,7 +166,7 @@ namespace de4dot.blocks {
 			return true;
 		}
 
-		public static bool isEmptyObfuscated(MethodDefinition method) {
+		public static bool isEmptyObfuscated(MethodDef method) {
 			if (method.Body == null)
 				return false;
 			int index = 0;
@@ -352,32 +177,33 @@ namespace de4dot.blocks {
 			return true;
 		}
 
-		public static FieldDefinition findFieldType(TypeDefinition typeDefinition, string typeName, bool isStatic) {
+		public static FieldDef findFieldType(TypeDef typeDefinition, string typeName, bool isStatic) {
 			if (typeDefinition == null)
 				return null;
 			foreach (var field in typeDefinition.Fields) {
-				if (field.FieldType.FullName == typeName && field.IsStatic == isStatic)
+				if (field.IsStatic == isStatic && field.FieldSig.GetFieldType().GetFullName() == typeName)
 					return field;
 			}
 			return null;
 		}
 
-		public static IEnumerable<MethodDefinition> findMethods(IEnumerable<MethodDefinition> methods, string returnType, string[] argsTypes) {
+		public static IEnumerable<MethodDef> findMethods(IEnumerable<MethodDef> methods, string returnType, string[] argsTypes) {
 			return findMethods(methods, returnType, argsTypes, true);
 		}
 
-		public static IEnumerable<MethodDefinition> findMethods(IEnumerable<MethodDefinition> methods, string returnType, string[] argsTypes, bool isStatic) {
+		public static IEnumerable<MethodDef> findMethods(IEnumerable<MethodDef> methods, string returnType, string[] argsTypes, bool isStatic) {
 			foreach (var method in methods) {
-				if (!method.HasBody || method.CallingConvention != MethodCallingConvention.Default)
+				var sig = method.MethodSig;
+				if (sig == null || !method.HasBody || !sig.IsDefault)
 					continue;
-				if (method.IsStatic != isStatic || method.Parameters.Count != argsTypes.Length)
+				if (method.IsStatic != isStatic || sig.Params.Count != argsTypes.Length)
 					continue;
-				if (method.GenericParameters.Count > 0)
+				if (sig.GenParamCount > 0)
 					continue;
-				if (method.MethodReturnType.ReturnType.FullName != returnType)
+				if (sig.RetType.GetFullName() != returnType)
 					continue;
 				for (int i = 0; i < argsTypes.Length; i++) {
-					if (method.Parameters[i].ParameterType.FullName != argsTypes[i])
+					if (sig.Params[i].GetFullName() != argsTypes[i])
 						goto next;
 				}
 				yield return method;
@@ -385,14 +211,18 @@ namespace de4dot.blocks {
 			}
 		}
 
-		public static bool isDelegate(TypeReference type) {
-			return type != null && (type.FullName == "System.Delegate" || type.FullName == "System.MulticastDelegate");
+		public static bool isDelegate(IType type) {
+			if (type == null)
+				return false;
+			var fn = type.FullName;
+			return fn == "System.Delegate" || fn == "System.MulticastDelegate";
 		}
 
-		public static bool derivesFromDelegate(TypeDefinition type) {
+		public static bool derivesFromDelegate(TypeDef type) {
 			return type != null && isDelegate(type.BaseType);
 		}
 
+#if PORT
 		public static bool isSameAssembly(TypeReference type, string assembly) {
 			return MemberReferenceHelper.getCanonicalizedScopeName(type.Scope) == assembly.ToLowerInvariant();
 		}
@@ -400,37 +230,10 @@ namespace de4dot.blocks {
 		public static bool isMethod(MethodReference method, string returnType, string parameters) {
 			return method != null && method.FullName == returnType + " " + method.DeclaringType.FullName + "::" + method.Name + parameters;
 		}
+#endif
 
-		public static bool hasPinvokeMethod(TypeDefinition type, string methodName) {
-			return getPInvokeMethod(type, methodName) != null;
-		}
-
-		public static MethodDefinition getPInvokeMethod(TypeDefinition type, string methodName) {
-			if (type == null)
-				return null;
-			foreach (var method in type.Methods) {
-				if (method.PInvokeInfo == null)
-					continue;
-				if (method.PInvokeInfo.EntryPoint == methodName)
-					return method;
-			}
-			return null;
-		}
-
-		public static MethodDefinition getPInvokeMethod(TypeDefinition type, string dll, string funcName) {
-			foreach (var method in type.Methods) {
-				if (isPinvokeMethod(method, dll, funcName))
-					return method;
-			}
-			return null;
-		}
-
-		public static bool isPinvokeMethod(MethodDefinition method, string dll, string funcName) {
-			if (method == null)
-				return false;
-			if (method.PInvokeInfo == null || method.PInvokeInfo.EntryPoint != funcName)
-				return false;
-			return getDllName(dll).Equals(getDllName(method.PInvokeInfo.Module.Name), StringComparison.OrdinalIgnoreCase);
+		public static bool isMethod(IMethod method, string returnType, string parameters) {
+			return method != null && method.FullName == returnType + " " + method.DeclaringType.FullName + "::" + method.Name + parameters;
 		}
 
 		public static string getDllName(string dll) {
@@ -439,7 +242,41 @@ namespace de4dot.blocks {
 			return dll;
 		}
 
-		public static MethodDefinition getMethod(TypeDefinition type, string name) {
+		public static bool hasPinvokeMethod(TypeDef type, string methodName) {
+			return getPInvokeMethod(type, methodName) != null;
+		}
+
+		public static MethodDef getPInvokeMethod(TypeDef type, string methodName) {
+			if (type == null)
+				return null;
+			var mname = new UTF8String(methodName);
+			foreach (var method in type.Methods) {
+				if (method.ImplMap == null)
+					continue;
+				if (UTF8String.Equals(method.ImplMap.Name, mname))
+					return method;
+			}
+			return null;
+		}
+
+		public static MethodDef getPInvokeMethod(TypeDef type, string dll, string funcName) {
+			foreach (var method in type.Methods) {
+				if (isPinvokeMethod(method, dll, funcName))
+					return method;
+			}
+			return null;
+		}
+
+		public static bool isPinvokeMethod(MethodDef method, string dll, string funcName) {
+			if (method == null)
+				return false;
+			if (method.ImplMap == null || method.ImplMap.Name.String != funcName)
+				return false;
+			return getDllName(dll).Equals(getDllName(method.ImplMap.Module.Name.String), StringComparison.OrdinalIgnoreCase);
+		}
+
+#if PORT
+		public static MethodDef getMethod(TypeDefinition type, string name) {
 			if (type == null)
 				return null;
 			foreach (var method in type.Methods) {
@@ -449,39 +286,44 @@ namespace de4dot.blocks {
 			return null;
 		}
 
-		public static MethodDefinition getMethod(TypeDefinition type, MethodReference methodReference) {
+		public static MethodDef getMethod(TypeDefinition type, MethodReference methodReference) {
 			if (type == null || methodReference == null)
 				return null;
-			if (methodReference is MethodDefinition)
-				return (MethodDefinition)methodReference;
+			if (methodReference is MethodDef)
+				return (MethodDef)methodReference;
 			foreach (var method in type.Methods) {
 				if (MemberReferenceHelper.compareMethodReference(method, methodReference))
 					return method;
 			}
 			return null;
 		}
+#endif
 
-		public static MethodDefinition getMethod(ModuleDefinition module, MethodReference method) {
+		public static MethodDef getMethod(ModuleDefMD module, IMethod method) {
 			if (method == null)
 				return null;
 			return getMethod(module, method, method.DeclaringType);
 		}
 
-		public static MethodDefinition getMethod2(ModuleDefinition module, MethodReference method) {
+		public static MethodDef getMethod2(ModuleDefMD module, IMethod method) {
 			if (method == null)
 				return null;
-			return getMethod(module, method, method.DeclaringType.GetElementType());
+			if (method is MethodDef)
+				return (MethodDef)method;
+			var git = method.DeclaringType.ToGenericInstSig();
+			var dt = git == null ? method.DeclaringType : git.GenericType.TypeDefOrRef;
+			return getMethod(module, method, dt);
 		}
 
-		static MethodDefinition getMethod(ModuleDefinition module, MethodReference method, TypeReference declaringType) {
+		static MethodDef getMethod(ModuleDefMD module, IMethod method, ITypeDefOrRef declaringType) {
 			if (method == null)
 				return null;
-			if (method is MethodDefinition)
-				return (MethodDefinition)method;
+			if (method is MethodDef)
+				return (MethodDef)method;
 			return getMethod(getType(module, declaringType), method);
 		}
 
-		public static MethodDefinition getMethod(TypeDefinition type, string returnType, string parameters) {
+		public static MethodDef getMethod(TypeDef type, string returnType, string parameters) {
 			foreach (var method in type.Methods) {
 				if (isMethod(method, returnType, parameters))
 					return method;
@@ -489,17 +331,62 @@ namespace de4dot.blocks {
 			return null;
 		}
 
-		public static IEnumerable<MethodDefinition> getNormalMethods(TypeDefinition type) {
+		public static MethodDef getMethod2(ModuleDef module, IMethod method) {
+			if (method == null)
+				return null;
+			return getMethod(module, method, method.DeclaringType.ScopeType);
+		}
+
+		public static TypeDef getType(ModuleDef module, TypeSig type) {
+			type = type.RemovePinnedAndModifiers();
+			var tdr = type as TypeDefOrRefSig;
+			if (tdr == null)
+				return null;
+			return getType(module, tdr.TypeDefOrRef);
+		}
+
+		public static TypeDef getType(ModuleDef module, ITypeDefOrRef type) {
+			var td = type as TypeDef;
+			if (td == null) {
+				var tr = type as TypeRef;
+				if (tr != null) {
+					var trAsm = tr.DefinitionAssembly;
+					var modAsm = module.Assembly;
+					if (trAsm != null && modAsm != null && trAsm.Name == modAsm.Name)
+						td = tr.Resolve();
+				}
+			}
+			return td != null && td.Module == module ? td : null;
+		}
+
+		static MethodDef getMethod(ModuleDef module, IMethod method, ITypeDefOrRef declaringType) {
+			if (method == null)
+				return null;
+			if (method is MethodDef)
+				return (MethodDef)method;
+			return getMethod(getType(module, declaringType), method);
+		}
+
+		public static MethodDef getMethod(TypeDef type, IMethod methodRef) {
+			if (type == null || methodRef == null)
+				return null;
+			if (methodRef is MethodDef)
+				return (MethodDef)methodRef;
+			return type.FindMethod(methodRef.Name, methodRef.MethodSig);
+		}
+
+		public static IEnumerable<MethodDef> getNormalMethods(TypeDef type) {
 			foreach (var method in type.Methods) {
-				if (method.HasPInvokeInfo)
+				if (method.HasImplMap)
 					continue;
-				if (method.Name == ".ctor" || method.Name == ".cctor")
+				if (method.IsConstructor)
 					continue;
 
 				yield return method;
 			}
 		}
 
+#if PORT
 		public static TypeDefinition getType(ModuleDefinition module, TypeReference typeReference) {
 			if (typeReference == null)
 				return null;
@@ -507,37 +394,35 @@ namespace de4dot.blocks {
 				return (TypeDefinition)typeReference;
 			return typeCaches.lookup(module, typeReference);
 		}
+#endif
 
-		public static FieldDefinition getField(ModuleDefinition module, FieldReference field) {
+		public static FieldDef getField(ModuleDef module, IField field) {
 			if (field == null)
 				return null;
-			if (field is FieldDefinition)
-				return (FieldDefinition)field;
+			if (field is FieldDef)
+				return (FieldDef)field;
 			return getField(getType(module, field.DeclaringType), field);
 		}
 
-		public static FieldDefinition getField(TypeDefinition type, FieldReference fieldReference) {
+		public static FieldDef getField(TypeDef type, IField fieldReference) {
 			if (type == null || fieldReference == null)
 				return null;
-			if (fieldReference is FieldDefinition)
-				return (FieldDefinition)fieldReference;
-			foreach (var field in type.Fields) {
-				if (MemberReferenceHelper.compareFieldReference(field, fieldReference))
-					return field;
-			}
-			return null;
+			if (fieldReference is FieldDef)
+				return (FieldDef)fieldReference;
+			return type.FindField(fieldReference.Name, fieldReference.FieldSig);
 		}
 
-		public static FieldDefinition getField(TypeDefinition type, string typeFullName) {
+		public static FieldDef getField(TypeDef type, string typeFullName) {
 			if (type == null)
 				return null;
 			foreach (var field in type.Fields) {
-				if (field.FieldType.FullName == typeFullName)
+				if (field.FieldSig.GetFieldType().GetFullName() == typeFullName)
 					return field;
 			}
 			return null;
 		}
 
+#if PORT
 		public static FieldDefinition getFieldByName(TypeDefinition type, string name) {
 			if (type == null)
 				return null;
@@ -547,12 +432,13 @@ namespace de4dot.blocks {
 			}
 			return null;
 		}
+#endif
 
-		public static IEnumerable<MethodReference> getMethodCalls(MethodDefinition method) {
-			var list = new List<MethodReference>();
+		public static IEnumerable<IMethod> getMethodCalls(MethodDef method) {
+			var list = new List<IMethod>();
 			if (method.HasBody) {
 				foreach (var instr in method.Body.Instructions) {
-					var calledMethod = instr.Operand as MethodReference;
+					var calledMethod = instr.Operand as IMethod;
 					if (calledMethod != null)
 						list.Add(calledMethod);
 				}
@@ -560,13 +446,14 @@ namespace de4dot.blocks {
 			return list;
 		}
 
-		public static MethodCalls getMethodCallCounts(MethodDefinition method) {
+#if PORT
+		public static MethodCalls getMethodCallCounts(MethodDef method) {
 			var methodCalls = new MethodCalls();
 			methodCalls.addMethodCalls(method);
 			return methodCalls;
 		}
 
-		public static bool hasString(MethodDefinition method, string s) {
+		public static bool hasString(MethodDef method, string s) {
 			if (method == null || method.Body == null)
 				return false;
 			foreach (var instr in method.Body.Instructions) {
@@ -576,7 +463,19 @@ namespace de4dot.blocks {
 			return false;
 		}
 
-		public static IList<string> getCodeStrings(MethodDefinition method) {
+		public static IList<string> getCodeStrings(MethodDef method) {
+			var strings = new List<string>();
+			if (method != null && method.Body != null) {
+				foreach (var instr in method.Body.Instructions) {
+					if (instr.OpCode.Code == Code.Ldstr)
+						strings.Add((string)instr.Operand);
+				}
+			}
+			return strings;
+		}
+#endif
+
+		public static IList<string> getCodeStrings(MethodDef method) {
 			var strings = new List<string>();
 			if (method != null && method.Body != null) {
 				foreach (var instr in method.Body.Instructions) {
@@ -587,11 +486,11 @@ namespace de4dot.blocks {
 			return strings;
 		}
 
-		public static Resource getResource(ModuleDefinition module, string name) {
+		public static Resource getResource(ModuleDef module, string name) {
 			return getResource(module, new List<string> { name });
 		}
 
-		public static Resource getResource(ModuleDefinition module, IEnumerable<string> strings) {
+		public static Resource getResource(ModuleDef module, IEnumerable<string> strings) {
 			if (!module.HasResources)
 				return null;
 
@@ -600,8 +499,9 @@ namespace de4dot.blocks {
 				var resourceName = removeFromNullChar(tmp);
 				if (resourceName == null)
 					continue;
+				var name = new UTF8String(resourceName);
 				foreach (var resource in resources) {
-					if (resource.Name == resourceName)
+					if (UTF8String.Equals(resource.Name, name))
 						return resource;
 				}
 			}
@@ -616,9 +516,10 @@ namespace de4dot.blocks {
 			return s.Substring(0, index);
 		}
 
+#if PORT
 		// Copies most things but not everything
-		public static MethodDefinition clone(MethodDefinition method) {
-			var newMethod = new MethodDefinition(method.Name, method.Attributes, method.MethodReturnType.ReturnType);
+		public static MethodDef clone(MethodDef method) {
+			var newMethod = new MethodDef(method.Name, method.Attributes, method.MethodReturnType.ReturnType);
 			newMethod.MetadataToken = method.MetadataToken;
 			newMethod.Attributes = method.Attributes;
 			newMethod.ImplAttributes = method.ImplAttributes;
@@ -634,7 +535,27 @@ namespace de4dot.blocks {
 			copyBodyFromTo(method, newMethod);
 			return newMethod;
 		}
+#endif
 
+		// Copies most things but not everything
+		public static MethodDef clone(MethodDef method) {
+			var newMethod = new MethodDefUser(method.Name, method.MethodSig, method.ImplAttributes, method.Attributes);
+			newMethod.Rid = method.Rid;
+			newMethod.DeclaringType2 = method.DeclaringType;
+			foreach (var pd in method.ParamList)
+				newMethod.ParamList.Add(new ParamDefUser(pd.Name, pd.Sequence, pd.Attributes));
+			foreach (var gp in method.GenericParameters) {
+				var newGp = new GenericParamUser(gp.Number, gp.Flags, gp.Name);
+				foreach (var gpc in newGp.GenericParamConstraints)
+					newGp.GenericParamConstraints.Add(new GenericParamConstraintUser(gpc.Constraint));
+				newMethod.GenericParameters.Add(newGp);
+			}
+			newMethod.Body = new CilBody();
+			copyBodyFromTo(method, newMethod);
+			return newMethod;
+		}
+
+#if PORT
 		public static Instruction clone(Instruction instr) {
 			return new Instruction {
 				Offset = instr.Offset,
@@ -644,7 +565,7 @@ namespace de4dot.blocks {
 			};
 		}
 
-		public static void copyBody(MethodDefinition method, out IList<Instruction> instructions, out IList<ExceptionHandler> exceptionHandlers) {
+		public static void copyBody(MethodDef method, out IList<Instruction> instructions, out IList<ExceptionHandler> exceptionHandlers) {
 			if (method == null || !method.HasBody) {
 				instructions = new List<Instruction>();
 				exceptionHandlers = new List<ExceptionHandler>();
@@ -691,8 +612,58 @@ namespace de4dot.blocks {
 				return null;
 			return instructions[instructionToIndex[instruction]];
 		}
+#endif
 
-		public static void restoreBody(MethodDefinition method, IEnumerable<Instruction> instructions, IEnumerable<ExceptionHandler> exceptionHandlers) {
+		public static void copyBody(MethodDef method, out IList<Instruction> instructions, out IList<ExceptionHandler> exceptionHandlers) {
+			if (method == null || !method.HasBody) {
+				instructions = new List<Instruction>();
+				exceptionHandlers = new List<ExceptionHandler>();
+				return;
+			}
+
+			var oldInstrs = method.Body.Instructions;
+			var oldExHandlers = method.Body.ExceptionHandlers;
+			instructions = new List<Instruction>(oldInstrs.Count);
+			exceptionHandlers = new List<ExceptionHandler>(oldExHandlers.Count);
+			var oldToIndex = Utils.createObjectToIndexDictionary(oldInstrs);
+
+			foreach (var oldInstr in oldInstrs)
+				instructions.Add(oldInstr.Clone());
+
+			foreach (var newInstr in instructions) {
+				var operand = newInstr.Operand;
+				if (operand is Instruction)
+					newInstr.Operand = instructions[oldToIndex[(Instruction)operand]];
+				else if (operand is IList<Instruction>) {
+					var oldArray = (IList<Instruction>)operand;
+					var newArray = new Instruction[oldArray.Count];
+					for (int i = 0; i < oldArray.Count; i++)
+						newArray[i] = instructions[oldToIndex[oldArray[i]]];
+					newInstr.Operand = newArray;
+				}
+			}
+
+			foreach (var oldEx in oldExHandlers) {
+				var newEx = new ExceptionHandler(oldEx.HandlerType) {
+					TryStart = getInstruction(instructions, oldToIndex, oldEx.TryStart),
+					TryEnd = getInstruction(instructions, oldToIndex, oldEx.TryEnd),
+					FilterStart = getInstruction(instructions, oldToIndex, oldEx.FilterStart),
+					HandlerStart = getInstruction(instructions, oldToIndex, oldEx.HandlerStart),
+					HandlerEnd = getInstruction(instructions, oldToIndex, oldEx.HandlerEnd),
+					CatchType = oldEx.CatchType,
+				};
+				exceptionHandlers.Add(newEx);
+			}
+		}
+
+		static Instruction getInstruction(IList<Instruction> instructions, IDictionary<Instruction, int> instructionToIndex, Instruction instruction) {
+			if (instruction == null)
+				return null;
+			return instructions[instructionToIndex[instruction]];
+		}
+
+#if PORT
+		public static void restoreBody(MethodDef method, IEnumerable<Instruction> instructions, IEnumerable<ExceptionHandler> exceptionHandlers) {
 			if (method == null || !method.HasBody)
 				return;
 
@@ -706,8 +677,24 @@ namespace de4dot.blocks {
 			foreach (var eh in exceptionHandlers)
 				bodyExceptionHandlers.Add(eh);
 		}
+#endif
 
-		public static void copyBodyFromTo(MethodDefinition fromMethod, MethodDefinition toMethod) {
+		public static void restoreBody(MethodDef method, IEnumerable<Instruction> instructions, IEnumerable<ExceptionHandler> exceptionHandlers) {
+			if (method == null || method.Body == null)
+				return;
+
+			var bodyInstrs = method.Body.Instructions;
+			bodyInstrs.Clear();
+			foreach (var instr in instructions)
+				bodyInstrs.Add(instr);
+
+			var bodyExceptionHandlers = method.Body.ExceptionHandlers;
+			bodyExceptionHandlers.Clear();
+			foreach (var eh in exceptionHandlers)
+				bodyExceptionHandlers.Add(eh);
+		}
+
+		public static void copyBodyFromTo(MethodDef fromMethod, MethodDef toMethod) {
 			if (fromMethod == toMethod)
 				return;
 
@@ -719,31 +706,29 @@ namespace de4dot.blocks {
 			updateInstructionOperands(fromMethod, toMethod);
 		}
 
-		static void copyLocalsFromTo(MethodDefinition fromMethod, MethodDefinition toMethod) {
+		static void copyLocalsFromTo(MethodDef fromMethod, MethodDef toMethod) {
 			var fromBody = fromMethod.Body;
 			var toBody = toMethod.Body;
 
-			toBody.Variables.Clear();
-			foreach (var local in fromBody.Variables)
-				toBody.Variables.Add(new VariableDefinition(local.Name, local.VariableType));
+			toBody.LocalList.Clear();
+			foreach (var local in fromBody.LocalList)
+				toBody.LocalList.Add(new Local(local.Type));
 		}
 
-		static void updateInstructionOperands(MethodDefinition fromMethod, MethodDefinition toMethod) {
+		static void updateInstructionOperands(MethodDef fromMethod, MethodDef toMethod) {
 			var fromBody = fromMethod.Body;
 			var toBody = toMethod.Body;
 
 			toBody.InitLocals = fromBody.InitLocals;
-			toBody.MaxStackSize = fromBody.MaxStackSize;
+			toBody.MaxStack = fromBody.MaxStack;
 
 			var newOperands = new Dictionary<object, object>();
-			var fromParams = getParameters(fromMethod);
-			var toParams = getParameters(toMethod);
-			if (fromBody.ThisParameter != null)
-				newOperands[fromBody.ThisParameter] = toBody.ThisParameter;
+			var fromParams = fromMethod.Parameters;
+			var toParams = toMethod.Parameters;
 			for (int i = 0; i < fromParams.Count; i++)
 				newOperands[fromParams[i]] = toParams[i];
-			for (int i = 0; i < fromBody.Variables.Count; i++)
-				newOperands[fromBody.Variables[i]] = toBody.Variables[i];
+			for (int i = 0; i < fromBody.LocalList.Count; i++)
+				newOperands[fromBody.LocalList[i]] = toBody.LocalList[i];
 
 			foreach (var instr in toBody.Instructions) {
 				if (instr.Operand == null)
@@ -754,6 +739,7 @@ namespace de4dot.blocks {
 			}
 		}
 
+#if PORT
 		public static IEnumerable<CustomAttribute> findAttributes(ICustomAttributeProvider custAttrProvider, TypeReference attr) {
 			var list = new List<CustomAttribute>();
 			if (custAttrProvider == null)
@@ -764,22 +750,23 @@ namespace de4dot.blocks {
 			}
 			return list;
 		}
+#endif
 
 		public static string getCustomArgAsString(CustomAttribute cattr, int arg) {
 			if (cattr == null || arg >= cattr.ConstructorArguments.Count)
 				return null;
 			var carg = cattr.ConstructorArguments[arg];
-			if (carg.Type.FullName != "System.String")
+			if (carg.Type.GetElementType() != ElementType.String)
 				return null;
-			return (string)carg.Value;
+			return UTF8String.ToSystemStringOrEmpty((UTF8String)carg.Value);
 		}
 
-		public static IEnumerable<MethodDefinition> getCalledMethods(ModuleDefinition module, MethodDefinition method) {
+		public static IEnumerable<MethodDef> getCalledMethods(ModuleDef module, MethodDef method) {
 			if (method != null && method.HasBody) {
 				foreach (var call in method.Body.Instructions) {
 					if (call.OpCode.Code != Code.Call && call.OpCode.Code != Code.Callvirt)
 						continue;
-					var methodRef = call.Operand as MethodReference;
+					var methodRef = call.Operand as IMethod;
 					if (methodRef == null)
 						continue;
 					var type = getType(module, methodRef.DeclaringType);
@@ -808,13 +795,22 @@ namespace de4dot.blocks {
 			return list;
 		}
 
+#if PORT
 		public static bool hasReturnValue(IMethodSignature method) {
 			var type = method.MethodReturnType.ReturnType;
 			while (type.IsOptionalModifier || type.IsRequiredModifier)
 				type = ((TypeSpecification)type).ElementType;
 			return type.EType != ElementType.Void;
 		}
+#endif
 
+		public static bool hasReturnValue(IMethod method) {
+			if (method == null || method.MethodSig == null || method.MethodSig.RetType == null)
+				return false;
+			return method.MethodSig.RetType.RemovePinnedAndModifiers().ElementType != ElementType.Void;
+		}
+
+#if PORT
 		public static void updateStack(Instruction instr, ref int stack, bool methodHasReturnValue) {
 			int pushes, pops;
 			calculateStackUsage(instr, methodHasReturnValue, out pushes, out pops);
@@ -1001,7 +997,7 @@ namespace de4dot.blocks {
 		public static List<ParameterDefinition> getParameters(MethodReference method) {
 			var args = new List<ParameterDefinition>(method.Parameters.Count + 1);
 			if (method.HasImplicitThis) {
-				var methodDef = method as MethodDefinition;
+				var methodDef = method as MethodDef;
 				if (methodDef != null && methodDef.Body != null)
 					args.Add(methodDef.Body.ThisParameter);
 				else
@@ -1025,7 +1021,21 @@ namespace de4dot.blocks {
 				return parameters[index];
 			return null;
 		}
+#endif
 
+		public static Parameter getParameter(IList<Parameter> parameters, int index) {
+			if (0 <= index && index < parameters.Count)
+				return parameters[index];
+			return null;
+		}
+
+		public static TypeSig getArg(IList<TypeSig> args, int index) {
+			if (0 <= index && index < args.Count)
+				return args[index];
+			return null;
+		}
+
+#if PORT
 		public static List<TypeReference> getArgs(MethodReference method) {
 			var args = new List<TypeReference>(method.Parameters.Count + 1);
 			if (method.HasImplicitThis)
@@ -1034,7 +1044,19 @@ namespace de4dot.blocks {
 				args.Add(arg.ParameterType);
 			return args;
 		}
+#endif
 
+		public static List<TypeSig> getArgs(IMethod method) {
+			var sig = method.MethodSig;
+			var args = new List<TypeSig>(sig.Params.Count + 1);
+			if (sig.ImplicitThis)
+				args.Add(method.DeclaringType.ToTypeSig());
+			foreach (var arg in sig.Params)
+				args.Add(arg);
+			return args;
+		}
+
+#if PORT
 		public static TypeReference getArgType(MethodReference method, Instruction instr) {
 			return getArgType(getArgs(method), instr);
 		}
@@ -1055,45 +1077,54 @@ namespace de4dot.blocks {
 				count++;
 			return count;
 		}
+#endif
 
-		public static Instruction createLdci4(int value) {
-			if (value == -1) return Instruction.Create(OpCodes.Ldc_I4_M1);
-			if (value == 0) return Instruction.Create(OpCodes.Ldc_I4_0);
-			if (value == 1) return Instruction.Create(OpCodes.Ldc_I4_1);
-			if (value == 2) return Instruction.Create(OpCodes.Ldc_I4_2);
-			if (value == 3) return Instruction.Create(OpCodes.Ldc_I4_3);
-			if (value == 4) return Instruction.Create(OpCodes.Ldc_I4_4);
-			if (value == 5) return Instruction.Create(OpCodes.Ldc_I4_5);
-			if (value == 6) return Instruction.Create(OpCodes.Ldc_I4_6);
-			if (value == 7) return Instruction.Create(OpCodes.Ldc_I4_7);
-			if (value == 8) return Instruction.Create(OpCodes.Ldc_I4_8);
-			if (sbyte.MinValue <= value && value <= sbyte.MaxValue)
-				return Instruction.Create(OpCodes.Ldc_I4_S, (sbyte)value);
-			return Instruction.Create(OpCodes.Ldc_I4, value);
+		public static int getArgsCount(IMethod method) {
+			var sig = method.MethodSig;
+			if (sig == null)
+				return 0;
+			int count = sig.Params.Count;
+			if (sig.ImplicitThis)
+				count++;
+			return count;
 		}
 
-		// Doesn't fix everything (eg. T[] aren't replaced with eg. int[], but T -> int will be fixed)
-		public static IList<TypeReference> replaceGenericParameters(GenericInstanceType typeOwner, GenericInstanceMethod methodOwner, IList<TypeReference> types) {
-			//TODO: You should use MemberRefInstance.cs
+		public static IList<TypeSig> replaceGenericParameters(GenericInstSig typeOwner, MethodSpec methodOwner, IList<TypeSig> types) {
+			if (typeOwner == null && methodOwner == null)
+				return types;
 			for (int i = 0; i < types.Count; i++)
 				types[i] = getGenericArgument(typeOwner, methodOwner, types[i]);
 			return types;
 		}
 
-		public static TypeReference getGenericArgument(GenericInstanceType typeOwner, GenericInstanceMethod methodOwner, TypeReference type) {
-			var gp = type as GenericParameter;
-			if (gp == null)
-				return type;
-
-			if (typeOwner != null && MemberReferenceHelper.compareTypes(typeOwner.ElementType, gp.Owner as TypeReference))
-				return typeOwner.GenericArguments[gp.Position];
-
-			if (methodOwner != null && MemberReferenceHelper.compareMethodReferenceAndDeclaringType(methodOwner.ElementMethod, gp.Owner as MethodReference))
-				return methodOwner.GenericArguments[gp.Position];
-
-			return type;
+		public static TypeSig getGenericArgument(GenericInstSig typeOwner, MethodSpec methodOwner, TypeSig type) {
+			var typeArgs = typeOwner == null ? null : typeOwner.GenericArguments;
+			var genMethodArgs = methodOwner == null || methodOwner.GenericInstMethodSig == null ?
+						null : methodOwner.GenericInstMethodSig.GenericArguments;
+			return GenericArgsSubstitutor.create(type, typeArgs, genMethodArgs);
 		}
 
+#if PORT
+		public static Instruction getInstruction(IList<Instruction> instructions, ref int index) {
+			for (int i = 0; i < 10; i++) {
+				if (index < 0 || index >= instructions.Count)
+					return null;
+				var instr = instructions[index++];
+				if (instr.OpCode.Code == Code.Nop)
+					continue;
+				if (instr.OpCode.OpCodeType == OpCodeType.Prefix)
+					continue;
+				if (instr == null || (instr.OpCode.Code != Code.Br && instr.OpCode.Code != Code.Br_S))
+					return instr;
+				instr = instr.Operand as Instruction;
+				if (instr == null)
+					return null;
+				index = instructions.IndexOf(instr);
+			}
+			return null;
+		}
+#endif
+
 		public static Instruction getInstruction(IList<Instruction> instructions, ref int index) {
 			for (int i = 0; i < 10; i++) {
 				if (index < 0 || index >= instructions.Count)
@@ -1113,7 +1144,8 @@ namespace de4dot.blocks {
 			return null;
 		}
 
-		public static PropertyDefinition createPropertyDefinition(string name, TypeReference propType, MethodDefinition getter, MethodDefinition setter) {
+#if PORT
+		public static PropertyDefinition createPropertyDefinition(string name, TypeReference propType, MethodDef getter, MethodDef setter) {
 			return new PropertyDefinition(name, PropertyAttributes.None, propType) {
 				MetadataToken = nextPropertyToken(),
 				GetMethod = getter,
@@ -1181,14 +1213,23 @@ namespace de4dot.blocks {
 			typeRef.IsValueType = isValueType;
 			return typeRef;
 		}
+#endif
 
-		public static FrameworkType getFrameworkType(ModuleDefinition module) {
-			foreach (var modRef in module.AssemblyReferences) {
+		public static TypeDefOrRefSig findOrCreateTypeReference(ModuleDef module, AssemblyRef asmRef, string ns, string name, bool isValueType) {
+			var typeRef = module.UpdateRowId(new TypeRefUser(module, ns, name, asmRef));
+			if (isValueType)
+				return new ValueTypeSig(typeRef);
+			else
+				return new ClassSig(typeRef);
+		}
+
+		public static FrameworkType getFrameworkType(ModuleDefMD module) {
+			foreach (var modRef in module.GetAssemblyRefs()) {
 				if (modRef.Name != "mscorlib")
 					continue;
-				if (modRef.PublicKeyToken == null || modRef.PublicKeyToken.Length == 0)
+				if (PublicKeyBase.IsNullOrEmpty2(modRef.PublicKeyOrToken))
 					continue;
-				switch (BitConverter.ToString(modRef.PublicKeyToken).Replace("-", "").ToLowerInvariant()) {
+				switch (BitConverter.ToString(modRef.PublicKeyOrToken.Data).Replace("-", "").ToLowerInvariant()) {
 				case "b77a5c561934e089":
 					return FrameworkType.Desktop;
 				case "7cec85d7bea7798e":
@@ -1205,14 +1246,32 @@ namespace de4dot.blocks {
 			return FrameworkType.Unknown;
 		}
 
-		public static bool callsMethod(MethodDefinition method, string methodFullName) {
+		public static int getMethodCalls(MethodDef method, string methodFullName) {
+			if (method == null || method.Body == null)
+				return 0;
+
+			int count = 0;
+			foreach (var instr in method.Body.Instructions) {
+				if (instr.OpCode.Code != Code.Call && instr.OpCode.Code != Code.Callvirt && instr.OpCode.Code != Code.Newobj)
+					continue;
+				var calledMethod = instr.Operand as IMethod;
+				if (calledMethod == null)
+					continue;
+				if (calledMethod.FullName == methodFullName)
+					count++;
+			}
+
+			return count;
+		}
+
+		public static bool callsMethod(MethodDef method, string methodFullName) {
 			if (method == null || method.Body == null)
 				return false;
 
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Call && instr.OpCode.Code != Code.Callvirt && instr.OpCode.Code != Code.Newobj)
 					continue;
-				var calledMethod = instr.Operand as MethodReference;
+				var calledMethod = instr.Operand as IMethod;
 				if (calledMethod == null)
 					continue;
 				if (calledMethod.FullName == methodFullName)
@@ -1222,14 +1281,14 @@ namespace de4dot.blocks {
 			return false;
 		}
 
-		public static bool callsMethod(MethodDefinition method, string returnType, string parameters) {
+		public static bool callsMethod(MethodDef method, string returnType, string parameters) {
 			if (method == null || method.Body == null)
 				return false;
 
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Call && instr.OpCode.Code != Code.Callvirt && instr.OpCode.Code != Code.Newobj)
 					continue;
-				if (isMethod(instr.Operand as MethodReference, returnType, parameters))
+				if (isMethod(instr.Operand as IMethod, returnType, parameters))
 					return true;
 			}
 
@@ -1245,7 +1304,7 @@ namespace de4dot.blocks {
 				return null;
 			var startInstr = instrs[index];
 			int pushes, pops;
-			calculateStackUsage(startInstr, false, out pushes, out pops);
+			startInstr.CalculateStackUsage(false, out pushes, out pops);
 
 			index--;
 			int numArgs = pops;
@@ -1253,7 +1312,7 @@ namespace de4dot.blocks {
 			int stackSize = numArgs;
 			while (index >= 0 && args.Count != numArgs) {
 				var instr = instrs[index--];
-				calculateStackUsage(instr, false, out pushes, out pops);
+				instr.CalculateStackUsage(false, out pushes, out pops);
 				if (instr.OpCode.Code == Code.Dup) {
 					args.Add(instr);
 					stackSize--;
@@ -1281,6 +1340,7 @@ namespace de4dot.blocks {
 			return args;
 		}
 
+#if PORT
 		public static AssemblyNameReference addAssemblyReference(ModuleDefinition module, AssemblyNameReference asmRef) {
 			foreach (var modAsmRef in module.AssemblyReferences) {
 				if (modAsmRef.FullName == asmRef.FullName)
@@ -1302,5 +1362,6 @@ namespace de4dot.blocks {
 			module.ModuleReferences.Add(newModRef);
 			return newModRef;
 		}
+#endif
 	}
 }
diff --git a/blocks/DumpedMethod.cs b/blocks/DumpedMethod.cs
new file mode 100644
index 00000000..79e4b145
--- /dev/null
+++ b/blocks/DumpedMethod.cs
@@ -0,0 +1,42 @@
+/*
+    Copyright (C) 2011-2012 de4dot@gmail.com
+
+    This file is part of de4dot.
+
+    de4dot is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    de4dot is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+using System;
+
+namespace de4dot.blocks {
+	[Serializable]
+	public class DumpedMethod {
+		public ushort mhFlags;			// method header Flags
+		public ushort mhMaxStack;		// method header MaxStack
+		public uint mhCodeSize;			// method header CodeSize
+		public uint mhLocalVarSigTok;	// method header LocalVarSigTok
+
+		public uint mdRVA;				// methodDef RVA
+		public ushort mdImplFlags;		// methodDef ImplFlags
+		public ushort mdFlags;			// methodDef Flags
+		public uint mdName;				// methodDef Name (index into #String)
+		public uint mdSignature;		// methodDef Signature (index into #Blob)
+		public uint mdParamList;		// methodDef ParamList (index into Param table)
+
+		public uint token;				// metadata token
+
+		public byte[] code;
+		public byte[] extraSections;
+	}
+}
diff --git a/blocks/DumpedMethods.cs b/blocks/DumpedMethods.cs
new file mode 100644
index 00000000..322bc979
--- /dev/null
+++ b/blocks/DumpedMethods.cs
@@ -0,0 +1,54 @@
+/*
+    Copyright (C) 2011-2012 de4dot@gmail.com
+
+    This file is part of de4dot.
+
+    de4dot is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    de4dot is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+using System;
+using System.Collections.Generic;
+using dot10.DotNet.MD;
+using dot10.DotNet;
+
+namespace de4dot.blocks {
+	[Serializable]
+	public class DumpedMethods {
+		Dictionary<uint, DumpedMethod> methods = new Dictionary<uint, DumpedMethod>();
+
+		public int Count {
+			get { return methods.Count; }
+		}
+
+		public void add(uint token, DumpedMethod info) {
+			methods[token] = info;
+		}
+
+		public DumpedMethod get(MethodDef method) {
+			return get(method.MDToken.ToUInt32());
+		}
+
+		public DumpedMethod get(uint token) {
+			DumpedMethod dm;
+			methods.TryGetValue(token, out dm);
+			return dm;
+		}
+
+		public void add(DumpedMethod dm) {
+			if (MDToken.ToTable(dm.token) != Table.Method || MDToken.ToRID(dm.token) == 0)
+				throw new ArgumentException("Invalid token");
+			methods[dm.token] = dm;
+		}
+	}
+}
diff --git a/blocks/FilterHandlerBlock.cs b/blocks/FilterHandlerBlock.cs
index 24470c1a..63018be8 100644
--- a/blocks/FilterHandlerBlock.cs
+++ b/blocks/FilterHandlerBlock.cs
@@ -18,8 +18,6 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
 
 namespace de4dot.blocks {
 	public class FilterHandlerBlock : ScopeBlock {
diff --git a/blocks/ForwardScanOrder.cs b/blocks/ForwardScanOrder.cs
index 3ba0635d..751608ca 100644
--- a/blocks/ForwardScanOrder.cs
+++ b/blocks/ForwardScanOrder.cs
@@ -19,8 +19,6 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
 
 namespace de4dot.blocks {
 	// This class makes sure that each block that is entered with a non-empty stack has at
@@ -52,7 +50,7 @@ namespace de4dot.blocks {
 
 				int stack = stackStart;
 				foreach (var instr in block.Instructions)
-					DotNetUtils.updateStack(instr.Instruction, ref stack, false);
+					instr.Instruction.UpdateStack(ref stack, false);
 				stackEnd = stack;
 			}
 		}
diff --git a/blocks/GenericArgsSubstitutor.cs b/blocks/GenericArgsSubstitutor.cs
new file mode 100644
index 00000000..8dd7fe50
--- /dev/null
+++ b/blocks/GenericArgsSubstitutor.cs
@@ -0,0 +1,313 @@
+/*
+    Copyright (C) 2011-2012 de4dot@gmail.com
+
+    This file is part of de4dot.
+
+    de4dot is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    de4dot is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+using System.Collections.Generic;
+using dot10.DotNet;
+
+namespace de4dot.blocks {
+	public struct GenericArgsSubstitutor {
+		IList<TypeSig> genericArgs;
+		IList<TypeSig> genericMethodArgs;
+		bool updated;
+
+		public static ITypeDefOrRef create(ITypeDefOrRef type, GenericInstSig git) {
+			if (git == null)
+				return type;
+			return create(type, git.GenericArguments);
+		}
+
+		public static ITypeDefOrRef create(ITypeDefOrRef type, IList<TypeSig> genericArgs) {
+			if (genericArgs == null || genericArgs.Count == 0)
+				return type;
+			var ts = type as TypeSpec;
+			if (ts == null)
+				return type;
+			var newSig = create(ts.TypeSig, genericArgs);
+			return newSig == ts.TypeSig ? type : new TypeSpecUser(newSig);
+		}
+
+		public static TypeSig create(TypeSig type, IList<TypeSig> genericArgs) {
+			if (type == null || genericArgs == null || genericArgs.Count == 0)
+				return type;
+			return new GenericArgsSubstitutor(genericArgs).create(type);
+		}
+
+		public static TypeSig create(TypeSig type, IList<TypeSig> genericArgs, IList<TypeSig> genericMethodArgs) {
+			if (type == null || ((genericArgs == null || genericArgs.Count == 0) &&
+				(genericMethodArgs == null || genericMethodArgs.Count == 0)))
+				return type;
+			return new GenericArgsSubstitutor(genericArgs, genericMethodArgs).create(type);
+		}
+
+		public static IField create(IField field, GenericInstSig git) {
+			if (git == null)
+				return field;
+			return create(field, git.GenericArguments);
+		}
+
+		public static IField create(IField field, IList<TypeSig> genericArgs) {
+			if (field == null || genericArgs == null || genericArgs.Count == 0)
+				return field;
+			var newSig = create(field.FieldSig, genericArgs);
+			if (newSig == field.FieldSig)
+				return field;
+			var module = field.DeclaringType != null ? field.DeclaringType.Module : null;
+			return new MemberRefUser(module, field.Name, newSig, field.DeclaringType);
+		}
+
+		public static FieldSig create(FieldSig sig, GenericInstSig git) {
+			if (git == null)
+				return sig;
+			return create(sig, git.GenericArguments);
+		}
+
+		public static FieldSig create(FieldSig sig, IList<TypeSig> genericArgs) {
+			if (sig == null || genericArgs == null || genericArgs.Count == 0)
+				return sig;
+			return new GenericArgsSubstitutor(genericArgs).create(sig);
+		}
+
+		public static IMethod create(IMethod method, GenericInstSig git) {
+			if (git == null)
+				return method;
+
+			var mdr = method as IMethodDefOrRef;
+			if (mdr != null)
+				return create(mdr, git);
+
+			var ms = method as MethodSpec;
+			if (ms != null)
+				return create(ms, git);
+
+			return method;
+		}
+
+		public static MethodSpec create(MethodSpec method, GenericInstSig git) {
+			if (method == null || git == null)
+				return method;
+			var newMethod = create(method.Method, git);
+			var newInst = create(method.GenericInstMethodSig, git);
+			bool updated = newMethod != method.Method || newInst != method.GenericInstMethodSig;
+			return updated ? new MethodSpecUser(newMethod, newInst) : method;
+		}
+
+		public static GenericInstMethodSig create(GenericInstMethodSig sig, GenericInstSig git) {
+			if (git == null)
+				return sig;
+			return create(sig, git.GenericArguments);
+		}
+
+		public static GenericInstMethodSig create(GenericInstMethodSig sig, IList<TypeSig> genericArgs) {
+			if (sig == null || genericArgs == null || genericArgs.Count == 0)
+				return sig;
+			return new GenericArgsSubstitutor(genericArgs).create(sig);
+		}
+
+		public static IMethodDefOrRef create(IMethodDefOrRef method, GenericInstSig git) {
+			if (git == null)
+				return method;
+			return create(method, git.GenericArguments);
+		}
+
+		public static IMethodDefOrRef create(IMethodDefOrRef method, IList<TypeSig> genericArgs) {
+			return create(method, genericArgs, null);
+		}
+
+		public static IMethodDefOrRef create(IMethodDefOrRef method, GenericInstSig git, IList<TypeSig> genericMethodArgs) {
+			return create(method, git == null ? null : git.GenericArguments, genericMethodArgs);
+		}
+
+		// Creates a new method but keeps declaring type as is
+		public static IMethodDefOrRef create(IMethodDefOrRef method, IList<TypeSig> genericArgs, IList<TypeSig> genericMethodArgs) {
+			if (method == null)
+				return method;
+			if ((genericArgs == null || genericArgs.Count == 0) && (genericMethodArgs == null || genericMethodArgs.Count == 0))
+				return method;
+
+			var sig = method.MethodSig;
+			if (sig == null)
+				return method;
+
+			var newSig = new GenericArgsSubstitutor(genericArgs, genericMethodArgs).create(sig);
+			if (newSig == sig)
+				return method;
+
+			return new MemberRefUser(method.DeclaringType.Module, method.Name, newSig, method.DeclaringType);
+		}
+
+		GenericArgsSubstitutor(IList<TypeSig> genericArgs) {
+			this.genericArgs = genericArgs;
+			this.genericMethodArgs = null;
+			this.updated = false;
+		}
+
+		GenericArgsSubstitutor(IList<TypeSig> genericArgs, IList<TypeSig> genericMethodArgs) {
+			this.genericArgs = genericArgs;
+			this.genericMethodArgs = genericMethodArgs;
+			this.updated = false;
+		}
+
+		TypeSig create(TypeSig type) {
+			var newType = create2(type);
+			return updated ? newType : type;
+		}
+
+		TypeSig create2(TypeSig type) {
+			if (type == null)
+				return type;
+			TypeSig result;
+
+			GenericSig varSig;
+			switch (type.ElementType) {
+			case ElementType.Void:
+			case ElementType.Boolean:
+			case ElementType.Char:
+			case ElementType.I1:
+			case ElementType.U1:
+			case ElementType.I2:
+			case ElementType.U2:
+			case ElementType.I4:
+			case ElementType.U4:
+			case ElementType.I8:
+			case ElementType.U8:
+			case ElementType.R4:
+			case ElementType.R8:
+			case ElementType.String:
+			case ElementType.TypedByRef:
+			case ElementType.I:
+			case ElementType.U:
+			case ElementType.Object:
+				result = type;
+				break;
+
+			case ElementType.Ptr:
+				result = new PtrSig(create2(type.Next));
+				break;
+
+			case ElementType.ByRef:
+				result = new ByRefSig(create2(type.Next));
+				break;
+
+			case ElementType.Array:
+				var ary = (ArraySig)type;
+				result = new ArraySig(ary.Next, ary.Rank, ary.Sizes, ary.LowerBounds);
+				break;
+
+			case ElementType.SZArray:
+				result = new SZArraySig(create2(type.Next));
+				break;
+
+			case ElementType.Pinned:
+				result = new PinnedSig(create2(type.Next));
+				break;
+
+			case ElementType.ValueType:
+			case ElementType.Class:
+				result = type;
+				break;
+
+			case ElementType.Var:
+				varSig = (GenericSig)type;
+				if (genericArgs != null && varSig.Number < (uint)genericArgs.Count) {
+					result = genericArgs[(int)varSig.Number];
+					updated = true;
+				}
+				else
+					result = type;
+				break;
+
+			case ElementType.MVar:
+				varSig = (GenericSig)type;
+				if (genericMethodArgs != null && varSig.Number < (uint)genericMethodArgs.Count) {
+					result = genericMethodArgs[(int)varSig.Number];
+					updated = true;
+				}
+				else
+					result = type;
+				break;
+
+			case ElementType.GenericInst:
+				var gis = (GenericInstSig)type;
+				var newGis = new GenericInstSig(create2(gis.GenericType) as ClassOrValueTypeSig, gis.GenericArguments.Count);
+				for (int i = 0; i < gis.GenericArguments.Count; i++)
+					newGis.GenericArguments.Add(create2(gis.GenericArguments[i]));
+				result = newGis;
+				break;
+
+			case ElementType.ValueArray:
+				result = new ValueArraySig(type.Next, ((ValueArraySig)type).Size);
+				break;
+
+			case ElementType.Module:
+				result = new ModuleSig(((ModuleSig)type).Index, type.Next);
+				break;
+
+			case ElementType.CModReqd:
+				result = new CModReqdSig(((ModifierSig)type).Modifier, type.Next);
+				break;
+
+			case ElementType.CModOpt:
+				result = new CModOptSig(((ModifierSig)type).Modifier, type.Next);
+				break;
+
+			case ElementType.FnPtr:
+				result = new FnPtrSig(create(((FnPtrSig)type).MethodSig));
+				break;
+
+			case ElementType.End:
+			case ElementType.R:
+			case ElementType.Sentinel:
+			case ElementType.Internal:
+			default:
+				result = type;
+				break;
+			}
+
+			return result;
+		}
+
+		MethodSig create(MethodSig sig) {
+			if (sig == null)
+				return sig;
+			var newSig = new MethodSig(sig.GetCallingConvention());
+			newSig.RetType = create2(sig.RetType);
+			for (int i = 0; i < sig.Params.Count; i++)
+				newSig.Params.Add(create2(sig.Params[i]));
+			newSig.GenParamCount = sig.GenParamCount;
+			if (sig.ParamsAfterSentinel != null) {
+				newSig.ParamsAfterSentinel = new List<TypeSig>();
+				for (int i = 0; i < sig.ParamsAfterSentinel.Count; i++)
+					newSig.ParamsAfterSentinel.Add(create2(sig.ParamsAfterSentinel[i]));
+			}
+			return updated ? newSig : sig;
+		}
+
+		GenericInstMethodSig create(GenericInstMethodSig sig) {
+			var newSig = new GenericInstMethodSig();
+			for (int i = 0; i < sig.GenericArguments.Count; i++)
+				newSig.GenericArguments.Add(create2(sig.GenericArguments[i]));
+			return updated ? newSig : sig;
+		}
+
+		FieldSig create(FieldSig sig) {
+			var newSig = new FieldSig(create2(sig.Type));
+			return updated ? newSig : sig;
+		}
+	}
+}
diff --git a/blocks/HandlerBlock.cs b/blocks/HandlerBlock.cs
index 9b23d21b..7b53c88f 100644
--- a/blocks/HandlerBlock.cs
+++ b/blocks/HandlerBlock.cs
@@ -18,8 +18,6 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
 
 namespace de4dot.blocks {
 	// This is the block inside catch(xxx) { }.
diff --git a/blocks/Instr.cs b/blocks/Instr.cs
index 536a9c9c..9afb9c27 100644
--- a/blocks/Instr.cs
+++ b/blocks/Instr.cs
@@ -18,8 +18,8 @@
 */
 
 using System;
-using Mono.Cecil.Cil;
 using System.Collections.Generic;
+using dot10.DotNet.Emit;
 
 namespace de4dot.blocks {
 	public class Instr {
@@ -44,8 +44,8 @@ namespace de4dot.blocks {
 
 		// Returns the variable or null if it's not a ldloc/stloc instruction. It does not return
 		// a local variable if it's a ldloca/ldloca.s instruction.
-		public static VariableDefinition getLocalVar(IList<VariableDefinition> locals, Instr instr) {
-			return DotNetUtils.getLocalVar(locals, instr.Instruction);
+		public static Local getLocalVar(IList<Local> locals, Instr instr) {
+			return instr.Instruction.GetLocal(locals);
 		}
 
 		static public bool isFallThrough(OpCode opCode) {
@@ -104,23 +104,23 @@ namespace de4dot.blocks {
 		}
 
 		public bool isLdcI4() {
-			return DotNetUtils.isLdcI4(OpCode.Code);
+			return instruction.IsLdcI4();
 		}
 
 		public int getLdcI4Value() {
-			return DotNetUtils.getLdcI4Value(instruction);
+			return instruction.GetLdcI4Value();
 		}
 
 		public bool isLdarg() {
-			return DotNetUtils.isLdarg(instruction);
+			return instruction.IsLdarg();
 		}
 
 		public bool isStloc() {
-			return DotNetUtils.isStloc(instruction);
+			return instruction.IsStloc();
 		}
 
 		public bool isLdloc() {
-			return DotNetUtils.isLdloc(instruction);
+			return instruction.IsLdloc();
 		}
 
 		public bool isNop() {
@@ -132,23 +132,23 @@ namespace de4dot.blocks {
 		}
 
 		public bool isLeave() {
-			return DotNetUtils.isLeave(instruction);
+			return instruction.IsLeave();
 		}
 
 		public bool isBr() {
-			return DotNetUtils.isBr(instruction);
+			return instruction.IsBr();
 		}
 
 		public bool isBrfalse() {
-			return DotNetUtils.isBrfalse(instruction);
+			return instruction.IsBrfalse();
 		}
 
 		public bool isBrtrue() {
-			return DotNetUtils.isBrtrue(instruction);
+			return instruction.IsBrtrue();
 		}
 
 		public bool isConditionalBranch() {
-			return DotNetUtils.isConditionalBranch(OpCode.Code);
+			return instruction.IsConditionalBranch();
 		}
 
 		public bool getFlippedBranchOpCode(out OpCode opcode) {
diff --git a/blocks/InstructionListParser.cs b/blocks/InstructionListParser.cs
index 33288f03..82de56e3 100644
--- a/blocks/InstructionListParser.cs
+++ b/blocks/InstructionListParser.cs
@@ -19,7 +19,7 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil.Cil;
+using dot10.DotNet.Emit;
 
 namespace de4dot.blocks {
 	class InstructionListParser {
diff --git a/blocks/MemberDefDict.cs b/blocks/MemberDefDict.cs
new file mode 100644
index 00000000..28a4b465
--- /dev/null
+++ b/blocks/MemberDefDict.cs
@@ -0,0 +1,736 @@
+/*
+    Copyright (C) 2011-2012 de4dot@gmail.com
+
+    This file is part of de4dot.
+
+    de4dot is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    de4dot is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+using System;
+using System.Collections.Generic;
+using dot10.DotNet;
+
+namespace de4dot.blocks {
+	public class TypeDefinitionDict<TValue> {
+		Dictionary<ScopeAndTokenKey, TValue> tokenToValue = new Dictionary<ScopeAndTokenKey, TValue>();
+		Dictionary<ScopeAndTokenKey, TypeDef> tokenToKey = new Dictionary<ScopeAndTokenKey, TypeDef>();
+		Dictionary<IType, TValue> refToValue = new Dictionary<IType, TValue>(TypeEqualityComparer.Instance);
+		Dictionary<IType, TypeDef> refToKey = new Dictionary<IType, TypeDef>(TypeEqualityComparer.Instance);
+
+		public int Count {
+			get { return tokenToValue.Count; }
+		}
+
+		public IEnumerable<TypeDef> getKeys() {
+			return tokenToKey.Values;
+		}
+
+		public IEnumerable<TValue> getValues() {
+			return tokenToValue.Values;
+		}
+
+		ScopeAndTokenKey getTokenKey(TypeDef typeDef) {
+			return new ScopeAndTokenKey(typeDef);
+		}
+
+		public TValue find(IType typeRef) {
+			TValue value;
+			var typeDef = typeRef as TypeDef;
+			if (typeDef != null)
+				tokenToValue.TryGetValue(getTokenKey(typeDef), out value);
+			else if (typeRef != null)
+				refToValue.TryGetValue(typeRef, out value);
+			else
+				value = default(TValue);
+			return value;
+		}
+
+		public TValue findAny(IType type) {
+			TValue value;
+			var typeDef = type as TypeDef;
+			if (typeDef != null && tokenToValue.TryGetValue(getTokenKey(typeDef), out value))
+				return value;
+
+			refToValue.TryGetValue(type, out value);
+			return value;
+		}
+
+		public void add(TypeDef typeDef, TValue value) {
+			var tokenKey = getTokenKey(typeDef);
+			tokenToValue[tokenKey] = value;
+			tokenToKey[tokenKey] = typeDef;
+
+			if (!refToValue.ContainsKey(typeDef) ||
+				getAccessibilityOrder(typeDef) < getAccessibilityOrder(refToKey[typeDef])) {
+				refToKey[typeDef] = typeDef;
+				refToValue[typeDef] = value;
+			}
+		}
+
+		// Order: public, family, assembly, private
+		static int[] accessibilityOrder = new int[8] {
+			40,		// NotPublic
+			0,		// Public
+			10,		// NestedPublic
+			70,		// NestedPrivate
+			20,		// NestedFamily
+			50,		// NestedAssembly
+			60,		// NestedFamANDAssem
+			30,		// NestedFamORAssem
+		};
+		static int getAccessibilityOrder(TypeDef typeDef) {
+			return accessibilityOrder[(int)typeDef.Attributes & 7];
+		}
+
+		public void onTypesRenamed() {
+			var newTypeRefToValue = new Dictionary<IType, TValue>(refToValue.Count);
+			foreach (var kvp in refToValue)
+				newTypeRefToValue[kvp.Key] = kvp.Value;
+			refToValue = newTypeRefToValue;
+		}
+	}
+
+	public abstract class FieldDefinitionDictBase<TValue> {
+		Dictionary<ScopeAndTokenKey, TValue> tokenToValue = new Dictionary<ScopeAndTokenKey, TValue>();
+		Dictionary<ScopeAndTokenKey, FieldDef> tokenToKey = new Dictionary<ScopeAndTokenKey, FieldDef>();
+		Dictionary<IFieldReferenceKey, TValue> refToValue = new Dictionary<IFieldReferenceKey, TValue>();
+		Dictionary<IFieldReferenceKey, FieldDef> refToKey = new Dictionary<IFieldReferenceKey, FieldDef>();
+
+		public int Count {
+			get { return tokenToValue.Count; }
+		}
+
+		public IEnumerable<FieldDef> getKeys() {
+			return tokenToKey.Values;
+		}
+
+		public IEnumerable<TValue> getValues() {
+			return tokenToValue.Values;
+		}
+
+		ScopeAndTokenKey getTokenKey(FieldDef fieldDef) {
+			return new ScopeAndTokenKey(fieldDef);
+		}
+
+		internal abstract IFieldReferenceKey getReferenceKey(IField fieldRef);
+
+		public TValue find(IField fieldRef) {
+			TValue value;
+			var fieldDef = fieldRef as FieldDef;
+			if (fieldDef != null)
+				tokenToValue.TryGetValue(getTokenKey(fieldDef), out value);
+			else
+				refToValue.TryGetValue(getReferenceKey(fieldRef), out value);
+			return value;
+		}
+
+		public TValue findAny(IField fieldRef) {
+			TValue value;
+			var fieldDef = fieldRef as FieldDef;
+			if (fieldDef != null && tokenToValue.TryGetValue(getTokenKey(fieldDef), out value))
+				return value;
+
+			refToValue.TryGetValue(getReferenceKey(fieldRef), out value);
+			return value;
+		}
+
+		public void add(FieldDef fieldDef, TValue value) {
+			var tokenKey = getTokenKey(fieldDef);
+			tokenToValue[tokenKey] = value;
+			tokenToKey[tokenKey] = fieldDef;
+
+			var refKey = getReferenceKey(fieldDef);
+			if (!refToValue.ContainsKey(refKey) ||
+				getAccessibilityOrder(fieldDef) < getAccessibilityOrder(refToKey[refKey])) {
+				refToKey[refKey] = fieldDef;
+				refToValue[refKey] = value;
+			}
+		}
+
+		// Order: public, family, assembly, private
+		static int[] accessibilityOrder = new int[8] {
+			60,		// PrivateScope
+			50,		// Private
+			40,		// FamANDAssem
+			30,		// Assembly
+			10,		// Family
+			20,		// FamORAssem
+			0,		// Public
+			70,		// <reserved>
+		};
+		static int getAccessibilityOrder(FieldDef fieldDefinition) {
+			return accessibilityOrder[(int)fieldDefinition.Attributes & 7];
+		}
+
+		public void onTypesRenamed() {
+			var newFieldRefToDef = new Dictionary<IFieldReferenceKey, TValue>(refToValue.Count);
+			foreach (var kvp in refToValue)
+				newFieldRefToDef[getReferenceKey((FieldDef)kvp.Key.FieldReference)] = kvp.Value;
+			refToValue = newFieldRefToDef;
+		}
+	}
+
+	public class FieldDefinitionDict<TValue> : FieldDefinitionDictBase<TValue> {
+		internal override IFieldReferenceKey getReferenceKey(IField fieldRef) {
+			return new FieldReferenceKey(fieldRef);
+		}
+	}
+
+	public class FieldDefinitionAndDeclaringTypeDict<TValue> : FieldDefinitionDictBase<TValue> {
+		internal override IFieldReferenceKey getReferenceKey(IField fieldRef) {
+			return new FieldReferenceAndDeclaringTypeKey(fieldRef);
+		}
+	}
+
+	public abstract class MethodDefinitionDictBase<TValue> {
+		Dictionary<ScopeAndTokenKey, TValue> tokenToValue = new Dictionary<ScopeAndTokenKey, TValue>();
+		Dictionary<ScopeAndTokenKey, MethodDef> tokenToKey = new Dictionary<ScopeAndTokenKey, MethodDef>();
+		Dictionary<IMethodReferenceKey, TValue> refToValue = new Dictionary<IMethodReferenceKey, TValue>();
+		Dictionary<IMethodReferenceKey, MethodDef> refToKey = new Dictionary<IMethodReferenceKey, MethodDef>();
+
+		public int Count {
+			get { return tokenToValue.Count; }
+		}
+
+		public IEnumerable<MethodDef> getKeys() {
+			return tokenToKey.Values;
+		}
+
+		public IEnumerable<TValue> getValues() {
+			return tokenToValue.Values;
+		}
+
+		ScopeAndTokenKey getTokenKey(MethodDef methodDef) {
+			return new ScopeAndTokenKey(methodDef);
+		}
+
+		internal abstract IMethodReferenceKey getReferenceKey(IMethod methodRef);
+
+		public TValue find(IMethod methodRef) {
+			TValue value;
+			var methodDef = methodRef as MethodDef;
+			if (methodDef != null)
+				tokenToValue.TryGetValue(getTokenKey(methodDef), out value);
+			else
+				refToValue.TryGetValue(getReferenceKey(methodRef), out value);
+			return value;
+		}
+
+		public TValue findAny(IMethod methodRef) {
+			TValue value;
+			var methodDef = methodRef as MethodDef;
+			if (methodDef != null && tokenToValue.TryGetValue(getTokenKey(methodDef), out value))
+				return value;
+
+			refToValue.TryGetValue(getReferenceKey(methodRef), out value);
+			return value;
+		}
+
+		public void add(MethodDef methodDef, TValue value) {
+			var tokenKey = getTokenKey(methodDef);
+			tokenToValue[tokenKey] = value;
+			tokenToKey[tokenKey] = methodDef;
+
+			var refKey = getReferenceKey(methodDef);
+			if (!refToValue.ContainsKey(refKey) ||
+				getAccessibilityOrder(methodDef) < getAccessibilityOrder(refToKey[refKey])) {
+				refToKey[refKey] = methodDef;
+				refToValue[refKey] = value;
+			}
+		}
+
+		// Order: public, family, assembly, private
+		static int[] accessibilityOrder = new int[8] {
+			60,		// PrivateScope
+			50,		// Private
+			40,		// FamANDAssem
+			30,		// Assembly
+			10,		// Family
+			20,		// FamORAssem
+			0,		// Public
+			70,		// <reserved>
+		};
+		static int getAccessibilityOrder(MethodDef methodDefinition) {
+			return accessibilityOrder[(int)methodDefinition.Attributes & 7];
+		}
+
+		public void onTypesRenamed() {
+			var newFieldRefToDef = new Dictionary<IMethodReferenceKey, TValue>(refToValue.Count);
+			foreach (var kvp in refToValue)
+				newFieldRefToDef[getReferenceKey((MethodDef)kvp.Key.MethodReference)] = kvp.Value;
+			refToValue = newFieldRefToDef;
+		}
+	}
+
+	public class MethodDefinitionDict<TValue> : MethodDefinitionDictBase<TValue> {
+		internal override IMethodReferenceKey getReferenceKey(IMethod methodRef) {
+			return new MethodReferenceKey(methodRef);
+		}
+	}
+
+	public class MethodDefinitionAndDeclaringTypeDict<TValue> : MethodDefinitionDictBase<TValue> {
+		internal override IMethodReferenceKey getReferenceKey(IMethod methodRef) {
+			return new MethodReferenceAndDeclaringTypeKey(methodRef);
+		}
+	}
+
+	public abstract class EventDefinitionDictBase<TValue> {
+		Dictionary<ScopeAndTokenKey, TValue> tokenToValue = new Dictionary<ScopeAndTokenKey, TValue>();
+		Dictionary<ScopeAndTokenKey, EventDef> tokenToKey = new Dictionary<ScopeAndTokenKey, EventDef>();
+		Dictionary<IEventReferenceKey, TValue> refToValue = new Dictionary<IEventReferenceKey, TValue>();
+
+		public int Count {
+			get { return tokenToValue.Count; }
+		}
+
+		public IEnumerable<EventDef> getKeys() {
+			return tokenToKey.Values;
+		}
+
+		public IEnumerable<TValue> getValues() {
+			return tokenToValue.Values;
+		}
+
+		ScopeAndTokenKey getTokenKey(EventDef eventReference) {
+			return new ScopeAndTokenKey(eventReference);
+		}
+
+		internal abstract IEventReferenceKey getReferenceKey(EventDef eventRef);
+
+		public TValue find(EventDef eventRef) {
+			TValue value;
+			tokenToValue.TryGetValue(getTokenKey(eventRef), out value);
+			return value;
+		}
+
+		public TValue findAny(EventDef eventRef) {
+			TValue value;
+			if (tokenToValue.TryGetValue(getTokenKey(eventRef), out value))
+				return value;
+
+			refToValue.TryGetValue(getReferenceKey(eventRef), out value);
+			return value;
+		}
+
+		public void add(EventDef eventDef, TValue value) {
+			var tokenKey = getTokenKey(eventDef);
+			tokenToValue[tokenKey] = value;
+			tokenToKey[tokenKey] = eventDef;
+
+			refToValue[getReferenceKey(eventDef)] = value;
+		}
+
+		public void onTypesRenamed() {
+			var newFieldRefToDef = new Dictionary<IEventReferenceKey, TValue>(refToValue.Count);
+			foreach (var kvp in refToValue)
+				newFieldRefToDef[getReferenceKey((EventDef)kvp.Key.EventDef)] = kvp.Value;
+			refToValue = newFieldRefToDef;
+		}
+	}
+
+	public class EventDefinitionDict<TValue> : EventDefinitionDictBase<TValue> {
+		internal override IEventReferenceKey getReferenceKey(EventDef eventRef) {
+			return new EventReferenceKey(eventRef);
+		}
+	}
+
+	public class EventDefinitionAndDeclaringTypeDict<TValue> : EventDefinitionDictBase<TValue> {
+		internal override IEventReferenceKey getReferenceKey(EventDef eventRef) {
+			return new EventReferenceAndDeclaringTypeKey(eventRef);
+		}
+	}
+
+	public abstract class PropertyDefinitionDictBase<TValue> {
+		Dictionary<ScopeAndTokenKey, TValue> tokenToValue = new Dictionary<ScopeAndTokenKey, TValue>();
+		Dictionary<ScopeAndTokenKey, PropertyDef> tokenToKey = new Dictionary<ScopeAndTokenKey, PropertyDef>();
+		Dictionary<IPropertyReferenceKey, TValue> refToValue = new Dictionary<IPropertyReferenceKey, TValue>();
+
+		public int Count {
+			get { return tokenToValue.Count; }
+		}
+
+		public IEnumerable<PropertyDef> getKeys() {
+			return tokenToKey.Values;
+		}
+
+		public IEnumerable<TValue> getValues() {
+			return tokenToValue.Values;
+		}
+
+		ScopeAndTokenKey getTokenKey(PropertyDef propertyReference) {
+			return new ScopeAndTokenKey(propertyReference);
+		}
+
+		internal abstract IPropertyReferenceKey getReferenceKey(PropertyDef propertyReference);
+
+		public TValue find(PropertyDef propRef) {
+			TValue value;
+			tokenToValue.TryGetValue(getTokenKey(propRef), out value);
+			return value;
+		}
+
+		public TValue findAny(PropertyDef propRef) {
+			TValue value;
+			if (tokenToValue.TryGetValue(getTokenKey(propRef), out value))
+				return value;
+
+			refToValue.TryGetValue(getReferenceKey(propRef), out value);
+			return value;
+		}
+
+		public void add(PropertyDef propDef, TValue value) {
+			var tokenKey = getTokenKey(propDef);
+			tokenToValue[tokenKey] = value;
+			tokenToKey[tokenKey] = propDef;
+
+			refToValue[getReferenceKey(propDef)] = value;
+		}
+
+		public void onTypesRenamed() {
+			var newFieldRefToDef = new Dictionary<IPropertyReferenceKey, TValue>(refToValue.Count);
+			foreach (var kvp in refToValue)
+				newFieldRefToDef[getReferenceKey((PropertyDef)kvp.Key.PropertyDef)] = kvp.Value;
+			refToValue = newFieldRefToDef;
+		}
+	}
+
+	public class PropertyDefinitionDict<TValue> : PropertyDefinitionDictBase<TValue> {
+		internal override IPropertyReferenceKey getReferenceKey(PropertyDef propRef) {
+			return new PropertyReferenceKey(propRef);
+		}
+	}
+
+	public class PropertyDefinitionAndDeclaringTypeDict<TValue> : PropertyDefinitionDictBase<TValue> {
+		internal override IPropertyReferenceKey getReferenceKey(PropertyDef propRef) {
+			return new PropertyReferenceAndDeclaringTypeKey(propRef);
+		}
+	}
+
+	sealed class ScopeAndTokenKey {
+		readonly IScope scope;
+		readonly uint token;
+
+		public ScopeAndTokenKey(TypeDef type)
+			: this(type.Module, type.MDToken.Raw) {
+		}
+
+		public ScopeAndTokenKey(FieldDef field)
+			: this(field.DeclaringType == null ? null : field.DeclaringType.Module, field.MDToken.Raw) {
+		}
+
+		public ScopeAndTokenKey(MethodDef method)
+			: this(method.DeclaringType == null ? null : method.DeclaringType.Module, method.MDToken.Raw) {
+		}
+
+		public ScopeAndTokenKey(PropertyDef prop)
+			: this(prop.DeclaringType == null ? null : prop.DeclaringType.Module, prop.MDToken.Raw) {
+		}
+
+		public ScopeAndTokenKey(EventDef evt)
+			: this(evt.DeclaringType == null ? null : evt.DeclaringType.Module, evt.MDToken.Raw) {
+		}
+
+		public ScopeAndTokenKey(IScope scope, uint token) {
+			this.scope = scope;
+			this.token = token;
+		}
+
+		public override int GetHashCode() {
+			return (int)token + GetHashCode(scope);
+		}
+
+		public override bool Equals(object obj) {
+			var other = obj as ScopeAndTokenKey;
+			if (other == null)
+				return false;
+			return token == other.token &&
+				Equals(scope, other.scope);
+		}
+
+		public override string ToString() {
+			return string.Format("{0:X8} {1}", token, scope);
+		}
+
+		static bool Equals(IScope a, IScope b) {
+			if (a == b)
+				return true;
+			if (a == null || b == null)
+				return false;
+			return getCanonicalizedScopeName(a) == getCanonicalizedScopeName(b);
+		}
+
+		static int GetHashCode(IScope a) {
+			if (a == null)
+				return 0;
+			return getCanonicalizedScopeName(a).GetHashCode();
+		}
+
+		static string getAssemblyName(IScope a) {
+			switch (a.ScopeType) {
+			case ScopeType.AssemblyRef:
+				return ((AssemblyRef)a).Name.String;
+			case ScopeType.ModuleDef:
+				var asm = ((ModuleDef)a).Assembly;
+				if (asm != null)
+					return asm.Name.String;
+				break;
+			}
+			return null;
+		}
+
+		static string getCanonicalizedScopeName(IScope a) {
+			if (a == null)
+				return string.Empty;
+			var asmName = getAssemblyName(a);
+			if (asmName != null) {
+				// The version number should be ignored. Older code may reference an old version of
+				// the assembly, but if the newer one has been loaded, that one is used.
+				return asmName.ToUpperInvariant();
+			}
+			return a.ScopeName.ToUpperInvariant();
+		}
+	}
+
+	interface IFieldReferenceKey {
+		IField FieldReference { get; }
+	}
+
+	interface IMethodReferenceKey {
+		IMethod MethodReference { get; }
+	}
+
+	interface IEventReferenceKey {
+		EventDef EventDef { get; }
+	}
+
+	interface IPropertyReferenceKey {
+		PropertyDef PropertyDef { get; }
+	}
+
+	sealed class FieldReferenceKey : IFieldReferenceKey {
+		readonly IField fieldRef;
+
+		public IField FieldReference {
+			get { return fieldRef; }
+		}
+
+		public FieldReferenceKey(IField fieldRef) {
+			this.fieldRef = fieldRef;
+		}
+
+		public override int GetHashCode() {
+			return new SigComparer().GetHashCode(fieldRef);
+		}
+
+		public override bool Equals(object obj) {
+			var other = obj as FieldReferenceKey;
+			if (other == null)
+				return false;
+			return new SigComparer().Equals(fieldRef, other.fieldRef);
+		}
+
+		public override string ToString() {
+			return fieldRef.ToString();
+		}
+	}
+
+	sealed class MethodReferenceKey : IMethodReferenceKey {
+		readonly IMethod methodRef;
+
+		public IMethod MethodReference {
+			get { return methodRef; }
+		}
+
+		public MethodReferenceKey(IMethod methodRef) {
+			this.methodRef = methodRef;
+		}
+
+		public override int GetHashCode() {
+			return new SigComparer().GetHashCode(methodRef);
+		}
+
+		public override bool Equals(object obj) {
+			var other = obj as MethodReferenceKey;
+			if (other == null)
+				return false;
+			return new SigComparer().Equals(methodRef, other.methodRef);
+		}
+
+		public override string ToString() {
+			return methodRef.ToString();
+		}
+	}
+
+	sealed class FieldReferenceAndDeclaringTypeKey : IFieldReferenceKey {
+		readonly IField fieldRef;
+
+		public IField FieldReference {
+			get { return fieldRef; }
+		}
+
+		public FieldReferenceAndDeclaringTypeKey(IField fieldRef) {
+			this.fieldRef = fieldRef;
+		}
+
+		public override int GetHashCode() {
+			return new SigComparer(SigComparerOptions.CompareMethodFieldDeclaringType).GetHashCode(fieldRef);
+		}
+
+		public override bool Equals(object obj) {
+			var other = obj as FieldReferenceAndDeclaringTypeKey;
+			if (other == null)
+				return false;
+			return new SigComparer(SigComparerOptions.CompareMethodFieldDeclaringType).Equals(fieldRef, other.fieldRef);
+		}
+
+		public override string ToString() {
+			return fieldRef.ToString();
+		}
+	}
+
+	sealed class MethodReferenceAndDeclaringTypeKey : IMethodReferenceKey {
+		readonly IMethod methodRef;
+
+		public IMethod MethodReference {
+			get { return methodRef; }
+		}
+
+		public MethodReferenceAndDeclaringTypeKey(IMethod methodRef) {
+			this.methodRef = methodRef;
+		}
+
+		public override int GetHashCode() {
+			return new SigComparer(SigComparerOptions.CompareMethodFieldDeclaringType).GetHashCode(methodRef);
+		}
+
+		public override bool Equals(object obj) {
+			var other = obj as MethodReferenceAndDeclaringTypeKey;
+			if (other == null)
+				return false;
+			return new SigComparer(SigComparerOptions.CompareMethodFieldDeclaringType).Equals(methodRef, other.methodRef);
+		}
+
+		public override string ToString() {
+			return methodRef.ToString();
+		}
+	}
+
+	sealed class EventReferenceKey : IEventReferenceKey {
+		readonly EventDef eventRef;
+
+		public EventDef EventDef {
+			get { return eventRef; }
+		}
+
+		public EventReferenceKey(EventDef eventRef) {
+			this.eventRef = eventRef;
+		}
+
+		public override int GetHashCode() {
+			return new SigComparer().GetHashCode(eventRef);
+		}
+
+		public override bool Equals(object obj) {
+			var other = obj as EventReferenceKey;
+			if (other == null)
+				return false;
+			return new SigComparer().Equals(eventRef, other.eventRef);
+		}
+
+		public override string ToString() {
+			return eventRef.ToString();
+		}
+	}
+
+	sealed class EventReferenceAndDeclaringTypeKey : IEventReferenceKey {
+		readonly EventDef eventRef;
+
+		public EventDef EventDef {
+			get { return eventRef; }
+		}
+
+		public EventReferenceAndDeclaringTypeKey(EventDef eventRef) {
+			this.eventRef = eventRef;
+		}
+
+		public override int GetHashCode() {
+			return new SigComparer(SigComparerOptions.CompareEventDeclaringType).GetHashCode(eventRef);
+		}
+
+		public override bool Equals(object obj) {
+			var other = obj as EventReferenceAndDeclaringTypeKey;
+			if (other == null)
+				return false;
+			return new SigComparer(SigComparerOptions.CompareEventDeclaringType).Equals(eventRef, other.eventRef);
+		}
+
+		public override string ToString() {
+			return eventRef.ToString();
+		}
+	}
+
+	sealed class PropertyReferenceKey : IPropertyReferenceKey {
+		readonly PropertyDef propRef;
+
+		public PropertyDef PropertyDef {
+			get { return propRef; }
+		}
+
+		public PropertyReferenceKey(PropertyDef propRef) {
+			this.propRef = propRef;
+		}
+
+		public override int GetHashCode() {
+			return new SigComparer().GetHashCode(propRef);
+		}
+
+		public override bool Equals(object obj) {
+			var other = obj as PropertyReferenceKey;
+			if (other == null)
+				return false;
+			return new SigComparer().Equals(propRef, other.propRef);
+		}
+
+		public override string ToString() {
+			return propRef.ToString();
+		}
+	}
+
+	sealed class PropertyReferenceAndDeclaringTypeKey : IPropertyReferenceKey {
+		readonly PropertyDef propRef;
+
+		public PropertyDef PropertyDef {
+			get { return propRef; }
+		}
+
+		public PropertyReferenceAndDeclaringTypeKey(PropertyDef propRef) {
+			this.propRef = propRef;
+		}
+
+		public override int GetHashCode() {
+			return new SigComparer(SigComparerOptions.ComparePropertyDeclaringType).GetHashCode(propRef);
+		}
+
+		public override bool Equals(object obj) {
+			var other = obj as PropertyReferenceAndDeclaringTypeKey;
+			if (other == null)
+				return false;
+			return new SigComparer(SigComparerOptions.ComparePropertyDeclaringType).Equals(propRef, other.propRef);
+		}
+
+		public override string ToString() {
+			return propRef.ToString();
+		}
+	}
+}
diff --git a/blocks/MemberRefInstance.cs b/blocks/MemberRefInstance.cs
index 751ff272..add812e4 100644
--- a/blocks/MemberRefInstance.cs
+++ b/blocks/MemberRefInstance.cs
@@ -17,6 +17,8 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#if PORT
+
 // Create a new type, method, etc, where all generic parameters have been replaced with the
 // corresponding generic argument.
 
@@ -226,3 +228,4 @@ namespace de4dot.blocks {
 		}
 	}
 }
+#endif
diff --git a/blocks/MemberReferenceHelper.cs b/blocks/MemberReferenceHelper.cs
index 7a33691a..88e433bf 100644
--- a/blocks/MemberReferenceHelper.cs
+++ b/blocks/MemberReferenceHelper.cs
@@ -17,34 +17,13 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#if PORT
 using System;
 using System.Collections.Generic;
 using Mono.Cecil;
 using Mono.Cecil.Metadata;
 
-namespace de4dot.blocks {
-	public enum CecilType {
-		ArrayType,
-		ByReferenceType,
-		EventDefinition,
-		FieldDefinition,
-		FieldReference,
-		FunctionPointerType,
-		GenericInstanceMethod,
-		GenericInstanceType,
-		GenericParameter,
-		MethodDefinition,
-		MethodReference,
-		OptionalModifierType,
-		PinnedType,
-		PointerType,
-		PropertyDefinition,
-		RequiredModifierType,
-		SentinelType,
-		TypeDefinition,
-		TypeReference,
-	}
-
+namespace de4dot.blocks.OLD_REMOVE {
 	public class TypeDefinitionDict<TValue> {
 		Dictionary<ScopeAndTokenKey, TValue> tokenToValue = new Dictionary<ScopeAndTokenKey, TValue>();
 		Dictionary<ScopeAndTokenKey, TypeDefinition> tokenToKey = new Dictionary<ScopeAndTokenKey, TypeDefinition>();
@@ -501,14 +480,14 @@ namespace de4dot.blocks {
 		}
 
 		public override int GetHashCode() {
-			return MemberReferenceHelper.typeHashCode(typeRef);
+			throw new NotImplementedException();
 		}
 
 		public override bool Equals(object obj) {
 			var other = obj as TypeReferenceKey;
 			if (other == null)
 				return false;
-			return MemberReferenceHelper.compareTypes(typeRef, other.typeRef);
+			throw new NotImplementedException();
 		}
 
 		public override string ToString() {
@@ -528,14 +507,14 @@ namespace de4dot.blocks {
 		}
 
 		public override int GetHashCode() {
-			return MemberReferenceHelper.typeReferenceHashCodeSameVersion(typeRef);
+			throw new NotImplementedException();
 		}
 
 		public override bool Equals(object obj) {
 			var other = obj as TypeReferenceSameVersionKey;
 			if (other == null)
 				return false;
-			return MemberReferenceHelper.compareTypeReferenceSameVersion(typeRef, other.typeRef);
+			throw new NotImplementedException();
 		}
 
 		public override string ToString() {
@@ -571,14 +550,14 @@ namespace de4dot.blocks {
 		}
 
 		public override int GetHashCode() {
-			return MemberReferenceHelper.fieldReferenceHashCode(fieldRef);
+			throw new NotImplementedException();
 		}
 
 		public override bool Equals(object obj) {
 			var other = obj as FieldReferenceKey;
 			if (other == null)
 				return false;
-			return MemberReferenceHelper.compareFieldReference(fieldRef, other.fieldRef);
+			throw new NotImplementedException();
 		}
 
 		public override string ToString() {
@@ -598,14 +577,14 @@ namespace de4dot.blocks {
 		}
 
 		public override int GetHashCode() {
-			return MemberReferenceHelper.propertyReferenceHashCode(propRef);
+			throw new NotImplementedException();
 		}
 
 		public override bool Equals(object obj) {
 			var other = obj as PropertyReferenceKey;
 			if (other == null)
 				return false;
-			return MemberReferenceHelper.comparePropertyReference(propRef, other.propRef);
+			throw new NotImplementedException();
 		}
 
 		public override string ToString() {
@@ -625,14 +604,14 @@ namespace de4dot.blocks {
 		}
 
 		public override int GetHashCode() {
-			return MemberReferenceHelper.eventReferenceHashCode(eventRef);
+			throw new NotImplementedException();
 		}
 
 		public override bool Equals(object obj) {
 			var other = obj as EventReferenceKey;
 			if (other == null)
 				return false;
-			return MemberReferenceHelper.compareEventReference(eventRef, other.eventRef);
+			throw new NotImplementedException();
 		}
 
 		public override string ToString() {
@@ -652,14 +631,14 @@ namespace de4dot.blocks {
 		}
 
 		public override int GetHashCode() {
-			return MemberReferenceHelper.methodReferenceHashCode(methodRef);
+			throw new NotImplementedException();
 		}
 
 		public override bool Equals(object obj) {
 			var other = obj as MethodReferenceKey;
 			if (other == null)
 				return false;
-			return MemberReferenceHelper.compareMethodReference(methodRef, other.methodRef);
+			throw new NotImplementedException();
 		}
 
 		public override string ToString() {
@@ -679,16 +658,14 @@ namespace de4dot.blocks {
 		}
 
 		public override int GetHashCode() {
-			return MemberReferenceHelper.fieldReferenceHashCode(fieldRef) +
-					MemberReferenceHelper.typeHashCode(fieldRef.DeclaringType);
+			throw new NotImplementedException();
 		}
 
 		public override bool Equals(object obj) {
 			var other = obj as FieldReferenceAndDeclaringTypeKey;
 			if (other == null)
 				return false;
-			return MemberReferenceHelper.compareFieldReference(fieldRef, other.fieldRef) &&
-					MemberReferenceHelper.compareTypes(fieldRef.DeclaringType, other.fieldRef.DeclaringType);
+			throw new NotImplementedException();
 		}
 
 		public override string ToString() {
@@ -708,16 +685,14 @@ namespace de4dot.blocks {
 		}
 
 		public override int GetHashCode() {
-			return MemberReferenceHelper.propertyReferenceHashCode(propRef) +
-					MemberReferenceHelper.typeHashCode(propRef.DeclaringType);
+			throw new NotImplementedException();
 		}
 
 		public override bool Equals(object obj) {
 			var other = obj as PropertyReferenceAndDeclaringTypeKey;
 			if (other == null)
 				return false;
-			return MemberReferenceHelper.comparePropertyReference(propRef, other.propRef) &&
-					MemberReferenceHelper.compareTypes(propRef.DeclaringType, other.propRef.DeclaringType);
+			throw new NotImplementedException();
 		}
 
 		public override string ToString() {
@@ -737,16 +712,14 @@ namespace de4dot.blocks {
 		}
 
 		public override int GetHashCode() {
-			return MemberReferenceHelper.eventReferenceHashCode(eventRef) +
-					MemberReferenceHelper.typeHashCode(eventRef.DeclaringType);
+			throw new NotImplementedException();
 		}
 
 		public override bool Equals(object obj) {
 			var other = obj as EventReferenceAndDeclaringTypeKey;
 			if (other == null)
 				return false;
-			return MemberReferenceHelper.compareEventReference(eventRef, other.eventRef) &&
-					MemberReferenceHelper.compareTypes(eventRef.DeclaringType, other.eventRef.DeclaringType);
+			throw new NotImplementedException();
 		}
 
 		public override string ToString() {
@@ -766,55 +739,24 @@ namespace de4dot.blocks {
 		}
 
 		public override int GetHashCode() {
-			return MemberReferenceHelper.methodReferenceHashCode(methodRef) +
-					MemberReferenceHelper.typeHashCode(methodRef.DeclaringType);
+			throw new NotImplementedException();
 		}
 
 		public override bool Equals(object obj) {
 			var other = obj as MethodReferenceAndDeclaringTypeKey;
 			if (other == null)
 				return false;
-			return MemberReferenceHelper.compareMethodReference(methodRef, other.methodRef) &&
-					MemberReferenceHelper.compareTypes(methodRef.DeclaringType, other.methodRef.DeclaringType);
+			throw new NotImplementedException();
 		}
 
 		public override string ToString() {
 			return methodRef.ToString();
 		}
 	}
+}
 
+namespace de4dot.blocks {
 	public static class MemberReferenceHelper {
-		static Dictionary<Type, CecilType> typeToCecilTypeDict = new Dictionary<Type, CecilType>();
-		static MemberReferenceHelper() {
-			typeToCecilTypeDict[typeof(ArrayType)] = CecilType.ArrayType;
-			typeToCecilTypeDict[typeof(ByReferenceType)] = CecilType.ByReferenceType;
-			typeToCecilTypeDict[typeof(EventDefinition)] = CecilType.EventDefinition;
-			typeToCecilTypeDict[typeof(FieldDefinition)] = CecilType.FieldDefinition;
-			typeToCecilTypeDict[typeof(FieldReference)] = CecilType.FieldReference;
-			typeToCecilTypeDict[typeof(FunctionPointerType)] = CecilType.FunctionPointerType;
-			typeToCecilTypeDict[typeof(GenericInstanceMethod)] = CecilType.GenericInstanceMethod;
-			typeToCecilTypeDict[typeof(GenericInstanceType)] = CecilType.GenericInstanceType;
-			typeToCecilTypeDict[typeof(GenericParameter)] = CecilType.GenericParameter;
-			typeToCecilTypeDict[typeof(MethodDefinition)] = CecilType.MethodDefinition;
-			typeToCecilTypeDict[typeof(MethodReference)] = CecilType.MethodReference;
-			typeToCecilTypeDict[typeof(OptionalModifierType)] = CecilType.OptionalModifierType;
-			typeToCecilTypeDict[typeof(PinnedType)] = CecilType.PinnedType;
-			typeToCecilTypeDict[typeof(PointerType)] = CecilType.PointerType;
-			typeToCecilTypeDict[typeof(PropertyDefinition)] = CecilType.PropertyDefinition;
-			typeToCecilTypeDict[typeof(RequiredModifierType)] = CecilType.RequiredModifierType;
-			typeToCecilTypeDict[typeof(SentinelType)] = CecilType.SentinelType;
-			typeToCecilTypeDict[typeof(TypeDefinition)] = CecilType.TypeDefinition;
-			typeToCecilTypeDict[typeof(TypeReference)] = CecilType.TypeReference;
-		}
-
-		public static CecilType getMemberReferenceType(MemberReference memberReference) {
-			CecilType cecilType;
-			var type = memberReference.GetType();
-			if (typeToCecilTypeDict.TryGetValue(type, out cecilType))
-				return cecilType;
-			throw new ApplicationException(string.Format("Unknown MemberReference type: {0}", type));
-		}
-
 		public static bool verifyType(TypeReference typeReference, string assembly, string type) {
 			return verifyType(typeReference, assembly, type, "");
 		}
@@ -900,511 +842,21 @@ namespace de4dot.blocks {
 			return getCanonicalizedScopeAndVersion(a).GetHashCode();
 		}
 
-		public static bool compareEventReference(EventReference a, EventReference b) {
-			if (ReferenceEquals(a, b))
-				return true;
-			if (a == null || b == null)
-				return false;
-			return a.Name == b.Name &&
-					compareTypes(a.EventType, b.EventType);
-		}
-
-		public static int eventReferenceHashCode(EventReference a) {
-			if (a == null)
-				return 0;
-			int res = 0;
-			res += a.Name.GetHashCode();
-			res += typeHashCode(a.EventType);
-			return res;
-		}
-
-		public static bool compareFieldReferenceAndDeclaringType(FieldReference a, FieldReference b) {
-			if (!compareFieldReference(a, b))
-				return false;
-			if (a == null)
-				return true;
-			return compareTypes(a.DeclaringType, b.DeclaringType);
-		}
-
-		public static bool compareFieldReference(FieldReference a, FieldReference b) {
-			if (ReferenceEquals(a, b))
-				return true;
-			if (a == null || b == null)
-				return false;
-			return a.Name == b.Name &&
-				compareTypes(a.FieldType, b.FieldType);
-		}
-
-		public static int fieldReferenceHashCode(FieldReference a) {
-			if (a == null)
-				return 0;
-			int res = 0;
-			res += a.Name.GetHashCode();
-			res += typeHashCode(a.FieldType);
-			return res;
+		public static bool compareMethodReference(MethodReference a, MethodReference b) {
+			throw new NotImplementedException();
 		}
 
 		public static bool compareMethodReferenceAndDeclaringType(MethodReference a, MethodReference b) {
-			if (!compareMethodReference(a, b))
-				return false;
-			if (a == null)
-				return true;
-			return compareTypes(a.DeclaringType, b.DeclaringType);
+			throw new NotImplementedException();
 		}
 
-		public static bool compareMethodReferenceSignature(MethodReference a, MethodReference b) {
-			if (ReferenceEquals(a, b))
-				return true;
-			if (a == null || b == null)
-				return false;
-			if (a.HasThis != b.HasThis || a.ExplicitThis != b.ExplicitThis)
-				return false;
-			if (a.CallingConvention != b.CallingConvention)
-				return false;
-			if (!compareTypes(a.MethodReturnType.ReturnType, b.MethodReturnType.ReturnType))
-				return false;
-			if (a.HasParameters != b.HasParameters)
-				return false;
-			if (a.HasParameters) {
-				if (a.Parameters.Count != b.Parameters.Count)
-					return false;
-				for (int i = 0; i < a.Parameters.Count; i++) {
-					if (!compareTypes(a.Parameters[i].ParameterType, b.Parameters[i].ParameterType))
-						return false;
-				}
-			}
-			if (a.HasGenericParameters != b.HasGenericParameters)
-				return false;
-			if (a.HasGenericParameters && a.GenericParameters.Count != b.GenericParameters.Count)
-				return false;
-
-			return true;
-		}
-
-		public static int methodReferenceSignatureHashCode(MethodReference a) {
-			if (a == null)
-				return 0;
-			int res = 0;
-
-			res += a.HasThis.GetHashCode();
-			res += a.ExplicitThis.GetHashCode();
-			res += a.CallingConvention.GetHashCode();
-			res += typeHashCode(a.MethodReturnType.ReturnType);
-			res += a.HasParameters.GetHashCode();
-			if (a.HasParameters) {
-				res += a.Parameters.Count.GetHashCode();
-				foreach (var param in a.Parameters)
-					res += typeHashCode(param.ParameterType);
-			}
-			res += a.HasGenericParameters.GetHashCode();
-			if (a.HasGenericParameters)
-				res += a.GenericParameters.Count.GetHashCode();
-
-			return res;
-		}
-
-		public static bool compareMethodReference(MethodReference a, MethodReference b) {
-			if (ReferenceEquals(a, b))
-				return true;
-			if (a == null || b == null)
-				return false;
-
-			if (a.Name != b.Name)
-				return false;
-			return compareMethodReferenceSignature(a, b);
-		}
-
-		public static int methodReferenceAndDeclaringTypeHashCode(MethodReference a) {
-			if (a == null)
-				return 0;
-			return methodReferenceHashCode(a) + typeReferenceHashCode(a.DeclaringType);
-		}
-
-		public static int methodReferenceHashCode(MethodReference a) {
-			if (a == null)
-				return 0;
-			int res = 0;
-
-			res += a.Name.GetHashCode();
-			res += methodReferenceSignatureHashCode(a);
-
-			return res;
-		}
-
-		public static bool comparePropertyReference(PropertyReference a, PropertyReference b) {
-			if (ReferenceEquals(a, b))
-				return true;
-			if (a == null || b == null)
-				return false;
-			if ((a.Parameters == null && b.Parameters != null) || (a.Parameters != null && b.Parameters == null))
-				return false;
-			if (a.Parameters != null) {
-				if (a.Parameters.Count != b.Parameters.Count)
-					return false;
-				for (int i = 0; i < a.Parameters.Count; i++) {
-					if (!compareTypes(a.Parameters[i].ParameterType, b.Parameters[i].ParameterType))
-						return false;
-				}
-			}
-			return a.Name == b.Name &&
-				compareTypes(a.PropertyType, b.PropertyType);
-		}
-
-		public static int propertyReferenceHashCode(PropertyReference a) {
-			if (a == null)
-				return 0;
-			int res = 0;
-
-			if (a.Parameters != null) {
-				res += a.Parameters.Count.GetHashCode();
-				foreach (var param in a.Parameters)
-					res += typeHashCode(param.ParameterType);
-			}
-
-			res += a.Name.GetHashCode();
-			res += typeHashCode(a.PropertyType);
-			return res;
+		public static bool compareFieldReference(FieldReference a, FieldReference b) {
+			throw new NotImplementedException();
 		}
 
 		public static bool compareTypes(TypeReference a, TypeReference b) {
-			if (ReferenceEquals(a, b))
-				return true;
-			if (a == null || b == null)
-				return false;
-
-			var atype = a.GetType();
-			var btype = b.GetType();
-			if (atype != btype) {
-				if ((atype == typeof(TypeReference) || atype == typeof(TypeDefinition)) &&
-					(btype == typeof(TypeReference) || btype == typeof(TypeDefinition)))
-					return compareTypeReferences(a, b);
-				return false;
-			}
-
-			var type = getMemberReferenceType(a);
-			switch (type) {
-			case CecilType.ArrayType:
-				return compareArrayTypes((ArrayType)a, (ArrayType)b);
-			case CecilType.ByReferenceType:
-				return compareByReferenceTypes((ByReferenceType)a, (ByReferenceType)b);
-			case CecilType.FunctionPointerType:
-				return compareFunctionPointerTypes((FunctionPointerType)a, (FunctionPointerType)b);
-			case CecilType.GenericInstanceType:
-				return compareGenericInstanceTypes((GenericInstanceType)a, (GenericInstanceType)b);
-			case CecilType.GenericParameter:
-				return compareGenericParameters((GenericParameter)a, (GenericParameter)b);
-			case CecilType.OptionalModifierType:
-				return compareOptionalModifierTypes((OptionalModifierType)a, (OptionalModifierType)b);
-			case CecilType.PinnedType:
-				return comparePinnedTypes((PinnedType)a, (PinnedType)b);
-			case CecilType.PointerType:
-				return comparePointerTypes((PointerType)a, (PointerType)b);
-			case CecilType.RequiredModifierType:
-				return compareRequiredModifierTypes((RequiredModifierType)a, (RequiredModifierType)b);
-			case CecilType.SentinelType:
-				return compareSentinelTypes((SentinelType)a, (SentinelType)b);
-			case CecilType.TypeDefinition:
-				return compareTypeDefinitions((TypeDefinition)a, (TypeDefinition)b);
-			case CecilType.TypeReference:
-				return compareTypeReferences((TypeReference)a, (TypeReference)b);
-			default:
-				throw new ApplicationException(string.Format("Unknown cecil type {0}", type));
-			}
-		}
-
-		public static int typeHashCode(TypeReference a) {
-			if (a == null)
-				return 0;
-
-			var type = getMemberReferenceType(a);
-			switch (type) {
-			case CecilType.ArrayType:
-				return arrayTypeHashCode((ArrayType)a);
-			case CecilType.ByReferenceType:
-				return byReferenceTypeHashCode((ByReferenceType)a);
-			case CecilType.FunctionPointerType:
-				return functionPointerTypeHashCode((FunctionPointerType)a);
-			case CecilType.GenericInstanceType:
-				return genericInstanceTypeHashCode((GenericInstanceType)a);
-			case CecilType.GenericParameter:
-				return genericParameterHashCode((GenericParameter)a);
-			case CecilType.OptionalModifierType:
-				return optionalModifierTypeHashCode((OptionalModifierType)a);
-			case CecilType.PinnedType:
-				return pinnedTypeHashCode((PinnedType)a);
-			case CecilType.PointerType:
-				return pointerTypeHashCode((PointerType)a);
-			case CecilType.RequiredModifierType:
-				return requiredModifierTypeHashCode((RequiredModifierType)a);
-			case CecilType.SentinelType:
-				return sentinelTypeHashCode((SentinelType)a);
-			case CecilType.TypeDefinition:
-				return typeDefinitionHashCode((TypeDefinition)a);
-			case CecilType.TypeReference:
-				return typeReferenceHashCode((TypeReference)a);
-			default:
-				throw new ApplicationException(string.Format("Unknown cecil type {0}", type));
-			}
-		}
-
-		static bool compareArrayTypes(ArrayType a, ArrayType b) {
-			if (a.Rank != b.Rank || a.IsVector != b.IsVector)
-				return false;
-			if (!a.IsVector) {
-				for (int i = 0; i < a.Dimensions.Count; i++) {
-					if (!compareArrayDimensions(a.Dimensions[i], b.Dimensions[i]))
-						return false;
-				}
-			}
-			return compareTypeSpecifications(a, b);
-		}
-
-		static int arrayTypeHashCode(ArrayType a) {
-			if (a == null)
-				return 0;
-			int res = 0;
-
-			res += a.Rank.GetHashCode();
-			res += a.IsVector.GetHashCode();
-			if (!a.IsVector) {
-				foreach (var dim in a.Dimensions)
-					res += arrayDimensionHashCode(dim);
-			}
-			res += typeSpecificationHashCode(a);
-
-			return res;
-		}
-
-		static bool compareArrayDimensions(ArrayDimension a, ArrayDimension b) {
-			return a.LowerBound == b.LowerBound && a.UpperBound == b.UpperBound;
-		}
-
-		static int arrayDimensionHashCode(ArrayDimension a) {
-			return a.LowerBound.GetHashCode() + a.UpperBound.GetHashCode();
-		}
-
-		static bool compareGenericInstanceTypes(GenericInstanceType a, GenericInstanceType b) {
-			if (a.HasGenericArguments != b.HasGenericArguments)
-				return false;
-			if (a.HasGenericArguments) {
-				if (a.GenericArguments.Count != b.GenericArguments.Count)
-					return false;
-				for (int i = 0; i < a.GenericArguments.Count; i++) {
-					if (!compareTypes(a.GenericArguments[i], b.GenericArguments[i]))
-						return false;
-				}
-			}
-			return compareTypeSpecifications(a, b);
-		}
-
-		static int genericInstanceTypeHashCode(GenericInstanceType a) {
-			if (a == null)
-				return 0;
-			int res = 0;
-
-			res += a.HasGenericArguments.GetHashCode();
-			if (a.HasGenericArguments) {
-				res += a.GenericArguments.Count.GetHashCode();
-				foreach (var arg in a.GenericArguments)
-					res += typeHashCode(arg);
-			}
-			res += typeSpecificationHashCode(a);
-
-			return res;
-		}
-
-		static bool comparePointerTypes(PointerType a, PointerType b) {
-			return compareTypeSpecifications(a, b);
-		}
-
-		static int pointerTypeHashCode(PointerType a) {
-			if (a == null)
-				return 0;
-			return typeSpecificationHashCode(a);
-		}
-
-		static bool compareByReferenceTypes(ByReferenceType a, ByReferenceType b) {
-			return compareTypeSpecifications(a, b);
-		}
-
-		static int byReferenceTypeHashCode(ByReferenceType a) {
-			if (a == null)
-				return 0;
-			return typeSpecificationHashCode(a);
-		}
-
-		static bool comparePinnedTypes(PinnedType a, PinnedType b) {
-			return compareTypeSpecifications(a, b);
-		}
-
-		static int pinnedTypeHashCode(PinnedType a) {
-			if (a == null)
-				return 0;
-			return typeSpecificationHashCode(a);
-		}
-
-		static bool compareFunctionPointerTypes(FunctionPointerType a, FunctionPointerType b) {
-			return compareMethodReference(a.function, b.function) &&
-				compareTypeSpecifications(a, b);
-		}
-
-		static int functionPointerTypeHashCode(FunctionPointerType a) {
-			if (a == null)
-				return 0;
-			return methodReferenceHashCode(a.function) + typeSpecificationHashCode(a);
-		}
-
-		static bool compareOptionalModifierTypes(OptionalModifierType a, OptionalModifierType b) {
-			return compareTypes(a.ModifierType, b.ModifierType) &&
-				compareTypeSpecifications(a, b);
-		}
-
-		static int optionalModifierTypeHashCode(OptionalModifierType a) {
-			if (a == null)
-				return 0;
-			return typeHashCode(a.ModifierType) + typeSpecificationHashCode(a);
-		}
-
-		static bool compareRequiredModifierTypes(RequiredModifierType a, RequiredModifierType b) {
-			return compareTypes(a.ModifierType, b.ModifierType) &&
-				compareTypeSpecifications(a, b);
-		}
-
-		static int requiredModifierTypeHashCode(RequiredModifierType a) {
-			if (a == null)
-				return 0;
-			return typeHashCode(a.ModifierType) + typeSpecificationHashCode(a);
-		}
-
-		static bool compareSentinelTypes(SentinelType a, SentinelType b) {
-			return compareTypeSpecifications(a, b);
-		}
-
-		static int sentinelTypeHashCode(SentinelType a) {
-			if (a == null)
-				return 0;
-			return typeSpecificationHashCode(a);
-		}
-
-		static bool compareTypeSpecifications(TypeSpecification a, TypeSpecification b) {
-			// It overrides everything of importance in TypeReference. The only thing to check
-			// is the ElementType.
-			return compareTypes(a.ElementType, b.ElementType);
-		}
-
-		static int typeSpecificationHashCode(TypeSpecification a) {
-			if (a == null)
-				return 0;
-			return typeHashCode(a.ElementType);
-		}
-
-		static bool compareTypeDefinitions(TypeDefinition a, TypeDefinition b) {
-			return compareTypeReferences(a, b);
-		}
-
-		static int typeDefinitionHashCode(TypeDefinition a) {
-			if (a == null)
-				return 0;
-			return typeReferenceHashCode(a);
-		}
-
-		static bool compareGenericParameters(GenericParameter a, GenericParameter b) {
-			return a.Position == b.Position &&
-				compareGenericParameterProvider(a.Owner, b.Owner);
-		}
-
-		static int genericParameterHashCode(GenericParameter a) {
-			if (a == null)
-				return 0;
-			return a.Position.GetHashCode() + genericParameterProviderHashCode(a.Owner);
-		}
-
-		// a and b must be either exactly a TypeReference or exactly a TypeDefinition
-		static bool compareTypeReferences(TypeReference a, TypeReference b) {
-			if ((a.GetType() != typeof(TypeReference) && a.GetType() != typeof(TypeDefinition)) ||
-				(b.GetType() != typeof(TypeReference) && b.GetType() != typeof(TypeDefinition)))
-				throw new ApplicationException("arg must be exactly of type TypeReference or TypeDefinition");
-
-			if (ReferenceEquals(a, b))
-				return true;
-
-			return a.Name == b.Name &&
-				a.Namespace == b.Namespace &&
-				compareTypes(a.DeclaringType, b.DeclaringType) &&
-				compareScope(a.Scope, b.Scope);
-		}
-
-		// a must be exactly a TypeReference or a TypeDefinition
-		static int typeReferenceHashCode(TypeReference a) {
-			if (a == null)
-				return 0;
-
-			if (a.GetType() != typeof(TypeReference) && a.GetType() != typeof(TypeDefinition))
-				throw new ApplicationException("arg must be exactly of type TypeReference or TypeDefinition");
-
-			int res = 0;
-
-			res += a.Name.GetHashCode();
-			res += a.Namespace.GetHashCode();
-			res += typeHashCode(a.DeclaringType);
-			res += scopeHashCode(a.Scope);
-
-			return res;
-		}
-
-		public static bool compareTypeReferenceSameVersion(TypeReference a, TypeReference b) {
-			if (ReferenceEquals(a, b))
-				return true;
-			if (a == null || b == null)
-				return false;
-
-			if ((a.GetType() != typeof(TypeReference) && a.GetType() != typeof(TypeDefinition)) ||
-				(b.GetType() != typeof(TypeReference) && b.GetType() != typeof(TypeDefinition)))
-				throw new ApplicationException("arg must be exactly of type TypeReference or TypeDefinition");
-
-			return a.Name == b.Name &&
-				a.Namespace == b.Namespace &&
-				compareTypeReferenceSameVersion(a.DeclaringType, b.DeclaringType) &&
-				compareScopeSameVersion(a.Scope, b.Scope);
-		}
-
-		public static int typeReferenceHashCodeSameVersion(TypeReference a) {
-			if (a == null)
-				return 0;
-
-			if (a.GetType() != typeof(TypeReference) && a.GetType() != typeof(TypeDefinition))
-				throw new ApplicationException("arg must be exactly of type TypeReference or TypeDefinition");
-
-			int res = 0;
-
-			res += a.Name.GetHashCode();
-			res += a.Namespace.GetHashCode();
-			res += typeReferenceHashCodeSameVersion(a.DeclaringType);
-			res += scopeHashCodeSameVersion(a.Scope);
-
-			return res;
-		}
-
-		static bool compareGenericParameterProvider(IGenericParameterProvider a, IGenericParameterProvider b) {
-			if (ReferenceEquals(a, b))
-				return true;
-			if (a == null || b == null)
-				return false;
-			if (a is TypeReference && b is TypeReference)
-				return compareTypes((TypeReference)a, (TypeReference)b);
-			if (a is MethodReference && b is MethodReference)
-				return true;
-			return false;
-		}
-
-		static int genericParameterProviderHashCode(IGenericParameterProvider a) {
-			if (a == null)
-				return 0;
-			if (a is TypeReference)
-				return typeHashCode((TypeReference)a);
-			if (a is MethodReference)
-				return 0;
-			throw new ApplicationException(string.Format("Unknown IGenericParameterProvider type {0}", a.GetType()));
+			throw new NotImplementedException();
 		}
 	}
 }
+#endif
diff --git a/blocks/ScopeBlock.cs b/blocks/ScopeBlock.cs
index 2ca81c95..677bd4b8 100644
--- a/blocks/ScopeBlock.cs
+++ b/blocks/ScopeBlock.cs
@@ -19,7 +19,7 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil.Cil;
+using dot10.DotNet.Emit;
 
 namespace de4dot.blocks {
 	// A normal branch may not transfer out of a protected block (try block), filter handler,
diff --git a/blocks/TryHandlerBlock.cs b/blocks/TryHandlerBlock.cs
index 1fc7b5b8..9772777d 100644
--- a/blocks/TryHandlerBlock.cs
+++ b/blocks/TryHandlerBlock.cs
@@ -17,8 +17,8 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 
 namespace de4dot.blocks {
 	// Contains the filter handler block and the catch handler block.
@@ -27,10 +27,10 @@ namespace de4dot.blocks {
 		HandlerBlock handlerBlock = new HandlerBlock();
 
 		// State for an ExceptionHandler instance
-		TypeReference catchType;
+		ITypeDefOrRef catchType;
 		ExceptionHandlerType handlerType;
 
-		public TypeReference CatchType {
+		public ITypeDefOrRef CatchType {
 			get { return catchType; }
 		}
 
diff --git a/blocks/TypeReferenceUpdaterBase.cs b/blocks/TypeReferenceUpdaterBase.cs
index e3543698..03e8babd 100644
--- a/blocks/TypeReferenceUpdaterBase.cs
+++ b/blocks/TypeReferenceUpdaterBase.cs
@@ -17,6 +17,7 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#if PORT
 using System;
 using Mono.Cecil;
 
@@ -26,35 +27,7 @@ namespace de4dot.blocks {
 			if (a == null)
 				return null;
 
-			var type = MemberReferenceHelper.getMemberReferenceType(a);
-			switch (type) {
-			case CecilType.ArrayType:
-				return updateArrayType((ArrayType)a);
-			case CecilType.ByReferenceType:
-				return updateByReferenceType((ByReferenceType)a);
-			case CecilType.FunctionPointerType:
-				return updateFunctionPointerType((FunctionPointerType)a);
-			case CecilType.GenericInstanceType:
-				return updateGenericInstanceType((GenericInstanceType)a);
-			case CecilType.GenericParameter:
-				return updateGenericParameter((GenericParameter)a);
-			case CecilType.OptionalModifierType:
-				return updateOptionalModifierType((OptionalModifierType)a);
-			case CecilType.PinnedType:
-				return updatePinnedType((PinnedType)a);
-			case CecilType.PointerType:
-				return updatePointerType((PointerType)a);
-			case CecilType.RequiredModifierType:
-				return updateRequiredModifierType((RequiredModifierType)a);
-			case CecilType.SentinelType:
-				return updateSentinelType((SentinelType)a);
-			case CecilType.TypeDefinition:
-				return updateTypeDefinition((TypeDefinition)a);
-			case CecilType.TypeReference:
-				return updateTypeReference((TypeReference)a);
-			default:
-				throw new ApplicationException(string.Format("Unknown cecil type {0}", type));
-			}
+			throw new NotImplementedException();
 		}
 
 		protected virtual ArrayType updateArrayType(ArrayType a) {
@@ -116,3 +89,4 @@ namespace de4dot.blocks {
 		}
 	}
 }
+#endif
diff --git a/blocks/Utils.cs b/blocks/Utils.cs
index da1d63ca..ab5b7ad5 100644
--- a/blocks/Utils.cs
+++ b/blocks/Utils.cs
@@ -1,4 +1,23 @@
-using System.Collections.Generic;
+/*
+    Copyright (C) 2011-2012 de4dot@gmail.com
+
+    This file is part of de4dot.
+
+    de4dot is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    de4dot is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+using System.Collections.Generic;
 
 namespace de4dot.blocks {
 	internal delegate TResult Func<TResult>();
diff --git a/blocks/blocks.csproj b/blocks/blocks.csproj
index eff0ba86..691797a5 100644
--- a/blocks/blocks.csproj
+++ b/blocks/blocks.csproj
@@ -40,6 +40,7 @@
     <Compile Include="BlocksSorter.cs" />
     <Compile Include="cflow\BlockCflowDeobfuscator.cs" />
     <Compile Include="cflow\BlockDeobfuscator.cs" />
+    <Compile Include="cflow\BlocksCflowDeobfuscator.cs" />
     <Compile Include="cflow\BranchEmulator.cs" />
     <Compile Include="cflow\CachedCflowDeobfuscator.cs" />
     <Compile Include="cflow\CflowDeobfuscator.cs" />
@@ -60,16 +61,19 @@
     <Compile Include="cflow\Value.cs" />
     <Compile Include="cflow\ValueStack.cs" />
     <Compile Include="CodeGenerator.cs" />
-    <Compile Include="cflow\BlocksCflowDeobfuscator.cs" />
     <Compile Include="DeadBlocksRemover.cs" />
     <Compile Include="DotNetUtils.cs" />
+    <Compile Include="DumpedMethod.cs" />
+    <Compile Include="DumpedMethods.cs" />
     <Compile Include="FilterHandlerBlock.cs" />
     <Compile Include="ForwardScanOrder.cs" />
+    <Compile Include="GenericArgsSubstitutor.cs" />
     <Compile Include="HandlerBlock.cs" />
     <Compile Include="Instr.cs" />
     <Compile Include="InstructionListParser.cs" />
-    <Compile Include="MemberRefInstance.cs" />
+    <Compile Include="MemberDefDict.cs" />
     <Compile Include="MemberReferenceHelper.cs" />
+    <Compile Include="MemberRefInstance.cs" />
     <Compile Include="MethodBlocks.cs" />
     <Compile Include="PE\Cor20Header.cs" />
     <Compile Include="PE\DataDirectory.cs" />
@@ -95,9 +99,9 @@
     <Compile Include="Utils.cs" />
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\cecil\Mono.Cecil.csproj">
-      <Project>{D68133BD-1E63-496E-9EDE-4FBDBF77B486}</Project>
-      <Name>Mono.Cecil</Name>
+    <ProjectReference Include="..\dot10\src\dot10.csproj">
+      <Project>{FDFC1237-143F-4919-8318-4926901F4639}</Project>
+      <Name>dot10</Name>
     </ProjectReference>
   </ItemGroup>
   <ItemGroup>
diff --git a/blocks/cflow/BlockCflowDeobfuscator.cs b/blocks/cflow/BlockCflowDeobfuscator.cs
index efc31a05..3060f828 100644
--- a/blocks/cflow/BlockCflowDeobfuscator.cs
+++ b/blocks/cflow/BlockCflowDeobfuscator.cs
@@ -18,7 +18,7 @@
 */
 
 using System;
-using Mono.Cecil.Cil;
+using dot10.DotNet.Emit;
 
 namespace de4dot.blocks.cflow {
 	class BlockCflowDeobfuscator : BlockDeobfuscator, IBranchHandler {
@@ -33,7 +33,7 @@ namespace de4dot.blocks.cflow {
 
 		protected override bool deobfuscate(Block block) {
 			this.block = block;
-			if (!DotNetUtils.isConditionalBranch(block.LastInstr.OpCode.Code) && block.LastInstr.OpCode.Code != Code.Switch)
+			if (!block.LastInstr.isConditionalBranch() && block.LastInstr.OpCode.Code != Code.Switch)
 				return false;
 			instructionEmulator.init(blocks);
 
diff --git a/blocks/cflow/BlocksCflowDeobfuscator.cs b/blocks/cflow/BlocksCflowDeobfuscator.cs
index 0c9a2236..d21e6ad9 100644
--- a/blocks/cflow/BlocksCflowDeobfuscator.cs
+++ b/blocks/cflow/BlocksCflowDeobfuscator.cs
@@ -18,8 +18,7 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet.Emit;
 
 namespace de4dot.blocks.cflow {
 	public class BlocksCflowDeobfuscator {
diff --git a/blocks/cflow/BranchEmulator.cs b/blocks/cflow/BranchEmulator.cs
index ab605146..f0a89639 100644
--- a/blocks/cflow/BranchEmulator.cs
+++ b/blocks/cflow/BranchEmulator.cs
@@ -17,7 +17,7 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil.Cil;
+using dot10.DotNet.Emit;
 
 namespace de4dot.blocks.cflow {
 	public interface IBranchHandler {
diff --git a/blocks/cflow/CachedCflowDeobfuscator.cs b/blocks/cflow/CachedCflowDeobfuscator.cs
index c3a8bd86..273951b6 100644
--- a/blocks/cflow/CachedCflowDeobfuscator.cs
+++ b/blocks/cflow/CachedCflowDeobfuscator.cs
@@ -18,14 +18,14 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 
 namespace de4dot.blocks.cflow {
 	// Only deobfuscates a method once. A copy of the method (now deobfuscated) is returned.
 	public class CachedCflowDeobfuscator {
 		BlocksCflowDeobfuscator cflowDeobfuscator = new BlocksCflowDeobfuscator();
-		Dictionary<MethodDefinition, MethodDefinition> deobfuscated = new Dictionary<MethodDefinition, MethodDefinition>();
+		Dictionary<MethodDef, MethodDef> deobfuscated = new Dictionary<MethodDef, MethodDef>();
 
 		public CachedCflowDeobfuscator() {
 		}
@@ -43,8 +43,8 @@ namespace de4dot.blocks.cflow {
 			cflowDeobfuscator.add(blocksDeobfuscator);
 		}
 
-		public MethodDefinition deobfuscate(MethodDefinition method) {
-			MethodDefinition deobfuscatedMethod;
+		public MethodDef deobfuscate(MethodDef method) {
+			MethodDef deobfuscatedMethod;
 			if (deobfuscated.TryGetValue(method, out deobfuscatedMethod))
 				return deobfuscatedMethod;
 
diff --git a/blocks/cflow/CflowDeobfuscator.cs b/blocks/cflow/CflowDeobfuscator.cs
index 3af00398..9452094d 100644
--- a/blocks/cflow/CflowDeobfuscator.cs
+++ b/blocks/cflow/CflowDeobfuscator.cs
@@ -18,8 +18,8 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 
 namespace de4dot.blocks.cflow {
 	public class CflowDeobfuscator : ICflowDeobfuscator {
@@ -32,18 +32,18 @@ namespace de4dot.blocks.cflow {
 			cflowDeobfuscator.add(blocksDeobfuscator);
 		}
 
-		public void deobfuscate(MethodDefinition method) {
+		public void deobfuscate(MethodDef method) {
 			deobfuscate(method, (blocks) => {
 				cflowDeobfuscator.init(blocks);
 				cflowDeobfuscator.deobfuscate();
 			});
 		}
 
-		static bool hasNonEmptyBody(MethodDefinition method) {
+		static bool hasNonEmptyBody(MethodDef method) {
 			return method.Body != null && method.Body.Instructions.Count > 0;
 		}
 
-		void deobfuscate(MethodDefinition method, Action<Blocks> handler) {
+		void deobfuscate(MethodDef method, Action<Blocks> handler) {
 			if (hasNonEmptyBody(method)) {
 				var blocks = new Blocks(method);
 
diff --git a/blocks/cflow/ConstantsFolder.cs b/blocks/cflow/ConstantsFolder.cs
index 327a0288..473efcb8 100644
--- a/blocks/cflow/ConstantsFolder.cs
+++ b/blocks/cflow/ConstantsFolder.cs
@@ -19,19 +19,19 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.blocks.cflow {
 	// Very simple constants folder which is all that's needed at the moment
 	class ConstantsFolder : BlockDeobfuscator {
 		InstructionEmulator instructionEmulator = new InstructionEmulator();
-		List<ParameterDefinition> args;
+		IList<Parameter> args;
 
 		protected override void init(List<Block> allBlocks) {
 			base.init(allBlocks);
-			args = DotNetUtils.getParameters(blocks.Method);
+			args = blocks.Method.Parameters;
 		}
 
 		protected override bool deobfuscate(Block block) {
@@ -49,7 +49,7 @@ namespace de4dot.blocks.cflow {
 				case Code.Ldarg_2:
 				case Code.Ldarg_3:
 				case Code.Ldarg_S:
-					changed |= fixLoadInstruction(block, i, instructionEmulator.getArg(DotNetUtils.getParameter(args, instr.Instruction)));
+					changed |= fixLoadInstruction(block, i, instructionEmulator.getArg(instr.Instruction.GetParameter(args)));
 					break;
 
 				case Code.Ldloc:
@@ -58,17 +58,17 @@ namespace de4dot.blocks.cflow {
 				case Code.Ldloc_2:
 				case Code.Ldloc_3:
 				case Code.Ldloc_S:
-					changed |= fixLoadInstruction(block, i, instructionEmulator.getLocal(DotNetUtils.getLocalVar(blocks.Locals, instr.Instruction)));
+					changed |= fixLoadInstruction(block, i, instructionEmulator.getLocal(instr.Instruction.GetLocal(blocks.Locals)));
 					break;
 
 				case Code.Ldarga:
 				case Code.Ldarga_S:
-					instructionEmulator.makeArgUnknown((ParameterDefinition)instr.Operand);
+					instructionEmulator.makeArgUnknown((Parameter)instr.Operand);
 					break;
 
 				case Code.Ldloca:
 				case Code.Ldloca_S:
-					instructionEmulator.makeLocalUnknown((VariableDefinition)instr.Operand);
+					instructionEmulator.makeLocalUnknown((Local)instr.Operand);
 					break;
 				}
 
@@ -89,7 +89,7 @@ namespace de4dot.blocks.cflow {
 				var intValue = (Int32Value)value;
 				if (!intValue.allBitsValid())
 					return false;
-				block.Instructions[index] = new Instr(DotNetUtils.createLdci4(intValue.value));
+				block.Instructions[index] = new Instr(Instruction.CreateLdcI4(intValue.value));
 				return true;
 			}
 			else if (value.isInt64()) {
diff --git a/blocks/cflow/DeadCodeRemover.cs b/blocks/cflow/DeadCodeRemover.cs
index 410a62cc..07b1f77d 100644
--- a/blocks/cflow/DeadCodeRemover.cs
+++ b/blocks/cflow/DeadCodeRemover.cs
@@ -18,7 +18,7 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil.Cil;
+using dot10.DotNet.Emit;
 
 namespace de4dot.blocks.cflow {
 	// Removes dead code that is the result of one of our optimizations, or created by the
@@ -185,7 +185,7 @@ namespace de4dot.blocks.cflow {
 				case Code.Ldc_I8:
 				case Code.Ldc_R4:
 				case Code.Ldc_R8:
-				case Code.Ldelem_Any:
+				case Code.Ldelem:
 				case Code.Ldelem_I:
 				case Code.Ldelem_I1:
 				case Code.Ldelem_I2:
@@ -237,7 +237,6 @@ namespace de4dot.blocks.cflow {
 				case Code.Mul_Ovf_Un:
 				case Code.Neg:
 				case Code.Newarr:
-				case Code.No:
 				case Code.Nop:
 				case Code.Not:
 				case Code.Or:
@@ -257,7 +256,7 @@ namespace de4dot.blocks.cflow {
 				case Code.Sub_Ovf:
 				case Code.Sub_Ovf_Un:
 				case Code.Switch:
-				case Code.Tail:
+				case Code.Tailcall:
 				case Code.Throw:
 				case Code.Unaligned:
 				case Code.Unbox:
@@ -276,7 +275,7 @@ namespace de4dot.blocks.cflow {
 				case Code.Newobj:
 				case Code.Starg:
 				case Code.Starg_S:
-				case Code.Stelem_Any:
+				case Code.Stelem:
 				case Code.Stelem_I:
 				case Code.Stelem_I1:
 				case Code.Stelem_I2:
@@ -380,7 +379,7 @@ namespace de4dot.blocks.cflow {
 		}
 
 		static void calculateStackUsage(Instruction instr, bool methodHasReturnValue, out int pushes, out int pops) {
-			DotNetUtils.calculateStackUsage(instr, false, out pushes, out pops);
+			instr.CalculateStackUsage(false, out pushes, out pops);
 		}
 	}
 }
diff --git a/blocks/cflow/DeadStoreRemover.cs b/blocks/cflow/DeadStoreRemover.cs
index 3d7f870c..27174878 100644
--- a/blocks/cflow/DeadStoreRemover.cs
+++ b/blocks/cflow/DeadStoreRemover.cs
@@ -19,7 +19,7 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil.Cil;
+using dot10.DotNet.Emit;
 
 namespace de4dot.blocks.cflow {
 	// Removes dead stores by replacing the stloc with a pop. Other optimizations will notice it's
@@ -80,7 +80,7 @@ namespace de4dot.blocks.cflow {
 		void findLoadStores() {
 			foreach (var block in allBlocks) {
 				foreach (var instr in block.Instructions) {
-					VariableDefinition local;
+					Local local;
 					AccessFlags flags;
 					switch (instr.OpCode.Code) {
 					case Code.Ldloc:
@@ -105,7 +105,7 @@ namespace de4dot.blocks.cflow {
 
 					case Code.Ldloca_S:
 					case Code.Ldloca:
-						local = instr.Operand as VariableDefinition;
+						local = instr.Operand as Local;
 						flags = AccessFlags.Read | AccessFlags.Write;
 						break;
 
@@ -128,7 +128,7 @@ namespace de4dot.blocks.cflow {
 				var instructions = block.Instructions;
 				for (int i = 0; i < instructions.Count; i++) {
 					var instr = instructions[i];
-					VariableDefinition local;
+					Local local;
 					switch (instr.OpCode.Code) {
 					case Code.Stloc:
 					case Code.Stloc_S:
diff --git a/blocks/cflow/ICflowDeobfuscator.cs b/blocks/cflow/ICflowDeobfuscator.cs
index a4c083b7..d5897254 100644
--- a/blocks/cflow/ICflowDeobfuscator.cs
+++ b/blocks/cflow/ICflowDeobfuscator.cs
@@ -17,10 +17,10 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace de4dot.blocks.cflow {
 	public interface ICflowDeobfuscator {
-		void deobfuscate(MethodDefinition method);
+		void deobfuscate(MethodDef method);
 	}
 }
diff --git a/blocks/cflow/InstructionEmulator.cs b/blocks/cflow/InstructionEmulator.cs
index 6ca70268..e110f374 100644
--- a/blocks/cflow/InstructionEmulator.cs
+++ b/blocks/cflow/InstructionEmulator.cs
@@ -19,29 +19,26 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.Cecil.Metadata;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 
 namespace de4dot.blocks.cflow {
 	public class InstructionEmulator {
 		ValueStack valueStack = new ValueStack();
 		Dictionary<Value, bool> protectedStackValues = new Dictionary<Value, bool>();
-		IList<ParameterDefinition> parameterDefinitions;
-		IList<VariableDefinition> variableDefinitions;
+		IList<Parameter> parameterDefs;
+		IList<Local> localDefs;
 		List<Value> args = new List<Value>();
 		List<Value> locals = new List<Value>();
-		int argBase;
 
-		MethodDefinition prev_method;
+		MethodDef prev_method;
 		List<Value> cached_args = new List<Value>();
 		List<Value> cached_locals = new List<Value>();
-		int cached_argBase;
 
 		public InstructionEmulator() {
 		}
 
-		public InstructionEmulator(MethodDefinition method) {
+		public InstructionEmulator(MethodDef method) {
 			init(method);
 		}
 
@@ -49,9 +46,9 @@ namespace de4dot.blocks.cflow {
 			init(blocks.Method);
 		}
 
-		public void init(MethodDefinition method) {
-			this.parameterDefinitions = method.Parameters;
-			this.variableDefinitions = method.Body.Variables;
+		public void init(MethodDef method) {
+			this.parameterDefs = method.Parameters;
+			this.localDefs = method.Body.LocalList;
 			valueStack.init();
 			protectedStackValues.Clear();
 
@@ -59,20 +56,14 @@ namespace de4dot.blocks.cflow {
 				prev_method = method;
 
 				cached_args.Clear();
-				cached_argBase = 0;
-				if (method.HasImplicitThis) {
-					cached_argBase = 1;
-					cached_args.Add(new UnknownValue());
-				}
-				for (int i = 0; i < parameterDefinitions.Count; i++)
-					cached_args.Add(getUnknownValue(parameterDefinitions[i].ParameterType));
+				for (int i = 0; i < parameterDefs.Count; i++)
+					cached_args.Add(getUnknownValue(parameterDefs[i].Type));
 
 				cached_locals.Clear();
-				for (int i = 0; i < variableDefinitions.Count; i++)
-					cached_locals.Add(getUnknownValue(variableDefinitions[i].VariableType));
+				for (int i = 0; i < localDefs.Count; i++)
+					cached_locals.Add(getUnknownValue(localDefs[i].Type));
 			}
 
-			argBase = cached_argBase;
 			args.Clear();
 			args.AddRange(cached_args);
 			locals.Clear();
@@ -83,10 +74,14 @@ namespace de4dot.blocks.cflow {
 			protectedStackValues[value] = true;
 		}
 
-		static Value getUnknownValue(TypeReference typeReference) {
-			if (typeReference == null)
+		static Value getUnknownValue(ITypeDefOrRef type) {
+			return getUnknownValue(type.ToTypeSig(false));
+		}
+
+		static Value getUnknownValue(TypeSig type) {
+			if (type == null)
 				return new UnknownValue();
-			switch (typeReference.EType) {
+			switch (type.ElementType) {
 			case ElementType.Boolean: return Int32Value.createUnknownBool();
 			case ElementType.I1: return Int32Value.createUnknown();
 			case ElementType.U1: return Int32Value.createUnknownUInt8();
@@ -100,13 +95,13 @@ namespace de4dot.blocks.cflow {
 			return new UnknownValue();
 		}
 
-		Value truncateValue(Value value, TypeReference typeReference) {
-			if (typeReference == null)
+		Value truncateValue(Value value, TypeSig type) {
+			if (type == null)
 				return value;
 			if (protectedStackValues.ContainsKey(value))
 				return value;
 
-			switch (typeReference.EType) {
+			switch (type.ElementType) {
 			case ElementType.Boolean:
 				if (value.isInt32())
 					return ((Int32Value)value).toBoolean();
@@ -167,27 +162,26 @@ namespace de4dot.blocks.cflow {
 			return getValue(args, i);
 		}
 
-		int index(ParameterDefinition arg) {
-			return arg.Sequence;
+		public Value getArg(Parameter arg) {
+			if (arg == null)
+				return new UnknownValue();
+			return getArg(arg.Index);
 		}
 
-		public Value getArg(ParameterDefinition arg) {
-			return getArg(index(arg));
-		}
-
-		TypeReference getArgType(int index) {
-			index -= argBase;
-			if (0 <= index && index < parameterDefinitions.Count)
-				return parameterDefinitions[index].ParameterType;
+		TypeSig getArgType(int index) {
+			if (0 <= index && index < parameterDefs.Count)
+				return parameterDefs[index].Type;
 			return null;
 		}
 
-		public void setArg(ParameterDefinition arg, Value value) {
-			setArg(index(arg), value);
+		public void setArg(Parameter arg, Value value) {
+			if (arg != null)
+				setArg(arg.Index, value);
 		}
 
-		public void makeArgUnknown(ParameterDefinition arg) {
-			setArg(arg, getUnknownArg(index(arg)));
+		public void makeArgUnknown(Parameter arg) {
+			if (arg != null)
+				setArg(arg, getUnknownArg(arg.Index));
 		}
 
 		void setArg(int index, Value value) {
@@ -203,26 +197,30 @@ namespace de4dot.blocks.cflow {
 			return getValue(locals, i);
 		}
 
-		public Value getLocal(VariableDefinition local) {
+		public Value getLocal(Local local) {
+			if (local == null)
+				return new UnknownValue();
 			return getLocal(local.Index);
 		}
 
-		public void setLocal(VariableDefinition local, Value value) {
-			setLocal(local.Index, value);
+		public void setLocal(Local local, Value value) {
+			if (local != null)
+				setLocal(local.Index, value);
 		}
 
-		public void makeLocalUnknown(VariableDefinition local) {
-			setLocal(local.Index, getUnknownLocal(local.Index));
+		public void makeLocalUnknown(Local local) {
+			if (local != null)
+				setLocal(local.Index, getUnknownLocal(local.Index));
 		}
 
 		void setLocal(int index, Value value) {
 			if (0 <= index && index < locals.Count)
-				locals[index] = truncateValue(value, variableDefinitions[index].VariableType);
+				locals[index] = truncateValue(value, localDefs[index].Type);
 		}
 
 		Value getUnknownLocal(int index) {
-			if (0 <= index && index < variableDefinitions.Count)
-				return getUnknownValue(variableDefinitions[index].VariableType);
+			if (0 <= index && index < localDefs.Count)
+				return getUnknownValue(localDefs[index].Type);
 			return new UnknownValue();
 		}
 
@@ -255,31 +253,31 @@ namespace de4dot.blocks.cflow {
 		public void emulate(Instruction instr) {
 			switch (instr.OpCode.Code) {
 			case Code.Starg:
-			case Code.Starg_S:	emulate_Starg((ParameterDefinition)instr.Operand); break;
+			case Code.Starg_S:	emulate_Starg((Parameter)instr.Operand); break;
 			case Code.Stloc:
-			case Code.Stloc_S:	emulate_Stloc(((VariableDefinition)instr.Operand).Index); break;
+			case Code.Stloc_S:	emulate_Stloc((Local)instr.Operand); break;
 			case Code.Stloc_0:	emulate_Stloc(0); break;
 			case Code.Stloc_1:	emulate_Stloc(1); break;
 			case Code.Stloc_2:	emulate_Stloc(2); break;
 			case Code.Stloc_3:	emulate_Stloc(3); break;
 
 			case Code.Ldarg:
-			case Code.Ldarg_S:	valueStack.push(getArg((ParameterDefinition)instr.Operand)); break;
+			case Code.Ldarg_S:	valueStack.push(getArg((Parameter)instr.Operand)); break;
 			case Code.Ldarg_0:	valueStack.push(getArg(0)); break;
 			case Code.Ldarg_1:	valueStack.push(getArg(1)); break;
 			case Code.Ldarg_2:	valueStack.push(getArg(2)); break;
 			case Code.Ldarg_3:	valueStack.push(getArg(3)); break;
 			case Code.Ldloc:
-			case Code.Ldloc_S:	valueStack.push(getLocal((VariableDefinition)instr.Operand)); break;
+			case Code.Ldloc_S:	valueStack.push(getLocal((Local)instr.Operand)); break;
 			case Code.Ldloc_0:	valueStack.push(getLocal(0)); break;
 			case Code.Ldloc_1:	valueStack.push(getLocal(1)); break;
 			case Code.Ldloc_2:	valueStack.push(getLocal(2)); break;
 			case Code.Ldloc_3:	valueStack.push(getLocal(3)); break;
 
 			case Code.Ldarga:
-			case Code.Ldarga_S:	emulate_Ldarga((ParameterDefinition)instr.Operand); break;
+			case Code.Ldarga_S:	emulate_Ldarga((Parameter)instr.Operand); break;
 			case Code.Ldloca:
-			case Code.Ldloca_S:	emulate_Ldloca(((VariableDefinition)instr.Operand).Index); break;
+			case Code.Ldloca_S:	emulate_Ldloca((Local)instr.Operand); break;
 
 			case Code.Dup:		valueStack.copyTop(); break;
 
@@ -369,7 +367,7 @@ namespace de4dot.blocks.cflow {
 			case Code.Ldelem_U1: valueStack.pop(2); valueStack.push(Int32Value.createUnknownUInt8()); break;
 			case Code.Ldelem_U2: valueStack.pop(2); valueStack.push(Int32Value.createUnknownUInt16()); break;
 			case Code.Ldelem_U4: valueStack.pop(2); valueStack.push(Int32Value.createUnknown()); break;
-			case Code.Ldelem_Any:valueStack.pop(2); valueStack.push(getUnknownValue(instr.Operand as TypeReference)); break;
+			case Code.Ldelem:	 valueStack.pop(2); valueStack.push(getUnknownValue(instr.Operand as ITypeDefOrRef)); break;
 
 			case Code.Ldind_I1:	valueStack.pop(); valueStack.push(Int32Value.createUnknown()); break;
 			case Code.Ldind_I2:	valueStack.pop(); valueStack.push(Int32Value.createUnknown()); break;
@@ -457,7 +455,6 @@ namespace de4dot.blocks.cflow {
 			case Code.Mkrefany:
 			case Code.Newarr:
 			case Code.Newobj:
-			case Code.No:
 			case Code.Nop:
 			case Code.Pop:
 			case Code.Readonly:
@@ -465,7 +462,7 @@ namespace de4dot.blocks.cflow {
 			case Code.Refanyval:
 			case Code.Ret:
 			case Code.Rethrow:
-			case Code.Stelem_Any:
+			case Code.Stelem:
 			case Code.Stelem_I:
 			case Code.Stelem_I1:
 			case Code.Stelem_I2:
@@ -486,7 +483,7 @@ namespace de4dot.blocks.cflow {
 			case Code.Stobj:
 			case Code.Stsfld:
 			case Code.Switch:
-			case Code.Tail:
+			case Code.Tailcall:
 			case Code.Throw:
 			case Code.Unaligned:
 			case Code.Volatile:
@@ -498,7 +495,7 @@ namespace de4dot.blocks.cflow {
 
 		void updateStack(Instruction instr) {
 			int pushes, pops;
-			DotNetUtils.calculateStackUsage(instr, false, out pushes, out pops);
+			instr.CalculateStackUsage(out pushes, out pops);
 			if (pops == -1)
 				valueStack.clear();
 			else {
@@ -847,38 +844,46 @@ namespace de4dot.blocks.cflow {
 				valueStack.pushUnknown();
 		}
 
-		void emulate_Starg(ParameterDefinition arg) {
-			setArg(index(arg), valueStack.pop());
+		void emulate_Starg(Parameter arg) {
+			setArg(arg == null ? -1 : arg.Index, valueStack.pop());
+		}
+
+		void emulate_Stloc(Local local) {
+			emulate_Stloc(local == null ? -1 : local.Index);
 		}
 
 		void emulate_Stloc(int index) {
 			setLocal(index, valueStack.pop());
 		}
 
-		void emulate_Ldarga(ParameterDefinition arg) {
+		void emulate_Ldarga(Parameter arg) {
 			valueStack.pushUnknown();
 			makeArgUnknown(arg);
 		}
 
+		void emulate_Ldloca(Local local) {
+			emulate_Ldloca(local == null ? -1 : local.Index);
+		}
+
 		void emulate_Ldloca(int index) {
 			valueStack.pushUnknown();
 			setLocal(index, getUnknownLocal(index));
 		}
 
 		void emulate_Call(Instruction instr) {
-			emulate_Call(instr, (MethodReference)instr.Operand);
+			emulate_Call(instr, (IMethod)instr.Operand);
 		}
 
 		void emulate_Callvirt(Instruction instr) {
-			emulate_Call(instr, (MethodReference)instr.Operand);
+			emulate_Call(instr, (IMethod)instr.Operand);
 		}
 
-		void emulate_Call(Instruction instr, MethodReference method) {
+		void emulate_Call(Instruction instr, IMethod method) {
 			int pushes, pops;
-			DotNetUtils.calculateStackUsage(instr, false, out pushes, out pops);
+			instr.CalculateStackUsage(out pushes, out pops);
 			valueStack.pop(pops);
 			if (pushes == 1)
-				valueStack.push(getUnknownValue(method.MethodReturnType.ReturnType));
+				valueStack.push(getUnknownValue(method.MethodSig.GetRetType()));
 			else
 				valueStack.push(pushes);
 		}
@@ -903,16 +908,16 @@ namespace de4dot.blocks.cflow {
 
 		void emulate_Ldfld(Instruction instr) {
 			var val1 = valueStack.pop();
-			emulateLoadField(instr.Operand as FieldReference);
+			emulateLoadField(instr.Operand as IField);
 		}
 
 		void emulate_Ldsfld(Instruction instr) {
-			emulateLoadField(instr.Operand as FieldReference);
+			emulateLoadField(instr.Operand as IField);
 		}
 
-		void emulateLoadField(FieldReference fieldReference) {
-			if (fieldReference != null)
-				valueStack.push(getUnknownValue(fieldReference.FieldType));
+		void emulateLoadField(IField field) {
+			if (field != null)
+				valueStack.push(getUnknownValue(field.FieldSig.GetFieldType()));
 			else
 				valueStack.pushUnknown();
 		}
diff --git a/blocks/cflow/MethodCallInliner.cs b/blocks/cflow/MethodCallInliner.cs
index 91ab747f..17f209b7 100644
--- a/blocks/cflow/MethodCallInliner.cs
+++ b/blocks/cflow/MethodCallInliner.cs
@@ -18,8 +18,8 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 
 namespace de4dot.blocks.cflow {
 	public class MethodCallInliner : MethodCallInlinerBase {
@@ -40,12 +40,12 @@ namespace de4dot.blocks.cflow {
 			return changed;
 		}
 
-		protected virtual bool canInline(MethodDefinition method) {
+		protected virtual bool canInline(MethodDef method) {
 			if (method.GenericParameters.Count > 0)
 				return false;
 			if (method == blocks.Method)
 				return false;
-			if (!MemberReferenceHelper.compareTypes(method.DeclaringType, blocks.Method.DeclaringType))
+			if (!new SigComparer().Equals(method.DeclaringType, blocks.Method.DeclaringType))
 				return false;
 
 			if (method.IsStatic)
@@ -56,7 +56,7 @@ namespace de4dot.blocks.cflow {
 		}
 
 		bool inlineMethod(Instruction callInstr, int instrIndex) {
-			var methodToInline = callInstr.Operand as MethodDefinition;
+			var methodToInline = callInstr.Operand as MethodDef;
 			if (methodToInline == null)
 				return false;
 
@@ -113,10 +113,10 @@ namespace de4dot.blocks.cflow {
 			}
 		}
 
-		protected override bool isCompatibleType(int paramIndex, TypeReference origType, TypeReference newType) {
-			if (MemberReferenceHelper.compareTypes(origType, newType))
+		protected override bool isCompatibleType(int paramIndex, IType origType, IType newType) {
+			if (new SigComparer(SigComparerOptions.IgnoreModifiers).Equals(origType, newType))
 				return true;
-			if (newType.IsValueType || origType.IsValueType)
+			if (isValueType(newType) || isValueType(origType))
 				return false;
 			return newType.FullName == "System.Object";
 		}
diff --git a/blocks/cflow/MethodCallInlinerBase.cs b/blocks/cflow/MethodCallInlinerBase.cs
index b8d20296..f81baba2 100644
--- a/blocks/cflow/MethodCallInlinerBase.cs
+++ b/blocks/cflow/MethodCallInlinerBase.cs
@@ -18,8 +18,8 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 
 namespace de4dot.blocks.cflow {
 	public abstract class MethodCallInlinerBase : IBlocksDeobfuscator {
@@ -29,6 +29,7 @@ namespace de4dot.blocks.cflow {
 		protected Blocks blocks;
 		protected Block block;
 		int iteration;
+		AccessChecker accessChecker;
 
 		public bool ExecuteOnNoChange { get; set; }
 
@@ -60,7 +61,7 @@ namespace de4dot.blocks.cflow {
 				this.patchIndex = patchIndex;
 				this.afterIndex = afterIndex;
 				this.lastInstr = lastInstr;
-				this.clonedInstr = new Instr(DotNetUtils.clone(lastInstr));
+				this.clonedInstr = new Instr(lastInstr.Clone());
 			}
 
 			public void patch(Block block) {
@@ -68,7 +69,7 @@ namespace de4dot.blocks.cflow {
 			}
 		}
 
-		protected bool inlineLoadMethod(int patchIndex, MethodDefinition methodToInline, Instruction loadInstr, int instrIndex) {
+		protected bool inlineLoadMethod(int patchIndex, MethodDef methodToInline, Instruction loadInstr, int instrIndex) {
 			if (!isReturn(methodToInline, instrIndex))
 				return false;
 
@@ -76,19 +77,19 @@ namespace de4dot.blocks.cflow {
 			for (int i = 0; i < methodArgsCount; i++)
 				block.insert(patchIndex++, Instruction.Create(OpCodes.Pop));
 
-			block.Instructions[patchIndex] = new Instr(DotNetUtils.clone(loadInstr));
+			block.Instructions[patchIndex] = new Instr(loadInstr.Clone());
 			return true;
 		}
 
-		protected bool inlineOtherMethod(int patchIndex, MethodDefinition methodToInline, Instruction instr, int instrIndex) {
+		protected bool inlineOtherMethod(int patchIndex, MethodDef methodToInline, Instruction instr, int instrIndex) {
 			return inlineOtherMethod(patchIndex, methodToInline, instr, instrIndex, 0);
 		}
 
-		protected bool inlineOtherMethod(int patchIndex, MethodDefinition methodToInline, Instruction instr, int instrIndex, int popLastArgs) {
+		protected bool inlineOtherMethod(int patchIndex, MethodDef methodToInline, Instruction instr, int instrIndex, int popLastArgs) {
 			return patchMethod(methodToInline, tryInlineOtherMethod(patchIndex, methodToInline, instr, instrIndex, popLastArgs));
 		}
 
-		protected bool patchMethod(MethodDefinition methodToInline, InstructionPatcher patcher) {
+		protected bool patchMethod(MethodDef methodToInline, InstructionPatcher patcher) {
 			if (patcher == null)
 				return false;
 
@@ -99,11 +100,11 @@ namespace de4dot.blocks.cflow {
 			return true;
 		}
 
-		protected InstructionPatcher tryInlineOtherMethod(int patchIndex, MethodDefinition methodToInline, Instruction instr, int instrIndex) {
+		protected InstructionPatcher tryInlineOtherMethod(int patchIndex, MethodDef methodToInline, Instruction instr, int instrIndex) {
 			return tryInlineOtherMethod(patchIndex, methodToInline, instr, instrIndex, 0);
 		}
 
-		protected InstructionPatcher tryInlineOtherMethod(int patchIndex, MethodDefinition methodToInline, Instruction instr, int instrIndex, int popLastArgs) {
+		protected InstructionPatcher tryInlineOtherMethod(int patchIndex, MethodDef methodToInline, Instruction instr, int instrIndex, int popLastArgs) {
 			int loadIndex = 0;
 			int methodArgsCount = DotNetUtils.getArgsCount(methodToInline);
 			bool foundLdarga = false;
@@ -128,7 +129,7 @@ namespace de4dot.blocks.cflow {
 				if (!isLdarg)
 					break;
 
-				if (DotNetUtils.getArgIndex(instr) != loadIndex)
+				if (instr.GetParameterIndex() != loadIndex)
 					return null;
 				loadIndex++;
 				instr = DotNetUtils.getInstruction(methodToInline.Body.Instructions, ref instrIndex);
@@ -140,38 +141,44 @@ namespace de4dot.blocks.cflow {
 				if (foundLdarga)
 					return null;
 				var callInstr = instr;
-				var calledMethod = callInstr.Operand as MethodReference;
+				var calledMethod = callInstr.Operand as IMethod;
 				if (calledMethod == null)
 					return null;
 
-				if (!isCompatibleType(-1, calledMethod.MethodReturnType.ReturnType, methodToInline.MethodReturnType.ReturnType))
+				if (!isCompatibleType(-1, calledMethod.MethodSig.RetType, methodToInline.MethodSig.RetType))
 					return null;
 
 				if (!checkSameMethods(calledMethod, methodToInline, popLastArgs))
 					return null;
 
+				if (!hasAccessTo(instr.Operand))
+					return null;
+
 				return new InstructionPatcher(patchIndex, instrIndex, callInstr);
 			}
 			else if (instr.OpCode.Code == Code.Newobj) {
 				if (foundLdarga)
 					return null;
 				var newobjInstr = instr;
-				var ctor = newobjInstr.Operand as MethodReference;
+				var ctor = newobjInstr.Operand as IMethod;
 				if (ctor == null)
 					return null;
 
-				if (!isCompatibleType(-1, ctor.DeclaringType, methodToInline.MethodReturnType.ReturnType))
+				if (!isCompatibleType(-1, ctor.DeclaringType, methodToInline.MethodSig.RetType))
 					return null;
 
-				var methodArgs = DotNetUtils.getArgs(methodToInline);
+				var methodArgs = methodToInline.Parameters;
 				var calledMethodArgs = DotNetUtils.getArgs(ctor);
 				if (methodArgs.Count + 1 - popLastArgs != calledMethodArgs.Count)
 					return null;
 				for (int i = 1; i < calledMethodArgs.Count; i++) {
-					if (!isCompatibleType(i, calledMethodArgs[i], methodArgs[i - 1]))
+					if (!isCompatibleType(i, calledMethodArgs[i], methodArgs[i - 1].Type))
 						return null;
 				}
 
+				if (!hasAccessTo(instr.Operand))
+					return null;
+
 				return new InstructionPatcher(patchIndex, instrIndex, newobjInstr);
 			}
 			else if (instr.OpCode.Code == Code.Ldfld || instr.OpCode.Code == Code.Ldflda ||
@@ -180,31 +187,46 @@ namespace de4dot.blocks.cflow {
 				if (methodArgsCount != 1)
 					return null;
 
+				if (!hasAccessTo(instr.Operand))
+					return null;
+
 				return new InstructionPatcher(patchIndex, instrIndex, ldInstr);
 			}
 
 			return null;
 		}
 
-		protected virtual bool isReturn(MethodDefinition methodToInline, int instrIndex) {
+		bool hasAccessTo(object operand) {
+			if (operand == null)
+				return false;
+			accessChecker.UserType = blocks.Method.DeclaringType;
+			return accessChecker.CanAccess(operand) ?? getDefaultAccessResult();
+		}
+
+		protected virtual bool getDefaultAccessResult() {
+			return true;
+		}
+
+		protected virtual bool isReturn(MethodDef methodToInline, int instrIndex) {
 			var instr = DotNetUtils.getInstruction(methodToInline.Body.Instructions, ref instrIndex);
 			return instr != null && instr.OpCode.Code == Code.Ret;
 		}
 
-		protected bool checkSameMethods(MethodReference method, MethodDefinition methodToInline) {
+		protected bool checkSameMethods(IMethod method, MethodDef methodToInline) {
 			return checkSameMethods(method, methodToInline, 0);
 		}
 
-		protected bool checkSameMethods(MethodReference method, MethodDefinition methodToInline, int ignoreLastMethodToInlineArgs) {
-			var methodToInlineArgs = DotNetUtils.getArgs(methodToInline);
+		protected bool checkSameMethods(IMethod method, MethodDef methodToInline, int ignoreLastMethodToInlineArgs) {
+			var methodToInlineArgs = methodToInline.Parameters;
 			var methodArgs = DotNetUtils.getArgs(method);
+			bool hasImplicitThis = method.MethodSig.ImplicitThis;
 			if (methodToInlineArgs.Count - ignoreLastMethodToInlineArgs != methodArgs.Count)
 				return false;
 			for (int i = 0; i < methodArgs.Count; i++) {
 				var methodArg = methodArgs[i];
-				var methodToInlineArg = methodToInlineArgs[i];
+				var methodToInlineArg = methodToInlineArgs[i].Type;
 				if (!isCompatibleType(i, methodArg, methodToInlineArg)) {
-					if (i != 0 || !method.HasImplicitThis)
+					if (i != 0 || !hasImplicitThis)
 						return false;
 					if (!isCompatibleValueThisPtr(methodArg, methodToInlineArg))
 						return false;
@@ -214,17 +236,26 @@ namespace de4dot.blocks.cflow {
 			return true;
 		}
 
-		protected virtual bool isCompatibleType(int paramIndex, TypeReference origType, TypeReference newType) {
-			return MemberReferenceHelper.compareTypes(origType, newType);
+		protected virtual bool isCompatibleType(int paramIndex, IType origType, IType newType) {
+			return new SigComparer().Equals(origType, newType);
 		}
 
-		static bool isCompatibleValueThisPtr(TypeReference origType, TypeReference newType) {
-			var newByRef = newType as ByReferenceType;
+		static bool isCompatibleValueThisPtr(IType origType, IType newType) {
+			var newByRef = newType as ByRefSig;
 			if (newByRef == null)
 				return false;
-			if (!newByRef.ElementType.IsValueType || !origType.IsValueType)
+			if (!isValueType(newByRef.Next) || !isValueType(origType))
 				return false;
-			return MemberReferenceHelper.compareTypes(origType, newByRef.ElementType);
+			return new SigComparer().Equals(origType, newByRef.Next);
+		}
+
+		protected static bool isValueType(IType type) {
+			if (type == null)
+				return false;
+			var ts = type as TypeSig;
+			if (ts == null)
+				return type.IsValueType;
+			return ts.IsValueType && ts.ElementType != ElementType.Void;
 		}
 	}
 }
diff --git a/blocks/cflow/StLdlocFixer.cs b/blocks/cflow/StLdlocFixer.cs
index 3e6a69c8..771f76c2 100644
--- a/blocks/cflow/StLdlocFixer.cs
+++ b/blocks/cflow/StLdlocFixer.cs
@@ -18,12 +18,13 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 
 namespace de4dot.blocks.cflow {
 	// Replace stloc + ldloc with dup + stloc
 	class StLdlocFixer : BlockDeobfuscator {
-		IList<VariableDefinition> locals;
+		IList<Local> locals;
 
 		protected override void init(List<Block> allBlocks) {
 			base.init(allBlocks);
@@ -49,7 +50,7 @@ namespace de4dot.blocks.cflow {
 					if (!instructions[i + 1].isLdloc())
 						break;
 					var local = Instr.getLocalVar(locals, instr);
-					if (local.VariableType.FullName != "System.Boolean")
+					if (local.Type.ElementType != ElementType.Boolean)
 						continue;
 					if (local != Instr.getLocalVar(locals, instructions[i + 1]))
 						break;
diff --git a/blocks/cflow/SwitchCflowDeobfuscator.cs b/blocks/cflow/SwitchCflowDeobfuscator.cs
index ae61943e..a72484ee 100644
--- a/blocks/cflow/SwitchCflowDeobfuscator.cs
+++ b/blocks/cflow/SwitchCflowDeobfuscator.cs
@@ -19,7 +19,8 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 
 namespace de4dot.blocks.cflow {
 	class SwitchCflowDeobfuscator : BlockDeobfuscator {
@@ -64,7 +65,7 @@ namespace de4dot.blocks.cflow {
 		}
 
 		bool isSwitchType2(Block switchBlock) {
-			VariableDefinition local = null;
+			Local local = null;
 			foreach (var instr in switchBlock.Instructions) {
 				if (!instr.isLdloc())
 					continue;
@@ -178,7 +179,7 @@ namespace de4dot.blocks.cflow {
 		//	swblk:
 		//		ldloc N
 		//		switch (......)
-		bool deobfuscateLdloc(IList<Block> switchTargets, Block switchFallThrough, Block block, VariableDefinition switchVariable) {
+		bool deobfuscateLdloc(IList<Block> switchTargets, Block switchFallThrough, Block block, Local switchVariable) {
 			bool changed = false;
 			foreach (var source in new List<Block>(block.Sources)) {
 				if (isBranchBlock(source)) {
@@ -366,18 +367,18 @@ namespace de4dot.blocks.cflow {
 			return changed;
 		}
 
-		static Block createBlock(Dictionary<VariableDefinition, int> consts, Block fallThrough) {
+		static Block createBlock(Dictionary<Local, int> consts, Block fallThrough) {
 			var block = new Block();
 			foreach (var kv in consts) {
-				block.Instructions.Add(new Instr(DotNetUtils.createLdci4(kv.Value)));
+				block.Instructions.Add(new Instr(Instruction.CreateLdcI4(kv.Value)));
 				block.Instructions.Add(new Instr(Instruction.Create(OpCodes.Stloc, kv.Key)));
 			}
 			fallThrough.Parent.add(block);
 			return block;
 		}
 
-		Dictionary<VariableDefinition, int> getBccLocalConstants(Block block) {
-			var dict = new Dictionary<VariableDefinition, int>();
+		Dictionary<Local, int> getBccLocalConstants(Block block) {
+			var dict = new Dictionary<Local, int>();
 			var instrs = block.Instructions;
 			for (int i = 0; i < instrs.Count; i++) {
 				var instr = instrs[i];
@@ -397,7 +398,7 @@ namespace de4dot.blocks.cflow {
 						dict.Remove(local);
 				}
 				else if (instr.OpCode.Code == Code.Ldloca || instr.OpCode.Code == Code.Ldloca_S) {
-					var local = instr.Operand as VariableDefinition;
+					var local = instr.Operand as Local;
 					if (local != null)
 						dict.Remove(local);
 				}
diff --git a/cecil b/cecil
deleted file mode 160000
index 119a3d40..00000000
--- a/cecil
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 119a3d404ab12a8a19a249e97c1e5f6ca0850b6a
diff --git a/de4dot.code/AssemblyModule.cs b/de4dot.code/AssemblyModule.cs
index 457f5aa7..527d6443 100644
--- a/de4dot.code/AssemblyModule.cs
+++ b/de4dot.code/AssemblyModule.cs
@@ -20,52 +20,74 @@
 using System;
 using System.IO;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.MyStuff;
+using dot10.DotNet;
+using dot10.DotNet.Writer;
 using de4dot.blocks;
 
 namespace de4dot.code {
 	class AssemblyModule {
 		string filename;
-		ModuleDefinition module;
+		ModuleDefMD module;
+		ModuleContext moduleContext;
 
-		public AssemblyModule(string filename) {
+		public AssemblyModule(string filename, ModuleContext moduleContext) {
 			this.filename = Utils.getFullPath(filename);
+			this.moduleContext = moduleContext;
 		}
 
-		ReaderParameters getReaderParameters() {
-			return new ReaderParameters(ReadingMode.Deferred) {
-				AssemblyResolver = AssemblyResolver.Instance
-			};
+		public ModuleDefMD load() {
+			return setModule(ModuleDefMD.Load(filename, moduleContext));
 		}
 
-		public ModuleDefinition load() {
-			return setModule(ModuleDefinition.ReadModule(filename, getReaderParameters()));
+		public ModuleDefMD load(byte[] fileData) {
+			return setModule(ModuleDefMD.Load(fileData, moduleContext));
 		}
 
-		public ModuleDefinition load(byte[] fileData) {
-			return setModule(ModuleDefinition.ReadModule(new MemoryStream(fileData), getReaderParameters()));
-		}
-
-		ModuleDefinition setModule(ModuleDefinition newModule) {
+		ModuleDefMD setModule(ModuleDefMD newModule) {
 			module = newModule;
-			AssemblyResolver.Instance.addModule(module);
-			module.FullyQualifiedName = filename;
+			TheAssemblyResolver.Instance.addModule(module);
+			module.EnableTypeDefFindCache = true;
+			module.Location = filename;
 			return module;
 		}
 
-		public void save(string newFilename, bool updateMaxStack, IWriterListener writerListener) {
-			var writerParams = new WriterParameters() {
-				UpdateMaxStack = updateMaxStack,
-				WriterListener = writerListener,
-			};
-			module.Write(newFilename, writerParams);
+		public void save(string newFilename, bool preserveTokens, bool updateMaxStack, IModuleWriterListener writerListener) {
+			MetaDataFlags mdFlags = 0;
+			if (!updateMaxStack)
+				mdFlags |= MetaDataFlags.KeepOldMaxStack;
+			if (preserveTokens) {
+				mdFlags |= MetaDataFlags.PreserveRids |
+						MetaDataFlags.PreserveUSOffsets |
+						MetaDataFlags.PreserveBlobOffsets |
+						MetaDataFlags.PreserveExtraSignatureData;
+			}
+
+			if (module.IsILOnly) {
+				var writerOptions = new ModuleWriterOptions(module, writerListener);
+				writerOptions.MetaDataOptions.Flags |= mdFlags;
+				writerOptions.Logger = Logger.Instance;
+				module.Write(newFilename, writerOptions);
+			}
+			else {
+				var writerOptions = new NativeModuleWriterOptions(module, writerListener);
+				writerOptions.MetaDataOptions.Flags |= mdFlags;
+				writerOptions.Logger = Logger.Instance;
+				writerOptions.KeepExtraPEData = true;
+				writerOptions.KeepWin32Resources = true;
+				module.NativeWrite(newFilename, writerOptions);
+			}
 		}
 
-		public ModuleDefinition reload(byte[] newModuleData, DumpedMethods dumpedMethods) {
-			AssemblyResolver.Instance.removeModule(module);
-			DotNetUtils.typeCaches.invalidate(module);
-			return setModule(ModuleDefinition.ReadModule(new MemoryStream(newModuleData), getReaderParameters(), dumpedMethods));
+		public ModuleDefMD reload(byte[] newModuleData, DumpedMethodsRestorer dumpedMethodsRestorer, IStringDecrypter stringDecrypter) {
+			TheAssemblyResolver.Instance.removeModule(module);
+			var mod = ModuleDefMD.Load(newModuleData, moduleContext);
+			if (dumpedMethodsRestorer != null)
+				dumpedMethodsRestorer.Module = mod;
+			mod.StringDecrypter = stringDecrypter;
+			mod.MethodDecrypter = dumpedMethodsRestorer;
+			mod.TablesStream.ColumnReader = dumpedMethodsRestorer;
+			mod.TablesStream.MethodRowReader = dumpedMethodsRestorer;
+			return setModule(mod);
 		}
 
 		public override string ToString() {
diff --git a/de4dot.code/AssemblyResolver.cs b/de4dot.code/AssemblyResolver.cs
index 1eeb8f92..daf32410 100644
--- a/de4dot.code/AssemblyResolver.cs
+++ b/de4dot.code/AssemblyResolver.cs
@@ -17,176 +17,42 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Text.RegularExpressions;
-using System.Xml;
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace de4dot.code {
-	public class AssemblyResolver : DefaultAssemblyResolver {
-		public static readonly AssemblyResolver Instance = new AssemblyResolver();
-		Dictionary<string, bool> addedDirectories = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase);
+	public class TheAssemblyResolver : dot10.DotNet.AssemblyResolver {
+		public static readonly TheAssemblyResolver Instance = new TheAssemblyResolver();
 
-		static AssemblyResolver() {
-			Instance.resetSearchPaths();
-		}
-
-		void resetSearchPaths() {
-			addedDirectories.Clear();
-			addOtherAssemblySearchPaths();
-		}
-
-		void addOtherAssemblySearchPaths() {
-			addOtherAssemblySearchPaths(Environment.GetEnvironmentVariable("ProgramFiles"));
-			addOtherAssemblySearchPaths(Environment.GetEnvironmentVariable("ProgramFiles(x86)"));
-		}
-
-		void addOtherAssemblySearchPaths(string path) {
-			if (string.IsNullOrEmpty(path))
-				return;
-			addSilverlightDirs(Path.Combine(path, @"Microsoft Silverlight"));
-			addIfExists(path, @"Microsoft SDKs\Silverlight\v2.0\Libraries\Client");
-			addIfExists(path, @"Microsoft SDKs\Silverlight\v2.0\Libraries\Server");
-			addIfExists(path, @"Microsoft SDKs\Silverlight\v2.0\Reference Assemblies");
-			addIfExists(path, @"Microsoft SDKs\Silverlight\v3.0\Libraries\Client");
-			addIfExists(path, @"Microsoft SDKs\Silverlight\v3.0\Libraries\Server");
-			addIfExists(path, @"Microsoft SDKs\Silverlight\v4.0\Libraries\Client");
-			addIfExists(path, @"Microsoft SDKs\Silverlight\v4.0\Libraries\Server");
-			addIfExists(path, @"Microsoft SDKs\Silverlight\v5.0\Libraries\Client");
-			addIfExists(path, @"Microsoft SDKs\Silverlight\v5.0\Libraries\Server");
-			addIfExists(path, @"Microsoft.NET\SDK\CompactFramework\v2.0\WindowsCE");
-			addIfExists(path, @"Microsoft.NET\SDK\CompactFramework\v3.5\WindowsCE");
-			addIfExists(path, @"Reference Assemblies\Microsoft\Framework\Silverlight\v3.0");
-			addIfExists(path, @"Reference Assemblies\Microsoft\Framework\Silverlight\v4.0");
-			addIfExists(path, @"Reference Assemblies\Microsoft\Framework\Silverlight\v5.0");
-			addIfExists(path, @"Reference Assemblies\Microsoft\FSharp\2.0\Runtime\v2.0");
-			addIfExists(path, @"Reference Assemblies\Microsoft\FSharp\2.0\Runtime\v4.0");
-			addIfExists(path, @"Reference Assemblies\Microsoft\WindowsPowerShell\v1.0");
-			addIfExists(path, @"Microsoft Visual Studio .NET\Common7\IDE\PublicAssemblies");
-			addIfExists(path, @"Microsoft Visual Studio .NET\Common7\IDE\PrivateAssemblies");
-			addIfExists(path, @"Microsoft Visual Studio 8.0\Common7\IDE\PublicAssemblies");
-			addIfExists(path, @"Microsoft Visual Studio 8.0\Common7\IDE\PrivateAssemblies");
-			addIfExists(path, @"Microsoft Visual Studio 9.0\Common7\IDE\PublicAssemblies");
-			addIfExists(path, @"Microsoft Visual Studio 9.0\Common7\IDE\PrivateAssemblies");
-			addIfExists(path, @"Microsoft Visual Studio 10.0\Common7\IDE\PublicAssemblies");
-			addIfExists(path, @"Microsoft Visual Studio 10.0\Common7\IDE\PrivateAssemblies");
-			addIfExists(path, @"Microsoft Visual Studio 11.0\Common7\IDE\PublicAssemblies");
-			addIfExists(path, @"Microsoft Visual Studio 11.0\Common7\IDE\PrivateAssemblies");
-			addIfExists(path, @"Microsoft XNA\XNA Game Studio\v2.0\References\Windows\x86");
-			addIfExists(path, @"Microsoft XNA\XNA Game Studio\v2.0\References\Xbox360");
-			addIfExists(path, @"Microsoft XNA\XNA Game Studio\v3.0\References\Windows\x86");
-			addIfExists(path, @"Microsoft XNA\XNA Game Studio\v3.0\References\Xbox360");
-			addIfExists(path, @"Microsoft XNA\XNA Game Studio\v3.0\References\Zune");
-			addIfExists(path, @"Microsoft XNA\XNA Game Studio\v3.1\References\Windows\x86");
-			addIfExists(path, @"Microsoft XNA\XNA Game Studio\v3.1\References\Xbox360");
-			addIfExists(path, @"Microsoft XNA\XNA Game Studio\v3.1\References\Zune");
-			addIfExists(path, @"Microsoft XNA\XNA Game Studio\v4.0\References\Windows\x86");
-			addIfExists(path, @"Microsoft XNA\XNA Game Studio\v4.0\References\Xbox360");
-			addIfExists(path, @"Windows CE Tools\wce500\Windows Mobile 5.0 Pocket PC SDK\Designtimereferences");
-			addIfExists(path, @"Windows CE Tools\wce500\Windows Mobile 5.0 Smartphone SDK\Designtimereferences");
-			addIfExists(path, @"Windows Mobile 5.0 SDK R2\Managed Libraries");
-			addIfExists(path, @"Windows Mobile 6 SDK\Managed Libraries");
-			addIfExists(path, @"Windows Mobile 6.5.3 DTK\Managed Libraries");
-			addIfExists(path, @"Microsoft SQL Server\90\SDK\Assemblies");
-			addIfExists(path, @"Microsoft SQL Server\100\SDK\Assemblies");
-			addIfExists(path, @"Microsoft SQL Server\110\SDK\Assemblies");
-			addIfExists(path, @"Microsoft ASP.NET\ASP.NET MVC 2\Assemblies");
-			addIfExists(path, @"Microsoft ASP.NET\ASP.NET MVC 3\Assemblies");
-			addIfExists(path, @"Microsoft ASP.NET\ASP.NET MVC 4\Assemblies");
-			addIfExists(path, @"Microsoft ASP.NET\ASP.NET Web Pages\v1.0\Assemblies");
-			addIfExists(path, @"Microsoft ASP.NET\ASP.NET Web Pages\v2.0\Assemblies");
-			addIfExists(path, @"Microsoft SDKs\F#\3.0\Framework\v4.0");
-		}
-
-		// basePath is eg. "C:\Program Files (x86)\Microsoft Silverlight"
-		void addSilverlightDirs(string basePath) {
-			try {
-				var di = new DirectoryInfo(basePath);
-				foreach (var dir in di.GetDirectories()) {
-					if (Regex.IsMatch(dir.Name, @"^\d+(?:\.\d+){3}$"))
-						addIfExists(basePath, dir.Name);
-				}
-			}
-			catch (Exception) {
-			}
-		}
-
-		void addIfExists(string basePath, string extraPath) {
-			try {
-				var path = Path.Combine(basePath, extraPath);
-				if (Utils.pathExists(path))
-					Instance.addSearchDirectory(path);
-			}
-			catch (Exception) {
-			}
+		public TheAssemblyResolver() {
+			EnableTypeDefCache = true;
 		}
 
 		public void addSearchDirectory(string dir) {
-			if (!addedDirectories.ContainsKey(dir)) {
-				addedDirectories[dir] = true;
-				AddSearchDirectory(dir);
-			}
+			if (!PostSearchPaths.Contains(dir))
+				PostSearchPaths.Add(dir);
 		}
 
-		public void addModule(ModuleDefinition module) {
-			if (module.FullyQualifiedName != "") {
-				addSearchDirectory(Path.GetDirectoryName(module.FullyQualifiedName));
-				if (module.FullyQualifiedName.EndsWith(".exe", StringComparison.OrdinalIgnoreCase))
-					addConfigFile(module.FullyQualifiedName + ".config");
-			}
-
-			var assembly = module.Assembly;
-			if (assembly != null) {
-				var name = assembly.Name.FullName;
-				cache[name] = assembly;
-			}
+		public void addModule(ModuleDef module) {
+			AddToCache(module.Assembly);
 		}
 
-		void addConfigFile(string configFilename) {
-			var dirName = Utils.getDirName(Utils.getFullPath(configFilename));
-			addSearchDirectory(dirName);
-
-			try {
-				using (var xmlStream = new FileStream(configFilename, FileMode.Open, FileAccess.Read, FileShare.Read)) {
-					var doc = new XmlDocument();
-					doc.Load(XmlReader.Create(xmlStream));
-					foreach (var tmp in doc.GetElementsByTagName("probing")) {
-						var probingElem = tmp as XmlElement;
-						if (probingElem == null)
-							continue;
-						var privatePath = probingElem.GetAttribute("privatePath");
-						if (string.IsNullOrEmpty(privatePath))
-							continue;
-						foreach (var path in privatePath.Split(';'))
-							addSearchDirectory(Path.Combine(dirName, path));
-					}
-				}
-			}
-			catch (IOException) {
-			}
-			catch (XmlException) {
-			}
-		}
-
-		public void removeModule(ModuleDefinition module) {
+		public void removeModule(ModuleDef module) {
 			var assembly = module.Assembly;
 			if (assembly == null)
 				return;
 
-			removeModule(assembly.Name.FullName);
+			removeModule(assembly.FullName);
 		}
 
 		public void removeModule(string asmFullName) {
 			if (string.IsNullOrEmpty(asmFullName))
 				return;
-			cache.Remove(asmFullName);
+			//TODO: Remove it from the cache
 		}
 
 		public void clearAll() {
-			cache.Clear();
-			resetSearchPaths();
+			//TODO: cache.Clear();
+			//TODO: resetSearchPaths();
 		}
 	}
 }
diff --git a/de4dot.code/DeobfuscatorContext.cs b/de4dot.code/DeobfuscatorContext.cs
index 6b1ecbb1..400f41d7 100644
--- a/de4dot.code/DeobfuscatorContext.cs
+++ b/de4dot.code/DeobfuscatorContext.cs
@@ -19,19 +19,17 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code {
 	// "global" data and methods that is shared between all deobfuscators that deobfuscate
 	// assemblies at the same time.
 	public class DeobfuscatorContext : IDeobfuscatorContext {
-		ExternalAssemblies externalAssemblies = new ExternalAssemblies();
 		Dictionary<string, object> dataDict = new Dictionary<string, object>(StringComparer.Ordinal);
 
 		public void clear() {
 			dataDict.Clear();
-			externalAssemblies.unloadAll();
 		}
 
 		public void setData(string name, object data) {
@@ -48,61 +46,68 @@ namespace de4dot.code {
 			dataDict.Remove(name);
 		}
 
-		static TypeReference getNonGenericTypeReference(TypeReference typeReference) {
-			if (typeReference == null)
-				return null;
-			if (!typeReference.IsGenericInstance)
-				return typeReference;
-			var type = (GenericInstanceType)typeReference;
-			return type.ElementType;
+		static ITypeDefOrRef getNonGenericTypeReference(ITypeDefOrRef typeRef) {
+			var ts = typeRef as TypeSpec;
+			if (ts == null)
+				return typeRef;
+			var gis = ts.ToGenericInstSig();
+			if (gis == null || gis.GenericType == null)
+				return typeRef;
+			return gis.GenericType.TypeDefOrRef;
 		}
 
-		public TypeDefinition resolve(TypeReference type) {
+		public TypeDef resolveType(ITypeDefOrRef type) {
 			if (type == null)
 				return null;
-			var typeDef = getNonGenericTypeReference(type) as TypeDefinition;
+			type = getNonGenericTypeReference(type);
+
+			var typeDef = type as TypeDef;
 			if (typeDef != null)
 				return typeDef;
 
-			return externalAssemblies.resolve(type);
+			var tr = type as TypeRef;
+			if (tr != null)
+				return tr.Resolve();
+
+			return null;
 		}
 
-		public MethodDefinition resolve(MethodReference method) {
+		public MethodDef resolveMethod(IMethod method) {
 			if (method == null)
 				return null;
-			var methodDef = method as MethodDefinition;
-			if (methodDef != null)
-				return methodDef;
 
-			var type = resolve(method.DeclaringType);
+			var md = method as MethodDef;
+			if (md != null)
+				return md;
+
+			var mr = method as MemberRef;
+			if (mr == null || !mr.IsMethodRef)
+				return null;
+
+			var type = resolveType(mr.DeclaringType);
 			if (type == null)
 				return null;
 
-			foreach (var m in type.Methods) {
-				if (MemberReferenceHelper.compareMethodReference(method, m))
-					return m;
-			}
-
-			return null;
+			return type.Resolve(mr) as MethodDef;
 		}
 
-		public FieldDefinition resolve(FieldReference field) {
+		public FieldDef resolveField(IField field) {
 			if (field == null)
 				return null;
-			var fieldDef = field as FieldDefinition;
-			if (fieldDef != null)
-				return fieldDef;
 
-			var type = resolve(field.DeclaringType);
+			var fd = field as FieldDef;
+			if (fd != null)
+				return fd;
+
+			var mr = field as MemberRef;
+			if (mr == null || !mr.IsFieldRef)
+				return null;
+
+			var type = resolveType(mr.DeclaringType);
 			if (type == null)
 				return null;
 
-			foreach (var f in type.Fields) {
-				if (MemberReferenceHelper.compareFieldReference(field, f))
-					return f;
-			}
-
-			return null;
+			return type.Resolve(mr) as FieldDef;
 		}
 	}
 }
diff --git a/de4dot.code/DumpedMethodsRestorer.cs b/de4dot.code/DumpedMethodsRestorer.cs
new file mode 100644
index 00000000..935fc3d1
--- /dev/null
+++ b/de4dot.code/DumpedMethodsRestorer.cs
@@ -0,0 +1,75 @@
+/*
+    Copyright (C) 2011-2012 de4dot@gmail.com
+
+    This file is part of de4dot.
+
+    de4dot is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    de4dot is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+using System.Collections.Generic;
+using dot10.PE;
+using dot10.DotNet.MD;
+using dot10.DotNet.Emit;
+using dot10.DotNet;
+using de4dot.blocks;
+
+namespace de4dot.code {
+	class DumpedMethodsRestorer : IRowReader<RawMethodRow>, IColumnReader, IMethodDecrypter {
+		ModuleDefMD module;
+		DumpedMethods dumpedMethods;
+
+		public ModuleDefMD Module {
+			set { module = value; }
+		}
+
+		public DumpedMethodsRestorer(DumpedMethods dumpedMethods) {
+			this.dumpedMethods = dumpedMethods;
+		}
+
+		DumpedMethod getDumpedMethod(uint rid) {
+			return dumpedMethods.get(0x06000000 | rid);
+		}
+
+		public RawMethodRow ReadRow(uint rid) {
+			var dm = getDumpedMethod(rid);
+			if (dm == null)
+				return null;
+			return new RawMethodRow(dm.mdRVA, dm.mdImplFlags, dm.mdFlags, dm.mdName, dm.mdSignature, dm.mdParamList);
+		}
+
+		public bool ReadColumn(MDTable table, uint rid, ColumnInfo column, out uint value) {
+			if (table.Table == Table.Method) {
+				var row = ReadRow(rid);
+				if (row != null) {
+					value = row.Read(column.Index);
+					return true;
+				}
+			}
+
+			value = 0;
+			return false;
+		}
+
+		public bool HasMethodBody(uint rid) {
+			return getDumpedMethod(rid) != null;
+		}
+
+		public MethodBody GetMethodBody(uint rid, RVA rva, IList<Parameter> parameters) {
+			var dm = getDumpedMethod(rid);
+			if (dm == null)
+				return null;
+			return MethodBodyReader.Create(module, dm.code, dm.extraSections, parameters, dm.mhFlags, dm.mhMaxStack, dm.mhCodeSize, dm.mhLocalVarSigTok);
+		}
+	}
+}
diff --git a/de4dot.code/ExternalAssemblies.cs b/de4dot.code/ExternalAssemblies.cs
deleted file mode 100644
index 8c29764b..00000000
--- a/de4dot.code/ExternalAssemblies.cs
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
-    Copyright (C) 2011-2012 de4dot@gmail.com
-
-    This file is part of de4dot.
-
-    de4dot is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    de4dot is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-using System;
-using System.Collections.Generic;
-using Mono.Cecil;
-using de4dot.blocks;
-
-namespace de4dot.code {
-	class ExternalAssembly {
-		AssemblyDefinition asmDef;
-
-		public ExternalAssembly(AssemblyDefinition asmDef) {
-			this.asmDef = asmDef;
-		}
-
-		public TypeDefinition resolve(TypeReference type) {
-			foreach (var module in asmDef.Modules) {
-				var typeDef = DotNetUtils.getType(module, type);
-				if (typeDef != null)
-					return typeDef;
-			}
-
-			return null;
-		}
-
-		public void unload(string asmFullName) {
-			foreach (var module in asmDef.Modules) {
-				DotNetUtils.typeCaches.invalidate(module);
-				AssemblyResolver.Instance.removeModule(module);
-			}
-			AssemblyResolver.Instance.removeModule(asmFullName);
-		}
-	}
-
-	// Loads assemblies that aren't renamed
-	class ExternalAssemblies {
-		Dictionary<string, ExternalAssembly> assemblies = new Dictionary<string, ExternalAssembly>(StringComparer.Ordinal);
-		Dictionary<string, bool> failedLoads = new Dictionary<string, bool>(StringComparer.Ordinal);
-
-		ExternalAssembly load(TypeReference type) {
-			var asmFullName = DotNetUtils.getFullAssemblyName(type);
-			if (asmFullName == null)
-				return null;
-			ExternalAssembly asm;
-			if (assemblies.TryGetValue(asmFullName, out asm))
-				return asm;
-
-			AssemblyDefinition asmDef = null;
-			try {
-				asmDef = AssemblyResolver.Instance.Resolve(asmFullName);
-			}
-			catch (ResolutionException) {
-			}
-			catch (AssemblyResolutionException) {
-			}
-			if (asmDef == null) {
-				if (!failedLoads.ContainsKey(asmFullName))
-					Log.w("Could not load assembly {0}", asmFullName);
-				failedLoads[asmFullName] = true;
-				return null;
-			}
-			if (assemblies.ContainsKey(asmDef.Name.FullName)) {
-				assemblies[asmFullName] = assemblies[asmDef.Name.FullName];
-				return assemblies[asmDef.Name.FullName];
-			}
-
-			if (asmFullName == asmDef.Name.FullName)
-				Log.v("Loaded assembly {0}", asmFullName);
-			else
-				Log.v("Loaded assembly {0} (but wanted {1})", asmDef.Name.FullName, asmFullName);
-
-			asm = new ExternalAssembly(asmDef);
-			assemblies[asmFullName] = asm;
-			assemblies[asmDef.Name.FullName] = asm;
-			return asm;
-		}
-
-		public TypeDefinition resolve(TypeReference type) {
-			if (type == null)
-				return null;
-			var asm = load(type);
-			if (asm == null)
-				return null;
-			return asm.resolve(type);
-		}
-
-		public void unloadAll() {
-			foreach (var pair in assemblies) {
-				if (pair.Value == null)
-					continue;
-				pair.Value.unload(pair.Key);
-			}
-			assemblies.Clear();
-			failedLoads.Clear();
-		}
-	}
-}
diff --git a/de4dot.code/IDeobfuscatorContext.cs b/de4dot.code/IDeobfuscatorContext.cs
index 8a666876..6efa3126 100644
--- a/de4dot.code/IDeobfuscatorContext.cs
+++ b/de4dot.code/IDeobfuscatorContext.cs
@@ -17,7 +17,7 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace de4dot.code {
 	public interface IDeobfuscatorContext {
@@ -25,8 +25,8 @@ namespace de4dot.code {
 		void setData(string name, object data);
 		object getData(string name);
 		void clearData(string name);
-		TypeDefinition resolve(TypeReference type);
-		MethodDefinition resolve(MethodReference method);
-		FieldDefinition resolve(FieldReference field);
+		TypeDef resolveType(ITypeDefOrRef type);
+		MethodDef resolveMethod(IMethod method);
+		FieldDef resolveField(IField field);
 	}
 }
diff --git a/de4dot.code/IObfuscatedFile.cs b/de4dot.code/IObfuscatedFile.cs
index d02c900b..e47dc3c9 100644
--- a/de4dot.code/IObfuscatedFile.cs
+++ b/de4dot.code/IObfuscatedFile.cs
@@ -17,14 +17,15 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+using System;
 using System.Collections.Generic;
 using de4dot.code.deobfuscators;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.code.renamer;
 
 namespace de4dot.code {
-	public interface IObfuscatedFile {
-		ModuleDefinition ModuleDefinition { get; }
+	public interface IObfuscatedFile : IDisposable {
+		ModuleDefMD ModuleDefMD { get; }
 		IDeobfuscator Deobfuscator { get; }
 		IDeobfuscatorContext DeobfuscatorContext { get; set; }
 		string Filename { get; }
diff --git a/de4dot.code/Log.cs b/de4dot.code/Log.cs
deleted file mode 100644
index 1b9aff73..00000000
--- a/de4dot.code/Log.cs
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
-    Copyright (C) 2011-2012 de4dot@gmail.com
-
-    This file is part of de4dot.
-
-    de4dot is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    de4dot is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-using System;
-using System.Collections.Generic;
-
-namespace de4dot.code {
-	public static class Log {
-		public static int indentLevel = 0;
-		const int indentSize = 2;
-
-		public enum LogLevel {
-			error,
-			warning,
-			normal,
-			verbose,
-			veryverbose,
-		}
-		public static LogLevel logLevel = LogLevel.normal;
-		public static string indentString = "";
-
-		public static bool isAtLeast(LogLevel ll) {
-			return logLevel >= ll;
-		}
-
-		static void initIndentString() {
-			indentString = new string(' ', indentLevel * indentSize);
-		}
-
-		public static void indent() {
-			indentLevel++;
-			initIndentString();
-		}
-
-		public static void deIndent() {
-			if (indentLevel <= 0)
-				throw new ApplicationException("Can't de-indent!");
-			indentLevel--;
-			initIndentString();
-		}
-
-		public static void log(LogLevel l, string format, params object[] args) {
-			if (!isAtLeast(l))
-				return;
-			var indent = l <= LogLevel.warning ? "" : indentString;
-			Console.WriteLine(indent + format, args);
-		}
-
-		public static void e(string format, params object[] args) {
-			log(LogLevel.error, format, args);
-		}
-
-		public static void w(string format, params object[] args) {
-			log(LogLevel.warning, format, args);
-		}
-
-		public static void n(string format, params object[] args) {
-			log(LogLevel.normal, format, args);
-		}
-
-		public static void v(string format, params object[] args) {
-			log(LogLevel.verbose, format, args);
-		}
-
-		public static void vv(string format, params object[] args) {
-			log(LogLevel.veryverbose, format, args);
-		}
-	}
-}
diff --git a/de4dot.code/Logger.cs b/de4dot.code/Logger.cs
new file mode 100644
index 00000000..1286dea1
--- /dev/null
+++ b/de4dot.code/Logger.cs
@@ -0,0 +1,165 @@
+/*
+    Copyright (C) 2011-2012 de4dot@gmail.com
+
+    This file is part of de4dot.
+
+    de4dot is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    de4dot is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+using System;
+using System.Collections.Generic;
+using dot10.DotNet;
+
+namespace de4dot.code {
+	public class Logger : ILogger {
+		public readonly static Logger Instance = new Logger();
+
+		int indentLevel = 0;
+		readonly int indentSize = 0;
+		LoggerEvent maxLoggerEvent = LoggerEvent.Info;
+		string indentString = "";
+		Dictionary<string, bool> ignoredMessages = new Dictionary<string, bool>(StringComparer.Ordinal);
+		int numIgnoredMessages;
+		bool canIgnoreMessages;
+
+		public int IndentLevel {
+			get { return indentLevel; }
+			set {
+				if (indentLevel == value)
+					return;
+				indentLevel = value;
+				initIndentString();
+			}
+		}
+
+		public LoggerEvent MaxLoggerEvent {
+			get { return maxLoggerEvent; }
+			set { maxLoggerEvent = value; }
+		}
+
+		public bool CanIgnoreMessages {
+			get { return canIgnoreMessages; }
+			set { canIgnoreMessages = value; }
+		}
+
+		public int NumIgnoredMessages {
+			get { return numIgnoredMessages; }
+		}
+
+		public Logger()
+			: this(2, true) {
+		}
+
+		public Logger(int indentSize, bool canIgnoreMessages) {
+			this.indentSize = indentSize;
+			this.canIgnoreMessages = canIgnoreMessages;
+		}
+
+		void initIndentString() {
+			if (indentLevel < 0)
+				indentLevel = 0;
+			indentString = new string(' ', indentLevel * indentSize);
+		}
+
+		public void indent() {
+			indentLevel++;
+			initIndentString();
+		}
+
+		public void deIndent() {
+			indentLevel--;
+			initIndentString();
+		}
+
+		public void Log(object sender, LoggerEvent loggerEvent, string format, params object[] args) {
+			Log(true, sender, loggerEvent, format, args);
+		}
+
+		public void LogErrorDontIgnore(string format, params object[] args) {
+			Log(false, null, LoggerEvent.Error, format, args);
+		}
+
+		public void Log(bool canIgnore, object sender, LoggerEvent loggerEvent, string format, params object[] args) {
+			if (IgnoresEvent(loggerEvent))
+				return;
+			if (canIgnore && ignoreMessage(loggerEvent, format, args))
+				return;
+
+			switch (loggerEvent) {
+			case LoggerEvent.Error:
+				foreach (var l in string.Format(format, args).Split('\n'))
+					LogMessage(string.Empty, string.Format("ERROR: {0}", l));
+				break;
+
+			case LoggerEvent.Warning:
+				foreach (var l in string.Format(format, args).Split('\n'))
+					LogMessage(string.Empty, string.Format("WARNING: {0}", l));
+				break;
+
+			default:
+				var indent = loggerEvent <= LoggerEvent.Warning ? "" : indentString;
+				LogMessage(indent, format, args);
+				break;
+			}
+		}
+
+		bool ignoreMessage(LoggerEvent loggerEvent, string format, object[] args) {
+			if (loggerEvent != LoggerEvent.Error && loggerEvent != LoggerEvent.Warning)
+				return false;
+			if (!canIgnoreMessages)
+				return false;
+			if (ignoredMessages.ContainsKey(format)) {
+				numIgnoredMessages++;
+				return true;
+			}
+			ignoredMessages[format] = true;
+			return false;
+		}
+
+		void LogMessage(string indent, string format, params object[] args) {
+			if (args == null || args.Length == 0)
+				Console.WriteLine("{0}{1}", indent, format);
+			else
+				Console.WriteLine(indent + format, args);
+		}
+
+		public bool IgnoresEvent(LoggerEvent loggerEvent) {
+			return loggerEvent > maxLoggerEvent;
+		}
+
+		public static void log(LoggerEvent loggerEvent, string format, params object[] args) {
+			Instance.Log(null, loggerEvent, format, args);
+		}
+
+		public static void e(string format, params object[] args) {
+			Instance.Log(null, LoggerEvent.Error, format, args);
+		}
+
+		public static void w(string format, params object[] args) {
+			Instance.Log(null, LoggerEvent.Warning, format, args);
+		}
+
+		public static void n(string format, params object[] args) {
+			Instance.Log(null, LoggerEvent.Info, format, args);
+		}
+
+		public static void v(string format, params object[] args) {
+			Instance.Log(null, LoggerEvent.Verbose, format, args);
+		}
+
+		public static void vv(string format, params object[] args) {
+			Instance.Log(null, LoggerEvent.VeryVerbose, format, args);
+		}
+	}
+}
diff --git a/de4dot.code/MethodPrinter.cs b/de4dot.code/MethodPrinter.cs
index d6ed2881..0ce91c79 100644
--- a/de4dot.code/MethodPrinter.cs
+++ b/de4dot.code/MethodPrinter.cs
@@ -19,13 +19,13 @@
 
 using System.Collections.Generic;
 using System.Text;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code {
 	class MethodPrinter {
-		Log.LogLevel logLevel;
+		LoggerEvent loggerEvent;
 		IList<Instruction> allInstructions;
 		IList<ExceptionHandler> allExceptionHandlers;
 		Dictionary<Instruction, bool> targets = new Dictionary<Instruction, bool>();
@@ -41,9 +41,9 @@ namespace de4dot.code {
 		Dictionary<Instruction, ExInfo> exInfos = new Dictionary<Instruction, ExInfo>();
 		ExInfo lastExInfo;
 
-		public void print(Log.LogLevel logLevel, IList<Instruction> allInstructions, IList<ExceptionHandler> allExceptionHandlers) {
+		public void print(LoggerEvent loggerEvent, IList<Instruction> allInstructions, IList<ExceptionHandler> allExceptionHandlers) {
 			try {
-				this.logLevel = logLevel;
+				this.loggerEvent = loggerEvent;
 				this.allInstructions = allInstructions;
 				this.allExceptionHandlers = allExceptionHandlers;
 				lastExInfo = new ExInfo();
@@ -83,7 +83,7 @@ namespace de4dot.code {
 			}
 
 			var sortedTargets = new List<Instruction>(targets.Keys);
-			sortedTargets.Sort((a, b) => Utils.compareInt32(a.Offset, b.Offset));
+			sortedTargets.Sort((a, b) => a.Offset.CompareTo(b.Offset));
 			for (int i = 0; i < sortedTargets.Count; i++)
 				labels[sortedTargets[i]] = string.Format("label_{0}", i);
 		}
@@ -121,28 +121,28 @@ namespace de4dot.code {
 			initTargets();
 			initExHandlers();
 
-			Log.indent();
+			Logger.Instance.indent();
 			foreach (var instr in allInstructions) {
 				if (targets.ContainsKey(instr)) {
-					Log.deIndent();
-					Log.log(logLevel, "{0}:", getLabel(instr));
-					Log.indent();
+					Logger.Instance.deIndent();
+					Logger.log(loggerEvent, "{0}:", getLabel(instr));
+					Logger.Instance.indent();
 				}
 				ExInfo exInfo;
 				if (exInfos.TryGetValue(instr, out exInfo))
 					printExInfo(exInfo);
-				var instrString = instr.GetOpCodeString();
+				var instrString = instr.OpCode.Name;
 				var operandString = getOperandString(instr);
-				var memberReference = instr.Operand as MemberReference;
+				var memberReference = instr.Operand as ITokenOperand;
 				if (operandString == "")
-					Log.log(logLevel, "{0}", instrString);
+					Logger.log(loggerEvent, "{0}", instrString);
 				else if (memberReference != null)
-					Log.log(logLevel, "{0,-9} {1} // {2:X8}", instrString, Utils.removeNewlines(operandString), memberReference.MetadataToken.ToUInt32());
+					Logger.log(loggerEvent, "{0,-9} {1} // {2:X8}", instrString, Utils.removeNewlines(operandString), memberReference.MDToken.ToUInt32());
 				else
-					Log.log(logLevel, "{0,-9} {1}", instrString, Utils.removeNewlines(operandString));
+					Logger.log(loggerEvent, "{0,-9} {1}", instrString, Utils.removeNewlines(operandString));
 			}
 			printExInfo(lastExInfo);
-			Log.deIndent();
+			Logger.Instance.deIndent();
 		}
 
 		string getOperandString(Instruction instr) {
@@ -160,30 +160,30 @@ namespace de4dot.code {
 			}
 			else if (instr.Operand is string)
 				return Utils.toCsharpString((string)instr.Operand);
-			else if (instr.Operand is ParameterDefinition) {
-				var arg = (ParameterDefinition)instr.Operand;
-				var s = instr.GetOperandString();
+			else if (instr.Operand is Parameter) {
+				var arg = (Parameter)instr.Operand;
+				var s = InstructionPrinter.GetOperandString(instr);
 				if (s != "")
 					return s;
-				return string.Format("<arg_{0}>", DotNetUtils.getArgIndex(arg));
+				return string.Format("<arg_{0}>", arg.Index);
 			}
 			else
-				return instr.GetOperandString();
+				return InstructionPrinter.GetOperandString(instr);
 		}
 
 		void printExInfo(ExInfo exInfo) {
-			Log.deIndent();
+			Logger.Instance.deIndent();
 			foreach (var ex in exInfo.tryStarts)
-				Log.log(logLevel, "// try start: {0}", getExceptionString(ex));
+				Logger.log(loggerEvent, "// try start: {0}", getExceptionString(ex));
 			foreach (var ex in exInfo.tryEnds)
-				Log.log(logLevel, "// try end: {0}", getExceptionString(ex));
+				Logger.log(loggerEvent, "// try end: {0}", getExceptionString(ex));
 			foreach (var ex in exInfo.filterStarts)
-				Log.log(logLevel, "// filter start: {0}", getExceptionString(ex));
+				Logger.log(loggerEvent, "// filter start: {0}", getExceptionString(ex));
 			foreach (var ex in exInfo.handlerStarts)
-				Log.log(logLevel, "// handler start: {0}", getExceptionString(ex));
+				Logger.log(loggerEvent, "// handler start: {0}", getExceptionString(ex));
 			foreach (var ex in exInfo.handlerEnds)
-				Log.log(logLevel, "// handler end: {0}", getExceptionString(ex));
-			Log.indent();
+				Logger.log(loggerEvent, "// handler end: {0}", getExceptionString(ex));
+			Logger.Instance.indent();
 		}
 
 		string getExceptionString(ExceptionHandler ex) {
diff --git a/de4dot.code/MethodReturnValueInliner.cs b/de4dot.code/MethodReturnValueInliner.cs
index 309a4827..c2a55fbb 100644
--- a/de4dot.code/MethodReturnValueInliner.cs
+++ b/de4dot.code/MethodReturnValueInliner.cs
@@ -19,17 +19,16 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.Cecil.Metadata;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code {
 	// A simple class that statically detects the values of some local variables
 	class VariableValues {
 		IList<Block> allBlocks;
-		IList<VariableDefinition> locals;
-		Dictionary<VariableDefinition, Variable> variableToValue = new Dictionary<VariableDefinition, Variable>();
+		IList<Local> locals;
+		Dictionary<Local, Variable> variableToValue = new Dictionary<Local, Variable>();
 
 		public class Variable {
 			int writes = 0;
@@ -58,7 +57,7 @@ namespace de4dot.code {
 			}
 		}
 
-		public VariableValues(IList<VariableDefinition> locals, IList<Block> allBlocks) {
+		public VariableValues(IList<Local> locals, IList<Block> allBlocks) {
 			this.locals = locals;
 			this.allBlocks = allBlocks;
 			init();
@@ -136,7 +135,7 @@ namespace de4dot.code {
 			}
 		}
 
-		public Variable getValue(VariableDefinition variable) {
+		public Variable getValue(Local variable) {
 			return variableToValue[variable];
 		}
 	}
@@ -144,7 +143,7 @@ namespace de4dot.code {
 	abstract class MethodReturnValueInliner {
 		protected List<CallResult> callResults;
 		List<Block> allBlocks;
-		MethodDefinition theMethod;
+		MethodDef theMethod;
 		VariableValues variableValues;
 		int errors = 0;
 		bool useUnknownArgs = false;
@@ -166,8 +165,8 @@ namespace de4dot.code {
 				this.callEndIndex = callEndIndex;
 			}
 
-			public MethodReference getMethodReference() {
-				return (MethodReference)block.Instructions[callEndIndex].Operand;
+			public IMethod getMethodReference() {
+				return (IMethod)block.Instructions[callEndIndex].Operand;
 			}
 		}
 
@@ -177,14 +176,14 @@ namespace de4dot.code {
 
 		public abstract bool HasHandlers { get; }
 
-		public MethodDefinition Method {
+		public MethodDef Method {
 			get { return theMethod; }
 		}
 
 		protected abstract void inlineAllCalls();
 
 		// Returns null if method is not a method we should inline
-		protected abstract CallResult createCallResult(MethodReference method, GenericInstanceMethod gim, Block block, int callInstrIndex);
+		protected abstract CallResult createCallResult(IMethod method, MethodSpec gim, Block block, int callInstrIndex);
 
 		public int decrypt(Blocks blocks) {
 			if (!HasHandlers)
@@ -192,7 +191,7 @@ namespace de4dot.code {
 			return decrypt(blocks.Method, blocks.MethodBlocks.getAllBlocks());
 		}
 
-		public int decrypt(MethodDefinition method, List<Block> allBlocks) {
+		public int decrypt(MethodDef method, List<Block> allBlocks) {
 			if (!HasHandlers)
 				return 0;
 			try {
@@ -217,9 +216,9 @@ namespace de4dot.code {
 			}
 		}
 
-		bool getLocalVariableValue(VariableDefinition variable, out object value) {
+		bool getLocalVariableValue(Local variable, out object value) {
 			if (variableValues == null)
-				variableValues = new VariableValues(theMethod.Body.Variables, allBlocks);
+				variableValues = new VariableValues(theMethod.Body.LocalList, allBlocks);
 			var val = variableValues.getValue(variable);
 			if (!val.isValid()) {
 				value = null;
@@ -239,14 +238,14 @@ namespace de4dot.code {
 				var instr = block.Instructions[i];
 				if (instr.OpCode != OpCodes.Call)
 					continue;
-				var method = instr.Operand as MethodReference;
+				var method = instr.Operand as IMethod;
 				if (method == null)
 					continue;
 
-				MethodReference elementMethod = method;
-				var gim = method as GenericInstanceMethod;
+				IMethod elementMethod = method;
+				var gim = method as MethodSpec;
 				if (gim != null)
-					elementMethod = gim.ElementMethod;
+					elementMethod = gim.Method;
 				var callResult = createCallResult(elementMethod, gim, block, i);
 				if (callResult == null)
 					continue;
@@ -259,7 +258,7 @@ namespace de4dot.code {
 		bool findArgs(CallResult callResult) {
 			var block = callResult.block;
 			var method = callResult.getMethodReference();
-			var methodArgs = DotNetUtils.getParameters(method);
+			var methodArgs = DotNetUtils.getArgs(method);
 			int numArgs = methodArgs.Count;
 			var args = new object[numArgs];
 
@@ -269,9 +268,9 @@ namespace de4dot.code {
 				if (!getArg(method, block, ref arg, ref instrIndex))
 					return false;
 				if (arg is int)
-					arg = fixIntArg(methodArgs[i].ParameterType, (int)arg);
+					arg = fixIntArg(methodArgs[i], (int)arg);
 				else if (arg is long)
-					arg = fixIntArg(methodArgs[i].ParameterType, (long)arg);
+					arg = fixIntArg(methodArgs[i], (long)arg);
 				args[i] = arg;
 			}
 
@@ -280,8 +279,8 @@ namespace de4dot.code {
 			return true;
 		}
 
-		object fixIntArg(TypeReference type, long value) {
-			switch (type.EType) {
+		object fixIntArg(TypeSig type, long value) {
+			switch (type.ElementType) {
 			case ElementType.Boolean: return value != 0;
 			case ElementType.Char: return (char)value;
 			case ElementType.I1: return (sbyte)value;
@@ -296,15 +295,15 @@ namespace de4dot.code {
 			throw new ApplicationException(string.Format("Wrong type {0}", type));
 		}
 
-		bool getArg(MethodReference method, Block block, ref object arg, ref int instrIndex) {
+		bool getArg(IMethod method, Block block, ref object arg, ref int instrIndex) {
 			while (true) {
 				if (instrIndex < 0) {
 					// We're here if there were no cflow deobfuscation, or if there are two or
 					// more blocks branching to the decrypter method, or the two blocks can't be
 					// merged because one is outside the exception handler (eg. buggy obfuscator).
-					Log.w("Could not find all arguments to method {0} ({1:X8})",
+					Logger.w("Could not find all arguments to method {0} ({1:X8})",
 								Utils.removeNewlines(method),
-								method.MetadataToken.ToInt32());
+								method.MDToken.ToInt32());
 					errors++;
 					return false;
 				}
@@ -343,7 +342,7 @@ namespace de4dot.code {
 				case Code.Ldloc_1:
 				case Code.Ldloc_2:
 				case Code.Ldloc_3:
-					getLocalVariableValue(Instr.getLocalVar(theMethod.Body.Variables, instr), out arg);
+					getLocalVariableValue(instr.Instruction.GetLocal(theMethod.Body.LocalList), out arg);
 					break;
 
 				case Code.Ldfld:
@@ -353,11 +352,11 @@ namespace de4dot.code {
 
 				default:
 					int pushes, pops;
-					DotNetUtils.calculateStackUsage(instr.Instruction, false, out pushes, out pops);
+					instr.Instruction.CalculateStackUsage(false, out pushes, out pops);
 					if (!useUnknownArgs || pushes != 1) {
-						Log.w("Could not find all arguments to method {0} ({1:X8}), instr: {2}",
+						Logger.w("Could not find all arguments to method {0} ({1:X8}), instr: {2}",
 									Utils.removeNewlines(method),
-									method.MetadataToken.ToInt32(),
+									method.MDToken.ToInt32(),
 									instr);
 						errors++;
 						return false;
@@ -381,10 +380,10 @@ namespace de4dot.code {
 			callResults.Sort((a, b) => {
 				int i1 = allBlocks.FindIndex((x) => a.block == x);
 				int i2 = allBlocks.FindIndex((x) => b.block == x);
-				if (i1 < i2) return -1;
-				if (i1 > i2) return 1;
+				if (i1 != i2)
+					return i1.CompareTo(i2);
 
-				return Utils.compareInt32(a.callStartIndex, b.callStartIndex);
+				return a.callStartIndex.CompareTo(b.callStartIndex);
 			});
 			callResults.Reverse();
 			inlineReturnValues(callResults);
diff --git a/de4dot.code/ObfuscatedFile.cs b/de4dot.code/ObfuscatedFile.cs
index 88b33c45..743101b8 100644
--- a/de4dot.code/ObfuscatedFile.cs
+++ b/de4dot.code/ObfuscatedFile.cs
@@ -22,20 +22,20 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
 using System.Text;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.MyStuff;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
+using dot10.DotNet.Writer;
+using dot10.PE;
 using de4dot.code.deobfuscators;
 using de4dot.blocks;
 using de4dot.blocks.cflow;
 using de4dot.code.AssemblyClient;
 using de4dot.code.renamer;
-using de4dot.PE;
 
 namespace de4dot.code {
 	public class ObfuscatedFile : IObfuscatedFile, IDeobfuscatedFile {
 		Options options;
-		ModuleDefinition module;
+		ModuleDefMD module;
 		IDeobfuscator deob;
 		IDeobfuscatorContext deobfuscatorContext;
 		AssemblyModule assemblyModule;
@@ -46,14 +46,14 @@ namespace de4dot.code {
 		bool userStringDecrypterMethods = false;
 
 		class SavedMethodBodies {
-			Dictionary<MethodDefinition, SavedMethodBody> savedMethodBodies = new Dictionary<MethodDefinition, SavedMethodBody>();
+			Dictionary<MethodDef, SavedMethodBody> savedMethodBodies = new Dictionary<MethodDef, SavedMethodBody>();
 
 			class SavedMethodBody {
-				MethodDefinition method;
+				MethodDef method;
 				IList<Instruction> instructions;
 				IList<ExceptionHandler> exceptionHandlers;
 
-				public SavedMethodBody(MethodDefinition method) {
+				public SavedMethodBody(MethodDef method) {
 					this.method = method;
 					DotNetUtils.copyBody(method, out instructions, out exceptionHandlers);
 				}
@@ -63,7 +63,7 @@ namespace de4dot.code {
 				}
 			}
 
-			public void save(MethodDefinition method) {
+			public void save(MethodDef method) {
 				if (isSaved(method))
 					return;
 				savedMethodBodies[method] = new SavedMethodBody(method);
@@ -75,7 +75,7 @@ namespace de4dot.code {
 				savedMethodBodies.Clear();
 			}
 
-			public bool isSaved(MethodDefinition method) {
+			public bool isSaved(MethodDef method) {
 				return savedMethodBodies.ContainsKey(method);
 			}
 		}
@@ -103,7 +103,7 @@ namespace de4dot.code {
 			get { return options.NewFilename; }
 		}
 
-		public ModuleDefinition ModuleDefinition {
+		public ModuleDefMD ModuleDefMD {
 			get { return module; }
 		}
 
@@ -132,12 +132,12 @@ namespace de4dot.code {
 			set { deobfuscatorContext = value; }
 		}
 
-		public ObfuscatedFile(Options options, IAssemblyClientFactory assemblyClientFactory) {
+		public ObfuscatedFile(Options options, ModuleContext moduleContext, IAssemblyClientFactory assemblyClientFactory) {
 			this.assemblyClientFactory = assemblyClientFactory;
 			this.options = options;
 			userStringDecrypterMethods = options.StringDecrypterMethods.Count > 0;
 			options.Filename = Utils.getFullPath(options.Filename);
-			assemblyModule = new AssemblyModule(options.Filename);
+			assemblyModule = new AssemblyModule(options.Filename, moduleContext);
 
 			if (options.NewFilename == null)
 				options.NewFilename = getDefaultNewFilename();
@@ -162,8 +162,8 @@ namespace de4dot.code {
 
 		public void load(IEnumerable<IDeobfuscator> deobfuscators) {
 			loadModule(deobfuscators);
-			AssemblyResolver.Instance.addSearchDirectory(Utils.getDirName(Filename));
-			AssemblyResolver.Instance.addSearchDirectory(Utils.getDirName(NewFilename));
+			TheAssemblyResolver.Instance.addSearchDirectory(Utils.getDirName(Filename));
+			TheAssemblyResolver.Instance.addSearchDirectory(Utils.getDirName(NewFilename));
 			detectObfuscator(deobfuscators);
 			if (deob == null)
 				throw new ApplicationException("Could not detect obfuscator!");
@@ -171,18 +171,23 @@ namespace de4dot.code {
 		}
 
 		void loadModule(IEnumerable<IDeobfuscator> deobfuscators) {
+			ModuleDefMD oldModule = module;
 			try {
 				module = assemblyModule.load();
 			}
 			catch (BadImageFormatException) {
 				if (!unpackNativeImage(deobfuscators))
 					throw new BadImageFormatException();
-				Log.v("Unpacked native file");
+				Logger.v("Unpacked native file");
+			}
+			finally {
+				if (oldModule != null)
+					oldModule.Dispose();
 			}
 		}
 
 		bool unpackNativeImage(IEnumerable<IDeobfuscator> deobfuscators) {
-			var peImage = new PeImage(Utils.readFile(Filename));
+			var peImage = new PEImage(Filename);
 
 			foreach (var deob in deobfuscators) {
 				byte[] unpackedData = null;
@@ -194,13 +199,18 @@ namespace de4dot.code {
 				if (unpackedData == null)
 					continue;
 
+				var oldModule = module;
 				try {
 					module = assemblyModule.load(unpackedData);
 				}
 				catch {
-					Log.w("Could not load unpacked data. Deobfuscator: {0}", deob.TypeLong);
+					Logger.w("Could not load unpacked data. File: {0}, deobfuscator: {0}", peImage.FileName ?? "(unknown filename)", deob.TypeLong);
 					continue;
 				}
+				finally {
+					if (oldModule != null)
+						oldModule.Dispose();
+				}
 				this.deob = deob;
 				return true;
 			}
@@ -283,7 +293,7 @@ namespace de4dot.code {
 				catch {
 					val = deob.Type == "un" ? 1 : 0;
 				}
-				Log.v("{0,3}: {1}", val, deob.TypeLong);
+				Logger.v("{0,3}: {1}", val, deob.TypeLong);
 				if (val > 0 && deob.Type != "un")
 					allDetected.Add(deob);
 				if (val > detectVal) {
@@ -294,23 +304,27 @@ namespace de4dot.code {
 			this.deob = null;
 
 			if (allDetected.Count > 1) {
-				Log.n("More than one obfuscator detected:");
-				Log.indent();
+				Logger.n("More than one obfuscator detected:");
+				Logger.Instance.indent();
 				foreach (var deob in allDetected)
-					Log.n("{0} (use: -p {1})", deob.Name, deob.Type);
-				Log.deIndent();
+					Logger.n("{0} (use: -p {1})", deob.Name, deob.Type);
+				Logger.Instance.deIndent();
 			}
 
 			return detected;
 		}
 
-		public void save() {
-			Log.n("Saving {0}", options.NewFilename);
-			assemblyModule.save(options.NewFilename, options.ControlFlowDeobfuscation, deob as IWriterListener);
+		bool ShouldPreserveTokens() {
+			return options.KeepObfuscatorTypes || deob.Type == "un";
 		}
 
-		IList<MethodDefinition> getAllMethods() {
-			var list = new List<MethodDefinition>();
+		public void save() {
+			Logger.n("Saving {0}", options.NewFilename);
+			assemblyModule.save(options.NewFilename, ShouldPreserveTokens(), options.ControlFlowDeobfuscation, deob as IModuleWriterListener);
+		}
+
+		IList<MethodDef> getAllMethods() {
+			var list = new List<MethodDef>();
 
 			foreach (var type in module.GetTypes()) {
 				foreach (var method in type.Methods)
@@ -349,7 +363,7 @@ namespace de4dot.code {
 		}
 
 		public void deobfuscate() {
-			Log.n("Cleaning {0}", options.Filename);
+			Logger.n("Cleaning {0}", options.Filename);
 			initAssemblyClient();
 
 			for (int i = 0; ; i++) {
@@ -366,15 +380,23 @@ namespace de4dot.code {
 		}
 
 		void reloadModule(byte[] newModuleData, DumpedMethods dumpedMethods) {
-			Log.v("Reloading decrypted assembly (original filename: {0})", Filename);
+			Logger.v("Reloading decrypted assembly (original filename: {0})", Filename);
 			simpleDeobfuscatorFlags.Clear();
-			module = assemblyModule.reload(newModuleData, dumpedMethods);
-			deob = deob.moduleReloaded(module);
+			using (var oldModule = module) {
+				module = assemblyModule.reload(newModuleData, createDumpedMethodsRestorer(dumpedMethods), deob as IStringDecrypter);
+				deob = deob.moduleReloaded(module);
+			}
 			initializeDeobfuscator();
 			deob.DeobfuscatedFile = this;
 			updateDynamicStringInliner();
 		}
 
+		DumpedMethodsRestorer createDumpedMethodsRestorer(DumpedMethods dumpedMethods) {
+			if (dumpedMethods == null || dumpedMethods.Count == 0)
+				return null;
+			return new DumpedMethodsRestorer(dumpedMethods);
+		}
+
 		void initAssemblyClient() {
 			if (assemblyClient == null)
 				return;
@@ -429,26 +451,29 @@ namespace de4dot.code {
 				if (typeString != null && typeString != type.FullName)
 					continue;
 				foreach (var method in type.Methods) {
-					if (!method.IsStatic || method.MethodReturnType.ReturnType.FullName != "System.String")
+					if (!method.IsStatic)
+						continue;
+					if (method.MethodSig.GetRetType().GetElementType() != ElementType.String && method.MethodSig.GetRetType().GetElementType() != ElementType.Object)
 						continue;
 					if (methodName != null && methodName != method.Name)
 						continue;
 
+					var sig = method.MethodSig;
 					if (argsStrings == null) {
-						if (method.Parameters.Count == 0)
+						if (sig.Params.Count == 0)
 							continue;
 					}
 					else {
-						if (argsStrings.Length != method.Parameters.Count)
+						if (argsStrings.Length != sig.Params.Count)
 							continue;
 						for (int i = 0; i < argsStrings.Length; i++) {
-							if (argsStrings[i] != method.Parameters[i].ParameterType.FullName)
+							if (argsStrings[i] != sig.Params[i].FullName)
 								continue;
 						}
 					}
 
-					Log.v("Adding string decrypter; token: {0:X8}, method: {1}", method.MetadataToken.ToInt32(), Utils.removeNewlines(method.FullName));
-					tokens.Add(method.MetadataToken.ToInt32());
+					Logger.v("Adding string decrypter; token: {0:X8}, method: {1}", method.MDToken.ToInt32(), Utils.removeNewlines(method.FullName));
+					tokens.Add(method.MDToken.ToInt32());
 				}
 			}
 
@@ -521,45 +546,52 @@ namespace de4dot.code {
 			if (!options.ControlFlowDeobfuscation) {
 				// If it's the unknown type, we don't remove any types that could cause Mono.Cecil
 				// to throw an exception.
-				if (deob.Type == "un" || options.KeepObfuscatorTypes)
+				if (ShouldPreserveTokens())
 					return;
 			}
 
-			Log.v("Deobfuscating methods");
+			bool isVerbose = !Logger.Instance.IgnoresEvent(LoggerEvent.Verbose);
+			bool isVV = !Logger.Instance.IgnoresEvent(LoggerEvent.VeryVerbose);
+			if (isVerbose)
+				Logger.v("Deobfuscating methods");
 			var methodPrinter = new MethodPrinter();
 			var cflowDeobfuscator = new BlocksCflowDeobfuscator(deob.BlocksDeobfuscators);
 			foreach (var method in getAllMethods()) {
-				Log.v("Deobfuscating {0} ({1:X8})", Utils.removeNewlines(method), method.MetadataToken.ToUInt32());
-				Log.indent();
+				if (isVerbose) {
+					Logger.v("Deobfuscating {0} ({1:X8})", Utils.removeNewlines(method), method.MDToken.ToUInt32());
+					Logger.Instance.indent();
+				}
 
-				int oldIndentLevel = Log.indentLevel;
+				int oldIndentLevel = Logger.Instance.IndentLevel;
 				try {
-					deobfuscate(method, cflowDeobfuscator, methodPrinter);
+					deobfuscate(method, cflowDeobfuscator, methodPrinter, isVerbose, isVV);
 				}
 				catch (ApplicationException) {
 					throw;
 				}
 				catch (Exception ex) {
 					if (!canLoadMethodBody(method)) {
-						Log.v("Invalid method body. {0:X8}", method.MetadataToken.ToInt32());
-						method.Body = new MethodBody(method);
+						if (isVerbose)
+							Logger.v("Invalid method body. {0:X8}", method.MDToken.ToInt32());
+						method.Body = new CilBody();
 					}
 					else {
-						Log.w("Could not deobfuscate method {0:X8}. Hello, E.T.: {1}",	// E.T. = exception type
-								method.MetadataToken.ToInt32(),
+						Logger.w("Could not deobfuscate method {0:X8}. Hello, E.T.: {1}",	// E.T. = exception type
+								method.MDToken.ToInt32(),
 								ex.GetType());
 					}
 				}
 				finally {
-					Log.indentLevel = oldIndentLevel;
+					Logger.Instance.IndentLevel = oldIndentLevel;
 				}
 				removeNoInliningAttribute(method);
 
-				Log.deIndent();
+				if (isVerbose)
+					Logger.Instance.deIndent();
 			}
 		}
 
-		static bool canLoadMethodBody(MethodDefinition method) {
+		static bool canLoadMethodBody(MethodDef method) {
 			try {
 				var body = method.Body;
 				return true;
@@ -569,7 +601,7 @@ namespace de4dot.code {
 			}
 		}
 
-		void deobfuscate(MethodDefinition method, BlocksCflowDeobfuscator cflowDeobfuscator, MethodPrinter methodPrinter) {
+		void deobfuscate(MethodDef method, BlocksCflowDeobfuscator cflowDeobfuscator, MethodPrinter methodPrinter, bool isVerbose, bool isVV) {
 			if (!hasNonEmptyBody(method))
 				return;
 
@@ -587,7 +619,10 @@ namespace de4dot.code {
 				cflowDeobfuscator.deobfuscate();
 
 			if (options.ControlFlowDeobfuscation) {
-				numRemovedLocals = blocks.optimizeLocals();
+				// Don't remove any locals if we should preserve tokens or we won't be able
+				// to always preserve StandAloneSig tokens.
+				if (!ShouldPreserveTokens())
+					numRemovedLocals = blocks.optimizeLocals();
 				blocks.repartitionBlocks();
 			}
 
@@ -599,22 +634,21 @@ namespace de4dot.code {
 			blocks.getCode(out allInstructions, out allExceptionHandlers);
 			DotNetUtils.restoreBody(method, allInstructions, allExceptionHandlers);
 
-			if (numRemovedLocals > 0)
-				Log.v("Removed {0} unused local(s)", numRemovedLocals);
+			if (isVerbose && numRemovedLocals > 0)
+				Logger.v("Removed {0} unused local(s)", numRemovedLocals);
 			int numRemovedInstructions = oldNumInstructions - method.Body.Instructions.Count;
-			if (numRemovedInstructions > 0)
-				Log.v("Removed {0} dead instruction(s)", numRemovedInstructions);
+			if (isVerbose && numRemovedInstructions > 0)
+				Logger.v("Removed {0} dead instruction(s)", numRemovedInstructions);
 
-			const Log.LogLevel dumpLogLevel = Log.LogLevel.veryverbose;
-			if (Log.isAtLeast(dumpLogLevel)) {
-				Log.log(dumpLogLevel, "Deobfuscated code:");
-				Log.indent();
-				methodPrinter.print(dumpLogLevel, allInstructions, allExceptionHandlers);
-				Log.deIndent();
+			if (isVV) {
+				Logger.log(LoggerEvent.VeryVerbose, "Deobfuscated code:");
+				Logger.Instance.indent();
+				methodPrinter.print(LoggerEvent.VeryVerbose, allInstructions, allExceptionHandlers);
+				Logger.Instance.deIndent();
 			}
 		}
 
-		bool hasNonEmptyBody(MethodDefinition method) {
+		bool hasNonEmptyBody(MethodDef method) {
 			return method.HasBody && method.Body.Instructions.Count > 0;
 		}
 
@@ -637,11 +671,11 @@ namespace de4dot.code {
 			}
 		}
 
-		void removeNoInliningAttribute(MethodDefinition method) {
-			method.ImplAttributes = method.ImplAttributes & ~MethodImplAttributes.NoInlining;
+		void removeNoInliningAttribute(MethodDef method) {
+			method.IsNoInlining = false;
 			for (int i = 0; i < method.CustomAttributes.Count; i++) {
 				var cattr = method.CustomAttributes[i];
-				if (cattr.AttributeType.FullName != "System.Runtime.CompilerServices.MethodImplAttribute")
+				if (cattr.TypeFullName != "System.Runtime.CompilerServices.MethodImplAttribute")
 					continue;
 				int options = 0;
 				if (!getMethodImplOptions(cattr, ref options))
@@ -654,9 +688,11 @@ namespace de4dot.code {
 		}
 
 		static bool getMethodImplOptions(CustomAttribute cattr, ref int value) {
+			if (cattr.IsRawBlob)
+				return false;
 			if (cattr.ConstructorArguments.Count != 1)
 				return false;
-			if (cattr.ConstructorArguments[0].Type.FullName != "System.Int16" &&
+			if (cattr.ConstructorArguments[0].Type.ElementType != ElementType.I2 &&
 				cattr.ConstructorArguments[0].Type.FullName != "System.Runtime.CompilerServices.MethodImplOptions")
 				return false;
 
@@ -683,20 +719,20 @@ namespace de4dot.code {
 		enum SimpleDeobFlags {
 			HasDeobfuscated = 0x1,
 		}
-		Dictionary<MethodDefinition, SimpleDeobFlags> simpleDeobfuscatorFlags = new Dictionary<MethodDefinition, SimpleDeobFlags>();
-		bool check(MethodDefinition method, SimpleDeobFlags flag) {
+		Dictionary<MethodDef, SimpleDeobFlags> simpleDeobfuscatorFlags = new Dictionary<MethodDef, SimpleDeobFlags>();
+		bool check(MethodDef method, SimpleDeobFlags flag) {
 			SimpleDeobFlags oldFlags;
 			simpleDeobfuscatorFlags.TryGetValue(method, out oldFlags);
 			simpleDeobfuscatorFlags[method] = oldFlags | flag;
 			return (oldFlags & flag) == flag;
 		}
 
-		void deobfuscate(MethodDefinition method, string msg, Action<Blocks> handler) {
+		void deobfuscate(MethodDef method, string msg, Action<Blocks> handler) {
 			if (savedMethodBodies != null)
 				savedMethodBodies.save(method);
 
-			Log.v("{0}: {1} ({2:X8})", msg, Utils.removeNewlines(method), method.MetadataToken.ToUInt32());
-			Log.indent();
+			Logger.v("{0}: {1} ({2:X8})", msg, Utils.removeNewlines(method), method.MDToken.ToUInt32());
+			Logger.Instance.indent();
 
 			if (hasNonEmptyBody(method)) {
 				try {
@@ -710,18 +746,18 @@ namespace de4dot.code {
 					DotNetUtils.restoreBody(method, allInstructions, allExceptionHandlers);
 				}
 				catch {
-					Log.v("Could not deobfuscate {0:X8}", method.MetadataToken.ToInt32());
+					Logger.v("Could not deobfuscate {0:X8}", method.MDToken.ToInt32());
 				}
 			}
 
-			Log.deIndent();
+			Logger.Instance.deIndent();
 		}
 
-		void ISimpleDeobfuscator.deobfuscate(MethodDefinition method) {
+		void ISimpleDeobfuscator.deobfuscate(MethodDef method) {
 			((ISimpleDeobfuscator)this).deobfuscate(method, false);
 		}
 
-		void ISimpleDeobfuscator.deobfuscate(MethodDefinition method, bool force) {
+		void ISimpleDeobfuscator.deobfuscate(MethodDef method, bool force) {
 			if (!force && check(method, SimpleDeobFlags.HasDeobfuscated))
 				return;
 
@@ -732,7 +768,7 @@ namespace de4dot.code {
 			});
 		}
 
-		void ISimpleDeobfuscator.decryptStrings(MethodDefinition method, IDeobfuscator theDeob) {
+		void ISimpleDeobfuscator.decryptStrings(MethodDef method, IDeobfuscator theDeob) {
 			deobfuscate(method, "Static string decryption", (blocks) => theDeob.deobfuscateStrings(blocks));
 		}
 
@@ -741,7 +777,7 @@ namespace de4dot.code {
 				extension = ".dll";
 			var baseDir = Utils.getDirName(options.NewFilename);
 			var newName = Path.Combine(baseDir, assemblyName + extension);
-			Log.n("Creating file {0}", newName);
+			Logger.n("Creating file {0}", newName);
 			using (var writer = new BinaryWriter(new FileStream(newName, FileMode.Create))) {
 				writer.Write(data);
 			}
@@ -754,5 +790,13 @@ namespace de4dot.code {
 		void IDeobfuscatedFile.setDeobfuscator(IDeobfuscator deob) {
 			this.deob = deob;
 		}
+
+		public void Dispose() {
+			deobfuscateCleanUp();
+			if (module != null)
+				module.Dispose();
+			module = null;
+			deob = null;
+		}
 	}
 }
diff --git a/de4dot.code/StringInliner.cs b/de4dot.code/StringInliner.cs
index 7e0e6147..cf586ddd 100644
--- a/de4dot.code/StringInliner.cs
+++ b/de4dot.code/StringInliner.cs
@@ -19,8 +19,8 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.code.AssemblyClient;
 using de4dot.blocks;
 
@@ -49,7 +49,7 @@ namespace de4dot.code {
 				if (ldstrIndex + 1 < block.Instructions.Count) {
 					var instr = block.Instructions[ldstrIndex + 1];
 					if (instr.OpCode.Code == Code.Call) {
-						var calledMethod = instr.Operand as MethodReference;
+						var calledMethod = instr.Operand as IMethod;
 						if (calledMethod != null &&
 							calledMethod.FullName == "System.String System.String::Intern(System.String)") {
 							block.remove(ldstrIndex + 1, 1);
@@ -57,7 +57,7 @@ namespace de4dot.code {
 					}
 				}
 
-				Log.v("Decrypted string: {0}", Utils.toCsharpString(decryptedString));
+				Logger.v("Decrypted string: {0}", Utils.toCsharpString(decryptedString));
 			}
 		}
 	}
@@ -68,8 +68,8 @@ namespace de4dot.code {
 
 		class MyCallResult : CallResult {
 			public int methodId;
-			public GenericInstanceMethod gim;
-			public MyCallResult(Block block, int callEndIndex, int methodId, GenericInstanceMethod gim)
+			public MethodSpec gim;
+			public MyCallResult(Block block, int callEndIndex, int methodId, MethodSpec gim)
 				: base(block, callEndIndex) {
 				this.methodId = methodId;
 				this.gim = gim;
@@ -93,9 +93,9 @@ namespace de4dot.code {
 			}
 		}
 
-		protected override CallResult createCallResult(MethodReference method, GenericInstanceMethod gim, Block block, int callInstrIndex) {
+		protected override CallResult createCallResult(IMethod method, MethodSpec gim, Block block, int callInstrIndex) {
 			int methodId;
-			if (!methodTokenToId.TryGetValue(method.MetadataToken.ToInt32(), out methodId))
+			if (!methodTokenToId.TryGetValue(method.MDToken.ToInt32(), out methodId))
 				return null;
 			return new MyCallResult(block, callInstrIndex, methodId, gim);
 		}
@@ -117,7 +117,7 @@ namespace de4dot.code {
 					AssemblyData.SimpleData.pack(list[i].args);
 					args[i] = list[i].args;
 				}
-				var decryptedStrings = assemblyClient.Service.decryptStrings(methodId, args, Method.MetadataToken.ToInt32());
+				var decryptedStrings = assemblyClient.Service.decryptStrings(methodId, args, Method.MDToken.ToInt32());
 				if (decryptedStrings.Length != args.Length)
 					throw new ApplicationException("Invalid decrypted strings array length");
 				AssemblyData.SimpleData.unpack(decryptedStrings);
@@ -128,27 +128,27 @@ namespace de4dot.code {
 	}
 
 	class StaticStringInliner : StringInlinerBase {
-		MethodDefinitionAndDeclaringTypeDict<Func<MethodDefinition, GenericInstanceMethod, object[], string>> stringDecrypters = new MethodDefinitionAndDeclaringTypeDict<Func<MethodDefinition, GenericInstanceMethod, object[], string>>();
+		MethodDefinitionAndDeclaringTypeDict<Func<MethodDef, MethodSpec, object[], string>> stringDecrypters = new MethodDefinitionAndDeclaringTypeDict<Func<MethodDef, MethodSpec, object[], string>>();
 
 		public override bool HasHandlers {
 			get { return stringDecrypters.Count != 0; }
 		}
 
-		public IEnumerable<MethodDefinition> Methods {
+		public IEnumerable<MethodDef> Methods {
 			get { return stringDecrypters.getKeys(); }
 		}
 
 		class MyCallResult : CallResult {
-			public MethodReference methodReference;
-			public GenericInstanceMethod gim;
-			public MyCallResult(Block block, int callEndIndex, MethodReference method, GenericInstanceMethod gim)
+			public IMethod IMethod;
+			public MethodSpec gim;
+			public MyCallResult(Block block, int callEndIndex, IMethod method, MethodSpec gim)
 				: base(block, callEndIndex) {
-				this.methodReference = method;
+				this.IMethod = method;
 				this.gim = gim;
 			}
 		}
 
-		public void add(MethodDefinition method, Func<MethodDefinition, GenericInstanceMethod, object[], string> handler) {
+		public void add(MethodDef method, Func<MethodDef, MethodSpec, object[], string> handler) {
 			if (method != null)
 				stringDecrypters.add(method, handler);
 		}
@@ -156,12 +156,12 @@ namespace de4dot.code {
 		protected override void inlineAllCalls() {
 			foreach (var tmp in callResults) {
 				var callResult = (MyCallResult)tmp;
-				var handler = stringDecrypters.find(callResult.methodReference);
-				callResult.returnValue = handler((MethodDefinition)callResult.methodReference, callResult.gim, callResult.args);
+				var handler = stringDecrypters.find(callResult.IMethod);
+				callResult.returnValue = handler((MethodDef)callResult.IMethod, callResult.gim, callResult.args);
 			}
 		}
 
-		protected override CallResult createCallResult(MethodReference method, GenericInstanceMethod gim, Block block, int callInstrIndex) {
+		protected override CallResult createCallResult(IMethod method, MethodSpec gim, Block block, int callInstrIndex) {
 			if (stringDecrypters.find(method) == null)
 				return null;
 			return new MyCallResult(block, callInstrIndex, method, gim);
diff --git a/de4dot.code/Utils.cs b/de4dot.code/Utils.cs
index 6ece6e7b..d3caac88 100644
--- a/de4dot.code/Utils.cs
+++ b/de4dot.code/Utils.cs
@@ -21,6 +21,8 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
+using dot10.DotNet;
+using dot10.IO;
 
 namespace de4dot.code {
 	// These are in .NET 3.5 and later...
@@ -61,6 +63,10 @@ namespace de4dot.code {
 			return dict.Keys;
 		}
 
+		public static string toCsharpString(UTF8String s) {
+			return toCsharpString(UTF8String.ToSystemStringOrEmpty(s));
+		}
+
 		public static string toCsharpString(string s) {
 			var sb = new StringBuilder(s.Length + 2);
 			sb.Append('"');
@@ -209,12 +215,6 @@ namespace de4dot.code {
 			return true;
 		}
 
-		public static int compareInt32(int a, int b) {
-			if (a < b) return -1;
-			if (a > b) return 1;
-			return 0;
-		}
-
 		public static byte[] readFile(string filename) {
 			// If the file is on the network, and we read more than 2MB, we'll read from the wrong
 			// offset in the file! Tested: VMware 8, Win7 x64.
@@ -232,22 +232,5 @@ namespace de4dot.code {
 				return fileData;
 			}
 		}
-
-		public static uint readEncodedUInt32(BinaryReader reader) {
-			uint val = 0;
-			int bits = 0;
-			for (int i = 0; i < 5; i++) {
-				byte b = reader.ReadByte();
-				val |= (uint)(b & 0x7F) << bits;
-				if ((b & 0x80) == 0)
-					return val;
-				bits += 7;
-			}
-			throw new ApplicationException("Invalid encoded int32");
-		}
-
-		public static int readEncodedInt32(BinaryReader reader) {
-			return (int)readEncodedUInt32(reader);
-		}
 	}
 }
diff --git a/de4dot.code/de4dot.code.csproj b/de4dot.code/de4dot.code.csproj
index d373674f..6ebcfa82 100644
--- a/de4dot.code/de4dot.code.csproj
+++ b/de4dot.code/de4dot.code.csproj
@@ -60,8 +60,28 @@
     <Compile Include="AssemblyClient\NewAppDomainAssemblyServerLoader.cs" />
     <Compile Include="AssemblyClient\NewProcessAssemblyServerLoader.cs" />
     <Compile Include="AssemblyClient\SameAppDomainAssemblyServerLoader.cs" />
+    <Compile Include="AssemblyModule.cs" />
     <Compile Include="AssemblyResolver.cs" />
     <Compile Include="DeobfuscatorContext.cs" />
+    <Compile Include="deobfuscators\Agile_NET\CliSecureRtType.cs" />
+    <Compile Include="deobfuscators\Agile_NET\CsBlowfish.cs" />
+    <Compile Include="deobfuscators\Agile_NET\Deobfuscator.cs" />
+    <Compile Include="deobfuscators\Agile_NET\MethodsDecrypter.cs" />
+    <Compile Include="deobfuscators\Agile_NET\ProxyCallFixer.cs" />
+    <Compile Include="deobfuscators\Agile_NET\ResourceDecrypter.cs" />
+    <Compile Include="deobfuscators\Agile_NET\StackFrameHelper.cs" />
+    <Compile Include="deobfuscators\Agile_NET\StringDecrypter.cs" />
+    <Compile Include="deobfuscators\Agile_NET\vm\CilOperandInstructionRestorer.cs" />
+    <Compile Include="deobfuscators\Agile_NET\vm\Csvm.cs" />
+    <Compile Include="deobfuscators\Agile_NET\vm\CsvmDataReader.cs" />
+    <Compile Include="deobfuscators\Agile_NET\vm\CsvmMethodData.cs" />
+    <Compile Include="deobfuscators\Agile_NET\vm\CsvmToCilMethodConverter.cs" />
+    <Compile Include="deobfuscators\Agile_NET\vm\FieldsInfo.cs" />
+    <Compile Include="deobfuscators\Agile_NET\vm\OpCodeHandler.cs" />
+    <Compile Include="deobfuscators\Agile_NET\vm\OpCodeHandlers.cs" />
+    <Compile Include="deobfuscators\Agile_NET\vm\UnknownHandlerInfo.cs" />
+    <Compile Include="deobfuscators\Agile_NET\vm\VmOpCodeHandlerDetector.cs" />
+    <Compile Include="deobfuscators\Agile_NET\vm\VmOperands.cs" />
     <Compile Include="deobfuscators\ArrayFinder.cs" />
     <Compile Include="deobfuscators\Babel_NET\AssemblyResolver.cs" />
     <Compile Include="deobfuscators\Babel_NET\BabelInflater.cs" />
@@ -96,109 +116,84 @@
     <Compile Include="deobfuscators\Confuser\Unpacker.cs" />
     <Compile Include="deobfuscators\Confuser\VersionDetector.cs" />
     <Compile Include="deobfuscators\Confuser\x86Emulator.cs" />
-    <Compile Include="deobfuscators\CryptoObfuscator\CoUtils.cs" />
-    <Compile Include="deobfuscators\CryptoObfuscator\MethodBodyReader.cs" />
-    <Compile Include="deobfuscators\CryptoObfuscator\MethodsDecrypter.cs" />
-    <Compile Include="deobfuscators\dotNET_Reactor\v4\ProxyCallFixer.cs" />
-    <Compile Include="deobfuscators\ILProtector\MethodReader.cs" />
-    <Compile Include="deobfuscators\ILProtector\MethodsDecrypter.cs" />
-    <Compile Include="deobfuscators\DeepSea\ArrayBlockState.cs" />
-    <Compile Include="deobfuscators\MaxtoCode\CryptDecrypter.cs" />
-    <Compile Include="deobfuscators\MaxtoCode\Decrypter6.cs" />
-    <Compile Include="deobfuscators\MaxtoCode\DecrypterInfo.cs" />
-    <Compile Include="deobfuscators\MaxtoCode\EncryptionInfos.cs" />
-    <Compile Include="deobfuscators\MaxtoCode\McKey.cs" />
-    <Compile Include="deobfuscators\MaxtoCode\PeHeader.cs" />
-    <Compile Include="deobfuscators\MaxtoCode\StringDecrypter.cs" />
-    <Compile Include="deobfuscators\CryptoObfuscator\ConstantsDecrypter.cs" />
-    <Compile Include="deobfuscators\MethodBodyReaderBase.cs" />
     <Compile Include="deobfuscators\Babel_NET\MethodsDecrypter.cs" />
     <Compile Include="deobfuscators\Babel_NET\ProxyCallFixer.cs" />
     <Compile Include="deobfuscators\Babel_NET\ResourceDecrypter.cs" />
     <Compile Include="deobfuscators\Babel_NET\ResourceResolver.cs" />
     <Compile Include="deobfuscators\Babel_NET\StringDecrypter.cs" />
     <Compile Include="deobfuscators\Blowfish.cs" />
-    <Compile Include="deobfuscators\CliSecure\CliSecureRtType.cs" />
-    <Compile Include="deobfuscators\CliSecure\CsBlowfish.cs" />
-    <Compile Include="deobfuscators\CliSecure\Deobfuscator.cs" />
-    <Compile Include="deobfuscators\CliSecure\MethodsDecrypter.cs" />
-    <Compile Include="deobfuscators\CliSecure\ProxyCallFixer.cs" />
-    <Compile Include="deobfuscators\CliSecure\ResourceDecrypter.cs" />
-    <Compile Include="deobfuscators\CliSecure\StackFrameHelper.cs" />
-    <Compile Include="deobfuscators\CliSecure\StringDecrypter.cs" />
-    <Compile Include="deobfuscators\CliSecure\vm\CilOperandInstructionRestorer.cs" />
-    <Compile Include="deobfuscators\CliSecure\vm\Csvm.cs" />
-    <Compile Include="deobfuscators\CliSecure\vm\CsvmDataReader.cs" />
-    <Compile Include="deobfuscators\CliSecure\vm\CsvmMethodData.cs" />
-    <Compile Include="deobfuscators\CliSecure\vm\CsvmToCilMethodConverter.cs" />
-    <Compile Include="deobfuscators\CliSecure\vm\FieldsInfo.cs" />
-    <Compile Include="deobfuscators\CliSecure\vm\OpCodeHandler.cs" />
-    <Compile Include="deobfuscators\CliSecure\vm\OpCodeHandlers.cs" />
-    <Compile Include="deobfuscators\CliSecure\vm\UnknownHandlerInfo.cs" />
-    <Compile Include="deobfuscators\CliSecure\vm\VmOpCodeHandlerDetector.cs" />
-    <Compile Include="deobfuscators\CliSecure\vm\VmOperands.cs" />
-    <Compile Include="deobfuscators\CodeFort\PasswordFinder.cs" />
     <Compile Include="deobfuscators\CodeFort\AssemblyData.cs" />
     <Compile Include="deobfuscators\CodeFort\AssemblyDecrypter.cs" />
     <Compile Include="deobfuscators\CodeFort\CfMethodCallInliner.cs" />
     <Compile Include="deobfuscators\CodeFort\Deobfuscator.cs" />
+    <Compile Include="deobfuscators\CodeFort\PasswordFinder.cs" />
     <Compile Include="deobfuscators\CodeFort\ProxyCallFixer.cs" />
     <Compile Include="deobfuscators\CodeFort\StringDecrypter.cs" />
     <Compile Include="deobfuscators\CodeVeil\AssemblyResolver.cs" />
+    <Compile Include="deobfuscators\CodeVeil\Deobfuscator.cs" />
     <Compile Include="deobfuscators\CodeVeil\ErexResourceReader.cs" />
     <Compile Include="deobfuscators\CodeVeil\InvalidDataException.cs" />
     <Compile Include="deobfuscators\CodeVeil\InvalidMethodsFinder.cs" />
     <Compile Include="deobfuscators\CodeVeil\MainType.cs" />
     <Compile Include="deobfuscators\CodeVeil\MethodsDecrypter.cs" />
     <Compile Include="deobfuscators\CodeVeil\ObfuscatorVersion.cs" />
+    <Compile Include="deobfuscators\CodeVeil\ProxyCallFixer.cs" />
     <Compile Include="deobfuscators\CodeVeil\ResourceConverter.cs" />
     <Compile Include="deobfuscators\CodeVeil\ResourceDecrypter.cs" />
     <Compile Include="deobfuscators\CodeVeil\ResourceInfo.cs" />
     <Compile Include="deobfuscators\CodeVeil\ResourceReader.cs" />
     <Compile Include="deobfuscators\CodeVeil\StringDecrypter.cs" />
-    <Compile Include="deobfuscators\CodeVeil\Deobfuscator.cs" />
-    <Compile Include="deobfuscators\CodeVeil\ProxyCallFixer.cs" />
     <Compile Include="deobfuscators\CodeVeil\TamperDetection.cs" />
     <Compile Include="deobfuscators\CodeWall\AssemblyDecrypter.cs" />
     <Compile Include="deobfuscators\CodeWall\Deobfuscator.cs" />
+    <Compile Include="deobfuscators\CodeWall\KeyGenerator.cs" />
     <Compile Include="deobfuscators\CodeWall\MethodsDecrypter.cs" />
     <Compile Include="deobfuscators\CodeWall\randomc\CRandomMersenne.cs" />
     <Compile Include="deobfuscators\CodeWall\randomc\CRandomMother.cs" />
-    <Compile Include="deobfuscators\CodeWall\KeyGenerator.cs" />
     <Compile Include="deobfuscators\CodeWall\StringDecrypter.cs" />
     <Compile Include="deobfuscators\ConstantsReader.cs" />
     <Compile Include="deobfuscators\CryptoObfuscator\AntiDebugger.cs" />
     <Compile Include="deobfuscators\CryptoObfuscator\AssemblyResolver.cs" />
+    <Compile Include="deobfuscators\CryptoObfuscator\ConstantsDecrypter.cs" />
+    <Compile Include="deobfuscators\CryptoObfuscator\CoUtils.cs" />
     <Compile Include="deobfuscators\CryptoObfuscator\Deobfuscator.cs" />
+    <Compile Include="deobfuscators\CryptoObfuscator\MethodBodyReader.cs" />
+    <Compile Include="deobfuscators\CryptoObfuscator\MethodsDecrypter.cs" />
     <Compile Include="deobfuscators\CryptoObfuscator\ProxyCallFixer.cs" />
     <Compile Include="deobfuscators\CryptoObfuscator\ResourceDecrypter.cs" />
     <Compile Include="deobfuscators\CryptoObfuscator\ResourceResolver.cs" />
     <Compile Include="deobfuscators\CryptoObfuscator\StringDecrypter.cs" />
     <Compile Include="deobfuscators\CryptoObfuscator\TamperDetection.cs" />
     <Compile Include="deobfuscators\DeepSea\ArrayBlockDeobfuscator.cs" />
+    <Compile Include="deobfuscators\DeepSea\ArrayBlockState.cs" />
+    <Compile Include="deobfuscators\DeepSea\AssemblyResolver.cs" />
     <Compile Include="deobfuscators\DeepSea\CastDeobfuscator.cs" />
+    <Compile Include="deobfuscators\DeepSea\Deobfuscator.cs" />
     <Compile Include="deobfuscators\DeepSea\DsConstantsReader.cs" />
+    <Compile Include="deobfuscators\DeepSea\DsInlinedMethodsFinder.cs" />
+    <Compile Include="deobfuscators\DeepSea\DsMethodCallInliner.cs" />
     <Compile Include="deobfuscators\DeepSea\DsUtils.cs" />
     <Compile Include="deobfuscators\DeepSea\FieldsRestorer.cs" />
-    <Compile Include="deobfuscators\DeobfuscatorBase.cs" />
-    <Compile Include="deobfuscators\DeobfuscatorInfoBase.cs" />
-    <Compile Include="deobfuscators\DeobUtils.cs" />
-    <Compile Include="deobfuscators\DeepSea\AssemblyResolver.cs" />
-    <Compile Include="deobfuscators\DeepSea\DsInlinedMethodsFinder.cs" />
     <Compile Include="deobfuscators\DeepSea\ResolverBase.cs" />
     <Compile Include="deobfuscators\DeepSea\ResourceResolver.cs" />
     <Compile Include="deobfuscators\DeepSea\StringDecrypter.cs" />
-    <Compile Include="deobfuscators\DeepSea\Deobfuscator.cs" />
-    <Compile Include="deobfuscators\DeepSea\DsMethodCallInliner.cs" />
+    <Compile Include="deobfuscators\DeobfuscatorBase.cs" />
+    <Compile Include="deobfuscators\DeobfuscatorInfoBase.cs" />
+    <Compile Include="deobfuscators\DeobUtils.cs" />
     <Compile Include="deobfuscators\Dotfuscator\Deobfuscator.cs" />
     <Compile Include="deobfuscators\Dotfuscator\StringDecrypter.cs" />
+    <Compile Include="deobfuscators\dotNET_Reactor\MyPEImage.cs" />
     <Compile Include="deobfuscators\dotNET_Reactor\v3\AntiStrongName.cs" />
     <Compile Include="deobfuscators\dotNET_Reactor\v3\ApplicationModeDecrypter.cs" />
     <Compile Include="deobfuscators\dotNET_Reactor\v3\ApplicationModeUnpacker.cs" />
+    <Compile Include="deobfuscators\dotNET_Reactor\v3\AssemblyResolver.cs" />
     <Compile Include="deobfuscators\dotNET_Reactor\v3\DecrypterType.cs" />
+    <Compile Include="deobfuscators\dotNET_Reactor\v3\DecryptMethod.cs" />
     <Compile Include="deobfuscators\dotNET_Reactor\v3\Deobfuscator.cs" />
     <Compile Include="deobfuscators\dotNET_Reactor\v3\LibAssemblyResolver.cs" />
+    <Compile Include="deobfuscators\dotNET_Reactor\v3\MemoryPatcher.cs" />
     <Compile Include="deobfuscators\dotNET_Reactor\v3\NativeLibSaver.cs" />
+    <Compile Include="deobfuscators\dotNET_Reactor\v4\AntiStrongName.cs" />
     <Compile Include="deobfuscators\dotNET_Reactor\v4\AssemblyResolver.cs" />
     <Compile Include="deobfuscators\dotNET_Reactor\v4\BooleanDecrypter.cs" />
     <Compile Include="deobfuscators\dotNET_Reactor\v4\Deobfuscator.cs" />
@@ -208,26 +203,20 @@
     <Compile Include="deobfuscators\dotNET_Reactor\v4\MethodsDecrypter.cs" />
     <Compile Include="deobfuscators\dotNET_Reactor\v4\NativeFileDecrypter.cs" />
     <Compile Include="deobfuscators\dotNET_Reactor\v4\NativeImageUnpacker.cs" />
+    <Compile Include="deobfuscators\dotNET_Reactor\v4\ProxyCallFixer.cs" />
     <Compile Include="deobfuscators\dotNET_Reactor\v4\ResourceResolver.cs" />
     <Compile Include="deobfuscators\dotNET_Reactor\v4\StringDecrypter.cs" />
-    <Compile Include="deobfuscators\dotNET_Reactor\v4\AntiStrongName.cs" />
-    <Compile Include="deobfuscators\dotNET_Reactor\v3\AssemblyResolver.cs" />
-    <Compile Include="deobfuscators\dotNET_Reactor\v3\DecryptMethod.cs" />
-    <Compile Include="deobfuscators\dotNET_Reactor\v3\MemoryPatcher.cs" />
     <Compile Include="deobfuscators\Eazfuscator_NET\AssemblyResolver.cs" />
     <Compile Include="deobfuscators\Eazfuscator_NET\CodeCompilerMethodCallRestorer.cs" />
-    <Compile Include="deobfuscators\Eazfuscator_NET\EfConstantsReader.cs" />
     <Compile Include="deobfuscators\Eazfuscator_NET\DecrypterType.cs" />
     <Compile Include="deobfuscators\Eazfuscator_NET\Deobfuscator.cs" />
+    <Compile Include="deobfuscators\Eazfuscator_NET\EfConstantsReader.cs" />
     <Compile Include="deobfuscators\Eazfuscator_NET\EfUtils.cs" />
     <Compile Include="deobfuscators\Eazfuscator_NET\ResourceMethodsRestorer.cs" />
     <Compile Include="deobfuscators\Eazfuscator_NET\ResourceResolver.cs" />
     <Compile Include="deobfuscators\Eazfuscator_NET\StringDecrypter.cs" />
     <Compile Include="deobfuscators\Eazfuscator_NET\VersionDetector.cs" />
     <Compile Include="deobfuscators\ExceptionLoggerRemover.cs" />
-    <Compile Include="deobfuscators\ILProtector\Deobfuscator.cs" />
-    <Compile Include="deobfuscators\ILProtector\MainType.cs" />
-    <Compile Include="deobfuscators\MethodCallRestorerBase.cs" />
     <Compile Include="deobfuscators\Goliath_NET\ArrayDecrypter.cs" />
     <Compile Include="deobfuscators\Goliath_NET\ArrayValueInliner.cs" />
     <Compile Include="deobfuscators\Goliath_NET\DecrypterBase.cs" />
@@ -241,19 +230,33 @@
     <Compile Include="deobfuscators\IDeobfuscatedFile.cs" />
     <Compile Include="deobfuscators\IDeobfuscator.cs" />
     <Compile Include="deobfuscators\IDeobfuscatorInfo.cs" />
+    <Compile Include="deobfuscators\ILProtector\Deobfuscator.cs" />
+    <Compile Include="deobfuscators\ILProtector\MainType.cs" />
+    <Compile Include="deobfuscators\ILProtector\MethodReader.cs" />
+    <Compile Include="deobfuscators\ILProtector\MethodsDecrypter.cs" />
     <Compile Include="deobfuscators\InitializedDataCreator.cs" />
     <Compile Include="deobfuscators\InlinedMethodsFinder.cs" />
     <Compile Include="deobfuscators\ISimpleDeobfuscator.cs" />
+    <Compile Include="deobfuscators\MaxtoCode\CryptDecrypter.cs" />
+    <Compile Include="deobfuscators\MaxtoCode\Decrypter6.cs" />
+    <Compile Include="deobfuscators\MaxtoCode\DecrypterInfo.cs" />
     <Compile Include="deobfuscators\MaxtoCode\Deobfuscator.cs" />
-    <Compile Include="deobfuscators\MaxtoCode\MethodsDecrypter.cs" />
+    <Compile Include="deobfuscators\MaxtoCode\EncryptionInfos.cs" />
     <Compile Include="deobfuscators\MaxtoCode\MainType.cs" />
-    <Compile Include="deobfuscators\MethodBodyParser.cs" />
+    <Compile Include="deobfuscators\MaxtoCode\McKey.cs" />
+    <Compile Include="deobfuscators\MaxtoCode\MethodsDecrypter.cs" />
+    <Compile Include="deobfuscators\MaxtoCode\PeHeader.cs" />
+    <Compile Include="deobfuscators\MaxtoCode\StringDecrypter.cs" />
     <Compile Include="deobfuscators\MemberReferenceBuilder.cs" />
+    <Compile Include="deobfuscators\MethodBodyParser.cs" />
+    <Compile Include="deobfuscators\MethodCallRestorerBase.cs" />
     <Compile Include="deobfuscators\MethodCollection.cs" />
     <Compile Include="deobfuscators\MethodsDecrypter.cs" />
     <Compile Include="deobfuscators\MethodStack.cs" />
     <Compile Include="deobfuscators\MPRESS\Deobfuscator.cs" />
     <Compile Include="deobfuscators\MPRESS\Lzmat.cs" />
+    <Compile Include="deobfuscators\Operations.cs" />
+    <Compile Include="deobfuscators\ProxyCallFixerBase.cs" />
     <Compile Include="deobfuscators\QuickLZ.cs" />
     <Compile Include="deobfuscators\RandomNameChecker.cs" />
     <Compile Include="deobfuscators\Rummage\Deobfuscator.cs" />
@@ -261,14 +264,6 @@
     <Compile Include="deobfuscators\Skater_NET\Deobfuscator.cs" />
     <Compile Include="deobfuscators\Skater_NET\EnumClassFinder.cs" />
     <Compile Include="deobfuscators\Skater_NET\StringDecrypter.cs" />
-    <Compile Include="deobfuscators\Spices_Net\Deobfuscator.cs" />
-    <Compile Include="deobfuscators\Spices_Net\QclzDecompressor.cs" />
-    <Compile Include="deobfuscators\Spices_Net\ResourceNamesRestorer.cs" />
-    <Compile Include="deobfuscators\Spices_Net\SpicesMethodCallInliner.cs" />
-    <Compile Include="deobfuscators\Spices_Net\StringDecrypter.cs" />
-    <Compile Include="deobfuscators\StringCounts.cs" />
-    <Compile Include="deobfuscators\Operations.cs" />
-    <Compile Include="deobfuscators\ProxyCallFixerBase.cs" />
     <Compile Include="deobfuscators\SmartAssembly\AssemblyResolver.cs" />
     <Compile Include="deobfuscators\SmartAssembly\AssemblyResolverInfo.cs" />
     <Compile Include="deobfuscators\SmartAssembly\AutomatedErrorReportingFinder.cs" />
@@ -285,6 +280,12 @@
     <Compile Include="deobfuscators\SmartAssembly\StringDecrypterInfo.cs" />
     <Compile Include="deobfuscators\SmartAssembly\StringEncoderClassFinder.cs" />
     <Compile Include="deobfuscators\SmartAssembly\TamperProtectionRemover.cs" />
+    <Compile Include="deobfuscators\Spices_Net\Deobfuscator.cs" />
+    <Compile Include="deobfuscators\Spices_Net\QclzDecompressor.cs" />
+    <Compile Include="deobfuscators\Spices_Net\ResourceNamesRestorer.cs" />
+    <Compile Include="deobfuscators\Spices_Net\SpicesMethodCallInliner.cs" />
+    <Compile Include="deobfuscators\Spices_Net\StringDecrypter.cs" />
+    <Compile Include="deobfuscators\StringCounts.cs" />
     <Compile Include="deobfuscators\TypesRestorer.cs" />
     <Compile Include="deobfuscators\Unknown\Deobfuscator.cs" />
     <Compile Include="deobfuscators\UnpackedFile.cs" />
@@ -292,10 +293,10 @@
     <Compile Include="deobfuscators\ValueInlinerBase.cs" />
     <Compile Include="deobfuscators\Xenocode\Deobfuscator.cs" />
     <Compile Include="deobfuscators\Xenocode\StringDecrypter.cs" />
+    <Compile Include="DumpedMethodsRestorer.cs" />
     <Compile Include="IDeobfuscatorContext.cs" />
     <Compile Include="IObfuscatedFile.cs" />
-    <Compile Include="Log.cs" />
-    <Compile Include="AssemblyModule.cs" />
+    <Compile Include="Logger.cs" />
     <Compile Include="MethodPrinter.cs" />
     <Compile Include="MethodReturnValueInliner.cs" />
     <Compile Include="NameRegexes.cs" />
@@ -303,7 +304,6 @@
     <Compile Include="Option.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="renamer\asmmodules\EventDef.cs" />
-    <Compile Include="ExternalAssemblies.cs" />
     <Compile Include="renamer\asmmodules\FieldDef.cs" />
     <Compile Include="renamer\asmmodules\GenericParamDef.cs" />
     <Compile Include="renamer\asmmodules\IResolver.cs" />
@@ -331,11 +331,11 @@
     <Compile Include="renamer\VariableNameState.cs" />
     <Compile Include="resources\BuiltInResourceData.cs" />
     <Compile Include="resources\IResourceData.cs" />
+    <Compile Include="resources\ResourceDataCreator.cs" />
     <Compile Include="resources\ResourceElement.cs" />
     <Compile Include="resources\ResourceElementSet.cs" />
     <Compile Include="resources\ResourceReader.cs" />
     <Compile Include="resources\ResourceTypeCode.cs" />
-    <Compile Include="resources\ResourceDataCreator.cs" />
     <Compile Include="resources\ResourceWriter.cs" />
     <Compile Include="resources\UserResourceData.cs" />
     <Compile Include="resources\UserResourceType.cs" />
@@ -362,14 +362,14 @@
       <Project>{045B96F2-AF80-4C4C-8D27-E38635AC705E}</Project>
       <Name>blocks</Name>
     </ProjectReference>
-    <ProjectReference Include="..\cecil\Mono.Cecil.csproj">
-      <Project>{D68133BD-1E63-496E-9EDE-4FBDBF77B486}</Project>
-      <Name>Mono.Cecil</Name>
-    </ProjectReference>
     <ProjectReference Include="..\de4dot.mdecrypt\de4dot.mdecrypt.csproj">
       <Project>{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}</Project>
       <Name>de4dot.mdecrypt</Name>
     </ProjectReference>
+    <ProjectReference Include="..\dot10\src\dot10.csproj">
+      <Project>{FDFC1237-143F-4919-8318-4926901F4639}</Project>
+      <Name>dot10</Name>
+    </ProjectReference>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
diff --git a/de4dot.code/deobfuscators/CliSecure/CliSecureRtType.cs b/de4dot.code/deobfuscators/Agile_NET/CliSecureRtType.cs
similarity index 73%
rename from de4dot.code/deobfuscators/CliSecure/CliSecureRtType.cs
rename to de4dot.code/deobfuscators/Agile_NET/CliSecureRtType.cs
index a8cae51a..7ecf029e 100644
--- a/de4dot.code/deobfuscators/CliSecure/CliSecureRtType.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/CliSecureRtType.cs
@@ -20,65 +20,49 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 using de4dot.PE;
 
-namespace de4dot.code.deobfuscators.CliSecure {
+namespace de4dot.code.deobfuscators.Agile_NET {
 	class CliSecureRtType {
-		ModuleDefinition module;
-		TypeDefinition cliSecureRtType;
-		MethodDefinition postInitializeMethod;
-		MethodDefinition initializeMethod;
-		MethodDefinition stringDecrypterMethod;
-		MethodDefinition loadMethod;
+		ModuleDefMD module;
+		TypeDef cliSecureRtType;
+		MethodDef postInitializeMethod;
+		MethodDef initializeMethod;
+		MethodDef stringDecrypterMethod;
+		MethodDef loadMethod;
 		bool foundSig;
 
 		public bool Detected {
 			get { return foundSig || cliSecureRtType != null; }
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return cliSecureRtType; }
 		}
 
-		public MethodDefinition StringDecrypterMethod {
+		public MethodDef StringDecrypterMethod {
 			get { return stringDecrypterMethod; }
 		}
 
-		public MethodDefinition PostInitializeMethod {
+		public MethodDef PostInitializeMethod {
 			get { return postInitializeMethod; }
 		}
 
-		public MethodDefinition InitializeMethod {
+		public MethodDef InitializeMethod {
 			get { return initializeMethod; }
 		}
 
-		public MethodDefinition LoadMethod {
+		public MethodDef LoadMethod {
 			get { return loadMethod; }
 		}
 
-		public IEnumerable<ModuleReference> DecryptModuleReferences {
-			get {
-				var list = new List<ModuleReference>();
-				addModuleReference(list, "_Initialize");
-				addModuleReference(list, "_Initialize64");
-				return list;
-			}
-		}
-
-		void addModuleReference(List<ModuleReference> list, string methodName) {
-			var method = DotNetUtils.getPInvokeMethod(cliSecureRtType, methodName);
-			if (method == null)
-				return;
-			list.Add(method.PInvokeInfo.Module);
-		}
-
-		public CliSecureRtType(ModuleDefinition module) {
+		public CliSecureRtType(ModuleDefMD module) {
 			this.module = module;
 		}
 
-		public CliSecureRtType(ModuleDefinition module, CliSecureRtType oldOne) {
+		public CliSecureRtType(ModuleDefMD module, CliSecureRtType oldOne) {
 			this.module = module;
 			cliSecureRtType = lookup(oldOne.cliSecureRtType, "Could not find CliSecureRt type");
 			postInitializeMethod = lookup(oldOne.postInitializeMethod, "Could not find postInitializeMethod method");
@@ -88,7 +72,7 @@ namespace de4dot.code.deobfuscators.CliSecure {
 			foundSig = oldOne.foundSig;
 		}
 
-		T lookup<T>(T def, string errorMessage) where T : MemberReference {
+		T lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
 			return DeobUtils.lookup(module, def, errorMessage);
 		}
 
@@ -147,13 +131,13 @@ namespace de4dot.code.deobfuscators.CliSecure {
 			foreach (var type in module.Types) {
 				if (type.Fields.Count != 1)
 					continue;
-				if (type.Fields[0].FieldType.FullName != "System.Byte[]")
+				if (type.Fields[0].FieldSig.GetFieldType().GetFullName() != "System.Byte[]")
 					continue;
 				if (type.Methods.Count != 2)
 					continue;
-				if (DotNetUtils.getMethod(type, ".cctor") == null)
+				if (type.FindStaticConstructor() == null)
 					continue;
-				var cs = DotNetUtils.getMethod(type, "cs");
+				var cs = type.FindMethod("cs");
 				if (cs == null)
 					continue;
 
@@ -165,7 +149,7 @@ namespace de4dot.code.deobfuscators.CliSecure {
 			return false;
 		}
 
-		static MethodDefinition findStringDecrypterMethod(TypeDefinition type) {
+		static MethodDef findStringDecrypterMethod(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (method.Body == null || !method.IsStatic)
 					continue;
@@ -178,7 +162,7 @@ namespace de4dot.code.deobfuscators.CliSecure {
 			return null;
 		}
 
-		static MethodDefinition findMethod(TypeDefinition type, string returnType, string name, string parameters) {
+		static MethodDef findMethod(TypeDef type, string returnType, string name, string parameters) {
 			var methodName = returnType + " " + type.FullName + "::" + name + parameters;
 			foreach (var method in type.Methods) {
 				if (method.Body == null || !method.IsStatic)
@@ -192,16 +176,17 @@ namespace de4dot.code.deobfuscators.CliSecure {
 			return null;
 		}
 
-		static bool hasInitializeMethod(TypeDefinition type, string name) {
+		static bool hasInitializeMethod(TypeDef type, string name) {
 			var method = DotNetUtils.getPInvokeMethod(type, name);
 			if (method == null)
 				return false;
-			if (method.Parameters.Count != 1)
+			var sig = method.MethodSig;
+			if (sig.Params.Count != 1)
 				return false;
-			if (method.Parameters[0].ParameterType.FullName != "System.IntPtr")
+			if (sig.Params[0].GetElementType() != ElementType.I)
 				return false;
-			var retType = method.MethodReturnType.ReturnType.FullName;
-			if (retType != "System.Void" && retType != "System.Int32")
+			var retType = sig.RetType.GetElementType();
+			if (retType != ElementType.Void && retType != ElementType.I4)
 				return false;
 			return true;
 		}
@@ -209,7 +194,7 @@ namespace de4dot.code.deobfuscators.CliSecure {
 		bool findNativeCode(byte[] moduleBytes) {
 			var stream = moduleBytes != null ?
 				(Stream)new MemoryStream(moduleBytes) :
-				(Stream)new FileStream(module.FullyQualifiedName, FileMode.Open, FileAccess.Read, FileShare.Read);
+				(Stream)new FileStream(module.Location, FileMode.Open, FileAccess.Read, FileShare.Read);
 			using (stream) {
 				var peImage = new PeImage(stream);
 				return foundSig = MethodsDecrypter.detect(peImage);
@@ -239,7 +224,7 @@ namespace de4dot.code.deobfuscators.CliSecure {
 			}
 		}
 
-		static bool isOldStringDecrypterMethod(MethodDefinition method) {
+		static bool isOldStringDecrypterMethod(MethodDef method) {
 			if (method == null || method.Body == null || !method.IsStatic)
 				return false;
 			if (!DotNetUtils.isMethod(method, "System.String", "(System.String)"))
diff --git a/de4dot.code/deobfuscators/CliSecure/CsBlowfish.cs b/de4dot.code/deobfuscators/Agile_NET/CsBlowfish.cs
similarity index 96%
rename from de4dot.code/deobfuscators/CliSecure/CsBlowfish.cs
rename to de4dot.code/deobfuscators/Agile_NET/CsBlowfish.cs
index 75cd72e0..9f5b06c1 100644
--- a/de4dot.code/deobfuscators/CliSecure/CsBlowfish.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/CsBlowfish.cs
@@ -17,7 +17,7 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-namespace de4dot.code.deobfuscators.CliSecure {
+namespace de4dot.code.deobfuscators.Agile_NET {
 	class CsBlowfish : Blowfish {
 		public CsBlowfish() {
 		}
diff --git a/de4dot.code/deobfuscators/CliSecure/Deobfuscator.cs b/de4dot.code/deobfuscators/Agile_NET/Deobfuscator.cs
similarity index 83%
rename from de4dot.code/deobfuscators/CliSecure/Deobfuscator.cs
rename to de4dot.code/deobfuscators/Agile_NET/Deobfuscator.cs
index a9820940..fcfe1e5e 100644
--- a/de4dot.code/deobfuscators/CliSecure/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/Deobfuscator.cs
@@ -19,15 +19,16 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.MyStuff;
+using dot10.IO;
+using dot10.PE;
+using dot10.DotNet;
 using de4dot.blocks;
 using de4dot.PE;
 
-namespace de4dot.code.deobfuscators.CliSecure {
+namespace de4dot.code.deobfuscators.Agile_NET {
 	public class DeobfuscatorInfo : DeobfuscatorInfoBase {
-		public const string THE_NAME = "CliSecure";
-		public const string THE_TYPE = "cs";
+		public const string THE_NAME = "Agile.NET";
+		public const string THE_TYPE = "an";
 		const string DEFAULT_REGEX = @"[a-zA-Z_0-9>}$]$";
 		BoolOption decryptMethods;
 		BoolOption decryptResources;
@@ -78,7 +79,7 @@ namespace de4dot.code.deobfuscators.CliSecure {
 		Options options;
 		string obfuscatorName = DeobfuscatorInfo.THE_NAME;
 
-		List<TypeDefinition> cliSecureAttributes = new List<TypeDefinition>();
+		List<TypeDef> cliSecureAttributes = new List<TypeDef>();
 		ProxyCallFixer proxyCallFixer;
 		CliSecureRtType cliSecureRtType;
 		StringDecrypter stringDecrypter;
@@ -112,27 +113,29 @@ namespace de4dot.code.deobfuscators.CliSecure {
 			this.options = options;
 		}
 
-		public override void init(ModuleDefinition module) {
+		public override void init(ModuleDefMD module) {
 			base.init(module);
 		}
 
-		public override byte[] unpackNativeFile(PeImage peImage) {
+		public override byte[] unpackNativeFile(IPEImage peImage) {
 			return unpackNativeFile1(peImage) ?? unpackNativeFile2(peImage);
 		}
 
 		// Old CS versions
-		byte[] unpackNativeFile1(PeImage peImage) {
+		byte[] unpackNativeFile1(IPEImage peImage) {
 			const int dataDirNum = 6;	// debug dir
 			const int dotNetDirNum = 14;
 
-			if (peImage.OptionalHeader.dataDirectories[dataDirNum].virtualAddress == 0)
+			var optHeader = peImage.ImageNTHeaders.OptionalHeader;
+			if (optHeader.DataDirectories[dataDirNum].VirtualAddress == 0)
 				return null;
-			if (peImage.OptionalHeader.dataDirectories[dataDirNum].size != 0x48)
+			if (optHeader.DataDirectories[dataDirNum].Size != 0x48)
 				return null;
 
-			var fileData = peImage.readAllBytes();
-			int dataDir = (int)peImage.OptionalHeader.offsetOfDataDirectory(dataDirNum);
-			int dotNetDir = (int)peImage.OptionalHeader.offsetOfDataDirectory(dotNetDirNum);
+			var fileData = peImage.GetImageAsByteArray();
+			long dataDirBaseOffset = (long)optHeader.DataDirectories[0].StartOffset;
+			int dataDir = (int)dataDirBaseOffset + dataDirNum * 8;
+			int dotNetDir = (int)dataDirBaseOffset + dotNetDirNum * 8;
 			writeUInt32(fileData, dotNetDir, BitConverter.ToUInt32(fileData, dataDir));
 			writeUInt32(fileData, dotNetDir + 4, BitConverter.ToUInt32(fileData, dataDir + 4));
 			writeUInt32(fileData, dataDir, 0);
@@ -142,17 +145,12 @@ namespace de4dot.code.deobfuscators.CliSecure {
 		}
 
 		// CS 1.x
-		byte[] unpackNativeFile2(PeImage peImage) {
-			var dir = peImage.Resources.getRoot();
-			if ((dir = dir.getDirectory("ASSEMBLY")) == null)
-				return null;
-			if ((dir = dir.getDirectory(101)) == null)
-				return null;
-			var data = dir.getData(0);
+		byte[] unpackNativeFile2(IPEImage peImage) {
+			var data = peImage.FindWin32ResourceData("ASSEMBLY", 101, 0);
 			if (data == null)
 				return null;
 
-			return ModuleBytes = peImage.readBytes(data.RVA, (int)data.Size);
+			return ModuleBytes = data.Data.ReadAllBytes();
 		}
 
 		static void writeUInt32(byte[] data, int offset, uint value) {
@@ -213,7 +211,7 @@ namespace de4dot.code.deobfuscators.CliSecure {
 			var peImage = new PeImage(fileData);
 
 			if (!new MethodsDecrypter().decrypt(peImage, module, cliSecureRtType, ref dumpedMethods)) {
-				Log.v("Methods aren't encrypted or invalid signature");
+				Logger.v("Methods aren't encrypted or invalid signature");
 				return false;
 			}
 
@@ -221,7 +219,7 @@ namespace de4dot.code.deobfuscators.CliSecure {
 			return true;
 		}
 
-		public override IDeobfuscator moduleReloaded(ModuleDefinition module) {
+		public override IDeobfuscator moduleReloaded(ModuleDefMD module) {
 			var newOne = new Deobfuscator(options);
 			newOne.setModule(module);
 			newOne.cliSecureAttributes = lookup(module, cliSecureAttributes, "Could not find CliSecure attribute");
@@ -233,8 +231,8 @@ namespace de4dot.code.deobfuscators.CliSecure {
 			return newOne;
 		}
 
-		static List<TypeDefinition> lookup(ModuleDefinition module, List<TypeDefinition> types, string errorMsg) {
-			var list = new List<TypeDefinition>(types.Count);
+		static List<TypeDef> lookup(ModuleDefMD module, List<TypeDef> types, string errorMsg) {
+			var list = new List<TypeDef>(types.Count);
 			foreach (var type in types)
 				list.Add(DeobUtils.lookup(module, type, errorMsg));
 			return list;
@@ -274,7 +272,6 @@ namespace de4dot.code.deobfuscators.CliSecure {
 
 			if (options.RestoreVmCode) {
 				csvm.restore();
-				addAssemblyReferenceToBeRemoved(csvm.VmAssemblyReference, "CSVM assembly reference");
 				addResourceToBeRemoved(csvm.Resource, "CSVM data resource");
 			}
 		}
@@ -308,19 +305,20 @@ namespace de4dot.code.deobfuscators.CliSecure {
 			}
 			if (options.DecryptMethods) {
 				addResources("Obfuscator protection files");
-				addModuleReferencesToBeRemoved(cliSecureRtType.DecryptModuleReferences, "Obfuscator protection files");
-				addModuleReferences("Obfuscator protection files");
 			}
 
-			module.Attributes |= ModuleAttributes.ILOnly;
-
 			base.deobfuscateEnd();
+
+			// Call hasNativeMethods() after all types/methods/etc have been removed since
+			// some of the removed methods could be native methods
+			if (!module.IsILOnly && !hasNativeMethods())
+				module.IsILOnly = true;
 		}
 
 		public override IEnumerable<int> getStringDecrypterMethods() {
 			var list = new List<int>();
 			if (stringDecrypter.Method != null)
-				list.Add(stringDecrypter.Method.MetadataToken.ToInt32());
+				list.Add(stringDecrypter.Method.MDToken.ToInt32());
 			return list;
 		}
 
@@ -328,7 +326,7 @@ namespace de4dot.code.deobfuscators.CliSecure {
 			if (!options.RemoveStackFrameHelper)
 				return;
 			if (stackFrameHelper.ExceptionLoggerRemover.remove(blocks))
-				Log.v("Removed StackFrameHelper code");
+				Logger.v("Removed StackFrameHelper code");
 		}
 	}
 }
diff --git a/de4dot.code/deobfuscators/CliSecure/MethodsDecrypter.cs b/de4dot.code/deobfuscators/Agile_NET/MethodsDecrypter.cs
similarity index 96%
rename from de4dot.code/deobfuscators/CliSecure/MethodsDecrypter.cs
rename to de4dot.code/deobfuscators/Agile_NET/MethodsDecrypter.cs
index 4f73e063..42d5df84 100644
--- a/de4dot.code/deobfuscators/CliSecure/MethodsDecrypter.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/MethodsDecrypter.cs
@@ -20,11 +20,11 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using Mono.MyStuff;
+using dot10.DotNet;
 using de4dot.PE;
 using de4dot.blocks;
 
-namespace de4dot.code.deobfuscators.CliSecure {
+namespace de4dot.code.deobfuscators.Agile_NET {
 	class CodeHeader {
 		public byte[] signature;
 		public byte[] decryptionKey;
@@ -62,7 +62,7 @@ namespace de4dot.code.deobfuscators.CliSecure {
 		}
 
 		PeImage peImage;
-		Mono.Cecil.ModuleDefinition module;
+		ModuleDefMD module;
 		CliSecureRtType csRtType;
 		CodeHeader codeHeader = new CodeHeader();
 		IDecrypter decrypter;
@@ -155,7 +155,7 @@ namespace de4dot.code.deobfuscators.CliSecure {
 
 			public Decrypter5(PeImage peImage, CodeHeader codeHeader, uint codeHeaderSize)
 				: base(peImage, codeHeader) {
-					this.codeHeaderSize = codeHeaderSize;
+				this.codeHeaderSize = codeHeaderSize;
 			}
 
 			public override MethodBodyHeader decrypt(MethodInfo methodInfo, out byte[] code, out byte[] extraSections) {
@@ -434,7 +434,7 @@ namespace de4dot.code.deobfuscators.CliSecure {
 			Error,
 		}
 
-		public bool decrypt(PeImage peImage, Mono.Cecil.ModuleDefinition module, CliSecureRtType csRtType, ref DumpedMethods dumpedMethods) {
+		public bool decrypt(PeImage peImage, ModuleDefMD module, CliSecureRtType csRtType, ref DumpedMethods dumpedMethods) {
 			this.peImage = peImage;
 			this.csRtType = csRtType;
 			this.module = module;
@@ -444,9 +444,9 @@ namespace de4dot.code.deobfuscators.CliSecure {
 			case DecryptResult.NotEncrypted: return false;
 
 			case DecryptResult.Error:
-				Log.w("Using dynamic method decryption");
+				Logger.w("Using dynamic method decryption");
 				byte[] moduleCctorBytes = getModuleCctorBytes(csRtType);
-				dumpedMethods = de4dot.code.deobfuscators.MethodsDecrypter.decrypt(module.FullyQualifiedName, moduleCctorBytes);
+				dumpedMethods = de4dot.code.deobfuscators.MethodsDecrypter.decrypt(module.Location, moduleCctorBytes);
 				return true;
 
 			default:
@@ -458,7 +458,7 @@ namespace de4dot.code.deobfuscators.CliSecure {
 			var initMethod = csRtType.InitializeMethod;
 			if (initMethod == null)
 				return null;
-			uint initToken = initMethod.MetadataToken.ToUInt32();
+			uint initToken = initMethod.MDToken.ToUInt32();
 			var moduleCctorBytes = new byte[6];
 			moduleCctorBytes[0] = 0x28;	// call
 			moduleCctorBytes[1] = (byte)initToken;
@@ -542,7 +542,7 @@ namespace de4dot.code.deobfuscators.CliSecure {
 				var dm = new DumpedMethod();
 				dm.token = 0x06000001 + (uint)i;
 
-				var method = (Mono.Cecil.MethodDefinition)module.LookupToken((int)dm.token);
+				var method = (MethodDef)module.ResolveMethod(MDToken.ToRID(dm.token));
 				if (method == null || method.DeclaringType == DotNetUtils.getModuleType(module))
 					continue;
 
@@ -550,6 +550,7 @@ namespace de4dot.code.deobfuscators.CliSecure {
 				if (rva == 0)
 					continue;
 				uint bodyOffset = peImage.rvaToOffset(rva);
+				dm.mdRVA = peImage.offsetRead(offset + (uint)methodDefTable.fields[0].offset, methodDefTable.fields[0].size);
 				dm.mdImplFlags = peImage.offsetReadUInt16(offset + (uint)methodDefTable.fields[1].offset);
 				dm.mdFlags = peImage.offsetReadUInt16(offset + (uint)methodDefTable.fields[2].offset);
 				dm.mdName = peImage.offsetRead(offset + (uint)methodDefTable.fields[3].offset, methodDefTable.fields[3].size);
@@ -581,6 +582,7 @@ namespace de4dot.code.deobfuscators.CliSecure {
 				var dm = new DumpedMethod();
 				dm.token = 0x06000001 + (uint)i;
 
+				dm.mdRVA = peImage.offsetRead(offset + (uint)methodDefTable.fields[0].offset, methodDefTable.fields[0].size);
 				dm.mdImplFlags = peImage.offsetReadUInt16(offset + (uint)methodDefTable.fields[1].offset);
 				dm.mdFlags = peImage.offsetReadUInt16(offset + (uint)methodDefTable.fields[2].offset);
 				dm.mdName = peImage.offsetRead(offset + (uint)methodDefTable.fields[3].offset, methodDefTable.fields[3].size);
diff --git a/de4dot.code/deobfuscators/CliSecure/ProxyCallFixer.cs b/de4dot.code/deobfuscators/Agile_NET/ProxyCallFixer.cs
similarity index 62%
rename from de4dot.code/deobfuscators/CliSecure/ProxyCallFixer.cs
rename to de4dot.code/deobfuscators/Agile_NET/ProxyCallFixer.cs
index b7362f02..c2026dda 100644
--- a/de4dot.code/deobfuscators/CliSecure/ProxyCallFixer.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/ProxyCallFixer.cs
@@ -19,19 +19,17 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
-namespace de4dot.code.deobfuscators.CliSecure {
+namespace de4dot.code.deobfuscators.Agile_NET {
 	class ProxyCallFixer : ProxyCallFixer1 {
-		IList<MemberReference> memberReferences;
-
-		public ProxyCallFixer(ModuleDefinition module)
+		public ProxyCallFixer(ModuleDefMD module)
 			: base(module) {
 		}
 
-		public ProxyCallFixer(ModuleDefinition module, ProxyCallFixer oldOne)
+		public ProxyCallFixer(ModuleDefMD module, ProxyCallFixer oldOne)
 			: base(module) {
 			foreach (var method in oldOne.delegateCreatorMethods)
 				setDelegateCreatorMethod(lookup(method, "Could not find delegate creator method"));
@@ -49,31 +47,28 @@ namespace de4dot.code.deobfuscators.CliSecure {
 			}
 		}
 
-		protected override object checkCctor(ref TypeDefinition type, MethodDefinition cctor) {
+		protected override object checkCctor(ref TypeDef type, MethodDef cctor) {
 			var instrs = cctor.Body.Instructions;
 			if (instrs.Count != 3)
 				return null;
-			if (!DotNetUtils.isLdcI4(instrs[0].OpCode.Code))
+			if (!instrs[0].IsLdcI4())
 				return null;
-			if (instrs[1].OpCode != OpCodes.Call || !isDelegateCreatorMethod(instrs[1].Operand as MethodDefinition))
+			if (instrs[1].OpCode != OpCodes.Call || !isDelegateCreatorMethod(instrs[1].Operand as MethodDef))
 				return null;
 			if (instrs[2].OpCode != OpCodes.Ret)
 				return null;
 
-			int delegateToken = 0x02000001 + DotNetUtils.getLdcI4Value(instrs[0]);
-			if (type.MetadataToken.ToInt32() != delegateToken) {
-				Log.w("Delegate token is not current type");
+			int delegateToken = 0x02000001 + instrs[0].GetLdcI4Value();
+			if (type.MDToken.ToInt32() != delegateToken) {
+				Logger.w("Delegate token is not current type");
 				return null;
 			}
 
 			return new object();
 		}
 
-		protected override void getCallInfo(object context, FieldDefinition field, out MethodReference calledMethod, out OpCode callOpcode) {
-			if (memberReferences == null)
-				memberReferences = new List<MemberReference>(module.GetMemberReferences());
-
-			var name = field.Name;
+		protected override void getCallInfo(object context, FieldDef field, out IMethod calledMethod, out OpCode callOpcode) {
+			var name = field.Name.String;
 			callOpcode = OpCodes.Call;
 			if (name.EndsWith("%", StringComparison.Ordinal)) {
 				callOpcode = OpCodes.Callvirt;
@@ -81,9 +76,10 @@ namespace de4dot.code.deobfuscators.CliSecure {
 			}
 			byte[] value = Convert.FromBase64String(name);
 			int methodIndex = BitConverter.ToInt32(value, 0);	// 0-based memberRef index
-			if (methodIndex >= memberReferences.Count)
-				throw new ApplicationException(string.Format("methodIndex ({0}) >= memberReferences.Count ({1})", methodIndex, memberReferences.Count));
-			calledMethod = memberReferences[methodIndex] as MethodReference;
+			var mr = module.ResolveMemberRef((uint)methodIndex + 1);
+			if (mr == null || !mr.IsMethodRef)
+				throw new ApplicationException(string.Format("Invalid MemberRef index: {0}", methodIndex));
+			calledMethod = mr;
 		}
 	}
 }
diff --git a/de4dot.code/deobfuscators/CliSecure/ResourceDecrypter.cs b/de4dot.code/deobfuscators/Agile_NET/ResourceDecrypter.cs
similarity index 70%
rename from de4dot.code/deobfuscators/CliSecure/ResourceDecrypter.cs
rename to de4dot.code/deobfuscators/Agile_NET/ResourceDecrypter.cs
index 37118bf1..43a198aa 100644
--- a/de4dot.code/deobfuscators/CliSecure/ResourceDecrypter.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/ResourceDecrypter.cs
@@ -20,40 +20,41 @@
 using System.IO;
 using System.Security.Cryptography;
 using System.Text;
-using Mono.Cecil;
+using dot10.IO;
+using dot10.DotNet;
 using de4dot.blocks;
 
-namespace de4dot.code.deobfuscators.CliSecure {
+namespace de4dot.code.deobfuscators.Agile_NET {
 	class ResourceDecrypter {
-		ModuleDefinition module;
-		TypeDefinition rsrcType;
-		MethodDefinition rsrcRrrMethod;
-		MethodDefinition rsrcResolveMethod;
+		ModuleDefMD module;
+		TypeDef rsrcType;
+		MethodDef rsrcRrrMethod;
+		MethodDef rsrcResolveMethod;
 
 		public bool Detected {
 			get { return rsrcType != null; }
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return rsrcType; }
 		}
 
-		public MethodDefinition RsrcRrrMethod {
+		public MethodDef RsrcRrrMethod {
 			get { return rsrcRrrMethod; }
 		}
 
-		public ResourceDecrypter(ModuleDefinition module) {
+		public ResourceDecrypter(ModuleDefMD module) {
 			this.module = module;
 		}
 
-		public ResourceDecrypter(ModuleDefinition module, ResourceDecrypter oldOne) {
+		public ResourceDecrypter(ModuleDefMD module, ResourceDecrypter oldOne) {
 			this.module = module;
 			rsrcType = lookup(oldOne.rsrcType, "Could not find rsrcType");
 			rsrcRrrMethod = lookup(oldOne.rsrcRrrMethod, "Could not find rsrcRrrMethod");
 			rsrcResolveMethod = lookup(oldOne.rsrcResolveMethod, "Could not find rsrcResolveMethod");
 		}
 
-		T lookup<T>(T def, string errorMessage) where T : MemberReference {
+		T lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
 			return DeobUtils.lookup(module, def, errorMessage);
 		}
 
@@ -99,24 +100,22 @@ namespace de4dot.code.deobfuscators.CliSecure {
 			var resource = DotNetUtils.getResource(module, DotNetUtils.getCodeStrings(rsrcResolveMethod)) as EmbeddedResource;
 			if (resource == null)
 				return null;
-			DeobUtils.decryptAndAddResources(module, resource.Name, () => decryptResource(resource));
+			DeobUtils.decryptAndAddResources(module, resource.Name.String, () => decryptResource(resource));
 			return resource;
 		}
 
 		byte[] decryptResource(EmbeddedResource resource) {
-			using (var rsrcStream = resource.GetResourceStream()) {
-				using (var reader = new BinaryReader(rsrcStream)) {
-					var key = reader.ReadString();
-					var data = reader.ReadBytes((int)(rsrcStream.Length - rsrcStream.Position));
-					var cryptoTransform = new DESCryptoServiceProvider {
-						Key = Encoding.ASCII.GetBytes(key),
-						IV = Encoding.ASCII.GetBytes(key),
-					}.CreateDecryptor();
-					var memStream = new MemoryStream(data);
-					using (var reader2 = new BinaryReader(new CryptoStream(memStream, cryptoTransform, CryptoStreamMode.Read))) {
-						return reader2.ReadBytes((int)memStream.Length);
-					}
-				}
+			var reader = resource.Data;
+			reader.Position = 0;
+			var key = reader.ReadString();
+			var data = reader.ReadRemainingBytes();
+			var cryptoTransform = new DESCryptoServiceProvider {
+				Key = Encoding.ASCII.GetBytes(key),
+				IV = Encoding.ASCII.GetBytes(key),
+			}.CreateDecryptor();
+			var memStream = new MemoryStream(data);
+			using (var reader2 = new BinaryReader(new CryptoStream(memStream, cryptoTransform, CryptoStreamMode.Read))) {
+				return reader2.ReadBytes((int)memStream.Length);
 			}
 		}
 	}
diff --git a/de4dot.code/deobfuscators/CliSecure/StackFrameHelper.cs b/de4dot.code/deobfuscators/Agile_NET/StackFrameHelper.cs
similarity index 63%
rename from de4dot.code/deobfuscators/CliSecure/StackFrameHelper.cs
rename to de4dot.code/deobfuscators/Agile_NET/StackFrameHelper.cs
index dc465d8e..7313c5e9 100644
--- a/de4dot.code/deobfuscators/CliSecure/StackFrameHelper.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/StackFrameHelper.cs
@@ -18,16 +18,16 @@
 */
 
 using System;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
-namespace de4dot.code.deobfuscators.CliSecure {
+namespace de4dot.code.deobfuscators.Agile_NET {
 	class StackFrameHelper {
-		ModuleDefinition module;
-		TypeDefinition stackFrameHelperType;
+		ModuleDefMD module;
+		TypeDef stackFrameHelperType;
 		ExceptionLoggerRemover exceptionLoggerRemover = new ExceptionLoggerRemover();
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return stackFrameHelperType; }
 		}
 
@@ -35,7 +35,7 @@ namespace de4dot.code.deobfuscators.CliSecure {
 			get { return exceptionLoggerRemover; }
 		}
 
-		public StackFrameHelper(ModuleDefinition module) {
+		public StackFrameHelper(ModuleDefMD module) {
 			this.module = module;
 		}
 
@@ -46,19 +46,18 @@ namespace de4dot.code.deobfuscators.CliSecure {
 				if (type.Methods.Count > 3)
 					continue;
 
-				MethodDefinition errorMethod = null;
+				MethodDef errorMethod = null;
 				foreach (var method in type.Methods) {
-					if (method.IsRuntimeSpecialName && method.Name == ".ctor" && !method.HasParameters)
+					if (method.Name == ".ctor")
 						continue;	// .ctor is allowed
-					if (method.IsRuntimeSpecialName && method.Name == ".cctor" && !method.HasParameters)
+					if (method.Name == ".cctor")
 						continue;	// .cctor is allowed
-					if (method.IsStatic && method.CallingConvention == MethodCallingConvention.Default &&
-						method.ExplicitThis == false && method.HasThis == false &&
-						method.HasBody && method.IsManaged && method.IsIL && method.HasParameters &&
-						method.Parameters.Count == 2 && !method.HasGenericParameters &&
+					var sig = method.MethodSig;
+					if (sig != null && method.IsStatic && method.HasBody &&
+						sig.Params.Count == 2 && !method.HasGenericParameters &&
 						!DotNetUtils.hasReturnValue(method) &&
-						method.Parameters[0].ParameterType.FullName == "System.Exception" &&
-						method.Parameters[1].ParameterType.FullName == "System.Object[]") {
+						sig.Params[0].GetFullName() == "System.Exception" &&
+						sig.Params[1].GetFullName() == "System.Object[]") {
 						errorMethod = method;
 					}
 					else
diff --git a/de4dot.code/deobfuscators/CliSecure/StringDecrypter.cs b/de4dot.code/deobfuscators/Agile_NET/StringDecrypter.cs
similarity index 83%
rename from de4dot.code/deobfuscators/CliSecure/StringDecrypter.cs
rename to de4dot.code/deobfuscators/Agile_NET/StringDecrypter.cs
index ef3e5e5c..c7b858d6 100644
--- a/de4dot.code/deobfuscators/CliSecure/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/StringDecrypter.cs
@@ -19,41 +19,41 @@
 
 using System;
 using System.Text;
-using Mono.Cecil;
+using dot10.DotNet;
 
-namespace de4dot.code.deobfuscators.CliSecure {
+namespace de4dot.code.deobfuscators.Agile_NET {
 	class StringDecrypter {
-		ModuleDefinition module;
-		TypeDefinition stringDecrypterType;
-		MethodDefinition stringDecrypterMethod;
+		ModuleDefMD module;
+		TypeDef stringDecrypterType;
+		MethodDef stringDecrypterMethod;
 		byte[] stringDecrypterKey;
 
 		public bool Detected {
 			get { return stringDecrypterMethod != null; }
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return stringDecrypterType; }
 		}
 
-		public MethodDefinition Method {
+		public MethodDef Method {
 			get { return stringDecrypterMethod; }
 			set { stringDecrypterMethod = value; }
 		}
 
-		public StringDecrypter(ModuleDefinition module, MethodDefinition stringDecrypterMethod) {
+		public StringDecrypter(ModuleDefMD module, MethodDef stringDecrypterMethod) {
 			this.module = module;
 			this.stringDecrypterMethod = stringDecrypterMethod;
 		}
 
-		public StringDecrypter(ModuleDefinition module, StringDecrypter oldOne) {
+		public StringDecrypter(ModuleDefMD module, StringDecrypter oldOne) {
 			this.module = module;
 			stringDecrypterType = lookup(oldOne.stringDecrypterType, "Could not find stringDecrypterType");
 			stringDecrypterMethod = lookup(oldOne.stringDecrypterMethod, "Could not find stringDecrypterMethod");
 			stringDecrypterKey = oldOne.stringDecrypterKey;
 		}
 
-		T lookup<T>(T def, string errorMessage) where T : MemberReference {
+		T lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
 			return DeobUtils.lookup(module, def, errorMessage);
 		}
 
diff --git a/de4dot.code/deobfuscators/CliSecure/vm/CilOperandInstructionRestorer.cs b/de4dot.code/deobfuscators/Agile_NET/vm/CilOperandInstructionRestorer.cs
similarity index 61%
rename from de4dot.code/deobfuscators/CliSecure/vm/CilOperandInstructionRestorer.cs
rename to de4dot.code/deobfuscators/Agile_NET/vm/CilOperandInstructionRestorer.cs
index 4a1b48e3..2465201b 100644
--- a/de4dot.code/deobfuscators/CliSecure/vm/CilOperandInstructionRestorer.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/vm/CilOperandInstructionRestorer.cs
@@ -17,20 +17,19 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.Cecil.Metadata;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
-namespace de4dot.code.deobfuscators.CliSecure.vm {
+namespace de4dot.code.deobfuscators.Agile_NET.vm {
 	// Tries to restore the operands of the following CIL instructions:
 	//	ldelema
 	//	ldobj
 	//	stobj
 	class CilOperandInstructionRestorer {
-		MethodDefinition method;
+		MethodDef method;
 
-		public bool restore(MethodDefinition method) {
+		public bool restore(MethodDef method) {
 			this.method = method;
 			bool atLeastOneFailed = false;
 
@@ -43,13 +42,13 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 				if (instr.Operand != null)
 					continue;
 
-				TypeReference operandType = null;
+				TypeSig operandType = null;
 				switch (instr.OpCode.Code) {
 				case Code.Ldelema:
-					var arrayType = MethodStack.getLoadedType(method, instrs, i, 1) as ArrayType;
+					var arrayType = MethodStack.getLoadedType(method, instrs, i, 1) as SZArraySig;
 					if (arrayType == null)
 						break;
-					operandType = arrayType.ElementType;
+					operandType = arrayType.Next;
 					break;
 
 				case Code.Ldobj:
@@ -70,58 +69,58 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 					continue;
 				}
 
-				instr.Operand = operandType;
+				instr.Operand = operandType.ToTypeDefOrRef();
 			}
 
 			return !atLeastOneFailed;
 		}
 
-		static TypeReference getPtrElementType(TypeReference type) {
+		static TypeSig getPtrElementType(TypeSig type) {
 			if (type == null)
 				return null;
-			var pt = type as PointerType;
-			if (pt != null)
-				return pt.ElementType;
-			var bt = type as ByReferenceType;
-			if (bt != null)
-				return bt.ElementType;
+			if (type.IsPointer || type.IsByRef)
+				return type.Next;
 			return null;
 		}
 
-		bool isValidType(TypeReference type) {
+		bool isValidType(TypeSig type) {
+			type = type.RemovePinnedAndModifiers();
 			if (type == null)
 				return false;
-			if (type.EType == ElementType.Void)
+			if (type.ElementType == ElementType.Void)
 				return false;
 
 			while (type != null) {
-				switch (MemberReferenceHelper.getMemberReferenceType(type)) {
-				case CecilType.ArrayType:
-				case CecilType.GenericInstanceType:
-				case CecilType.PointerType:
-				case CecilType.TypeDefinition:
-				case CecilType.TypeReference:
-				case CecilType.FunctionPointerType:
+				switch (type.ElementType) {
+				case ElementType.SZArray:
+				case ElementType.Array:
+				case ElementType.GenericInst:
+				case ElementType.Ptr:
+				case ElementType.Class:
+				case ElementType.ValueType:
+				case ElementType.FnPtr:
 					break;
 
-				case CecilType.GenericParameter:
-					var gp = (GenericParameter)type;
-					if (method.DeclaringType != gp.Owner && method != gp.Owner)
+				case ElementType.MVar:
+					var gmvar = (GenericMVar)type;
+					if (gmvar.Number >= method.MethodSig.GetGenParamCount())
 						return false;
 					break;
 
-				case CecilType.ByReferenceType:
-				case CecilType.OptionalModifierType:
-				case CecilType.PinnedType:
-				case CecilType.RequiredModifierType:
-				case CecilType.SentinelType:
+				case ElementType.Var:
+					var gvar = (GenericVar)type;
+					var dt = method.DeclaringType;
+					if (dt == null || gvar.Number >= dt.GenericParameters.Count)
+						return false;
+					break;
+
+				case ElementType.ByRef:
 				default:
 					return false;
 				}
-
-				if (!(type is TypeSpecification))
+				if (type.Next == null)
 					break;
-				type = ((TypeSpecification)type).ElementType;
+				type = type.Next;
 			}
 
 			return type != null;
diff --git a/de4dot.code/deobfuscators/CliSecure/vm/Csvm.cs b/de4dot.code/deobfuscators/Agile_NET/vm/Csvm.cs
similarity index 64%
rename from de4dot.code/deobfuscators/CliSecure/vm/Csvm.cs
rename to de4dot.code/deobfuscators/Agile_NET/vm/Csvm.cs
index 234ea7cb..78495c2b 100644
--- a/de4dot.code/deobfuscators/CliSecure/vm/Csvm.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/vm/Csvm.cs
@@ -20,15 +20,15 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
-namespace de4dot.code.deobfuscators.CliSecure.vm {
+namespace de4dot.code.deobfuscators.Agile_NET.vm {
 	class Csvm {
 		IDeobfuscatorContext deobfuscatorContext;
-		ModuleDefinition module;
+		ModuleDefMD module;
 		EmbeddedResource resource;
-		AssemblyNameReference vmAssemblyReference;
+		AssemblyRef vmAssemblyReference;
 
 		public bool Detected {
 			get { return resource != null && vmAssemblyReference != null; }
@@ -38,22 +38,22 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			get { return Detected ? resource : null; }
 		}
 
-		public AssemblyNameReference VmAssemblyReference {
+		public AssemblyRef VmAssemblyReference {
 			get { return Detected ? vmAssemblyReference : null; }
 		}
 
-		public Csvm(IDeobfuscatorContext deobfuscatorContext, ModuleDefinition module) {
+		public Csvm(IDeobfuscatorContext deobfuscatorContext, ModuleDefMD module) {
 			this.deobfuscatorContext = deobfuscatorContext;
 			this.module = module;
 		}
 
-		public Csvm(IDeobfuscatorContext deobfuscatorContext, ModuleDefinition module, Csvm oldOne) {
+		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.vmAssemblyReference != null)
-				this.vmAssemblyReference = module.AssemblyReferences[oldOne.module.AssemblyReferences.IndexOf(oldOne.vmAssemblyReference)];
+				this.vmAssemblyReference = module.ResolveAssemblyRef(oldOne.vmAssemblyReference.Rid);
 		}
 
 		public void find() {
@@ -61,13 +61,19 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			vmAssemblyReference = findVmAssemblyReference();
 		}
 
-		AssemblyNameReference findVmAssemblyReference() {
-			foreach (var memberRef in module.GetMemberReferences()) {
-				var method = memberRef as MethodReference;
-				if (method == null)
+		AssemblyRef findVmAssemblyReference() {
+			foreach (var memberRef in module.GetMemberRefs()) {
+				var sig = memberRef.MethodSig;
+				if (sig == null)
 					continue;
-				if (method.FullName == "System.Object VMRuntime.Libraries.CSVMRuntime::RunMethod(System.String,System.Object[])")
-					return method.DeclaringType.Scope as AssemblyNameReference;
+				if (sig.RetType.GetElementType() != ElementType.Object)
+					continue;
+				if (sig.Params.Count != 2)
+					continue;
+				if (memberRef.Name != "RunMethod")
+					continue;
+				if (memberRef.FullName == "System.Object VMRuntime.Libraries.CSVMRuntime::RunMethod(System.String,System.Object[])")
+					return memberRef.DeclaringType.Scope as AssemblyRef;
 			}
 			return null;
 		}
@@ -80,59 +86,59 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			if (!Detected)
 				return;
 
-			int oldIndent = Log.indentLevel;
+			int oldIndent = Logger.Instance.IndentLevel;
 			try {
 				restore2();
 			}
 			finally {
-				Log.indentLevel = oldIndent;
+				Logger.Instance.IndentLevel = oldIndent;
 			}
 		}
 
 		void restore2() {
-			Log.v("Restoring CSVM methods");
-			Log.indent();
+			Logger.v("Restoring CSVM methods");
+			Logger.Instance.indent();
 
 			var opcodeDetector = getVmOpCodeHandlerDetector();
-			var csvmMethods = new CsvmDataReader(resource.GetResourceStream()).read();
+			var csvmMethods = new CsvmDataReader(resource.Data).read();
 			var converter = new CsvmToCilMethodConverter(deobfuscatorContext, module, opcodeDetector);
 			var methodPrinter = new MethodPrinter();
 			foreach (var csvmMethod in csvmMethods) {
-				var cilMethod = module.LookupToken(csvmMethod.Token) as MethodDefinition;
+				var cilMethod = module.ResolveToken(csvmMethod.Token) as MethodDef;
 				if (cilMethod == null)
 					throw new ApplicationException(string.Format("Could not find method {0:X8}", csvmMethod.Token));
 				converter.convert(cilMethod, csvmMethod);
-				Log.v("Restored method {0:X8}", cilMethod.MetadataToken.ToInt32());
+				Logger.v("Restored method {0:X8}", cilMethod.MDToken.ToInt32());
 				printMethod(methodPrinter, cilMethod);
 			}
-			Log.deIndent();
+			Logger.Instance.deIndent();
 		}
 
-		static void printMethod(MethodPrinter methodPrinter, MethodDefinition method) {
-			const Log.LogLevel dumpLogLevel = Log.LogLevel.verbose;
-			if (!Log.isAtLeast(dumpLogLevel))
+		static void printMethod(MethodPrinter methodPrinter, MethodDef method) {
+			const LoggerEvent dumpLogLevel = LoggerEvent.Verbose;
+			if (Logger.Instance.IgnoresEvent(dumpLogLevel))
 				return;
 
-			Log.indent();
+			Logger.Instance.indent();
 
-			Log.v("Locals:");
-			Log.indent();
-			for (int i = 0; i < method.Body.Variables.Count; i++)
-				Log.v("#{0}: {1}", i, method.Body.Variables[i].VariableType);
-			Log.deIndent();
+			Logger.v("Locals:");
+			Logger.Instance.indent();
+			for (int i = 0; i < method.Body.LocalList.Count; i++)
+				Logger.v("#{0}: {1}", i, method.Body.LocalList[i].Type);
+			Logger.Instance.deIndent();
 
-			Log.v("Code:");
-			Log.indent();
+			Logger.v("Code:");
+			Logger.Instance.indent();
 			methodPrinter.print(dumpLogLevel, method.Body.Instructions, method.Body.ExceptionHandlers);
-			Log.deIndent();
+			Logger.Instance.deIndent();
 
-			Log.deIndent();
+			Logger.Instance.deIndent();
 		}
 
 		VmOpCodeHandlerDetector getVmOpCodeHandlerDetector() {
 			var vmFilename = vmAssemblyReference.Name + ".dll";
-			var vmModulePath = Path.Combine(Path.GetDirectoryName(module.FullyQualifiedName), vmFilename);
-			Log.v("CSVM filename: {0}", vmFilename);
+			var vmModulePath = Path.Combine(Path.GetDirectoryName(module.Location), vmFilename);
+			Logger.v("CSVM filename: {0}", vmFilename);
 
 			var dataKey = "cs cached VmOpCodeHandlerDetector";
 			var dict = (Dictionary<string, VmOpCodeHandlerDetector>)deobfuscatorContext.getData(dataKey);
@@ -141,14 +147,14 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			VmOpCodeHandlerDetector detector;
 			if (dict.TryGetValue(vmModulePath, out detector))
 				return detector;
-			dict[vmModulePath] = detector = new VmOpCodeHandlerDetector(ModuleDefinition.ReadModule(vmModulePath));
+			dict[vmModulePath] = detector = new VmOpCodeHandlerDetector(ModuleDefMD.Load(vmModulePath));
 
 			detector.findHandlers();
-			Log.v("CSVM opcodes:");
-			Log.indent();
+			Logger.v("CSVM opcodes:");
+			Logger.Instance.indent();
 			for (int i = 0; i < detector.Handlers.Count; i++)
-				Log.v("{0:X4}: {1}", i, detector.Handlers[i].Name);
-			Log.deIndent();
+				Logger.v("{0:X4}: {1}", i, detector.Handlers[i].Name);
+			Logger.Instance.deIndent();
 
 			return detector;
 		}
diff --git a/de4dot.code/deobfuscators/CliSecure/vm/CsvmDataReader.cs b/de4dot.code/deobfuscators/Agile_NET/vm/CsvmDataReader.cs
similarity index 89%
rename from de4dot.code/deobfuscators/CliSecure/vm/CsvmDataReader.cs
rename to de4dot.code/deobfuscators/Agile_NET/vm/CsvmDataReader.cs
index b3dd1ccd..c4201947 100644
--- a/de4dot.code/deobfuscators/CliSecure/vm/CsvmDataReader.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/vm/CsvmDataReader.cs
@@ -20,15 +20,16 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using Mono.Cecil;
+using dot10.IO;
+using dot10.DotNet;
 using de4dot.blocks;
 
-namespace de4dot.code.deobfuscators.CliSecure.vm {
+namespace de4dot.code.deobfuscators.Agile_NET.vm {
 	class CsvmDataReader {
-		BinaryReader reader;
+		IBinaryReader reader;
 
-		public CsvmDataReader(Stream stream) {
-			reader = new BinaryReader(stream);
+		public CsvmDataReader(IBinaryReader reader) {
+			this.reader = reader;
 		}
 
 		public List<CsvmMethodData> read() {
diff --git a/de4dot.code/deobfuscators/CliSecure/vm/CsvmMethodData.cs b/de4dot.code/deobfuscators/Agile_NET/vm/CsvmMethodData.cs
similarity index 95%
rename from de4dot.code/deobfuscators/CliSecure/vm/CsvmMethodData.cs
rename to de4dot.code/deobfuscators/Agile_NET/vm/CsvmMethodData.cs
index a476c00d..311b41f8 100644
--- a/de4dot.code/deobfuscators/CliSecure/vm/CsvmMethodData.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/vm/CsvmMethodData.cs
@@ -19,7 +19,7 @@
 
 using System;
 
-namespace de4dot.code.deobfuscators.CliSecure.vm {
+namespace de4dot.code.deobfuscators.Agile_NET.vm {
 	class CsvmMethodData {
 		public Guid Guid { get; set; }
 		public int Token { get; set; }
diff --git a/de4dot.code/deobfuscators/CliSecure/vm/CsvmToCilMethodConverter.cs b/de4dot.code/deobfuscators/Agile_NET/vm/CsvmToCilMethodConverter.cs
similarity index 73%
rename from de4dot.code/deobfuscators/CliSecure/vm/CsvmToCilMethodConverter.cs
rename to de4dot.code/deobfuscators/Agile_NET/vm/CsvmToCilMethodConverter.cs
index d0179294..33ba7882 100644
--- a/de4dot.code/deobfuscators/CliSecure/vm/CsvmToCilMethodConverter.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/vm/CsvmToCilMethodConverter.cs
@@ -20,41 +20,40 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.Cecil.Metadata;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
-namespace de4dot.code.deobfuscators.CliSecure.vm {
+namespace de4dot.code.deobfuscators.Agile_NET.vm {
 	class CsvmToCilMethodConverter {
 		IDeobfuscatorContext deobfuscatorContext;
-		ModuleDefinition module;
+		ModuleDefMD module;
 		VmOpCodeHandlerDetector opCodeDetector;
 		CilOperandInstructionRestorer operandRestorer = new CilOperandInstructionRestorer();
 
-		public CsvmToCilMethodConverter(IDeobfuscatorContext deobfuscatorContext, ModuleDefinition module, VmOpCodeHandlerDetector opCodeDetector) {
+		public CsvmToCilMethodConverter(IDeobfuscatorContext deobfuscatorContext, ModuleDefMD module, VmOpCodeHandlerDetector opCodeDetector) {
 			this.deobfuscatorContext = deobfuscatorContext;
 			this.module = module;
 			this.opCodeDetector = opCodeDetector;
 		}
 
-		public void convert(MethodDefinition cilMethod, CsvmMethodData csvmMethod) {
+		public void convert(MethodDef cilMethod, CsvmMethodData csvmMethod) {
 			var newInstructions = readInstructions(cilMethod, csvmMethod);
 			var newLocals = readLocals(cilMethod, csvmMethod);
 			var newExceptions = readExceptions(cilMethod, csvmMethod, newInstructions);
 
 			fixInstructionOperands(newInstructions);
-			fixLocals(newInstructions, cilMethod.Body.Variables);
+			fixLocals(newInstructions, cilMethod.Body.LocalList);
 			fixArgs(newInstructions, cilMethod);
 
 			DotNetUtils.restoreBody(cilMethod, newInstructions, newExceptions);
 
 			if (!operandRestorer.restore(cilMethod))
-				Log.w("Failed to restore one or more instruction operands in CSVM method {0:X8}", cilMethod.MetadataToken.ToInt32());
+				Logger.w("Failed to restore one or more instruction operands in CSVM method {0:X8}", cilMethod.MDToken.ToInt32());
 			restoreConstrainedPrefix(cilMethod);
 		}
 
-		void fixLocals(IList<Instruction> instrs, IList<VariableDefinition> locals) {
+		void fixLocals(IList<Instruction> instrs, IList<Local> locals) {
 			foreach (var instr in instrs) {
 				var op = instr.Operand as LocalOperand;
 				if (op == null)
@@ -64,7 +63,7 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			}
 		}
 
-		static void updateLocalInstruction(Instruction instr, VariableDefinition local, int index) {
+		static void updateLocalInstruction(Instruction instr, Local local, int index) {
 			object operand = null;
 			OpCode opcode;
 
@@ -129,25 +128,17 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			instr.Operand = operand;
 		}
 
-		void fixArgs(IList<Instruction> instrs, MethodDefinition method) {
+		void fixArgs(IList<Instruction> instrs, MethodDef method) {
 			foreach (var instr in instrs) {
 				var op = instr.Operand as ArgOperand;
 				if (op == null)
 					continue;
 
-				int argIndex = op.arg;
-				if (method.HasImplicitThis)
-					argIndex--;
-				ParameterDefinition arg;
-				if (argIndex == -1)
-					arg = method.Body.ThisParameter;
-				else
-					arg = method.Parameters[argIndex];
-				updateArgInstruction(instr, arg, op.arg);
+				updateArgInstruction(instr, method.Parameters[op.arg], op.arg);
 			}
 		}
 
-		static void updateArgInstruction(Instruction instr, ParameterDefinition arg, int index) {
+		static void updateArgInstruction(Instruction instr, Parameter arg, int index) {
 			switch (instr.OpCode.Code) {
 			case Code.Ldarg:
 			case Code.Ldarg_S:
@@ -206,15 +197,15 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			}
 		}
 
-		List<Instruction> readInstructions(MethodDefinition cilMethod, CsvmMethodData csvmMethod) {
+		List<Instruction> readInstructions(MethodDef cilMethod, CsvmMethodData csvmMethod) {
 			var reader = new BinaryReader(new MemoryStream(csvmMethod.Instructions));
 			var instrs = new List<Instruction>();
-			int offset = 0;
+			uint offset = 0;
 			while (reader.BaseStream.Position < reader.BaseStream.Length) {
 				int vmOpCode = reader.ReadUInt16();
 				var instr = opCodeDetector.Handlers[vmOpCode].Read(reader);
 				instr.Offset = offset;
-				offset += getInstructionSize(instr);
+				offset += (uint)getInstructionSize(instr);
 				instrs.Add(instr);
 			}
 			return instrs;
@@ -230,8 +221,8 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			return instr.OpCode.Size + (op.targetDisplacements.Length + 1) * 4;
 		}
 
-		List<VariableDefinition> readLocals(MethodDefinition cilMethod, CsvmMethodData csvmMethod) {
-			var locals = new List<VariableDefinition>();
+		List<Local> readLocals(MethodDef cilMethod, CsvmMethodData csvmMethod) {
+			var locals = new List<Local>();
 			var reader = new BinaryReader(new MemoryStream(csvmMethod.Locals));
 
 			if (csvmMethod.Locals.Length == 0)
@@ -243,67 +234,62 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 				throw new ApplicationException("Invalid number of locals");
 
 			for (int i = 0; i < numLocals; i++)
-				locals.Add(new VariableDefinition(readTypeReference(reader)));
+				locals.Add(new Local(readTypeReference(reader)));
 
 			return locals;
 		}
 
-		TypeReference readTypeReference(BinaryReader reader) {
+		TypeSig readTypeReference(BinaryReader reader) {
 			var etype = (ElementType)reader.ReadInt32();
 			switch (etype) {
-			case ElementType.Void: return module.TypeSystem.Void;
-			case ElementType.Boolean: return module.TypeSystem.Boolean;
-			case ElementType.Char: return module.TypeSystem.Char;
-			case ElementType.I1: return module.TypeSystem.SByte;
-			case ElementType.U1: return module.TypeSystem.Byte;
-			case ElementType.I2: return module.TypeSystem.Int16;
-			case ElementType.U2: return module.TypeSystem.UInt16;
-			case ElementType.I4: return module.TypeSystem.Int32;
-			case ElementType.U4: return module.TypeSystem.UInt32;
-			case ElementType.I8: return module.TypeSystem.Int64;
-			case ElementType.U8: return module.TypeSystem.UInt64;
-			case ElementType.R4: return module.TypeSystem.Single;
-			case ElementType.R8: return module.TypeSystem.Double;
-			case ElementType.String: return module.TypeSystem.String;
-			case ElementType.TypedByRef: return module.TypeSystem.TypedReference;
-			case ElementType.I: return module.TypeSystem.IntPtr;
-			case ElementType.U: return module.TypeSystem.UIntPtr;
-			case ElementType.Object: return module.TypeSystem.Object;
+			case ElementType.Void: return module.CorLibTypes.Void;
+			case ElementType.Boolean: return module.CorLibTypes.Boolean;
+			case ElementType.Char: return module.CorLibTypes.Char;
+			case ElementType.I1: return module.CorLibTypes.SByte;
+			case ElementType.U1: return module.CorLibTypes.Byte;
+			case ElementType.I2: return module.CorLibTypes.Int16;
+			case ElementType.U2: return module.CorLibTypes.UInt16;
+			case ElementType.I4: return module.CorLibTypes.Int32;
+			case ElementType.U4: return module.CorLibTypes.UInt32;
+			case ElementType.I8: return module.CorLibTypes.Int64;
+			case ElementType.U8: return module.CorLibTypes.UInt64;
+			case ElementType.R4: return module.CorLibTypes.Single;
+			case ElementType.R8: return module.CorLibTypes.Double;
+			case ElementType.String: return module.CorLibTypes.String;
+			case ElementType.TypedByRef: return module.CorLibTypes.TypedReference;
+			case ElementType.I: return module.CorLibTypes.IntPtr;
+			case ElementType.U: return module.CorLibTypes.UIntPtr;
+			case ElementType.Object: return module.CorLibTypes.Object;
 
 			case ElementType.ValueType:
 			case ElementType.Var:
 			case ElementType.MVar:
-				return (TypeReference)module.LookupToken(reader.ReadInt32());
+				return (module.ResolveToken(reader.ReadUInt32()) as ITypeDefOrRef).ToTypeSig();
 
 			case ElementType.GenericInst:
 				etype = (ElementType)reader.ReadInt32();
 				if (etype == ElementType.ValueType)
-					return (TypeReference)module.LookupToken(reader.ReadInt32());
+					return (module.ResolveToken(reader.ReadUInt32()) as ITypeDefOrRef).ToTypeSig();
 				// ElementType.Class
-				return module.TypeSystem.Object;
+				return module.CorLibTypes.Object;
 
 			case ElementType.Ptr:
 			case ElementType.Class:
 			case ElementType.Array:
 			case ElementType.FnPtr:
-			case ElementType.SzArray:
+			case ElementType.SZArray:
 			case ElementType.ByRef:
-			case ElementType.CModReqD:
+			case ElementType.CModReqd:
 			case ElementType.CModOpt:
 			case ElementType.Internal:
-			case ElementType.Modifier:
 			case ElementType.Sentinel:
 			case ElementType.Pinned:
-			case ElementType.Type:
-			case ElementType.Boxed:
-			case ElementType.Enum:
-			case ElementType.None:
 			default:
-				return module.TypeSystem.Object;
+				return module.CorLibTypes.Object;
 			}
 		}
 
-		List<ExceptionHandler> readExceptions(MethodDefinition cilMethod, CsvmMethodData csvmMethod, List<Instruction> cilInstructions) {
+		List<ExceptionHandler> readExceptions(MethodDef cilMethod, CsvmMethodData csvmMethod, List<Instruction> cilInstructions) {
 			var reader = new BinaryReader(new MemoryStream(csvmMethod.Exceptions));
 			var ehs = new List<ExceptionHandler>();
 
@@ -321,7 +307,7 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 				eh.HandlerStart = getInstruction(cilInstructions, reader.ReadInt32());
 				eh.HandlerEnd = getInstructionEnd(cilInstructions, reader.ReadInt32());
 				if (eh.HandlerType == ExceptionHandlerType.Catch)
-					eh.CatchType = (TypeReference)module.LookupToken(reader.ReadInt32());
+					eh.CatchType = module.ResolveToken(reader.ReadUInt32()) as ITypeDefOrRef;
 				else if (eh.HandlerType == ExceptionHandlerType.Filter)
 					eh.FilterStart = getInstruction(cilInstructions, reader.ReadInt32());
 
@@ -387,12 +373,12 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			throw new ApplicationException(string.Format("Unknown operand type: {0}", vmOperand.GetType()));
 		}
 
-		FieldReference fixLoadStoreFieldInstruction(Instruction instr, int token, OpCode staticInstr, OpCode instanceInstr) {
-			var fieldRef = (FieldReference)module.LookupToken(token);
-			var field = deobfuscatorContext.resolve(fieldRef);
+		IField fixLoadStoreFieldInstruction(Instruction instr, int token, OpCode staticInstr, OpCode instanceInstr) {
+			var fieldRef = module.ResolveToken(token) as IField;
+			var field = deobfuscatorContext.resolveField(fieldRef);
 			bool isStatic;
 			if (field == null) {
-				Log.w("Could not resolve field {0:X8}. Assuming it's not static.", token);
+				Logger.w("Could not resolve field {0:X8}. Assuming it's not static.", token);
 				isStatic = false;
 			}
 			else
@@ -401,14 +387,14 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			return fieldRef;
 		}
 
-		MemberReference getMemberReference(int token) {
-			var memberRef = module.LookupToken(token) as MemberReference;
+		ITokenOperand getMemberReference(int token) {
+			var memberRef = module.ResolveToken(token) as ITokenOperand;
 			if (memberRef == null)
 				throw new ApplicationException(string.Format("Could not find member ref: {0:X8}", token));
 			return memberRef;
 		}
 
-		static void restoreConstrainedPrefix(MethodDefinition method) {
+		static void restoreConstrainedPrefix(MethodDef method) {
 			if (method == null || method.Body == null)
 				return;
 
@@ -418,15 +404,18 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 				if (instr.OpCode.Code != Code.Callvirt)
 					continue;
 
-				var calledMethod = instr.Operand as MethodReference;
-				if (calledMethod == null || !calledMethod.HasThis)
+				var calledMethod = instr.Operand as IMethod;
+				if (calledMethod == null)
 					continue;
-				var thisType = MethodStack.getLoadedType(method, instrs, i, calledMethod.Parameters.Count) as ByReferenceType;
+				var sig = calledMethod.MethodSig;
+				if (sig == null || !sig.HasThis)
+					continue;
+				var thisType = MethodStack.getLoadedType(method, instrs, i, sig.Params.Count) as ByRefSig;
 				if (thisType == null)
 					continue;
 				if (hasPrefix(instrs, i, Code.Constrained))
 					continue;
-				instrs.Insert(i, Instruction.Create(OpCodes.Constrained, thisType.ElementType));
+				instrs.Insert(i, Instruction.Create(OpCodes.Constrained, thisType.Next.ToTypeDefOrRef()));
 				i++;
 			}
 		}
diff --git a/de4dot.code/deobfuscators/CliSecure/vm/FieldsInfo.cs b/de4dot.code/deobfuscators/Agile_NET/vm/FieldsInfo.cs
similarity index 84%
rename from de4dot.code/deobfuscators/CliSecure/vm/FieldsInfo.cs
rename to de4dot.code/deobfuscators/Agile_NET/vm/FieldsInfo.cs
index f4ba58e3..1d12513c 100644
--- a/de4dot.code/deobfuscators/CliSecure/vm/FieldsInfo.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/vm/FieldsInfo.cs
@@ -19,25 +19,25 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 
-namespace de4dot.code.deobfuscators.CliSecure.vm {
+namespace de4dot.code.deobfuscators.Agile_NET.vm {
 	class FieldsInfo {
 		public static readonly object EnumType = new object();
 		Dictionary<string, int> fieldTypes = new Dictionary<string, int>(StringComparer.Ordinal);
 		int numEnums = 0;
 
-		public FieldsInfo(TypeDefinition type)
+		public FieldsInfo(TypeDef type)
 			: this(type.Fields) {
 		}
 
-		public FieldsInfo(IEnumerable<FieldDefinition> fields) {
+		public FieldsInfo(IEnumerable<FieldDef> fields) {
 			foreach (var field in fields) {
-				var fieldTypeDef = field.FieldType as TypeDefinition;
+				var fieldTypeDef = field.FieldSig.GetFieldType().TryGetTypeDef();
 				if (fieldTypeDef != null && fieldTypeDef.IsEnum)
 					addEnum();
 				else
-					add(field.FieldType);
+					add(field.FieldSig.GetFieldType());
 			}
 		}
 
@@ -50,8 +50,8 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			}
 		}
 
-		void add(TypeReference type) {
-			add(type.FullName);
+		void add(TypeSig type) {
+			add(type.GetFullName());
 		}
 
 		void add(string typeFullName) {
diff --git a/de4dot.code/deobfuscators/CliSecure/vm/OpCodeHandler.cs b/de4dot.code/deobfuscators/Agile_NET/vm/OpCodeHandler.cs
similarity index 98%
rename from de4dot.code/deobfuscators/CliSecure/vm/OpCodeHandler.cs
rename to de4dot.code/deobfuscators/Agile_NET/vm/OpCodeHandler.cs
index d3aceec1..b9cc6b31 100644
--- a/de4dot.code/deobfuscators/CliSecure/vm/OpCodeHandler.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/vm/OpCodeHandler.cs
@@ -21,11 +21,10 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using de4dot.blocks;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.Cecil.Metadata;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 
-namespace de4dot.code.deobfuscators.CliSecure.vm {
+namespace de4dot.code.deobfuscators.Agile_NET.vm {
 	partial class OpCodeHandler {
 		public string Name { get; set; }
 		public OpCodeHandlerSigInfo OpCodeHandlerSigInfo { get; set; }
@@ -248,7 +247,7 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			new InstructionInfo2 { First = false, Second = true, Value = 12, OpCode = OpCodes.Stelem_R4 },
 			new InstructionInfo2 { First = false, Second = true, Value = 13, OpCode = OpCodes.Stelem_R8 },
 			new InstructionInfo2 { First = false, Second = true, Value = 28, OpCode = OpCodes.Stelem_Ref },
-			new InstructionInfo2 { First = false, Second = false, Value = 0, OpCode = OpCodes.Stelem_Any },
+			new InstructionInfo2 { First = false, Second = false, Value = 0, OpCode = OpCodes.Stelem },
 
 			new InstructionInfo2 { First = true, Second = true, Value = 24, OpCode = OpCodes.Ldelem_I },
 			new InstructionInfo2 { First = true, Second = true, Value = 4, OpCode = OpCodes.Ldelem_I1 },
@@ -261,7 +260,7 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			new InstructionInfo2 { First = true, Second = true, Value = 12, OpCode = OpCodes.Ldelem_R4 },
 			new InstructionInfo2 { First = true, Second = true, Value = 13, OpCode = OpCodes.Ldelem_R8 },
 			new InstructionInfo2 { First = true, Second = true, Value = 28, OpCode = OpCodes.Ldelem_Ref },
-			new InstructionInfo2 { First = true, Second = false, Value = 0, OpCode = OpCodes.Ldelem_Any },
+			new InstructionInfo2 { First = true, Second = false, Value = 0, OpCode = OpCodes.Ldelem },
 		};
 		static Instruction ldelem_read(BinaryReader reader) {
 			Instruction instr = null;
@@ -392,7 +391,7 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 
 		static Instruction ldc_read(BinaryReader reader) {
 			switch ((ElementType)reader.ReadByte()) {
-			case ElementType.I4: return DotNetUtils.createLdci4(reader.ReadInt32());
+			case ElementType.I4: return Instruction.CreateLdcI4(reader.ReadInt32());
 			case ElementType.I8: return Instruction.Create(OpCodes.Ldc_I8, reader.ReadInt64());
 			case ElementType.R4: return Instruction.Create(OpCodes.Ldc_R4, reader.ReadSingle());
 			case ElementType.R8: return Instruction.Create(OpCodes.Ldc_R8, reader.ReadDouble());
@@ -439,7 +438,7 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			return isEmptyMethod(info.ReadMethod) && isEmptyMethod(info.ExecuteMethod);
 		}
 
-		static bool isEmptyMethod(MethodDefinition method) {
+		static bool isEmptyMethod(MethodDef method) {
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code == Code.Ret)
 					return true;
@@ -463,7 +462,7 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 		}
 
 		static bool rethrow_check(UnknownHandlerInfo info) {
-			return info.ExecuteMethod.Body.Variables.Count == 0;
+			return info.ExecuteMethod.Body.LocalList.Count == 0;
 		}
 
 		static Instruction rethrow_read(BinaryReader reader) {
diff --git a/de4dot.code/deobfuscators/CliSecure/vm/OpCodeHandlers.cs b/de4dot.code/deobfuscators/Agile_NET/vm/OpCodeHandlers.cs
similarity index 99%
rename from de4dot.code/deobfuscators/CliSecure/vm/OpCodeHandlers.cs
rename to de4dot.code/deobfuscators/Agile_NET/vm/OpCodeHandlers.cs
index 3dc0eba0..48199216 100644
--- a/de4dot.code/deobfuscators/CliSecure/vm/OpCodeHandlers.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/vm/OpCodeHandlers.cs
@@ -17,7 +17,7 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-namespace de4dot.code.deobfuscators.CliSecure.vm {
+namespace de4dot.code.deobfuscators.Agile_NET.vm {
 	static partial class OpCodeHandlers {
 		public static readonly OpCodeHandler[][] opcodeHandlers = new OpCodeHandler[][] {
 			new OpCodeHandler[] {
diff --git a/de4dot.code/deobfuscators/CliSecure/vm/UnknownHandlerInfo.cs b/de4dot.code/deobfuscators/Agile_NET/vm/UnknownHandlerInfo.cs
similarity index 81%
rename from de4dot.code/deobfuscators/CliSecure/vm/UnknownHandlerInfo.cs
rename to de4dot.code/deobfuscators/Agile_NET/vm/UnknownHandlerInfo.cs
index 9ce21539..f2d923e1 100644
--- a/de4dot.code/deobfuscators/CliSecure/vm/UnknownHandlerInfo.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/vm/UnknownHandlerInfo.cs
@@ -19,24 +19,24 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
-namespace de4dot.code.deobfuscators.CliSecure.vm {
+namespace de4dot.code.deobfuscators.Agile_NET.vm {
 	class UnknownHandlerInfo {
-		TypeDefinition type;
+		TypeDef type;
 		CsvmInfo csvmInfo;
 		FieldsInfo fieldsInfo;
-		MethodDefinition readMethod, executeMethod;
+		MethodDef readMethod, executeMethod;
 		int numStaticMethods, numInstanceMethods, numVirtualMethods, numCtors;
 		int executeMethodThrows, executeMethodPops;
 
-		public MethodDefinition ReadMethod {
+		public MethodDef ReadMethod {
 			get { return readMethod; }
 		}
 
-		public MethodDefinition ExecuteMethod {
+		public MethodDef ExecuteMethod {
 			get { return executeMethod; }
 		}
 
@@ -64,7 +64,7 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			get { return numCtors; }
 		}
 
-		public UnknownHandlerInfo(TypeDefinition type, CsvmInfo csvmInfo) {
+		public UnknownHandlerInfo(TypeDef type, CsvmInfo csvmInfo) {
 			this.type = type;
 			this.csvmInfo = csvmInfo;
 			fieldsInfo = new FieldsInfo(getFields(type));
@@ -74,16 +74,16 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			executeMethodPops = countPops(executeMethod);
 		}
 
-		static internal IEnumerable<FieldDefinition> getFields(TypeDefinition type) {
-			var typeFields = new FieldDefinitionAndDeclaringTypeDict<FieldDefinition>();
+		static internal IEnumerable<FieldDef> getFields(TypeDef type) {
+			var typeFields = new FieldDefinitionAndDeclaringTypeDict<FieldDef>();
 			foreach (var field in type.Fields)
 				typeFields.add(field, field);
-			var realFields = new Dictionary<FieldDefinition, bool>();
+			var realFields = new Dictionary<FieldDef, bool>();
 			foreach (var method in type.Methods) {
 				if (method.Body == null)
 					continue;
 				foreach (var instr in method.Body.Instructions) {
-					var fieldRef = instr.Operand as FieldReference;
+					var fieldRef = instr.Operand as IField;
 					if (fieldRef == null)
 						continue;
 					var field = typeFields.find(fieldRef);
@@ -119,7 +119,7 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 						throw new ApplicationException("Found another read method");
 					readMethod = method;
 				}
-				else if (!DotNetUtils.hasReturnValue(method) && method.Parameters.Count == 1) {
+				else if (!DotNetUtils.hasReturnValue(method) && method.MethodSig.GetParamCount() == 1) {
 					if (executeMethod != null)
 						throw new ApplicationException("Found another execute method");
 					executeMethod = method;
@@ -132,7 +132,7 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 				throw new ApplicationException("Could not find execute method");
 		}
 
-		static int countThrows(MethodDefinition method) {
+		static int countThrows(MethodDef method) {
 			int count = 0;
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code == Code.Throw)
@@ -141,13 +141,13 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			return count;
 		}
 
-		int countPops(MethodDefinition method) {
+		int countPops(MethodDef method) {
 			int count = 0;
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Call && instr.OpCode.Code != Code.Callvirt)
 					continue;
-				var calledMethod = instr.Operand as MethodReference;
-				if (!MemberReferenceHelper.compareMethodReferenceAndDeclaringType(calledMethod, csvmInfo.PopMethod))
+				var calledMethod = instr.Operand as IMethod;
+				if (!MethodEqualityComparer.CompareDeclaringTypes.Equals(calledMethod, csvmInfo.PopMethod))
 					continue;
 
 				count++;
diff --git a/de4dot.code/deobfuscators/CliSecure/vm/VmOpCodeHandlerDetector.cs b/de4dot.code/deobfuscators/Agile_NET/vm/VmOpCodeHandlerDetector.cs
similarity index 76%
rename from de4dot.code/deobfuscators/CliSecure/vm/VmOpCodeHandlerDetector.cs
rename to de4dot.code/deobfuscators/Agile_NET/vm/VmOpCodeHandlerDetector.cs
index 639314e9..4d306ca9 100644
--- a/de4dot.code/deobfuscators/CliSecure/vm/VmOpCodeHandlerDetector.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/vm/VmOpCodeHandlerDetector.cs
@@ -19,12 +19,12 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 using de4dot.blocks.cflow;
 
-namespace de4dot.code.deobfuscators.CliSecure.vm {
+namespace de4dot.code.deobfuscators.Agile_NET.vm {
 	class OpCodeHandlerSigInfo {
 		public object[] RequiredFieldTypes { get; set; }
 		public string[] ExecuteMethodLocals { get; set; }
@@ -37,21 +37,21 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 	}
 
 	class CsvmInfo {
-		public TypeDefinition StackValue { get; set; }
-		public TypeDefinition Stack { get; set; }
-		public MethodDefinition PopMethod { get; set; }
-		public MethodDefinition PeekMethod { get; set; }
+		public TypeDef StackValue { get; set; }
+		public TypeDef Stack { get; set; }
+		public MethodDef PopMethod { get; set; }
+		public MethodDef PeekMethod { get; set; }
 	}
 
 	class VmOpCodeHandlerDetector {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		List<OpCodeHandler> opCodeHandlers;
 
 		public List<OpCodeHandler> Handlers {
 			get { return opCodeHandlers; }
 		}
 
-		public VmOpCodeHandlerDetector(ModuleDefinition module) {
+		public VmOpCodeHandlerDetector(ModuleDefMD module) {
 			this.module = module;
 		}
 
@@ -73,7 +73,7 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			return csvmInfo;
 		}
 
-		TypeDefinition findStackValueType() {
+		TypeDef findStackValueType() {
 			foreach (var type in module.Types) {
 				if (isStackType(type))
 					return type;
@@ -81,17 +81,17 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			return null;
 		}
 
-		static bool isStackType(TypeDefinition type) {
+		static bool isStackType(TypeDef type) {
 			if (type.Fields.Count != 2)
 				return false;
 
 			int enumTypes = 0;
 			int objectTypes = 0;
 			foreach (var field in type.Fields) {
-				var fieldType = field.FieldType as TypeDefinition;
+				var fieldType = field.FieldSig.GetFieldType().TryGetTypeDef();
 				if (fieldType != null && fieldType.IsEnum)
 					enumTypes++;
-				if (field.FieldType.FullName == "System.Object")
+				if (field.FieldSig.GetFieldType().GetElementType() == ElementType.Object)
 					objectTypes++;
 			}
 			if (enumTypes != 1 || objectTypes != 1)
@@ -100,7 +100,7 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			return true;
 		}
 
-		TypeDefinition findStackType(TypeDefinition stackValueType) {
+		TypeDef findStackType(TypeDef stackValueType) {
 			foreach (var type in module.Types) {
 				if (isStackType(type, stackValueType))
 					return type;
@@ -108,7 +108,7 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			return null;
 		}
 
-		bool isStackType(TypeDefinition type, TypeDefinition stackValueType) {
+		bool isStackType(TypeDef type, TypeDef stackValueType) {
 			if (type.Interfaces.Count != 2)
 				return false;
 			if (!implementsInterface(type, "System.Collections.ICollection"))
@@ -124,11 +124,14 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			foreach (var field in type.Fields) {
 				if (field.IsLiteral)
 					continue;
-				if (field.FieldType is ArrayType && ((ArrayType)field.FieldType).ElementType == stackValueType)
+				var fieldType = field.FieldSig.GetFieldType();
+				if (fieldType == null)
+					continue;
+				if (fieldType.IsSZArray && fieldType.Next.TryGetTypeDef() == stackValueType)
 					stackValueTypes++;
-				if (field.FieldType.FullName == "System.Int32")
+				if (fieldType.ElementType == ElementType.I4)
 					int32Types++;
-				if (field.FieldType.FullName == "System.Object")
+				if (fieldType.ElementType == ElementType.Object)
 					objectTypes++;
 			}
 			if (stackValueTypes != 2 || int32Types != 2 || objectTypes != 1)
@@ -137,9 +140,9 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			return true;
 		}
 
-		static bool implementsInterface(TypeDefinition type, string ifaceName) {
+		static bool implementsInterface(TypeDef type, string ifaceName) {
 			foreach (var iface in type.Interfaces) {
-				if (iface.FullName == ifaceName)
+				if (iface.Interface.FullName == ifaceName)
 					return true;
 			}
 			return false;
@@ -147,7 +150,8 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 
 		void initStackTypeMethods(CsvmInfo csvmInfo) {
 			foreach (var method in csvmInfo.Stack.Methods) {
-				if (method.Parameters.Count == 0 && method.MethodReturnType.ReturnType == csvmInfo.StackValue) {
+				var sig = method.MethodSig;
+				if (sig != null && sig.Params.Count == 0 && sig.RetType.TryGetTypeDef() == csvmInfo.StackValue) {
 					if (hasAdd(method))
 						csvmInfo.PopMethod = method;
 					else
@@ -156,7 +160,7 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			}
 		}
 
-		static bool hasAdd(MethodDefinition method) {
+		static bool hasAdd(MethodDef method) {
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code == Code.Add)
 					return true;
@@ -164,7 +168,7 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			return false;
 		}
 
-		List<TypeDefinition> findVmHandlerTypes() {
+		List<TypeDef> findVmHandlerTypes() {
 			var requiredFields = new string[] {
 				null,
 				"System.Collections.Generic.Dictionary`2<System.UInt16,System.Type>",
@@ -172,7 +176,7 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			};
 			var cflowDeobfuscator = new CflowDeobfuscator();
 			foreach (var type in module.Types) {
-				var cctor = DotNetUtils.getMethod(type, ".cctor");
+				var cctor = type.FindStaticConstructor();
 				if (cctor == null)
 					continue;
 				requiredFields[0] = type.FullName;
@@ -190,13 +194,13 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			return null;
 		}
 
-		static List<TypeDefinition> findVmHandlerTypes(MethodDefinition method) {
-			var list = new List<TypeDefinition>();
+		static List<TypeDef> findVmHandlerTypes(MethodDef method) {
+			var list = new List<TypeDef>();
 
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Ldtoken)
 					continue;
-				var type = instr.Operand as TypeDefinition;
+				var type = instr.Operand as TypeDef;
 				if (type == null)
 					continue;
 
@@ -206,7 +210,7 @@ namespace de4dot.code.deobfuscators.CliSecure.vm {
 			return list;
 		}
 
-		void detectHandlers(List<TypeDefinition> handlerTypes, CsvmInfo csvmInfo) {
+		void detectHandlers(List<TypeDef> handlerTypes, CsvmInfo csvmInfo) {
 			opCodeHandlers = new List<OpCodeHandler>();
 			var detected = new List<OpCodeHandler>();
 
diff --git a/de4dot.code/deobfuscators/CliSecure/vm/VmOperands.cs b/de4dot.code/deobfuscators/Agile_NET/vm/VmOperands.cs
similarity index 97%
rename from de4dot.code/deobfuscators/CliSecure/vm/VmOperands.cs
rename to de4dot.code/deobfuscators/Agile_NET/vm/VmOperands.cs
index 4d6d45cd..4e1e122d 100644
--- a/de4dot.code/deobfuscators/CliSecure/vm/VmOperands.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/vm/VmOperands.cs
@@ -17,7 +17,7 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-namespace de4dot.code.deobfuscators.CliSecure.vm {
+namespace de4dot.code.deobfuscators.Agile_NET.vm {
 	interface IVmOperand {
 	}
 
diff --git a/de4dot.code/deobfuscators/ArrayFinder.cs b/de4dot.code/deobfuscators/ArrayFinder.cs
index e15ddbc0..dc1c1ae4 100644
--- a/de4dot.code/deobfuscators/ArrayFinder.cs
+++ b/de4dot.code/deobfuscators/ArrayFinder.cs
@@ -18,26 +18,26 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 using de4dot.blocks.cflow;
 
 namespace de4dot.code.deobfuscators {
 	static class ArrayFinder {
-		public static List<byte[]> getArrays(MethodDefinition method) {
+		public static List<byte[]> getArrays(MethodDef method) {
 			return getArrays(method, null);
 		}
 
-		public static List<byte[]> getArrays(MethodDefinition method, TypeReference arrayElemntType) {
+		public static List<byte[]> getArrays(MethodDef method, IType arrayElementType) {
 			var arrays = new List<byte[]>();
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count; i++) {
-				TypeReference type;
+				IType type;
 				var ary = getArray(instrs, ref i, out type);
 				if (ary == null)
 					break;
-				if (arrayElemntType != null && !MemberReferenceHelper.compareTypes(type, arrayElemntType))
+				if (arrayElementType != null && !new SigComparer().Equals(type, arrayElementType))
 					continue;
 
 				arrays.Add(ary);
@@ -45,7 +45,7 @@ namespace de4dot.code.deobfuscators {
 			return arrays;
 		}
 
-		public static byte[] getArray(IList<Instruction> instrs, ref int index, out TypeReference type) {
+		public static byte[] getArray(IList<Instruction> instrs, ref int index, out IType type) {
 			for (int i = index; i < instrs.Count - 2; i++) {
 				var newarr = instrs[i++];
 				if (newarr.OpCode.Code != Code.Newarr)
@@ -57,12 +57,12 @@ namespace de4dot.code.deobfuscators {
 				var ldtoken = instrs[i++];
 				if (ldtoken.OpCode.Code != Code.Ldtoken)
 					continue;
-				var field = ldtoken.Operand as FieldDefinition;
+				var field = ldtoken.Operand as FieldDef;
 				if (field == null || field.InitialValue == null)
 					continue;
 
 				index = i - 3;
-				type = newarr.Operand as TypeReference;
+				type = newarr.Operand as IType;
 				return field.InitialValue;
 			}
 
@@ -71,14 +71,14 @@ namespace de4dot.code.deobfuscators {
 			return null;
 		}
 
-		public static byte[] getInitializedByteArray(MethodDefinition method, int arraySize) {
+		public static byte[] getInitializedByteArray(MethodDef method, int arraySize) {
 			int newarrIndex = findNewarr(method, arraySize);
 			if (newarrIndex < 0)
 				return null;
 			return getInitializedByteArray(arraySize, method, ref newarrIndex);
 		}
 
-		public static byte[] getInitializedByteArray(int arraySize, MethodDefinition method, ref int newarrIndex) {
+		public static byte[] getInitializedByteArray(int arraySize, MethodDef method, ref int newarrIndex) {
 			var resultValueArray = getInitializedArray(arraySize, method, ref newarrIndex, Code.Stelem_I1);
 
 			var resultArray = new byte[resultValueArray.Length];
@@ -91,7 +91,7 @@ namespace de4dot.code.deobfuscators {
 			return resultArray;
 		}
 
-		public static short[] getInitializedInt16Array(int arraySize, MethodDefinition method, ref int newarrIndex) {
+		public static short[] getInitializedInt16Array(int arraySize, MethodDef method, ref int newarrIndex) {
 			var resultValueArray = getInitializedArray(arraySize, method, ref newarrIndex, Code.Stelem_I2);
 
 			var resultArray = new short[resultValueArray.Length];
@@ -104,7 +104,7 @@ namespace de4dot.code.deobfuscators {
 			return resultArray;
 		}
 
-		public static int[] getInitializedInt32Array(int arraySize, MethodDefinition method, ref int newarrIndex) {
+		public static int[] getInitializedInt32Array(int arraySize, MethodDef method, ref int newarrIndex) {
 			var resultValueArray = getInitializedArray(arraySize, method, ref newarrIndex, Code.Stelem_I4);
 
 			var resultArray = new int[resultValueArray.Length];
@@ -117,7 +117,7 @@ namespace de4dot.code.deobfuscators {
 			return resultArray;
 		}
 
-		public static uint[] getInitializedUInt32Array(int arraySize, MethodDefinition method, ref int newarrIndex) {
+		public static uint[] getInitializedUInt32Array(int arraySize, MethodDef method, ref int newarrIndex) {
 			var resultArray = getInitializedInt32Array(arraySize, method, ref newarrIndex);
 			if (resultArray == null)
 				return null;
@@ -128,7 +128,7 @@ namespace de4dot.code.deobfuscators {
 			return ary;
 		}
 
-		public static Value[] getInitializedArray(int arraySize, MethodDefinition method, ref int newarrIndex, Code stelemOpCode) {
+		public static Value[] getInitializedArray(int arraySize, MethodDef method, ref int newarrIndex, Code stelemOpCode) {
 			var resultValueArray = new Value[arraySize];
 
 			var emulator = new InstructionEmulator(method);
@@ -183,7 +183,7 @@ done:
 			return resultValueArray;
 		}
 
-		static int findNewarr(MethodDefinition method, int arraySize) {
+		static int findNewarr(MethodDef method, int arraySize) {
 			for (int i = 0; ; i++) {
 				int size;
 				if (!findNewarr(method, ref i, out size))
@@ -193,17 +193,17 @@ done:
 			}
 		}
 
-		public static bool findNewarr(MethodDefinition method, ref int i, out int size) {
+		public static bool findNewarr(MethodDef method, ref int i, out int size) {
 			var instructions = method.Body.Instructions;
 			for (; i < instructions.Count; i++) {
 				var instr = instructions[i];
 				if (instr.OpCode.Code != Code.Newarr || i < 1)
 					continue;
 				var ldci4 = instructions[i - 1];
-				if (!DotNetUtils.isLdcI4(ldci4))
+				if (!ldci4.IsLdcI4())
 					continue;
 
-				size = DotNetUtils.getLdcI4Value(ldci4);
+				size = ldci4.GetLdcI4Value();
 				return true;
 			}
 
diff --git a/de4dot.code/deobfuscators/Babel_NET/AssemblyResolver.cs b/de4dot.code/deobfuscators/Babel_NET/AssemblyResolver.cs
index 1af66548..762c97f4 100644
--- a/de4dot.code/deobfuscators/Babel_NET/AssemblyResolver.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/AssemblyResolver.cs
@@ -19,15 +19,16 @@
 
 using System;
 using System.IO;
-using Mono.Cecil;
+using dot10.IO;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Babel_NET {
 	class AssemblyResolver {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		ResourceDecrypter resourceDecrypter;
-		TypeDefinition resolverType;
-		MethodDefinition registerMethod;
+		TypeDef resolverType;
+		MethodDef registerMethod;
 		EmbeddedResource encryptedResource;
 		EmbeddedAssemblyInfo[] embeddedAssemblyInfos = new EmbeddedAssemblyInfo[0];
 
@@ -47,11 +48,11 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			get { return resolverType != null; }
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return resolverType; }
 		}
 
-		public MethodDefinition InitMethod {
+		public MethodDef InitMethod {
 			get { return registerMethod; }
 		}
 
@@ -63,7 +64,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			get { return embeddedAssemblyInfos; }
 		}
 
-		public AssemblyResolver(ModuleDefinition module, ResourceDecrypter resourceDecrypter) {
+		public AssemblyResolver(ModuleDefMD module, ResourceDecrypter resourceDecrypter) {
 			this.module = module;
 			this.resourceDecrypter = resourceDecrypter;
 		}
@@ -80,7 +81,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				if (!new FieldTypes(type).exactly(requiredTypes))
 					continue;
 
-				MethodDefinition regMethod, handler;
+				MethodDef regMethod, handler;
 				if (!BabelUtils.findRegisterMethod(type, out regMethod, out handler))
 					continue;
 
@@ -95,7 +96,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			}
 		}
 
-		static MethodDefinition findDecryptMethod(TypeDefinition type) {
+		static MethodDef findDecryptMethod(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (!DotNetUtils.isMethod(method, "System.Void", "(System.IO.Stream)"))
 					continue;
@@ -110,18 +111,18 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 
 			encryptedResource = BabelUtils.findEmbeddedResource(module, resolverType, simpleDeobfuscator, deob);
 			if (encryptedResource == null) {
-				Log.w("Could not find embedded assemblies resource");
+				Logger.w("Could not find embedded assemblies resource");
 				return;
 			}
 
-			var decrypted = resourceDecrypter.decrypt(encryptedResource.GetResourceData());
+			var decrypted = resourceDecrypter.decrypt(encryptedResource.Data.ReadAllBytes());
 			var reader = new BinaryReader(new MemoryStream(decrypted));
 			int numAssemblies = reader.ReadInt32();
 			embeddedAssemblyInfos = new EmbeddedAssemblyInfo[numAssemblies];
 			for (int i = 0; i < numAssemblies; i++) {
 				string name = reader.ReadString();
 				var data = reader.ReadBytes(reader.ReadInt32());
-				var mod = ModuleDefinition.ReadModule(new MemoryStream(data));
+				var mod = ModuleDefMD.Load(data);
 				embeddedAssemblyInfos[i] = new EmbeddedAssemblyInfo(name, DeobUtils.getExtension(mod.Kind), data);
 			}
 		}
diff --git a/de4dot.code/deobfuscators/Babel_NET/BabelMethodCallInliner.cs b/de4dot.code/deobfuscators/Babel_NET/BabelMethodCallInliner.cs
index 10d9c955..87fbd7f0 100644
--- a/de4dot.code/deobfuscators/Babel_NET/BabelMethodCallInliner.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/BabelMethodCallInliner.cs
@@ -18,8 +18,8 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 using de4dot.blocks.cflow;
 
@@ -35,12 +35,12 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			branchEmulator = new BranchEmulator(emulator, this);
 		}
 
-		public static List<MethodDefinition> find(ModuleDefinition module, IEnumerable<MethodDefinition> notInlinedMethods) {
-			var notInlinedMethodsDict = new Dictionary<MethodDefinition, bool>();
+		public static List<MethodDef> find(ModuleDefMD module, IEnumerable<MethodDef> notInlinedMethods) {
+			var notInlinedMethodsDict = new Dictionary<MethodDef, bool>();
 			foreach (var method in notInlinedMethods)
 				notInlinedMethodsDict[method] = true;
 
-			var inlinedMethods = new List<MethodDefinition>();
+			var inlinedMethods = new List<MethodDef>();
 
 			foreach (var type in module.GetTypes()) {
 				foreach (var method in type.Methods) {
@@ -83,23 +83,23 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return changed;
 		}
 
-		static bool canInline(MethodDefinition method) {
+		static bool canInline(MethodDef method) {
 			if (!DotNetUtils.isMethod(method, "System.Int32", "(System.Int32)"))
 				return false;
 			if (!method.IsAssembly)
 				return false;
-			if (method.GenericParameters.Count > 0)
+			if (method.MethodSig.GetGenParamCount() > 0)
 				return false;
 
 			return method.IsStatic;
 		}
 
-		bool canInline2(MethodDefinition method) {
+		bool canInline2(MethodDef method) {
 			return canInline(method) && method != blocks.Method;
 		}
 
 		bool inlineMethod(Instruction callInstr, int instrIndex) {
-			var methodToInline = callInstr.Operand as MethodDefinition;
+			var methodToInline = callInstr.Operand as MethodDef;
 			if (methodToInline == null)
 				return false;
 
@@ -120,11 +120,11 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				return false;
 
 			block.Instructions[instrIndex - 1] = new Instr(Instruction.Create(OpCodes.Nop));
-			block.Instructions[instrIndex] = new Instr(DotNetUtils.createLdci4(newValue));
+			block.Instructions[instrIndex] = new Instr(Instruction.CreateLdcI4(newValue));
 			return true;
 		}
 
-		bool getNewValue(MethodDefinition method, int arg, out int newValue) {
+		bool getNewValue(MethodDef method, int arg, out int newValue) {
 			newValue = 0;
 			emulator.init(method);
 			emulator.setArg(method.Parameters[0], new Int32Value(arg));
@@ -233,10 +233,10 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			}
 		}
 
-		protected override bool isCompatibleType(int paramIndex, TypeReference origType, TypeReference newType) {
-			if (MemberReferenceHelper.compareTypes(origType, newType))
+		protected override bool isCompatibleType(int paramIndex, IType origType, IType newType) {
+			if (new SigComparer(SigComparerOptions.IgnoreModifiers).Equals(origType, newType))
 				return true;
-			if (newType.IsValueType || origType.IsValueType)
+			if (isValueType(newType) || isValueType(origType))
 				return false;
 			return newType.FullName == "System.Object";
 		}
diff --git a/de4dot.code/deobfuscators/Babel_NET/BabelUtils.cs b/de4dot.code/deobfuscators/Babel_NET/BabelUtils.cs
index 4052e33c..c216959e 100644
--- a/de4dot.code/deobfuscators/Babel_NET/BabelUtils.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/BabelUtils.cs
@@ -19,24 +19,24 @@
 
 using System.Collections.Generic;
 using System.Text;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Babel_NET {
 	static class BabelUtils {
-		public static EmbeddedResource findEmbeddedResource(ModuleDefinition module, TypeDefinition decrypterType) {
+		public static EmbeddedResource findEmbeddedResource(ModuleDefMD module, TypeDef decrypterType) {
 			return findEmbeddedResource(module, decrypterType, (method) => { });
 		}
 
-		public static EmbeddedResource findEmbeddedResource(ModuleDefinition module, TypeDefinition decrypterType, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
+		public static EmbeddedResource findEmbeddedResource(ModuleDefMD module, TypeDef decrypterType, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
 			return findEmbeddedResource(module, decrypterType, (method) => {
 				simpleDeobfuscator.deobfuscate(method);
 				simpleDeobfuscator.decryptStrings(method, deob);
 			});
 		}
 
-		public static EmbeddedResource findEmbeddedResource(ModuleDefinition module, TypeDefinition decrypterType, Action<MethodDefinition> fixMethod) {
+		public static EmbeddedResource findEmbeddedResource(ModuleDefMD module, TypeDef decrypterType, Action<MethodDef> fixMethod) {
 			foreach (var method in decrypterType.Methods) {
 				if (!DotNetUtils.isMethod(method, "System.String", "()"))
 					continue;
@@ -50,7 +50,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return null;
 		}
 
-		static EmbeddedResource findEmbeddedResource1(ModuleDefinition module, MethodDefinition method) {
+		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)
@@ -59,7 +59,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return null;
 		}
 
-		static EmbeddedResource findEmbeddedResource2(ModuleDefinition module, MethodDefinition method) {
+		static EmbeddedResource findEmbeddedResource2(ModuleDefMD module, MethodDef method) {
 			var strings = new List<string>(DotNetUtils.getCodeStrings(method));
 			if (strings.Count != 1)
 				return null;
@@ -75,7 +75,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return DotNetUtils.getResource(module, sb.ToString()) as EmbeddedResource;
 		}
 
-		static bool getXorKey2(MethodDefinition method, out int xorKey) {
+		static bool getXorKey2(MethodDef method, out int xorKey) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 2; i++) {
 				var ldelem = instrs[i];
@@ -83,13 +83,13 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 					continue;
 
 				var ldci4 = instrs[i + 1];
-				if (!DotNetUtils.isLdcI4(ldci4))
+				if (!ldci4.IsLdcI4())
 					continue;
 
 				if (instrs[i + 2].OpCode.Code != Code.Xor)
 					continue;
 
-				xorKey = DotNetUtils.getLdcI4Value(ldci4);
+				xorKey = ldci4.GetLdcI4Value();
 				return true;
 			}
 
@@ -97,7 +97,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return false;
 		}
 
-		public static bool findRegisterMethod(TypeDefinition type, out MethodDefinition regMethod, out MethodDefinition handler) {
+		public static bool findRegisterMethod(TypeDef type, out MethodDef regMethod, out MethodDef handler) {
 			foreach (var method in type.Methods) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
@@ -107,12 +107,12 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				foreach (var instr in method.Body.Instructions) {
 					if (instr.OpCode.Code != Code.Ldftn)
 						continue;
-					var handlerRef = instr.Operand as MethodReference;
+					var handlerRef = instr.Operand as IMethod;
 					if (handlerRef == null)
 						continue;
 					if (!DotNetUtils.isMethod(handlerRef, "System.Reflection.Assembly", "(System.Object,System.ResolveEventArgs)"))
 						continue;
-					if (!MemberReferenceHelper.compareTypes(type, handlerRef.DeclaringType))
+					if (!new SigComparer().Equals(type, handlerRef.DeclaringType))
 						continue;
 					handler = DotNetUtils.getMethod(type, handlerRef);
 					if (handler == null)
diff --git a/de4dot.code/deobfuscators/Babel_NET/ConstantsDecrypter.cs b/de4dot.code/deobfuscators/Babel_NET/ConstantsDecrypter.cs
index 3ac7059b..ae180590 100644
--- a/de4dot.code/deobfuscators/Babel_NET/ConstantsDecrypter.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/ConstantsDecrypter.cs
@@ -21,21 +21,22 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Runtime.Serialization.Formatters.Binary;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.IO;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Babel_NET {
 	class ConstantsDecrypter {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		ResourceDecrypter resourceDecrypter;
 		InitializedDataCreator initializedDataCreator;
-		TypeDefinition decrypterType;
-		MethodDefinition int32Decrypter;
-		MethodDefinition int64Decrypter;
-		MethodDefinition singleDecrypter;
-		MethodDefinition doubleDecrypter;
-		MethodDefinition arrayDecrypter;
+		TypeDef decrypterType;
+		MethodDef int32Decrypter;
+		MethodDef int64Decrypter;
+		MethodDef singleDecrypter;
+		MethodDef doubleDecrypter;
+		MethodDef arrayDecrypter;
 		EmbeddedResource encryptedResource;
 		int[] decryptedInts;
 		long[] decryptedLongs;
@@ -54,31 +55,31 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			get { return encryptedResource; }
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return decrypterType; }
 		}
 
-		public MethodDefinition Int32Decrypter {
+		public MethodDef Int32Decrypter {
 			get { return int32Decrypter; }
 		}
 
-		public MethodDefinition Int64Decrypter {
+		public MethodDef Int64Decrypter {
 			get { return int64Decrypter; }
 		}
 
-		public MethodDefinition SingleDecrypter {
+		public MethodDef SingleDecrypter {
 			get { return singleDecrypter; }
 		}
 
-		public MethodDefinition DoubleDecrypter {
+		public MethodDef DoubleDecrypter {
 			get { return doubleDecrypter; }
 		}
 
-		public MethodDefinition ArrayDecrypter {
+		public MethodDef ArrayDecrypter {
 			get { return arrayDecrypter; }
 		}
 
-		public ConstantsDecrypter(ModuleDefinition module, ResourceDecrypter resourceDecrypter, InitializedDataCreator initializedDataCreator) {
+		public ConstantsDecrypter(ModuleDefMD module, ResourceDecrypter resourceDecrypter, InitializedDataCreator initializedDataCreator) {
 			this.module = module;
 			this.resourceDecrypter = resourceDecrypter;
 			this.initializedDataCreator = initializedDataCreator;
@@ -99,7 +100,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			}
 		}
 
-		bool isConstantDecrypter(TypeDefinition type) {
+		bool isConstantDecrypter(TypeDef type) {
 			if (type.HasEvents)
 				return false;
 			if (type.NestedTypes.Count != 1)
@@ -109,7 +110,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			if (!checkNestedFields(nested))
 				return false;
 
-			resourceDecrypter.DecryptMethod = ResourceDecrypter.findDecrypterMethod(DotNetUtils.getMethod(nested, ".ctor"));
+			resourceDecrypter.DecryptMethod = ResourceDecrypter.findDecrypterMethod(nested.FindMethod(".ctor"));
 
 			if (DotNetUtils.getMethod(type, "System.Int32", "(System.Int32)") == null)
 				return false;
@@ -131,11 +132,11 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			"System.Single[]",
 			"System.Double[]",
 		};
-		bool checkNestedFields(TypeDefinition nested) {
+		bool checkNestedFields(TypeDef nested) {
 			if (!new FieldTypes(nested).all(requiredTypes))
 				return false;
 			foreach (var field in nested.Fields) {
-				if (MemberReferenceHelper.compareTypes(nested, field.FieldType))
+				if (new SigComparer().Equals(nested, field.FieldSig.GetFieldType()))
 					return true;
 			}
 			return false;
@@ -147,11 +148,11 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 
 			encryptedResource = BabelUtils.findEmbeddedResource(module, decrypterType, simpleDeobfuscator, deob);
 			if (encryptedResource == null) {
-				Log.w("Could not find encrypted constants resource");
+				Logger.w("Could not find encrypted constants resource");
 				return;
 			}
 
-			var decrypted = resourceDecrypter.decrypt(encryptedResource.GetResourceData());
+			var decrypted = resourceDecrypter.decrypt(encryptedResource.Data.ReadAllBytes());
 			var reader = new BinaryReader(new MemoryStream(decrypted));
 			int count;
 
@@ -193,11 +194,11 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 		}
 
 		struct ArrayInfo {
-			public FieldDefinition encryptedField;
-			public ArrayType arrayType;
+			public FieldDef encryptedField;
+			public SZArraySig arrayType;
 			public int start, len;
 
-			public ArrayInfo(int start, int len, FieldDefinition encryptedField, ArrayType arrayType) {
+			public ArrayInfo(int start, int len, FieldDef encryptedField, SZArraySig arrayType) {
 				this.start = start;
 				this.len = len;
 				this.encryptedField = encryptedField;
@@ -232,30 +233,30 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 					var ldtoken = instrs[index++];
 					if (ldtoken.OpCode.Code != Code.Ldtoken)
 						continue;
-					var field = ldtoken.Operand as FieldDefinition;
+					var field = ldtoken.Operand as FieldDef;
 					if (field == null)
 						continue;
 
 					var call1 = instrs[index++];
 					if (call1.OpCode.Code != Code.Call && call1.OpCode.Code != Code.Callvirt)
 						continue;
-					if (!DotNetUtils.isMethod(call1.Operand as MethodReference, "System.Void", "(System.Array,System.RuntimeFieldHandle)"))
+					if (!DotNetUtils.isMethod(call1.Operand as IMethod, "System.Void", "(System.Array,System.RuntimeFieldHandle)"))
 						continue;
 
 					var call2 = instrs[index++];
 					if (call2.OpCode.Code != Code.Call && call2.OpCode.Code != Code.Callvirt)
 						continue;
-					if (!MemberReferenceHelper.compareMethodReferenceAndDeclaringType(call2.Operand as MethodReference, arrayDecrypter))
+					if (!MethodEqualityComparer.CompareDeclaringTypes.Equals(call2.Operand as IMethod, arrayDecrypter))
 						continue;
 
 					var castclass = instrs[index++];
 					if (castclass.OpCode.Code != Code.Castclass)
 						continue;
-					var arrayType = castclass.Operand as ArrayType;
+					var arrayType = (castclass.Operand as ITypeDefOrRef).ToSZArraySig();
 					if (arrayType == null)
 						continue;
-					if (arrayType.ElementType.PrimitiveSize == -1) {
-						Log.w("Can't decrypt non-primitive type array in method {0}", blocks.Method.MetadataToken.ToInt32());
+					if (arrayType.Next.ElementType.GetPrimitiveSize() == -1) {
+						Logger.w("Can't decrypt non-primitive type array in method {0:X8}", blocks.Method.MDToken.ToInt32());
 						continue;
 					}
 
@@ -264,11 +265,11 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 
 				infos.Reverse();
 				foreach (var info in infos) {
-					var elemSize = info.arrayType.ElementType.PrimitiveSize;
+					var elemSize = info.arrayType.Next.ElementType.GetPrimitiveSize();
 					var decrypted = decryptArray(info.encryptedField.InitialValue, elemSize);
 
-					initializedDataCreator.addInitializeArrayCode(block, info.start, info.len, info.arrayType.ElementType, decrypted);
-					Log.v("Decrypted {0} array: {1} elements", info.arrayType.ElementType.ToString(), decrypted.Length / elemSize);
+					initializedDataCreator.addInitializeArrayCode(block, info.start, info.len, info.arrayType.Next.ToTypeDefOrRef(), decrypted);
+					Logger.v("Decrypted {0} array: {1} elements", info.arrayType.Next.ToString(), decrypted.Length / elemSize);
 				}
 			}
 		}
diff --git a/de4dot.code/deobfuscators/Babel_NET/Deobfuscator.cs b/de4dot.code/deobfuscators/Babel_NET/Deobfuscator.cs
index da943936..534d7e17 100644
--- a/de4dot.code/deobfuscators/Babel_NET/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/Deobfuscator.cs
@@ -19,7 +19,7 @@
 
 using System.Collections.Generic;
 using System.Text.RegularExpressions;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 using de4dot.blocks.cflow;
 
@@ -132,7 +132,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			this.options = options;
 		}
 
-		public override void init(ModuleDefinition module) {
+		public override void init(ModuleDefMD module) {
 			base.init(module);
 		}
 
@@ -182,10 +182,10 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			}
 		}
 
-		void checkVersion(TypeDefinition attr) {
-			var versionField = DotNetUtils.getFieldByName(attr, "Version");
-			if (versionField != null && versionField.IsLiteral && versionField.Constant != null && versionField.Constant is string) {
-				var val = Regex.Match((string)versionField.Constant, @"^(\d+\.\d+\.\d+\.\d+)$");
+		void checkVersion(TypeDef attr) {
+			var versionField = attr.FindField("Version");
+			if (versionField != null && versionField.IsLiteral && versionField.Constant != null && versionField.Constant.Value is string) {
+				var val = Regex.Match((string)versionField.Constant.Value, @"^(\d+\.\d+\.\d+\.\d+)$");
 				if (val.Groups.Count < 2)
 					return;
 				obfuscatorName = string.Format("{0} {1}", DeobfuscatorInfo.THE_NAME, val.Groups[1].ToString());
@@ -206,7 +206,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 
 			if (Operations.DecryptStrings != OpDecryptString.None) {
 				if (stringDecrypter.Resource != null)
-					Log.v("Adding string decrypter. Resource: {0}", Utils.toCsharpString(stringDecrypter.Resource.Name));
+					Logger.v("Adding string decrypter. Resource: {0}", Utils.toCsharpString(stringDecrypter.Resource.Name));
 				staticStringInliner.add(stringDecrypter.DecryptMethod, (method, gim, args) => {
 					return stringDecrypter.decrypt(args);
 				});
@@ -296,7 +296,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 		public override IEnumerable<int> getStringDecrypterMethods() {
 			var list = new List<int>();
 			if (stringDecrypter.DecryptMethod != null)
-				list.Add(stringDecrypter.DecryptMethod.MetadataToken.ToInt32());
+				list.Add(stringDecrypter.DecryptMethod.MDToken.ToInt32());
 			return list;
 		}
 	}
diff --git a/de4dot.code/deobfuscators/Babel_NET/ImageReader.cs b/de4dot.code/deobfuscators/Babel_NET/ImageReader.cs
index 59bd5994..cd9d623d 100644
--- a/de4dot.code/deobfuscators/Babel_NET/ImageReader.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/ImageReader.cs
@@ -22,10 +22,14 @@ using System.Collections.Generic;
 using System.Runtime.InteropServices;
 using System.IO;
 using System.Text;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.IO;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
+using CR = System.Runtime.InteropServices;
+using DR = dot10.DotNet;
+
 namespace de4dot.code.deobfuscators.Babel_NET {
 	class ImageReader {
 		static int METHODS_SIG			= 0x0000BEBA;
@@ -43,19 +47,19 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			ByRef = 4,
 		}
 
-		ModuleDefinition module;
-		BinaryReader reader;
+		ModuleDefMD module;
+		IBinaryReader reader;
 		string[] strings;
-		AssemblyNameReference[] assemblyNames;
+		AssemblyRef[] assemblyNames;
 		Dictionary<string, int> methodOffsets;
-		List<TypeReference> typeReferences;
+		List<TypeSig> typeReferences;
 		MemberReferenceConverter memberReferenceConverter;
 		IDeobfuscatorContext deobfuscatorContext;
 
-		public ImageReader(IDeobfuscatorContext deobfuscatorContext, ModuleDefinition module, byte[] data) {
+		public ImageReader(IDeobfuscatorContext deobfuscatorContext, ModuleDefMD module, byte[] data) {
 			this.deobfuscatorContext = deobfuscatorContext;
 			this.module = module;
-			this.reader = new BinaryReader(new MemoryStream(data));
+			this.reader = MemoryImageStream.Create(data);
 			this.memberReferenceConverter = new MemberReferenceConverter(module);
 		}
 
@@ -67,14 +71,14 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			if (metadataOffset < 0)
 				return false;
 			long pos = metadataOffset + 4;
-			reader.BaseStream.Position = pos;
+			reader.Position = pos;
 			int version = reader.ReadInt16();	// major, minor
 			if (version == 0x0001) {
 				initializeV10();
 				return true;
 			}
 
-			reader.BaseStream.Position = pos;
+			reader.Position = pos;
 			initializeV55();
 			return true;
 		}
@@ -104,22 +108,22 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			initializeTypeReferences(typeReferencesOffset);
 		}
 
-		public void restore(string name, MethodDefinition method) {
+		public void restore(string name, MethodDef method) {
 			var babelMethod = getMethod(name);
 			var body = method.Body;
 
-			body.MaxStackSize = babelMethod.MaxStack;
+			body.MaxStack = babelMethod.MaxStack;
 			body.InitLocals = babelMethod.InitLocals;
 
-			body.Variables.Clear();
+			body.LocalList.Clear();
 			foreach (var local in babelMethod.Locals)
-				body.Variables.Add(local);
+				body.LocalList.Add(local);
 
 			var toNewOperand = new Dictionary<object, object>();
 			if (babelMethod.ThisParameter != null)
-				toNewOperand[babelMethod.ThisParameter] = body.ThisParameter;
-			for (int i = 0; i < method.Parameters.Count; i++)
-				toNewOperand[babelMethod.Parameters[i]] = method.Parameters[i];
+				toNewOperand[babelMethod.ThisParameter] = method.Parameters[0];
+			for (int i = 0; i < babelMethod.Parameters.Length; i++)
+				toNewOperand[babelMethod.Parameters[i]] = method.Parameters[i + method.Parameters.MethodSigIndexBase];
 
 			body.Instructions.Clear();
 			foreach (var instr in babelMethod.Instructions) {
@@ -137,7 +141,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 		BabelMethodDefinition getMethod(string name) {
 			int offset = methodOffsets[name];
 			methodOffsets.Remove(name);
-			reader.BaseStream.Position = offset;
+			reader.Position = offset;
 			return new MethodDefinitionReader(this, reader).read();
 		}
 
@@ -145,20 +149,20 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return strings[readVariableLengthInt32()];
 		}
 
-		public TypeReference readTypeReference() {
+		public TypeSig readTypeSig() {
 			return typeReferences[readVariableLengthInt32()];
 		}
 
-		public TypeReference[] readTypeReferences() {
-			var refs = new TypeReference[readVariableLengthInt32()];
+		public TypeSig[] readTypeSigs() {
+			var refs = new TypeSig[readVariableLengthInt32()];
 			for (int i = 0; i < refs.Length; i++)
-				refs[i] = readTypeReference();
+				refs[i] = readTypeSig();
 			return refs;
 		}
 
-		public FieldReference readFieldReference() {
+		public IField readFieldReference() {
 			var name = readString();
-			var declaringType = readTypeReference();
+			var declaringType = readTypeSig();
 
 			var fields = getFields(resolve(declaringType), name);
 			if (fields == null || fields.Count != 1) {
@@ -170,18 +174,13 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return memberReferenceConverter.convert(fields[0]);
 		}
 
-		static List<FieldDefinition> getFields(TypeDefinition type, string name) {
+		static List<FieldDef> getFields(TypeDef type, string name) {
 			if (type == null)
 				return null;
-			var fields = new List<FieldDefinition>();
-			foreach (var field in type.Fields) {
-				if (field.Name == name)
-					fields.Add(field);
-			}
-			return fields;
+			return new List<FieldDef>(type.FindFields(name));
 		}
 
-		public MethodReference readMethodReference() {
+		public IMethod readMethodReference() {
 			var babelMethodRef = new MethodReferenceReader(this, reader).read();
 
 			var method = getMethodReference(babelMethodRef);
@@ -191,16 +190,15 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 							Utils.removeNewlines(babelMethodRef.DeclaringType)));
 			}
 
-			var git = babelMethodRef.DeclaringType as GenericInstanceType;
+			var git = babelMethodRef.DeclaringType.ToGenericInstSig();
 			if (git == null)
 				return method;
 
-			var newMethod = memberReferenceConverter.copy(method);
-			newMethod.DeclaringType = babelMethodRef.DeclaringType;
-			return newMethod;
+			var mr = new MemberRefUser(module, method.Name, method.MethodSig.Clone(), babelMethodRef.DeclaringType.ToTypeDefOrRef());
+			return module.UpdateRowId(mr);
 		}
 
-		MethodReference getMethodReference(BabelMethodreference babelMethodRef) {
+		IMethod getMethodReference(BabelMethodreference babelMethodRef) {
 			var declaringType = resolve(babelMethodRef.DeclaringType);
 			if (declaringType == null)
 				return null;
@@ -215,20 +213,19 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return methods[0];
 		}
 
-		List<MethodReference> getMethods(TypeDefinition declaringType, BabelMethodreference babelMethodRef) {
-			var methods = new List<MethodReference>();
+		List<IMethod> getMethods(TypeDef declaringType, BabelMethodreference babelMethodRef) {
+			var methods = new List<IMethod>();
 
-			var git = babelMethodRef.DeclaringType as GenericInstanceType;
-			IGenericInstance gim = babelMethodRef.IsGenericMethod ? babelMethodRef : null;
+			var gis = babelMethodRef.DeclaringType as GenericInstSig;
+			var gim = babelMethodRef.GenericArguments;
 			foreach (var method in declaringType.Methods) {
-				if (compareMethod(MethodReferenceInstance.make(method, git, gim), babelMethodRef)) {
+				if (compareMethod(GenericArgsSubstitutor.create(method, gis, gim), babelMethodRef)) {
 					if (!babelMethodRef.IsGenericMethod)
 						methods.Add(memberReferenceConverter.convert(method));
 					else {
-						var gim2 = new GenericInstanceMethod(memberReferenceConverter.convert(method));
-						foreach (var arg in babelMethodRef.GenericArguments)
-							gim2.GenericArguments.Add(arg);
-						methods.Add(gim2);
+						var gim2 = new GenericInstMethodSig(babelMethodRef.GenericArguments);
+						var ms = module.UpdateRowId(new MethodSpecUser(memberReferenceConverter.convert(method), gim2));
+						methods.Add(ms);
 					}
 				}
 			}
@@ -236,66 +233,71 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return methods;
 		}
 
-		bool compareMethod(MethodReference method, BabelMethodreference babelMethodRef) {
-			if (method.Parameters.Count != babelMethodRef.Parameters.Length)
+		bool compareMethod(IMethod method, BabelMethodreference babelMethodRef) {
+			var sig = method.MethodSig;
+			if (sig.Params.Count != babelMethodRef.Parameters.Length)
 				return false;
 			if (method.Name != babelMethodRef.Name)
 				return false;
-			if (method.HasThis != babelMethodRef.HasThis)
+			if (sig.HasThis != babelMethodRef.HasThis)
 				return false;
-			if (method.GenericParameters.Count != babelMethodRef.GenericArguments.Length)
+			if (sig.GenParamCount != babelMethodRef.GenericArguments.Length)
 				return false;
 
-			if (!MemberReferenceHelper.compareTypes(method.MethodReturnType.ReturnType, babelMethodRef.ReturnType))
+			if (!new SigComparer().Equals(sig.RetType, babelMethodRef.ReturnType))
 				return false;
 
 			for (int i = 0; i < babelMethodRef.Parameters.Length; i++) {
-				if (!MemberReferenceHelper.compareTypes(method.Parameters[i].ParameterType, babelMethodRef.Parameters[i].ParameterType))
+				if (!new SigComparer().Equals(sig.Params[i], babelMethodRef.Parameters[i].Type))
 					return false;
 			}
 
 			return true;
 		}
 
-		TypeDefinition resolve(TypeReference type) {
-			if (type is TypeDefinition)
-				return (TypeDefinition)type;
+		TypeDef resolve(TypeSig type) {
+			type = type.RemovePinnedAndModifiers();
 
-			if (type.IsGenericInstance)
-				type = ((GenericInstanceType)type).ElementType;
+			var gis = type as GenericInstSig;
+			if (gis != null)
+				type = gis.GenericType;
 
-			if (type.Module == module && isModuleAssembly(type.Scope))
-				return DotNetUtils.getType(module, type);
+			var tdrs = type as TypeDefOrRefSig;
+			if (tdrs == null)
+				return null;
 
-			return deobfuscatorContext.resolve(type);
+			var td = tdrs.TypeDef;
+			if (td != null)
+				return td;
+
+			var tr = tdrs.TypeRef;
+			if (tr != null)
+				return tr.Resolve();
+
+			return null;
 		}
 
-		public CallSite readCallSite() {
-			var returnType = readTypeReference();
-			var paramTypes = readTypeReferences();
-			var callingConvention = (CallingConvention)reader.ReadInt32();
+		public MethodSig readCallSite() {
+			var returnType = readTypeSig();
+			var paramTypes = readTypeSigs();
+			var callingConvention = (CR.CallingConvention)reader.ReadInt32();
 
-			var cs = new CallSite(returnType);
-			foreach (var paramType in paramTypes)
-				cs.Parameters.Add(new ParameterDefinition(paramType));
-			cs.CallingConvention = convertCallingConvention(callingConvention);
-
-			return cs;
+			return new MethodSig(convertCallingConvention(callingConvention), 0, returnType, paramTypes);
 		}
 
-		static MethodCallingConvention convertCallingConvention(CallingConvention callingConvention) {
+		static DR.CallingConvention convertCallingConvention(CR.CallingConvention callingConvention) {
 			switch (callingConvention) {
-			case CallingConvention.Winapi:		return MethodCallingConvention.Default;
-			case CallingConvention.Cdecl:		return MethodCallingConvention.C;
-			case CallingConvention.StdCall:		return MethodCallingConvention.StdCall;
-			case CallingConvention.ThisCall:	return MethodCallingConvention.ThisCall;
-			case CallingConvention.FastCall:	return MethodCallingConvention.FastCall;
+			case CR.CallingConvention.Winapi:	return DR.CallingConvention.Default;
+			case CR.CallingConvention.Cdecl:	return DR.CallingConvention.C;
+			case CR.CallingConvention.StdCall:	return DR.CallingConvention.StdCall;
+			case CR.CallingConvention.ThisCall:	return DR.CallingConvention.ThisCall;
+			case CR.CallingConvention.FastCall:	return DR.CallingConvention.FastCall;
 			default: throw new ApplicationException(string.Format("Unknown CallingConvention {0}", callingConvention));
 			}
 		}
 
 		void initializeStrings(int headerOffset) {
-			reader.BaseStream.Position = headerOffset;
+			reader.Position = headerOffset;
 			if (reader.ReadInt32() != STRINGS_SIG)
 				throw new ApplicationException("Invalid strings sig");
 
@@ -305,27 +307,17 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 		}
 
 		void initializeAssemblyNames(int headerOffset) {
-			reader.BaseStream.Position = headerOffset;
+			reader.Position = headerOffset;
 			if (reader.ReadInt32() != ASSEMBLY_NAMES_SIG)
 				throw new ApplicationException("Invalid assembly names sig");
 
-			assemblyNames = new AssemblyNameReference[readVariableLengthInt32()];
+			assemblyNames = new AssemblyRef[readVariableLengthInt32()];
 			for (int i = 0; i < assemblyNames.Length; i++)
-				assemblyNames[i] = getModuleAssemblyReference(AssemblyNameReference.Parse(readString()));
-		}
-
-		bool isModuleAssembly(IMetadataScope scope) {
-			return DotNetUtils.isReferenceToModule(module, scope);
-		}
-
-		AssemblyNameReference getModuleAssemblyReference(AssemblyNameReference asmRef) {
-			if (isModuleAssembly(asmRef))
-				return module.Assembly.Name;
-			return memberReferenceConverter.convert(asmRef);
+				assemblyNames[i] = module.UpdateRowId(new AssemblyRefUser(new AssemblyNameInfo(readString())));
 		}
 
 		void initializeMethodNames(int headerOffset) {
-			reader.BaseStream.Position = headerOffset;
+			reader.Position = headerOffset;
 			if (reader.ReadInt32() != METHOD_NAMES_SIG)
 				throw new ApplicationException("Invalid methods sig");
 
@@ -338,14 +330,14 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 		}
 
 		void initializeTypeReferences(int headerOffset) {
-			reader.BaseStream.Position = headerOffset;
+			reader.Position = headerOffset;
 			if (reader.ReadInt32() != TYPEREFS_SIG)
 				throw new ApplicationException("Invalid typerefs sig");
 
 			int numTypeRefs = reader.ReadInt32();
-			typeReferences = new List<TypeReference>(numTypeRefs + 1);
+			typeReferences = new List<TypeSig>(numTypeRefs + 1);
 			typeReferences.Add(null);
-			var genericArgFixes = new Dictionary<GenericInstanceType, List<int>>();
+			var genericArgFixes = new Dictionary<GenericInstSig, List<int>>();
 			for (int i = 0; i < numTypeRefs; i++) {
 				TypeId typeId = (TypeId)reader.ReadByte();
 				switch (typeId) {
@@ -384,35 +376,30 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			}
 		}
 
-		TypeReference readTypeRef() {
+		TypeSig readTypeRef() {
 			string ns, name;
 			parseReflectionTypeName(readString(), out ns, out name);
 			var asmRef = assemblyNames[readVariableLengthInt32()];
-			var declaringType = readTypeReference();
-			var typeReference = new TypeReference(ns, name, module, asmRef) {
-				DeclaringType = declaringType,
-			};
-			typeReference.UpdateElementType();
+			var declaringType = readTypeSig();
+			var typeReference = new TypeRefUser(module, ns, name);
+			if (declaringType != null)
+				typeReference.ResolutionScope = getTypeRef(declaringType);
+			else
+				typeReference.ResolutionScope = asmRef;
 
-			typeReference = memberReferenceConverter.convert(typeReference);
-			typeReference.IsValueType = isValueType(typeReference);
-			return typeReference;
+			return memberReferenceConverter.convert(typeReference);
 		}
 
-		bool isValueType(TypeReference typeRef) {
-			var typeDef = typeRef as TypeDefinition;
-			if (typeDef != null)
-				return typeDef.IsValueType;
-
-			if (typeRef.Module == module && isModuleAssembly(typeRef.Scope))
-				typeDef = DotNetUtils.getType(module, typeRef);
-			else 
-				typeDef = resolve(typeRef);
-			if (typeDef != null)
-				return typeDef.IsValueType;
-
-			Log.w("Could not determine whether type '{0}' is a value type", Utils.removeNewlines(typeRef));
-			return false;	// Assume it's a reference type
+		TypeRef getTypeRef(TypeSig type) {
+			var tdr = type as TypeDefOrRefSig;
+			if (tdr == null)
+				throw new ApplicationException("Not a type ref");
+			if (tdr.TypeRef != null)
+				return tdr.TypeRef;
+			var td = tdr.TypeDef;
+			if (td != null)
+				return new Importer(module).Import(td) as TypeRef;
+			throw new ApplicationException("Not a type ref");
 		}
 
 		static void parseReflectionTypeName(string fullName, out string ns, out string name) {
@@ -461,8 +448,8 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return sb.ToString();
 		}
 
-		GenericInstanceType readGenericInstanceType(out List<int> genericArgs) {
-			var git = new GenericInstanceType(readTypeReference());
+		GenericInstSig readGenericInstanceType(out List<int> genericArgs) {
+			var git = new GenericInstSig(readTypeSig() as ClassOrValueTypeSig);
 			int numArgs = readVariableLengthInt32();
 			genericArgs = new List<int>(numArgs);
 			for (int i = 0; i < numArgs; i++)
@@ -470,28 +457,40 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return git;
 		}
 
-		PointerType readPointerType() {
-			return new PointerType(readTypeReference());
+		PtrSig readPointerType() {
+			return new PtrSig(readTypeSig());
 		}
 
-		ArrayType readArrayType() {
-			return new ArrayType(readTypeReference(), readVariableLengthInt32());
+		TypeSig readArrayType() {
+			var typeSig = readTypeSig();
+			int rank = readVariableLengthInt32();
+			if (rank == 1)
+				return new SZArraySig(typeSig);
+			return new ArraySig(typeSig, rank);
 		}
 
-		ByReferenceType readByReferenceType() {
-			return new ByReferenceType(readTypeReference());
+		ByRefSig readByReferenceType() {
+			return new ByRefSig(readTypeSig());
+		}
+
+		public uint readVariableLengthUInt32() {
+			uint val;
+			reader.ReadCompressedUInt32(out val);
+			return val;
 		}
 
 		public int readVariableLengthInt32() {
-			return DeobUtils.readVariableLengthInt32(reader);
+			uint val;
+			reader.ReadCompressedUInt32(out val);
+			return (int)val;
 		}
 
 		int getMetadataOffset() {
-			reader.BaseStream.Position = reader.BaseStream.Length - 4;
+			reader.Position = reader.Length - 4;
 			for (int i = 0; i < 30; i++) {
 				if (reader.ReadInt32() == METADATA_SIG)
-					return (int)reader.BaseStream.Position - 4;
-				reader.BaseStream.Position -= 8;
+					return (int)reader.Position - 4;
+				reader.Position -= 8;
 			}
 			return -1;
 		}
diff --git a/de4dot.code/deobfuscators/Babel_NET/InflaterCreator.cs b/de4dot.code/deobfuscators/Babel_NET/InflaterCreator.cs
index 704f8b89..add950db 100644
--- a/de4dot.code/deobfuscators/Babel_NET/InflaterCreator.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/InflaterCreator.cs
@@ -18,17 +18,17 @@
 */
 
 using ICSharpCode.SharpZipLib.Zip.Compression;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Babel_NET {
 	class InflaterCreator {
-		public static Inflater create(MethodDefinition method, bool noHeader) {
+		public static Inflater create(MethodDef method, bool noHeader) {
 			return create(findInflaterType(method), noHeader);
 		}
 
-		public static Inflater create(TypeDefinition inflaterType, bool noHeader) {
+		public static Inflater create(TypeDef inflaterType, bool noHeader) {
 			if (inflaterType == null)
 				return createNormal(noHeader);
 			var initHeaderMethod = findInitHeaderMethod(inflaterType);
@@ -46,23 +46,23 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 
 		static Inflater createNormal(bool noHeader, string errorMessage) {
 			if (errorMessage != null)
-				Log.w("{0}", errorMessage);
+				Logger.w("{0}", errorMessage);
 			return new Inflater(noHeader);
 		}
 
-		static TypeDefinition findInflaterType(MethodDefinition method) {
+		static TypeDef findInflaterType(MethodDef method) {
 			if (method == null || method.Body == null)
 				return null;
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Call)
 					continue;
-				var calledMethod = instr.Operand as MethodDefinition;
+				var calledMethod = instr.Operand as MethodDef;
 				if (calledMethod == null || !calledMethod.IsStatic)
 					continue;
 
 				var type = calledMethod.DeclaringType;
 				foreach (var nested in type.NestedTypes) {
-					if (DeobUtils.hasInteger(DotNetUtils.getMethod(nested, ".ctor"), 0x8001))
+					if (DeobUtils.hasInteger(nested.FindMethod(".ctor"), 0x8001))
 						return type;
 				}
 			}
@@ -70,7 +70,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return null;
 		}
 
-		static MethodDefinition findInitHeaderMethod(TypeDefinition inflaterType) {
+		static MethodDef findInitHeaderMethod(TypeDef inflaterType) {
 			foreach (var nested in inflaterType.NestedTypes) {
 				var method = findInitHeaderMethod2(nested);
 				if (method != null)
@@ -79,7 +79,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return null;
 		}
 
-		static MethodDefinition findInitHeaderMethod2(TypeDefinition nested) {
+		static MethodDef findInitHeaderMethod2(TypeDef nested) {
 			foreach (var method in nested.Methods) {
 				if (method.IsStatic || method.Body == null)
 					continue;
@@ -92,13 +92,13 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return null;
 		}
 
-		static int? getMagic(MethodDefinition method) {
+		static int? getMagic(MethodDef method) {
 			if (method == null || method.Body == null)
 				return null;
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 3; i++) {
 				var ldci4_1 = instrs[i];
-				if (!DotNetUtils.isLdcI4(ldci4_1) || DotNetUtils.getLdcI4Value(ldci4_1) != 16)
+				if (!ldci4_1.IsLdcI4() || ldci4_1.GetLdcI4Value() != 16)
 					continue;
 
 				var callvirt = instrs[i + 1];
@@ -106,13 +106,13 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 					continue;
 
 				var ldci4_2 = instrs[i + 2];
-				if (!DotNetUtils.isLdcI4(ldci4_2))
+				if (!ldci4_2.IsLdcI4())
 					continue;
 
 				if (instrs[i + 3].OpCode.Code != Code.Xor)
 					continue;
 
-				return DotNetUtils.getLdcI4Value(ldci4_2);
+				return ldci4_2.GetLdcI4Value();
 			}
 
 			return null;
diff --git a/de4dot.code/deobfuscators/Babel_NET/MemberReferenceConverter.cs b/de4dot.code/deobfuscators/Babel_NET/MemberReferenceConverter.cs
index 17239cc7..4c7ff56c 100644
--- a/de4dot.code/deobfuscators/Babel_NET/MemberReferenceConverter.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/MemberReferenceConverter.cs
@@ -18,128 +18,62 @@
 */
 
 using System;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Babel_NET {
-	class TypeReferenceConverter : TypeReferenceUpdaterBase  {
-		MemberReferenceConverter memberReferenceConverter;
-
-		ModuleDefinition Module {
-			get { return memberReferenceConverter.Module; }
-		}
-
-		public TypeReferenceConverter(MemberReferenceConverter memberReferenceConverter) {
-			this.memberReferenceConverter = memberReferenceConverter;
-		}
-
-		public TypeReference convert(TypeReference a) {
-			var newOne = update(a);
-			if (!(a is GenericParameter) && !MemberReferenceHelper.compareTypes(newOne, a))
-				throw new ApplicationException("Could not convert type reference");
-			return newOne;
-		}
-
-		protected override TypeReference updateTypeReference(TypeReference a) {
-			if (a.Module == Module)
-				return a;
-
-			var newTypeRef = new TypeReference(a.Namespace, a.Name, Module, memberReferenceConverter.convert(a.Scope), a.IsValueType);
-			foreach (var gp in a.GenericParameters)
-				newTypeRef.GenericParameters.Add(new GenericParameter(gp.Name, newTypeRef));
-			newTypeRef.DeclaringType = update(a.DeclaringType);
-			newTypeRef.UpdateElementType();
-			return newTypeRef;
-		}
-	}
-
 	// Converts type references/definitions in one module to this module
 	class MemberReferenceConverter {
-		ModuleDefinition module;
+		ModuleDefMD module;
 
-		public ModuleDefinition Module {
+		public ModuleDefMD Module {
 			get { return module; }
 		}
 
-		public MemberReferenceConverter(ModuleDefinition module) {
+		public MemberReferenceConverter(ModuleDefMD module) {
 			this.module = module;
 		}
 
-		bool isInOurModule(MemberReference memberRef) {
+		bool isInOurModule(IMemberRef memberRef) {
 			return memberRef.Module == module;
 		}
 
-		public TypeReference convert(TypeReference typeRef) {
-			if (typeRef == null)
-				return null;
-			typeRef = new TypeReferenceConverter(this).convert(typeRef);
-			return tryGetTypeDefinition(typeRef);
+		Importer createImporter() {
+			return new Importer(module, ImporterOptions.TryToUseTypeDefs);
 		}
 
-		public FieldReference convert(FieldReference fieldRef) {
+		public TypeSig convert(TypeRef typeRef) {
+			return createImporter().Import(typeRef).ToTypeSig();
+		}
+
+		ITypeDefOrRef convert(ITypeDefOrRef tdr) {
+			return (ITypeDefOrRef)createImporter().Import(tdr);
+		}
+
+		TypeSig convert2(TypeSig ts) {
+			return createImporter().Import(ts);
+		}
+
+		public TypeSig convert(TypeSig ts) {
+			return createImporter().Import(ts);
+		}
+
+		public IField convert(IField fieldRef) {
 			if (isInOurModule(fieldRef))
 				return tryGetFieldDefinition(fieldRef);
-
-			return new FieldReference(fieldRef.Name, convert(fieldRef.FieldType), convert(fieldRef.DeclaringType));
+			return createImporter().Import(fieldRef);
 		}
 
-		public MethodReference convert(MethodReference methodRef) {
-			if (methodRef.GetType() != typeof(MethodReference) && methodRef.GetType() != typeof(MethodDefinition))
+		public IMethodDefOrRef convert(IMethod methodRef) {
+			if (!(methodRef is MemberRef || methodRef is MethodDef) || methodRef.MethodSig == null)
 				throw new ApplicationException("Invalid method reference type");
 			if (isInOurModule(methodRef))
-				return tryGetMethodDefinition(methodRef);
-
-			return copy(methodRef);
+				return (IMethodDefOrRef)tryGetMethodDefinition(methodRef);
+			return (IMethodDefOrRef)createImporter().Import(methodRef);
 		}
 
-		public MethodReference copy(MethodReference methodRef) {
-			if (methodRef.GetType() != typeof(MethodReference) && methodRef.GetType() != typeof(MethodDefinition))
-				throw new ApplicationException("Invalid method reference type");
-
-			var newMethodRef = new MethodReference(methodRef.Name, convert(methodRef.MethodReturnType.ReturnType), convert(methodRef.DeclaringType));
-			newMethodRef.HasThis = methodRef.HasThis;
-			newMethodRef.ExplicitThis = methodRef.ExplicitThis;
-			newMethodRef.CallingConvention = methodRef.CallingConvention;
-			foreach (var param in methodRef.Parameters)
-				newMethodRef.Parameters.Add(new ParameterDefinition(param.Name, param.Attributes, convert(param.ParameterType)));
-			foreach (var gp in methodRef.GenericParameters)
-				newMethodRef.GenericParameters.Add(new GenericParameter(gp.Name, newMethodRef));
-			return newMethodRef;
-		}
-
-		public IMetadataScope convert(IMetadataScope scope) {
-			switch (scope.MetadataScopeType) {
-			case MetadataScopeType.AssemblyNameReference:
-				return convert((AssemblyNameReference)scope);
-
-			case MetadataScopeType.ModuleDefinition:
-				var mod = (ModuleDefinition)scope;
-				if (mod.Assembly != null)
-					return convert((AssemblyNameReference)mod.Assembly.Name);
-				return convert((ModuleReference)scope);
-
-			case MetadataScopeType.ModuleReference:
-				return convert((ModuleReference)scope);
-
-			default:
-				throw new ApplicationException("Unknown MetadataScopeType");
-			}
-		}
-
-		public AssemblyNameReference convert(AssemblyNameReference asmRef) {
-			return DotNetUtils.addAssemblyReference(module, asmRef);
-		}
-
-		public ModuleReference convert(ModuleReference modRef) {
-			return DotNetUtils.addModuleReference(module, modRef);
-		}
-
-		public TypeReference tryGetTypeDefinition(TypeReference typeRef) {
-			return DotNetUtils.getType(module, typeRef) ?? typeRef;
-		}
-
-		public FieldReference tryGetFieldDefinition(FieldReference fieldRef) {
-			var fieldDef = fieldRef as FieldDefinition;
+		public IField tryGetFieldDefinition(IField fieldRef) {
+			var fieldDef = fieldRef as FieldDef;
 			if (fieldDef != null)
 				return fieldDef;
 
@@ -149,8 +83,8 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return DotNetUtils.getField(declaringType, fieldRef);
 		}
 
-		public MethodReference tryGetMethodDefinition(MethodReference methodRef) {
-			var methodDef = methodRef as MethodDefinition;
+		public IMethod tryGetMethodDefinition(IMethod methodRef) {
+			var methodDef = methodRef as MethodDef;
 			if (methodDef != null)
 				return methodDef;
 
diff --git a/de4dot.code/deobfuscators/Babel_NET/MethodBodyReader.cs b/de4dot.code/deobfuscators/Babel_NET/MethodBodyReader.cs
index b548b285..38c17a55 100644
--- a/de4dot.code/deobfuscators/Babel_NET/MethodBodyReader.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/MethodBodyReader.cs
@@ -18,75 +18,83 @@
 */
 
 using System;
+using System.Collections.Generic;
 using System.IO;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.IO;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 
 namespace de4dot.code.deobfuscators.Babel_NET {
 	class MethodBodyReader : MethodBodyReaderBase {
 		ImageReader imageReader;
 		public int Flags2 { get; set; }
-		public short MaxStack { get; set; }
+		public ushort MaxStack { get; set; }
 
-		public MethodBodyReader(ImageReader imageReader, BinaryReader reader)
+		public MethodBodyReader(ImageReader imageReader, IBinaryReader reader)
 			: base(reader) {
 			this.imageReader = imageReader;
 		}
 
-		public void read(ParameterDefinition[] parameters) {
+		public void read(IList<Parameter> parameters) {
 			this.parameters = parameters;
 			Flags2 = reader.ReadInt16();
-			MaxStack = reader.ReadInt16();
-			setLocals(imageReader.readTypeReferences());
-			readInstructions(imageReader.readVariableLengthInt32());
+			MaxStack = reader.ReadUInt16();
+			SetLocals(imageReader.readTypeSigs());
+			ReadInstructions(imageReader.readVariableLengthInt32());
 			readExceptionHandlers(imageReader.readVariableLengthInt32());
 		}
 
-		protected override FieldReference readInlineField(Instruction instr) {
+		protected override IField ReadInlineField(Instruction instr) {
 			return imageReader.readFieldReference();
 		}
 
-		protected override MethodReference readInlineMethod(Instruction instr) {
+		protected override IMethod ReadInlineMethod(Instruction instr) {
 			return imageReader.readMethodReference();
 		}
 
-		protected override CallSite readInlineSig(Instruction instr) {
+		protected override MethodSig ReadInlineSig(Instruction instr) {
 			return imageReader.readCallSite();
 		}
 
-		protected override string readInlineString(Instruction instr) {
+		protected override string ReadInlineString(Instruction instr) {
 			return imageReader.readString();
 		}
 
-		protected override MemberReference readInlineTok(Instruction instr) {
+		protected override ITokenOperand ReadInlineTok(Instruction instr) {
 			switch (reader.ReadByte()) {
-			case 0: return imageReader.readTypeReference();
+			case 0: return imageReader.readTypeSig().ToTypeDefOrRef();
 			case 1: return imageReader.readFieldReference();
 			case 2: return imageReader.readMethodReference();
 			default: throw new ApplicationException("Unknown token type");
 			}
 		}
 
-		protected override TypeReference readInlineType(Instruction instr) {
-			return imageReader.readTypeReference();
+		protected override ITypeDefOrRef ReadInlineType(Instruction instr) {
+			return imageReader.readTypeSig().ToTypeDefOrRef();
 		}
 
-		protected override ExceptionHandler readExceptionHandler() {
+		void readExceptionHandlers(int numExceptionHandlers) {
+			exceptionHandlers = new List<ExceptionHandler>(numExceptionHandlers);
+			for (int i = 0; i < numExceptionHandlers; i++)
+				Add(readExceptionHandler());
+		}
+
+		ExceptionHandler readExceptionHandler() {
 			var ehType = (ExceptionHandlerType)reader.ReadByte();
-			int tryOffset = imageReader.readVariableLengthInt32();
-			int tryLength = imageReader.readVariableLengthInt32();
-			int handlerOffset = imageReader.readVariableLengthInt32();
-			int handlerLength = imageReader.readVariableLengthInt32();
-			var catchType = imageReader.readTypeReference();
-			int filterOffset = imageReader.readVariableLengthInt32();
+			uint tryOffset = imageReader.readVariableLengthUInt32();
+			uint tryLength = imageReader.readVariableLengthUInt32();
+			uint handlerOffset = imageReader.readVariableLengthUInt32();
+			uint handlerLength = imageReader.readVariableLengthUInt32();
+			var catchType = imageReader.readTypeSig().ToTypeDefOrRef();
+			uint filterOffset = imageReader.readVariableLengthUInt32();
 
 			var eh = new ExceptionHandler(ehType);
-			eh.TryStart = getInstruction(tryOffset);
-			eh.TryEnd = getInstructionOrNull(tryOffset + tryLength);
+			eh.TryStart = GetInstructionThrow(tryOffset);
+			eh.TryEnd = GetInstruction(tryOffset + tryLength);
 			if (ehType == ExceptionHandlerType.Filter)
-				eh.FilterStart = getInstruction(filterOffset);
-			eh.HandlerStart = getInstruction(handlerOffset);
-			eh.HandlerEnd = getInstructionOrNull(handlerOffset + handlerLength);
+				eh.FilterStart = GetInstructionThrow(filterOffset);
+			eh.HandlerStart = GetInstructionThrow(handlerOffset);
+			eh.HandlerEnd = GetInstruction(handlerOffset + handlerLength);
 			eh.CatchType = catchType;
 			return eh;
 		}
diff --git a/de4dot.code/deobfuscators/Babel_NET/MethodReferenceReader.cs b/de4dot.code/deobfuscators/Babel_NET/MethodReferenceReader.cs
index 5988c41d..92d2f45e 100644
--- a/de4dot.code/deobfuscators/Babel_NET/MethodReferenceReader.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/MethodReferenceReader.cs
@@ -20,17 +20,17 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.Collections.Generic;
+using dot10.IO;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 
 namespace de4dot.code.deobfuscators.Babel_NET {
-	class BabelMethodreference : IGenericInstance {
+	class BabelMethodreference {
 		public string Name { get; set; }
-		public TypeReference DeclaringType { get; set; }
-		public TypeReference ReturnType { get; set; }
-		public ParameterDefinition[] Parameters { get; set; }
-		public TypeReference[] GenericArguments { get; set; }
+		public TypeSig DeclaringType { get; set; }
+		public TypeSig ReturnType { get; set; }
+		public Parameter[] Parameters { get; set; }
+		public TypeSig[] GenericArguments { get; set; }
 		public int Flags { get; set; }
 
 		public bool HasThis {
@@ -40,27 +40,14 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 		public bool IsGenericMethod {
 			get { return (Flags & 2) != 0; }
 		}
-
-		bool IGenericInstance.HasGenericArguments {
-			get { return IsGenericMethod; }
-		}
-
-		Collection<TypeReference> IGenericInstance.GenericArguments {
-			get { return new Collection<TypeReference>(GenericArguments); }
-		}
-
-		MetadataToken IMetadataTokenProvider.MetadataToken {
-			get { throw new NotImplementedException(); }
-			set { throw new NotImplementedException(); }
-		}
 	}
 
 	class BabelMethodDefinition : BabelMethodreference {
-		ParameterDefinition thisParameter;
+		Parameter thisParameter;
 
 		public int Flags2 { get; set; }
-		public short MaxStack { get; set; }
-		public IList<VariableDefinition> Locals { get; set; }
+		public ushort MaxStack { get; set; }
+		public IList<Local> Locals { get; set; }
 		public IList<Instruction> Instructions { get; set; }
 		public IList<ExceptionHandler> ExceptionHandlers { get; set; }
 
@@ -80,13 +67,13 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			get { return (Flags2 & 0x80) != 0; }
 		}
 
-		public ParameterDefinition ThisParameter {
+		public Parameter ThisParameter {
 			get {
 				if (!HasThis)
 					return null;
 				if (thisParameter != null)
 					return thisParameter;
-				return thisParameter = new ParameterDefinition(DeclaringType);
+				return thisParameter = new Parameter(0, Parameter.HIDDEN_THIS_METHOD_SIG_INDEX, DeclaringType);
 			}
 		}
 
@@ -98,10 +85,10 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			ExceptionHandlers = mbr.ExceptionHandlers;
 		}
 
-		public ParameterDefinition[] getRealParameters() {
+		public IList<Parameter> getRealParameters() {
 			if (ThisParameter == null)
 				return Parameters;
-			var parameters = new ParameterDefinition[Parameters.Length + 1];
+			var parameters = new Parameter[Parameters.Length + 1];
 			parameters[0] = ThisParameter;
 			Array.Copy(Parameters, 0, parameters, 1, Parameters.Length);
 			return parameters;
@@ -110,14 +97,14 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 
 	class MethodReferenceReader {
 		ImageReader imageReader;
-		BinaryReader reader;
+		IBinaryReader reader;
 		BabelMethodreference bmr;
 
-		public MethodReferenceReader(ImageReader imageReader, BinaryReader reader)
+		public MethodReferenceReader(ImageReader imageReader, IBinaryReader reader)
 			: this(imageReader, reader, new BabelMethodreference()) {
 		}
 
-		public MethodReferenceReader(ImageReader imageReader, BinaryReader reader, BabelMethodreference bmr) {
+		public MethodReferenceReader(ImageReader imageReader, IBinaryReader reader, BabelMethodreference bmr) {
 			this.imageReader = imageReader;
 			this.reader = reader;
 			this.bmr = bmr;
@@ -125,23 +112,24 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 
 		public BabelMethodreference read() {
 			bmr.Name = imageReader.readString();
-			bmr.DeclaringType = imageReader.readTypeReference();
-			bmr.ReturnType = imageReader.readTypeReference();
-			bmr.Parameters = readParameters();
+			bmr.DeclaringType = imageReader.readTypeSig();
+			bmr.ReturnType = imageReader.readTypeSig();
+			var argTypes = imageReader.readTypeSigs();
 			bmr.Flags = reader.ReadByte();
 			if (bmr.IsGenericMethod)
-				bmr.GenericArguments = imageReader.readTypeReferences();
+				bmr.GenericArguments = imageReader.readTypeSigs();
 			else
-				bmr.GenericArguments = new TypeReference[0];
+				bmr.GenericArguments = new TypeSig[0];
+			bmr.Parameters = readParameters(argTypes, bmr.HasThis);
 			return bmr;
 		}
 
-		ParameterDefinition[] readParameters() {
-			var typeReferences = imageReader.readTypeReferences();
-			var parameters = new ParameterDefinition[typeReferences.Length];
-			for (int i = 0; i < parameters.Length; i++)
-				parameters[i] = new ParameterDefinition(typeReferences[i]);
-			return parameters;
+		Parameter[] readParameters(IList<TypeSig> argTypes, bool hasThis) {
+			var ps = new Parameter[argTypes.Count];
+			int bi = hasThis ? 1 : 0;
+			for (int i = 0; i < ps.Length; i++)
+				ps[i] = new Parameter(bi + i, i, argTypes[i]);
+			return ps;
 		}
 	}
 
@@ -150,7 +138,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 		MethodBodyReader methodBodyReader;
 		BabelMethodDefinition bmd;
 
-		public MethodDefinitionReader(ImageReader imageReader, BinaryReader reader) {
+		public MethodDefinitionReader(ImageReader imageReader, IBinaryReader reader) {
 			this.bmd = new BabelMethodDefinition();
 			this.methodReferenceReader = new MethodReferenceReader(imageReader, reader, bmd);
 			this.methodBodyReader = new MethodBodyReader(imageReader, reader);
diff --git a/de4dot.code/deobfuscators/Babel_NET/MethodsDecrypter.cs b/de4dot.code/deobfuscators/Babel_NET/MethodsDecrypter.cs
index 09075dbb..6b6ee0ed 100644
--- a/de4dot.code/deobfuscators/Babel_NET/MethodsDecrypter.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/MethodsDecrypter.cs
@@ -20,26 +20,27 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.IO;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Babel_NET {
 	class MethodsDecrypter {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		ResourceDecrypter resourceDecrypter;
 		IDeobfuscatorContext deobfuscatorContext;
 		Dictionary<string, ImageReader> imageReaders = new Dictionary<string, ImageReader>(StringComparer.Ordinal);
-		TypeDefinition methodsDecrypterCreator;
-		TypeDefinition methodsDecrypter;
-		MethodDefinition decryptExecuteMethod;
+		TypeDef methodsDecrypterCreator;
+		TypeDef methodsDecrypter;
+		MethodDef decryptExecuteMethod;
 		EmbeddedResource encryptedResource;
 
 		public bool Detected {
 			get { return methodsDecrypterCreator != null; }
 		}
 
-		public MethodsDecrypter(ModuleDefinition module, ResourceDecrypter resourceDecrypter, IDeobfuscatorContext deobfuscatorContext) {
+		public MethodsDecrypter(ModuleDefMD module, ResourceDecrypter resourceDecrypter, IDeobfuscatorContext deobfuscatorContext) {
 			this.module = module;
 			this.resourceDecrypter = resourceDecrypter;
 			this.deobfuscatorContext = deobfuscatorContext;
@@ -54,7 +55,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				var fieldTypes = new FieldTypes(type);
 				if (!fieldTypes.all(requiredFields))
 					continue;
-				if (DotNetUtils.getMethod(type, "Finalize") == null)
+				if (type.FindMethod("Finalize") == null)
 					continue;
 				var executeMethod = DotNetUtils.getMethod(type, "System.Object", "(System.String,System.Object[])");
 				if (executeMethod == null || !executeMethod.IsStatic || executeMethod.Body == null)
@@ -73,7 +74,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			}
 		}
 
-		static MethodDefinition findDecryptMethod(TypeDefinition type) {
+		static MethodDef findDecryptMethod(TypeDef type) {
 			foreach (var method in type.Methods) {
 				var decryptMethod = ResourceDecrypter.findDecrypterMethod(method);
 				if (decryptMethod != null)
@@ -82,12 +83,12 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return null;
 		}
 
-		TypeDefinition findMethodsDecrypterType(TypeDefinition type) {
+		TypeDef findMethodsDecrypterType(TypeDef type) {
 			foreach (var field in type.Fields) {
-				var fieldType = DotNetUtils.getType(module, field.FieldType);
+				var fieldType = DotNetUtils.getType(module, field.FieldSig.GetFieldType());
 				if (fieldType == null)
 					continue;
-				if (DotNetUtils.getMethod(fieldType, "Finalize") == null)
+				if (fieldType.FindMethod("Finalize") == null)
 					continue;
 				if (!new FieldTypes(fieldType).exists("System.Collections.Hashtable"))
 					continue;
@@ -106,13 +107,13 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 
 			encryptedResource = BabelUtils.findEmbeddedResource(module, methodsDecrypter, simpleDeobfuscator, deob);
 			if (encryptedResource != null)
-				addImageReader("", resourceDecrypter.decrypt(encryptedResource.GetResourceData()));
+				addImageReader("", resourceDecrypter.decrypt(encryptedResource.Data.ReadAllBytes()));
 		}
 
 		ImageReader addImageReader(string name, byte[] data) {
 			var imageReader = new ImageReader(deobfuscatorContext, module, data);
 			if (!imageReader.initialize()) {
-				Log.w("Could not read encrypted methods");
+				Logger.w("Could not read encrypted methods");
 				return null;
 			}
 			if (imageReaders.ContainsKey(name))
@@ -124,7 +125,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 		class EncryptInfo {
 			public string encryptedMethodName;
 			public string feature;
-			public MethodDefinition method;
+			public MethodDef method;
 
 			public string FullName {
 				get {
@@ -134,7 +135,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				}
 			}
 
-			public EncryptInfo(string encryptedMethodName, string feature, MethodDefinition method) {
+			public EncryptInfo(string encryptedMethodName, string feature, MethodDef method) {
 				this.encryptedMethodName = encryptedMethodName;
 				this.feature = feature;
 				this.method = method;
@@ -142,9 +143,9 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 
 			public override string ToString() {
 				if (feature != "")
-					return string.Format("{0}:{1} {2:X8}", feature, encryptedMethodName, method.MetadataToken.ToInt32());
+					return string.Format("{0}:{1} {2:X8}", feature, encryptedMethodName, method.MDToken.ToInt32());
 				else
-					return string.Format("{0} {1:X8}", encryptedMethodName, method.MetadataToken.ToInt32());
+					return string.Format("{0} {1:X8}", encryptedMethodName, method.MDToken.ToInt32());
 			}
 		}
 
@@ -158,11 +159,11 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 					numNonDecryptedMethods++;
 					continue;
 				}
-				Log.v("Decrypting method {0:X8}", info.method.MetadataToken.ToInt32());
+				Logger.v("Decrypting method {0:X8}", info.method.MDToken.ToInt32());
 				imageReader.restore(info.FullName, info.method);
 			}
 			if (numNonDecryptedMethods > 0)
-				Log.w("{0}/{1} methods not decrypted", numNonDecryptedMethods, totalEncryptedMethods);
+				Logger.w("{0}/{1} methods not decrypted", numNonDecryptedMethods, totalEncryptedMethods);
 		}
 
 		ImageReader getImageReader(string feature) {
@@ -178,7 +179,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				return null;
 
 			try {
-				var encrypted = File.ReadAllBytes(getFile(Path.GetDirectoryName(module.FullyQualifiedName), feature));
+				var encrypted = File.ReadAllBytes(getFile(Path.GetDirectoryName(module.Location), feature));
 				var decrypted = resourceDecrypter.decrypt(encrypted);
 				return addImageReader(feature, decrypted);
 			}
@@ -214,7 +215,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return infos;
 		}
 
-		bool checkEncryptedMethod(MethodDefinition method, out EncryptInfo info) {
+		bool checkEncryptedMethod(MethodDef method, out EncryptInfo info) {
 			info = null;
 			if (method.Body == null)
 				return false;
@@ -237,11 +238,11 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return true;
 		}
 
-		bool callsExecuteMethod(MethodDefinition method) {
+		bool callsExecuteMethod(MethodDef method) {
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Call && instr.OpCode.Code != Code.Callvirt)
 					continue;
-				if (MemberReferenceHelper.compareMethodReferenceAndDeclaringType(decryptExecuteMethod, instr.Operand as MethodReference))
+				if (MethodEqualityComparer.CompareDeclaringTypes.Equals(decryptExecuteMethod, instr.Operand as IMethod))
 					return true;
 			}
 			return false;
diff --git a/de4dot.code/deobfuscators/Babel_NET/ProxyCallFixer.cs b/de4dot.code/deobfuscators/Babel_NET/ProxyCallFixer.cs
index af729d1a..b7d98a34 100644
--- a/de4dot.code/deobfuscators/Babel_NET/ProxyCallFixer.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/ProxyCallFixer.cs
@@ -19,15 +19,15 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Babel_NET {
 	class ProxyCallFixer : ProxyCallFixer2 {
 		MethodDefinitionAndDeclaringTypeDict<ProxyCreatorType> methodToType = new MethodDefinitionAndDeclaringTypeDict<ProxyCreatorType>();
 
-		public ProxyCallFixer(ModuleDefinition module)
+		public ProxyCallFixer(ModuleDefMD module)
 			: base(module) {
 		}
 
@@ -38,11 +38,11 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 		}
 
 		class Context {
-			public TypeReference delegateType;
+			public ITypeDefOrRef delegateType;
 			public int methodToken;
 			public int declaringTypeToken;
 			public ProxyCreatorType proxyCreatorType;
-			public Context(TypeReference delegateType, int methodToken, int declaringTypeToken, ProxyCreatorType proxyCreatorType) {
+			public Context(ITypeDefOrRef delegateType, int methodToken, int declaringTypeToken, ProxyCreatorType proxyCreatorType) {
 				this.delegateType = delegateType;
 				this.methodToken = methodToken;
 				this.declaringTypeToken = declaringTypeToken;
@@ -54,27 +54,27 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			get { return true; }
 		}
 
-		protected override object checkCctor(TypeDefinition type, MethodDefinition cctor) {
+		protected override object checkCctor(TypeDef type, MethodDef cctor) {
 			var instructions = cctor.Body.Instructions;
 			for (int i = 0; i < instructions.Count; i++) {
-				TypeReference delegateType;
-				FieldReference delegateField;
-				MethodReference createMethod;
+				ITypeDefOrRef delegateType;
+				IField delegateField;
+				IMethod createMethod;
 				int methodToken, declaringTypeToken;
 				var instrs = DotNetUtils.getInstructions(instructions, i, OpCodes.Ldtoken, OpCodes.Ldc_I4, OpCodes.Ldc_I4, OpCodes.Ldtoken, OpCodes.Call);
 				if (instrs != null) {
-					delegateType = instrs[0].Operand as TypeReference;
-					methodToken = DotNetUtils.getLdcI4Value(instrs[1]);
-					declaringTypeToken = DotNetUtils.getLdcI4Value(instrs[2]);
-					delegateField = instrs[3].Operand as FieldReference;
-					createMethod = instrs[4].Operand as MethodReference;
+					delegateType = instrs[0].Operand as ITypeDefOrRef;
+					methodToken = instrs[1].GetLdcI4Value();
+					declaringTypeToken = instrs[2].GetLdcI4Value();
+					delegateField = instrs[3].Operand as IField;
+					createMethod = instrs[4].Operand as IMethod;
 				}
 				else if ((instrs = DotNetUtils.getInstructions(instructions, i, OpCodes.Ldtoken, OpCodes.Ldc_I4, OpCodes.Ldtoken, OpCodes.Call)) != null) {
-					delegateType = instrs[0].Operand as TypeReference;
-					methodToken = DotNetUtils.getLdcI4Value(instrs[1]);
+					delegateType = instrs[0].Operand as ITypeDefOrRef;
+					methodToken = instrs[1].GetLdcI4Value();
 					declaringTypeToken = -1;
-					delegateField = instrs[2].Operand as FieldReference;
-					createMethod = instrs[3].Operand as MethodReference;
+					delegateField = instrs[2].Operand as IField;
+					createMethod = instrs[3].Operand as IMethod;
 				}
 				else
 					continue;
@@ -95,7 +95,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return null;
 		}
 
-		protected override void getCallInfo(object context, FieldDefinition field, out MethodReference calledMethod, out OpCode callOpcode) {
+		protected override void getCallInfo(object context, FieldDef field, out IMethod calledMethod, out OpCode callOpcode) {
 			var ctx = (Context)context;
 
 			switch (ctx.proxyCreatorType) {
@@ -109,7 +109,10 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				throw new ApplicationException(string.Format("Invalid proxy creator type: {0}", ctx.proxyCreatorType));
 			}
 
-			calledMethod = module.LookupToken(ctx.methodToken) as MethodReference;
+			var method = module.ResolveToken(ctx.methodToken) as IMethod;
+			if (method.MethodSig == null)
+				method = null;
+			calledMethod = method;
 		}
 
 		public void findDelegateCreator() {
@@ -141,11 +144,11 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			}
 		}
 
-		ProxyCreatorType getProxyCreatorType(MethodDefinition methodToCheck) {
+		ProxyCreatorType getProxyCreatorType(MethodDef methodToCheck) {
 			foreach (var calledMethod in DotNetUtils.getCalledMethods(module, methodToCheck)) {
 				if (!calledMethod.IsStatic || calledMethod.Body == null)
 					continue;
-				if (!MemberReferenceHelper.compareTypes(methodToCheck.DeclaringType, calledMethod.DeclaringType))
+				if (!new SigComparer().Equals(methodToCheck.DeclaringType, calledMethod.DeclaringType))
 					continue;
 				if (DotNetUtils.isMethod(calledMethod, "System.Void", "(System.Reflection.FieldInfo,System.Type,System.Reflection.MethodInfo)"))
 					return ProxyCreatorType.CallOrCallvirt;
diff --git a/de4dot.code/deobfuscators/Babel_NET/ResourceDecrypter.cs b/de4dot.code/deobfuscators/Babel_NET/ResourceDecrypter.cs
index 0abaad94..93ff93b5 100644
--- a/de4dot.code/deobfuscators/Babel_NET/ResourceDecrypter.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/ResourceDecrypter.cs
@@ -20,16 +20,16 @@
 using System;
 using System.IO;
 using ICSharpCode.SharpZipLib.Zip.Compression;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Babel_NET {
 	class ResourceDecrypterCreator {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		ISimpleDeobfuscator simpleDeobfuscator;
 
-		public ResourceDecrypterCreator(ModuleDefinition module, ISimpleDeobfuscator simpleDeobfuscator) {
+		public ResourceDecrypterCreator(ModuleDefMD module, ISimpleDeobfuscator simpleDeobfuscator) {
 			this.module = module;
 			this.simpleDeobfuscator = simpleDeobfuscator;
 		}
@@ -40,12 +40,12 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 	}
 
 	class ResourceDecrypter {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		ISimpleDeobfuscator simpleDeobfuscator;
-		MethodDefinition decryptMethod;
+		MethodDef decryptMethod;
 		IDecrypter decrypter;
 
-		public ResourceDecrypter(ModuleDefinition module, ISimpleDeobfuscator simpleDeobfuscator) {
+		public ResourceDecrypter(ModuleDefMD module, ISimpleDeobfuscator simpleDeobfuscator) {
 			this.module = module;
 			this.simpleDeobfuscator = simpleDeobfuscator;
 		}
@@ -56,9 +56,9 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 
 		// v3.0
 		class Decrypter1 : IDecrypter {
-			ModuleDefinition module;
+			ModuleDefMD module;
 
-			public Decrypter1(ModuleDefinition module) {
+			public Decrypter1(ModuleDefMD module) {
 				this.module = module;
 			}
 
@@ -82,7 +82,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 					key = reader.ReadBytes(reader.ReadByte());
 				else {
 					key = new byte[reader.ReadByte()];
-					Array.Copy(module.Assembly.Name.PublicKey, 0, key, 0, key.Length);
+					Array.Copy(module.Assembly.PublicKey.Data, 0, key, 0, key.Length);
 				}
 
 				reader.ReadBytes(reader.ReadInt32());	// hash
@@ -92,9 +92,9 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 
 		// v3.5+
 		class Decrypter2 : IDecrypter {
-			ModuleDefinition module;
+			ModuleDefMD module;
 
-			public Decrypter2(ModuleDefinition module) {
+			public Decrypter2(ModuleDefMD module) {
 				this.module = module;
 			}
 
@@ -143,7 +143,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 					key = reader.ReadBytes(reader.ReadByte());
 				else {
 					key = new byte[reader.ReadByte()];
-					Array.Copy(module.Assembly.Name.PublicKey, 12, key, 0, key.Length);
+					Array.Copy(module.Assembly.PublicKey.Data, 12, key, 0, key.Length);
 					key[5] |= 0x80;
 				}
 				return isCompressed;
@@ -152,10 +152,10 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 
 		// v5.0+ retail
 		class Decrypter3 : IDecrypter {
-			ModuleDefinition module;
+			ModuleDefMD module;
 			Inflater inflater;
 
-			public Decrypter3(ModuleDefinition module, MethodDefinition decryptMethod) {
+			public Decrypter3(ModuleDefMD module, MethodDef decryptMethod) {
 				this.module = module;
 				this.inflater = InflaterCreator.create(decryptMethod, true);
 			}
@@ -201,14 +201,14 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 					key = reader.ReadBytes(reader.ReadByte());
 				else {
 					key = new byte[reader.ReadByte()];
-					Array.Copy(module.Assembly.Name.PublicKey, 12, key, 0, key.Length);
+					Array.Copy(module.Assembly.PublicKey.Data, 12, key, 0, key.Length);
 					key[5] |= 0x80;
 				}
 				return isCompressed;
 			}
 		}
 
-		public MethodDefinition DecryptMethod {
+		public MethodDef DecryptMethod {
 			set {
 				if (value == null)
 					return;
@@ -221,14 +221,14 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			}
 		}
 
-		public static MethodDefinition findDecrypterMethod(MethodDefinition method) {
+		public static MethodDef findDecrypterMethod(MethodDef method) {
 			if (method == null || method.Body == null)
 				return null;
 
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Call)
 					continue;
-				var calledMethod = instr.Operand as MethodDefinition;
+				var calledMethod = instr.Operand as MethodDef;
 				if (calledMethod == null || !calledMethod.IsStatic || calledMethod.Body == null)
 					continue;
 				if (!DotNetUtils.isMethod(calledMethod, "System.IO.MemoryStream", "(System.IO.Stream)"))
diff --git a/de4dot.code/deobfuscators/Babel_NET/ResourceResolver.cs b/de4dot.code/deobfuscators/Babel_NET/ResourceResolver.cs
index a1f30f3e..6b35dc88 100644
--- a/de4dot.code/deobfuscators/Babel_NET/ResourceResolver.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/ResourceResolver.cs
@@ -20,17 +20,18 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.IO;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Babel_NET {
 	class ResourceResolver {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		ResourceDecrypter resourceDecrypter;
 		ISimpleDeobfuscator simpleDeobfuscator;
-		TypeDefinition resolverType;
-		MethodDefinition registerMethod;
+		TypeDef resolverType;
+		MethodDef registerMethod;
 		EmbeddedResource encryptedResource;
 		bool hasXorKeys;
 		int xorKey1, xorKey2;
@@ -39,15 +40,15 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			get { return resolverType != null; }
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return resolverType; }
 		}
 
-		public MethodDefinition InitMethod {
+		public MethodDef InitMethod {
 			get { return registerMethod; }
 		}
 
-		public ResourceResolver(ModuleDefinition module, ResourceDecrypter resourceDecrypter, ISimpleDeobfuscator simpleDeobfuscator) {
+		public ResourceResolver(ModuleDefMD module, ResourceDecrypter resourceDecrypter, ISimpleDeobfuscator simpleDeobfuscator) {
 			this.module = module;
 			this.resourceDecrypter = resourceDecrypter;
 			this.simpleDeobfuscator = simpleDeobfuscator;
@@ -66,7 +67,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				if (!new FieldTypes(type).all(requiredTypes))
 					continue;
 
-				MethodDefinition regMethod, handler;
+				MethodDef regMethod, handler;
 				if (!BabelUtils.findRegisterMethod(type, out regMethod, out handler))
 					continue;
 
@@ -87,7 +88,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			}
 		}
 
-		static MethodDefinition findDecryptMethod(TypeDefinition type) {
+		static MethodDef findDecryptMethod(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (!DotNetUtils.isMethod(method, "System.Reflection.Assembly", "(System.IO.Stream)"))
 					continue;
@@ -96,7 +97,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return null;
 		}
 
-		void initXorKeys(MethodDefinition method) {
+		void initXorKeys(MethodDef method) {
 			simpleDeobfuscator.deobfuscate(method);
 			var ints = new List<int>();
 			var instrs = method.Body.Instructions;
@@ -104,20 +105,20 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				var callvirt = instrs[i];
 				if (callvirt.OpCode.Code != Code.Callvirt)
 					continue;
-				var calledMethod = callvirt.Operand as MethodReference;
+				var calledMethod = callvirt.Operand as IMethod;
 				if (calledMethod == null)
 					continue;
 				if (calledMethod.FullName != "System.Int32 System.IO.BinaryReader::ReadInt32()")
 					continue;
 
 				var ldci4 = instrs[i + 1];
-				if (!DotNetUtils.isLdcI4(ldci4))
+				if (!ldci4.IsLdcI4())
 					continue;
 
 				if (instrs[i + 2].OpCode.Code != Code.Xor)
 					continue;
 
-				ints.Add(DotNetUtils.getLdcI4Value(ldci4));
+				ints.Add(ldci4.GetLdcI4Value());
 			}
 
 			if (ints.Count == 2) {
@@ -130,14 +131,14 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 		public EmbeddedResource mergeResources() {
 			if (encryptedResource == null)
 				return null;
-			DeobUtils.decryptAndAddResources(module, encryptedResource.Name, () => decryptResourceAssembly());
+			DeobUtils.decryptAndAddResources(module, encryptedResource.Name.String, () => decryptResourceAssembly());
 			var result = encryptedResource;
 			encryptedResource = null;
 			return result;
 		}
 
 		byte[] decryptResourceAssembly() {
-			var decrypted = resourceDecrypter.decrypt(encryptedResource.GetResourceData());
+			var decrypted = resourceDecrypter.decrypt(encryptedResource.Data.ReadAllBytes());
 			var reader = new BinaryReader(new MemoryStream(decrypted));
 
 			int numResources = reader.ReadInt32() ^ xorKey1;
diff --git a/de4dot.code/deobfuscators/Babel_NET/StringDecrypter.cs b/de4dot.code/deobfuscators/Babel_NET/StringDecrypter.cs
index e6f0a552..bb6791b1 100644
--- a/de4dot.code/deobfuscators/Babel_NET/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/StringDecrypter.cs
@@ -21,35 +21,36 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.IO;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 using de4dot.blocks.cflow;
 
 namespace de4dot.code.deobfuscators.Babel_NET {
 	class StringDecrypter {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		ResourceDecrypter resourceDecrypter;
 		ISimpleDeobfuscator simpleDeobfuscator;
-		TypeDefinition decrypterType;
+		TypeDef decrypterType;
 		EmbeddedResource encryptedResource;
 		IDecrypterInfo decrypterInfo;
 
 		interface IDecrypterInfo {
-			MethodDefinition Decrypter { get; }
+			MethodDef Decrypter { get; }
 			bool NeedsResource { get; }
-			void initialize(ModuleDefinition module, EmbeddedResource resource);
+			void initialize(ModuleDefMD module, EmbeddedResource resource);
 			string decrypt(object[] args);
 		}
 
 		// Babel .NET 2.x
 		class DecrypterInfoV1 : IDecrypterInfo {
-			public MethodDefinition Decrypter { get; set; }
+			public MethodDef Decrypter { get; set; }
 			public bool NeedsResource {
 				get { return false; }
 			}
 
-			public void initialize(ModuleDefinition module, EmbeddedResource resource) {
+			public void initialize(ModuleDefMD module, EmbeddedResource resource) {
 			}
 
 			public string decrypt(object[] args) {
@@ -67,13 +68,13 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 		class DecrypterInfoV2 : IDecrypterInfo {
 			byte[] key;
 
-			public MethodDefinition Decrypter { get; set; }
+			public MethodDef Decrypter { get; set; }
 			public bool NeedsResource {
 				get { return true; }
 			}
 
-			public void initialize(ModuleDefinition module, EmbeddedResource resource) {
-				key = resource.GetResourceData();
+			public void initialize(ModuleDefMD module, EmbeddedResource resource) {
+				key = resource.Data.ReadAllBytes();
 				if (key.Length != 0x100)
 					throw new ApplicationException(string.Format("Unknown key length: {0}", key.Length));
 			}
@@ -97,7 +98,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			InstructionEmulator emulator = new InstructionEmulator();
 
 			public IList<Instruction> OffsetCalcInstructions { get; set; }
-			public MethodDefinition Decrypter { get; set; }
+			public MethodDef Decrypter { get; set; }
 			public bool NeedsResource {
 				get { return true; }
 			}
@@ -106,20 +107,20 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				this.resourceDecrypter = resourceDecrypter;
 			}
 
-			public void initialize(ModuleDefinition module, EmbeddedResource resource) {
-				var decrypted = resourceDecrypter.decrypt(resource.GetResourceData());
+			public void initialize(ModuleDefMD module, EmbeddedResource resource) {
+				var decrypted = resourceDecrypter.decrypt(resource.Data.ReadAllBytes());
 				var reader = new BinaryReader(new MemoryStream(decrypted));
 				while (reader.BaseStream.Position < reader.BaseStream.Length)
 					offsetToString[getOffset((int)reader.BaseStream.Position)] = reader.ReadString();
 			}
 
-			MethodDefinition dummyMethod;
+			MethodDef dummyMethod;
 			int getOffset(int offset) {
 				if (OffsetCalcInstructions == null || OffsetCalcInstructions.Count == 0)
 					return offset;
 				if (dummyMethod == null) {
-					dummyMethod = new MethodDefinition("", 0, new TypeReference("", "", null, null));
-					dummyMethod.Body = new MethodBody(dummyMethod);
+					dummyMethod = new MethodDefUser();
+					dummyMethod.Body = new CilBody();
 				}
 				emulator.init(dummyMethod);
 				emulator.push(new Int32Value(offset));
@@ -141,11 +142,11 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			get { return decrypterType != null; }
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return decrypterType; }
 		}
 
-		public MethodDefinition DecryptMethod {
+		public MethodDef DecryptMethod {
 			get { return decrypterInfo == null ? null : decrypterInfo.Decrypter; }
 		}
 
@@ -153,7 +154,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			get { return encryptedResource; }
 		}
 
-		public StringDecrypter(ModuleDefinition module, ResourceDecrypter resourceDecrypter) {
+		public StringDecrypter(ModuleDefMD module, ResourceDecrypter resourceDecrypter) {
 			this.module = module;
 			this.resourceDecrypter = resourceDecrypter;
 		}
@@ -171,7 +172,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			}
 		}
 
-		IDecrypterInfo checkDecrypterType(TypeDefinition type) {
+		IDecrypterInfo checkDecrypterType(TypeDef type) {
 			if (type.HasEvents)
 				return null;
 			if (type.NestedTypes.Count > 2)
@@ -188,7 +189,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return checkDecrypterTypeBabel2x(type);
 		}
 
-		IDecrypterInfo checkDecrypterTypeBabel2x(TypeDefinition type) {
+		IDecrypterInfo checkDecrypterTypeBabel2x(TypeDef type) {
 			if (type.HasEvents || type.HasProperties || type.HasNestedTypes)
 				return null;
 			if (type.HasFields || type.Methods.Count != 1)
@@ -200,7 +201,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return new DecrypterInfoV1 { Decrypter = decrypter };
 		}
 
-		bool checkDecryptMethodBabel2x(MethodDefinition method) {
+		bool checkDecryptMethodBabel2x(MethodDef method) {
 			if (!method.IsStatic || !method.IsPublic)
 				return false;
 			if (method.Body == null)
@@ -212,7 +213,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 
 			int stringLength = 0, stringToCharArray = 0, stringCtor = 0;
 			foreach (var instr in method.Body.Instructions) {
-				var calledMethod = instr.Operand as MethodReference;
+				var calledMethod = instr.Operand as IMethod;
 				if (calledMethod == null)
 					continue;
 
@@ -242,11 +243,11 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return stringLength == 1 && stringToCharArray == 1 && stringCtor == 1;
 		}
 
-		IDecrypterInfo checkNested(TypeDefinition type, TypeDefinition nested) {
+		IDecrypterInfo checkNested(TypeDef type, TypeDef nested) {
 			if (nested.HasProperties || nested.HasEvents)
 				return null;
 
-			if (DotNetUtils.getMethod(nested, ".ctor") == null)
+			if (nested.FindMethod(".ctor") == null)
 				return null;
 
 			if (nested.Fields.Count == 1 || nested.Fields.Count == 3) {
@@ -259,7 +260,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				if (decrypterBuilderMethod == null)
 					return null;
 
-				resourceDecrypter.DecryptMethod = ResourceDecrypter.findDecrypterMethod(DotNetUtils.getMethod(nested, ".ctor"));
+				resourceDecrypter.DecryptMethod = ResourceDecrypter.findDecrypterMethod(nested.FindMethod(".ctor"));
 
 				var nestedDecrypter = DotNetUtils.getMethod(nested, "System.String", "(System.Int32)");
 				if (nestedDecrypter == null || nestedDecrypter.IsStatic)
@@ -286,7 +287,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 					if (decrypter == null || !decrypter.IsStatic)
 						return null;
 
-					resourceDecrypter.DecryptMethod = ResourceDecrypter.findDecrypterMethod(DotNetUtils.getMethod(nested, ".ctor"));
+					resourceDecrypter.DecryptMethod = ResourceDecrypter.findDecrypterMethod(nested.FindMethod(".ctor"));
 
 					return new DecrypterInfoV3(resourceDecrypter) { Decrypter = decrypter };
 				}
@@ -309,7 +310,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 		}
 
 		class ReflectionToCecilMethodCreator {
-			MethodDefinition method;
+			MethodDef method;
 			List<Instruction> instructions = new List<Instruction>();
 			InstructionEmulator emulator;
 			int index;
@@ -330,7 +331,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				get { return instructions; }
 			}
 
-			public ReflectionToCecilMethodCreator(MethodDefinition method) {
+			public ReflectionToCecilMethodCreator(MethodDef method) {
 				this.method = method;
 				this.emulator = new InstructionEmulator(method);
 			}
@@ -346,7 +347,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 						return true;
 
 					case Code.Newarr:
-						var arrayType = (TypeReference)instr.Operand;
+						var arrayType = (ITypeDefOrRef)instr.Operand;
 						int arrayCount = ((Int32Value)emulator.pop()).value;
 						if (arrayType.FullName == "System.Char")
 							emulator.push(new UserValue(new char[arrayCount]));
@@ -396,7 +397,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 						break;
 
 					case Code.Ldsfld:
-						emulator.push(new UserValue((FieldReference)instr.Operand));
+						emulator.push(new UserValue((IField)instr.Operand));
 						break;
 
 					default:
@@ -409,30 +410,32 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			}
 
 			bool doCall(Instruction instr) {
-				var calledMethod = (MethodReference)instr.Operand;
-				if (calledMethod.FullName == "System.Byte[] System.Convert::FromBase64String(System.String)") {
+				var calledMethod = (IMethod)instr.Operand;
+				var sig = calledMethod.MethodSig;
+				var fn = calledMethod.FullName;
+				if (fn == "System.Byte[] System.Convert::FromBase64String(System.String)") {
 					emulator.push(new UserValue(Convert.FromBase64String(((StringValue)emulator.pop()).value)));
 					return true;
 				}
-				else if (calledMethod.FullName == "System.String System.Text.Encoding::GetString(System.Byte[])") {
+				else if (fn == "System.String System.Text.Encoding::GetString(System.Byte[])") {
 					emulator.push(new StringValue(Encoding.UTF8.GetString((byte[])((UserValue)emulator.pop()).obj)));
 					return true;
 				}
-				else if (calledMethod.FullName == "System.Int32 System.Int32::Parse(System.String)") {
+				else if (fn == "System.Int32 System.Int32::Parse(System.String)") {
 					emulator.push(new Int32Value(int.Parse(((StringValue)emulator.pop()).value)));
 					return true;
 				}
-				else if (calledMethod.FullName == "System.String[] System.String::Split(System.Char[])") {
+				else if (fn == "System.String[] System.String::Split(System.Char[])") {
 					var ary = (char[])((UserValue)emulator.pop()).obj;
 					var s = ((StringValue)emulator.pop()).value;
 					emulator.push(new UserValue(s.Split(ary)));
 					return true;
 				}
-				else if (calledMethod.HasThis && calledMethod.DeclaringType.FullName == "System.Reflection.Emit.ILGenerator" && calledMethod.Name == "Emit") {
+				else if (sig != null && sig.HasThis && calledMethod.DeclaringType.FullName == "System.Reflection.Emit.ILGenerator" && calledMethod.Name == "Emit") {
 					Value operand = null;
-					if (calledMethod.Parameters.Count == 2)
+					if (calledMethod.MethodSig.GetParamCount() == 2)
 						operand = emulator.pop();
-					var opcode = reflectionToCecilOpCode((FieldReference)((UserValue)emulator.pop()).obj);
+					var opcode = reflectionToOpCode((IField)((UserValue)emulator.pop()).obj);
 					emulator.pop();	// the this ptr
 					addInstruction(new Instruction {
 						OpCode = opcode,
@@ -458,15 +461,15 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				instructions.Add(instr);
 			}
 
-			static OpCode reflectionToCecilOpCode(FieldReference reflectionField) {
-				var field = typeof(OpCodes).GetField(reflectionField.Name);
+			static OpCode reflectionToOpCode(IField reflectionField) {
+				var field = typeof(OpCodes).GetField(reflectionField.Name.String);
 				if (field == null || field.FieldType != typeof(OpCode))
 					return null;
 				return (OpCode)field.GetValue(null);
 			}
 		}
 
-		static List<Instruction> getOffsetCalcInstructions(MethodDefinition method) {
+		static List<Instruction> getOffsetCalcInstructions(MethodDef method) {
 			var creator = new ReflectionToCecilMethodCreator(method);
 			creator.create();
 			var instrs = creator.Instructions;
@@ -499,15 +502,15 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return -1;
 		}
 
-		static bool hasFieldType(IEnumerable<FieldDefinition> fields, TypeReference fieldType) {
+		static bool hasFieldType(IEnumerable<FieldDef> fields, TypeDef fieldType) {
 			foreach (var field in fields) {
-				if (MemberReferenceHelper.compareTypes(field.FieldType, fieldType))
+				if (new SigComparer().Equals(field.FieldSig.GetFieldType(), fieldType))
 					return true;
 			}
 			return false;
 		}
 
-		static int getOffsetMagic(MethodDefinition method) {
+		static int getOffsetMagic(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 4; i++) {
 				int index = i;
@@ -517,46 +520,46 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 					continue;
 
 				var ldci4 = instrs[index++];
-				if (!DotNetUtils.isLdcI4(ldci4))
+				if (!ldci4.IsLdcI4())
 					continue;
 
 				var callvirt = instrs[index++];
 				if (callvirt.OpCode.Code != Code.Callvirt)
 					continue;
-				var calledMethod = callvirt.Operand as MethodReference;
+				var calledMethod = callvirt.Operand as IMethod;
 				if (calledMethod == null)
 					continue;
 				if (calledMethod.FullName != "System.Void System.Reflection.Emit.ILGenerator::Emit(System.Reflection.Emit.OpCode,System.Int32)")
 					continue;
 
-				if (!DotNetUtils.isLdloc(instrs[index++]))
+				if (!instrs[index++].IsLdloc())
 					continue;
 
 				var ldsfld2 = instrs[index++];
 				if (ldsfld2.OpCode.Code != Code.Ldsfld)
 					continue;
-				var field = ldsfld2.Operand as FieldReference;
+				var field = ldsfld2.Operand as IField;
 				if (field == null)
 					continue;
 				if (field.FullName != "System.Reflection.Emit.OpCode System.Reflection.Emit.OpCodes::Xor")
 					continue;
 
 				// Here if Babel.NET 5.5
-				return DotNetUtils.getLdcI4Value(ldci4);
+				return ldci4.GetLdcI4Value();
 			}
 
 			// Here if Babel.NET <= 5.0
 			return 0;
 		}
 
-		bool checkFields(TypeDefinition type, string fieldType1, TypeDefinition fieldType2) {
+		bool checkFields(TypeDef type, string fieldType1, TypeDef fieldType2) {
 			if (type.Fields.Count != 2)
 				return false;
-			if (type.Fields[0].FieldType.FullName != fieldType1 &&
-				type.Fields[1].FieldType.FullName != fieldType1)
+			if (type.Fields[0].FieldSig.GetFieldType().GetFullName() != fieldType1 &&
+				type.Fields[1].FieldSig.GetFieldType().GetFullName() != fieldType1)
 				return false;
-			if (!MemberReferenceHelper.compareTypes(type.Fields[0].FieldType, fieldType2) &&
-				!MemberReferenceHelper.compareTypes(type.Fields[1].FieldType, fieldType2))
+			if (!new SigComparer().Equals(type.Fields[0].FieldSig.GetFieldType(), fieldType2) &&
+				!new SigComparer().Equals(type.Fields[1].FieldSig.GetFieldType(), fieldType2))
 				return false;
 			return true;
 		}
diff --git a/de4dot.code/deobfuscators/CodeFort/AssemblyData.cs b/de4dot.code/deobfuscators/CodeFort/AssemblyData.cs
index 374d65be..262bd97a 100644
--- a/de4dot.code/deobfuscators/CodeFort/AssemblyData.cs
+++ b/de4dot.code/deobfuscators/CodeFort/AssemblyData.cs
@@ -25,21 +25,21 @@ using System.Reflection.Emit;
 using System.Text;
 
 namespace de4dot.code.deobfuscators.CodeFort {
-	interface IType {
+	interface ICFType {
 		Type get(SerializedTypes serializedTypes);
 	}
 
 	static class ITypeCreator {
-		public static IType create(string name) {
+		public static ICFType create(string name) {
 			return new StringType(name);
 		}
 
-		public static IType create(Type type) {
+		public static ICFType create(Type type) {
 			return new ExistingType(type);
 		}
 	}
 
-	class StringType : IType {
+	class StringType : ICFType {
 		readonly string name;
 
 		public StringType(string name) {
@@ -55,7 +55,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 		}
 	}
 
-	class ExistingType : IType {
+	class ExistingType : ICFType {
 		readonly Type type;
 
 		public ExistingType(Type type) {
@@ -71,19 +71,19 @@ namespace de4dot.code.deobfuscators.CodeFort {
 		}
 	}
 
-	class GenericType : IType {
-		IType type;
-		IType[] genericArgs;
+	class GenericType : ICFType {
+		ICFType type;
+		ICFType[] genericArgs;
 
-		public GenericType(string type, IType[] genericArgs)
+		public GenericType(string type, ICFType[] genericArgs)
 			: this(ITypeCreator.create(type), genericArgs) {
 		}
 
-		public GenericType(Type type, IType[] genericArgs)
+		public GenericType(Type type, ICFType[] genericArgs)
 			: this(ITypeCreator.create(type), genericArgs) {
 		}
 
-		public GenericType(IType type, IType[] genericArgs) {
+		public GenericType(ICFType type, ICFType[] genericArgs) {
 			this.type = type;
 			this.genericArgs = genericArgs;
 		}
@@ -129,8 +129,8 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			: this(ITypeCreator.create(type)) {
 		}
 
-		public ListType(IType type)
-			: base(typeof(List<>), new IType[] { type }) {
+		public ListType(ICFType type)
+			: base(typeof(List<>), new ICFType[] { type }) {
 		}
 	}
 
@@ -153,7 +153,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 	}
 
 	class TypeInfo : TypeInfoBase {
-		public readonly IType baseType;
+		public readonly ICFType baseType;
 		public readonly TypeFieldInfo[] fieldInfos;
 
 		public TypeInfo(string name, string dcName, TypeFieldInfo[] fieldInfos)
@@ -164,11 +164,11 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			: this(ITypeCreator.create(typeof(object)), name, dcNamespace, dcName, fieldInfos) {
 		}
 
-		public TypeInfo(IType baseType, string name, string dcName, TypeFieldInfo[] fieldInfos)
+		public TypeInfo(ICFType baseType, string name, string dcName, TypeFieldInfo[] fieldInfos)
 			: this(baseType, name, "", dcName, fieldInfos) {
 		}
 
-		public TypeInfo(IType baseType, string name, string dcNamespace, string dcName, TypeFieldInfo[] fieldInfos)
+		public TypeInfo(ICFType baseType, string name, string dcNamespace, string dcName, TypeFieldInfo[] fieldInfos)
 			: base(name, dcNamespace, dcName) {
 			this.baseType = baseType;
 			this.fieldInfos = fieldInfos;
@@ -176,7 +176,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 	}
 
 	class TypeFieldInfo {
-		public readonly IType type;
+		public readonly ICFType type;
 		public readonly string name;
 		public readonly string dmName;
 
@@ -188,7 +188,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			: this(ITypeCreator.create(type), name, dmName) {
 		}
 
-		public TypeFieldInfo(IType type, string name, string dmName) {
+		public TypeFieldInfo(ICFType type, string name, string dmName) {
 			this.type = type;
 			this.name = name;
 			this.dmName = dmName;
diff --git a/de4dot.code/deobfuscators/CodeFort/AssemblyDecrypter.cs b/de4dot.code/deobfuscators/CodeFort/AssemblyDecrypter.cs
index 4716a6c2..2d2dd9c4 100644
--- a/de4dot.code/deobfuscators/CodeFort/AssemblyDecrypter.cs
+++ b/de4dot.code/deobfuscators/CodeFort/AssemblyDecrypter.cs
@@ -23,17 +23,18 @@ using System.IO;
 using System.Security.Cryptography;
 using System.Text;
 using System.Text.RegularExpressions;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.IO;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.CodeFort {
 	class AssemblyDecrypter {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		EmbeddedResource assemblyEncryptedResource;
 		PasswordInfo embedPassword;
-		MethodDefinition embedInitMethod;
-		MethodDefinition embedResolverMethod;
+		MethodDef embedInitMethod;
+		MethodDef embedResolverMethod;
 
 		public class AssemblyInfo {
 			public readonly byte[] data;
@@ -67,19 +68,19 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			get { return EncryptedDetected || MainAssemblyHasAssemblyResolver; }
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return embedInitMethod != null ? embedInitMethod.DeclaringType : null; }
 		}
 
-		public MethodDefinition InitMethod {
+		public MethodDef InitMethod {
 			get { return embedInitMethod; }
 		}
 
-		public AssemblyDecrypter(ModuleDefinition module) {
+		public AssemblyDecrypter(ModuleDefMD module) {
 			this.module = module;
 		}
 
-		public AssemblyDecrypter(ModuleDefinition module, AssemblyDecrypter oldOne) {
+		public AssemblyDecrypter(ModuleDefMD module, AssemblyDecrypter oldOne) {
 			this.module = module;
 			this.embedPassword = oldOne.embedPassword;
 		}
@@ -118,10 +119,10 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			return true;
 		}
 
-		MethodDefinition checkCalledMethods(MethodDefinition method) {
+		MethodDef checkCalledMethods(MethodDef method) {
 			int calls = 0;
-			TypeDefinition type = null;
-			MethodDefinition initMethod = null;
+			TypeDef type = null;
+			MethodDef initMethod = null;
 			foreach (var calledMethod in DotNetUtils.getCalledMethods(module, method)) {
 				calls++;
 				if (type != null && calledMethod.DeclaringType != type)
@@ -144,7 +145,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 				findEmbedded(module.EntryPoint);
 		}
 
-		bool findEmbedded(MethodDefinition method) {
+		bool findEmbedded(MethodDef method) {
 			if (method == null || method.Body == null)
 				return false;
 			foreach (var calledMethod in DotNetUtils.getCalledMethods(module, method)) {
@@ -162,7 +163,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			return false;
 		}
 
-		MethodDefinition checkInitMethod(MethodDefinition method) {
+		MethodDef checkInitMethod(MethodDef method) {
 			if (method == null || !method.IsStatic || method.Body == null)
 				return null;
 			if (!DotNetUtils.isMethod(method, "System.Void", "()"))
@@ -175,7 +176,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			return resolver;
 		}
 
-		bool checkType(TypeDefinition type) {
+		bool checkType(TypeDef type) {
 			if (DotNetUtils.getMethod(type, "System.Byte[]", "(System.Byte[],System.String,System.String,System.Int32,System.String,System.Int32)") == null)
 				return false;
 			if (DotNetUtils.getMethod(type, "System.String", "(System.String)") == null)
@@ -192,7 +193,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			if (assemblyEncryptedResource == null)
 				return null;
 
-			var reader = new BinaryReader(assemblyEncryptedResource.GetResourceStream());
+			var reader = new BinaryReader(assemblyEncryptedResource.Data.CreateStream());
 			var encryptedData = DeobUtils.gunzip(reader.BaseStream, reader.ReadInt32());
 			reader = new BinaryReader(new MemoryStream(encryptedData));
 			var serializedData = reader.ReadBytes(reader.ReadInt32());
@@ -235,18 +236,18 @@ namespace de4dot.code.deobfuscators.CodeFort {
 				var resource = rsrc as EmbeddedResource;
 				if (resource == null)
 					continue;
-				if (!Regex.IsMatch(resource.Name, "^cfd_([0-9a-f]{2})+_$"))
+				if (!Regex.IsMatch(resource.Name.String, "^cfd_([0-9a-f]{2})+_$"))
 					continue;
 
-				var asmData = decrypt(embedPassword, gunzip(resource.GetResourceData()));
-				var mod = ModuleDefinition.ReadModule(new MemoryStream(asmData));
-				infos.Add(new AssemblyInfo(asmData, resource, mod.Assembly.FullName, mod.Assembly.Name.Name, DeobUtils.getExtension(mod.Kind)));
+				var asmData = decrypt(embedPassword, gunzip(resource.Data.ReadAllBytes()));
+				var mod = ModuleDefMD.Load(asmData);
+				infos.Add(new AssemblyInfo(asmData, resource, mod.Assembly.FullName, mod.Assembly.Name.String, DeobUtils.getExtension(mod.Kind)));
 			}
 
 			return infos;
 		}
 
-		static PasswordInfo getEmbedPassword(MethodDefinition method) {
+		static PasswordInfo getEmbedPassword(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 3; i++) {
 				int index = i;
@@ -262,7 +263,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 				var salt = getString(ldstr2, instrs, ref index);
 
 				var ldci4 = instrs[index++];
-				if (!DotNetUtils.isLdcI4(ldci4))
+				if (!ldci4.IsLdcI4())
 					continue;
 
 				var ldstr3 = instrs[index++];
@@ -284,10 +285,10 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			if (call.OpCode.Code != Code.Call && call.OpCode.Code != Code.Callvirt)
 				return s;
 			index++;
-			var calledMethod = call.Operand as MethodReference;
-			if (calledMethod.Name == "ToUpper")
+			var calledMethod = call.Operand as IMethod;
+			if (calledMethod.Name.String == "ToUpper")
 				return s.ToUpper();
-			if (calledMethod.Name == "ToLower")
+			if (calledMethod.Name.String == "ToLower")
 				return s.ToLower();
 			throw new ApplicationException(string.Format("Unknown method {0}", calledMethod));
 		}
diff --git a/de4dot.code/deobfuscators/CodeFort/CfMethodCallInliner.cs b/de4dot.code/deobfuscators/CodeFort/CfMethodCallInliner.cs
index ba322243..84916b3b 100644
--- a/de4dot.code/deobfuscators/CodeFort/CfMethodCallInliner.cs
+++ b/de4dot.code/deobfuscators/CodeFort/CfMethodCallInliner.cs
@@ -17,7 +17,7 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 using de4dot.blocks.cflow;
 
@@ -30,11 +30,11 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			this.proxyCallFixer = proxyCallFixer;
 		}
 
-		protected override bool canInline(MethodDefinition method) {
+		protected override bool canInline(MethodDef method) {
 			return proxyCallFixer.isProxyTargetMethod(method);
 		}
 
-		protected override bool isCompatibleType(int paramIndex, TypeReference origType, TypeReference newType) {
+		protected override bool isCompatibleType(int paramIndex, IType origType, IType newType) {
 			return true;
 		}
 	}
diff --git a/de4dot.code/deobfuscators/CodeFort/Deobfuscator.cs b/de4dot.code/deobfuscators/CodeFort/Deobfuscator.cs
index 091ea869..244749fb 100644
--- a/de4dot.code/deobfuscators/CodeFort/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/CodeFort/Deobfuscator.cs
@@ -19,8 +19,7 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.MyStuff;
+using dot10.DotNet;
 using de4dot.blocks;
 using de4dot.PE;
 
@@ -115,7 +114,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			return newFileData != null;
 		}
 
-		public override IDeobfuscator moduleReloaded(ModuleDefinition module) {
+		public override IDeobfuscator moduleReloaded(ModuleDefMD module) {
 			var newOne = new Deobfuscator(options);
 			newOne.setModule(module);
 			newOne.proxyCallFixer = new ProxyCallFixer(module);
@@ -173,7 +172,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 		public override IEnumerable<int> getStringDecrypterMethods() {
 			var list = new List<int>();
 			if (stringDecrypter.Method != null)
-				list.Add(stringDecrypter.Method.MetadataToken.ToInt32());
+				list.Add(stringDecrypter.Method.MDToken.ToInt32());
 			return list;
 		}
 	}
diff --git a/de4dot.code/deobfuscators/CodeFort/PasswordFinder.cs b/de4dot.code/deobfuscators/CodeFort/PasswordFinder.cs
index be4cc4d2..b3428ae8 100644
--- a/de4dot.code/deobfuscators/CodeFort/PasswordFinder.cs
+++ b/de4dot.code/deobfuscators/CodeFort/PasswordFinder.cs
@@ -22,7 +22,7 @@ using System.Collections.Generic;
 using System.IO;
 using System.Reflection;
 using System.Reflection.Emit;
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace de4dot.code.deobfuscators.CodeFort {
 	class PasswordInfo {
diff --git a/de4dot.code/deobfuscators/CodeFort/ProxyCallFixer.cs b/de4dot.code/deobfuscators/CodeFort/ProxyCallFixer.cs
index 8fa60d7d..605c36f8 100644
--- a/de4dot.code/deobfuscators/CodeFort/ProxyCallFixer.cs
+++ b/de4dot.code/deobfuscators/CodeFort/ProxyCallFixer.cs
@@ -19,25 +19,24 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.CodeFort {
 	class ProxyCallFixer : ProxyCallFixer3 {
-		IList<MemberReference> memberReferences;
 		MethodDefinitionAndDeclaringTypeDict<bool> proxyTargetMethods = new MethodDefinitionAndDeclaringTypeDict<bool>();
-		TypeDefinition proxyMethodsType;
+		TypeDef proxyMethodsType;
 
-		public TypeDefinition ProxyMethodsType {
+		public TypeDef ProxyMethodsType {
 			get { return proxyMethodsType; }
 		}
 
-		public ProxyCallFixer(ModuleDefinition module)
+		public ProxyCallFixer(ModuleDefMD module)
 			: base(module) {
 		}
 
-		public bool isProxyTargetMethod(MethodReference method) {
+		public bool isProxyTargetMethod(IMethod method) {
 			return proxyTargetMethods.find(method);
 		}
 
@@ -52,19 +51,19 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			}
 		}
 
-		static MethodDefinition checkType(TypeDefinition type) {
+		static MethodDef checkType(TypeDef type) {
 			if (type.Fields.Count != 1)
 				return null;
-			if (type.Fields[0].FieldType.FullName != "System.Reflection.Module")
+			if (type.Fields[0].FieldSig.GetFieldType().GetFullName() != "System.Reflection.Module")
 				return null;
 			return checkMethods(type);
 		}
 
-		static MethodDefinition checkMethods(TypeDefinition type) {
+		static MethodDef checkMethods(TypeDef type) {
 			if (type.Methods.Count != 3)
 				return null;
 
-			MethodDefinition creatorMethod = null;
+			MethodDef creatorMethod = null;
 			foreach (var method in type.Methods) {
 				if (method.Name == ".cctor")
 					continue;
@@ -80,34 +79,31 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			return creatorMethod;
 		}
 
-		protected override object checkCctor(ref TypeDefinition type, MethodDefinition cctor) {
+		protected override object checkCctor(ref TypeDef type, MethodDef cctor) {
 			var instrs = cctor.Body.Instructions;
 			if (instrs.Count != 3)
 				return null;
 			var ldci4 = instrs[0];
-			if (!DotNetUtils.isLdcI4(ldci4))
+			if (!ldci4.IsLdcI4())
 				return null;
 			var call = instrs[1];
 			if (call.OpCode.Code != Code.Call)
 				return null;
-			if (!isDelegateCreatorMethod(call.Operand as MethodDefinition))
+			if (!isDelegateCreatorMethod(call.Operand as MethodDef))
 				return null;
-			int rid = DotNetUtils.getLdcI4Value(ldci4);
-			if (cctor.DeclaringType.MetadataToken.RID != rid)
+			int rid = ldci4.GetLdcI4Value();
+			if (cctor.DeclaringType.Rid != rid)
 				throw new ApplicationException("Invalid rid");
 			return rid;
 		}
 
-		protected override void getCallInfo(object context, FieldDefinition field, out MethodReference calledMethod, out OpCode callOpcode) {
-			if (memberReferences == null)
-				memberReferences = new List<MemberReference>(module.GetMemberReferences());
-
-			int rid = 0;
-			foreach (var c in field.Name)
-				rid = (rid << 4) + hexToInt((char)((byte)c + 0x2F));
+		protected override void getCallInfo(object context, FieldDef field, out IMethod calledMethod, out OpCode callOpcode) {
+			uint rid = 0;
+			foreach (var c in field.Name.String)
+				rid = (rid << 4) + (uint)hexToInt((char)((byte)c + 0x2F));
 			rid &= 0x00FFFFFF;
-			calledMethod = (MethodReference)memberReferences[rid - 1];
-			var calledMethodDef = DotNetUtils.getMethod(module, calledMethod);
+			calledMethod = module.ResolveMemberRef(rid);
+			var calledMethodDef = DotNetUtils.getMethod2(module, calledMethod);
 			if (calledMethodDef != null) {
 				proxyMethodsType = calledMethodDef.DeclaringType;
 				proxyTargetMethods.add(calledMethodDef, true);
diff --git a/de4dot.code/deobfuscators/CodeFort/StringDecrypter.cs b/de4dot.code/deobfuscators/CodeFort/StringDecrypter.cs
index 6575bab6..b38a5a0d 100644
--- a/de4dot.code/deobfuscators/CodeFort/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/CodeFort/StringDecrypter.cs
@@ -18,28 +18,28 @@
 */
 
 using System.Text;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.CodeFort {
 	class StringDecrypter {
-		ModuleDefinition module;
-		MethodDefinition decryptMethod;
+		ModuleDefMD module;
+		MethodDef decryptMethod;
 
 		public bool Detected {
 			get { return decryptMethod != null; }
 		}
 
-		public MethodDefinition Method {
+		public MethodDef Method {
 			get { return decryptMethod; }
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return decryptMethod == null ? null : decryptMethod.DeclaringType; }
 		}
 
-		public StringDecrypter(ModuleDefinition module) {
+		public StringDecrypter(ModuleDefMD module) {
 			this.module = module;
 		}
 
@@ -53,14 +53,14 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			}
 		}
 
-		static MethodDefinition checkType(TypeDefinition type) {
+		static MethodDef checkType(TypeDef type) {
 			if (type.HasFields)
 				return null;
 			return checkMethods(type);
 		}
 
-		static MethodDefinition checkMethods(TypeDefinition type) {
-			MethodDefinition decryptMethod = null;
+		static MethodDef checkMethods(TypeDef type) {
+			MethodDef decryptMethod = null;
 			foreach (var method in type.Methods) {
 				if (method.Name == ".cctor")
 					continue;
@@ -76,7 +76,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			return decryptMethod;
 		}
 
-		static bool hasDouble(MethodDefinition method, double value) {
+		static bool hasDouble(MethodDef method, double value) {
 			if (method == null || method.Body == null)
 				return false;
 			foreach (var instr in method.Body.Instructions) {
diff --git a/de4dot.code/deobfuscators/CodeVeil/AssemblyResolver.cs b/de4dot.code/deobfuscators/CodeVeil/AssemblyResolver.cs
index 04d8ccd2..d4930136 100644
--- a/de4dot.code/deobfuscators/CodeVeil/AssemblyResolver.cs
+++ b/de4dot.code/deobfuscators/CodeVeil/AssemblyResolver.cs
@@ -20,21 +20,22 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Xml;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.IO;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.CodeVeil {
 	class AssemblyResolver {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		EmbeddedResource bundleData;
 		EmbeddedResource bundleXmlFile;
-		TypeDefinition bundleType;
-		TypeDefinition assemblyManagerType;
-		TypeDefinition bundleStreamProviderIFace;
-		TypeDefinition xmlParserType;
-		TypeDefinition bundledAssemblyType;
-		TypeDefinition streamProviderType;
+		TypeDef bundleType;
+		TypeDef assemblyManagerType;
+		TypeDef bundleStreamProviderIFace;
+		TypeDef xmlParserType;
+		TypeDef bundledAssemblyType;
+		TypeDef streamProviderType;
 		List<AssemblyInfo> infos = new List<AssemblyInfo>();
 
 		public class AssemblyInfo {
@@ -66,9 +67,9 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			}
 		}
 
-		public IEnumerable<TypeDefinition> BundleTypes {
+		public IEnumerable<TypeDef> BundleTypes {
 			get {
-				var list = new List<TypeDefinition>();
+				var list = new List<TypeDef>();
 				if (!CanRemoveTypes)
 					return list;
 
@@ -95,7 +96,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			get { return bundleXmlFile; }
 		}
 
-		public AssemblyResolver(ModuleDefinition module) {
+		public AssemblyResolver(ModuleDefMD module) {
 			this.module = module;
 		}
 
@@ -124,13 +125,13 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 		}
 
 		void findEmbeddedAssemblies() {
-			var data = bundleData.GetResourceData();
+			var data = bundleData.Data.ReadAllBytes();
 
 			var doc = new XmlDocument();
-			doc.Load(XmlReader.Create(bundleXmlFile.GetResourceStream()));
+			doc.Load(XmlReader.Create(bundleXmlFile.Data.CreateStream()));
 			var manifest = doc.DocumentElement;
 			if (manifest.Name.ToLowerInvariant() != "manifest") {
-				Log.w("Could not find Manifest element");
+				Logger.w("Could not find Manifest element");
 				return;
 			}
 			foreach (var tmp in manifest.ChildNodes) {
@@ -139,18 +140,18 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 					continue;
 
 				if (assemblyElem.Name.ToLowerInvariant() != "assembly") {
-					Log.w("Unknown element: {0}", assemblyElem.Name);
+					Logger.w("Unknown element: {0}", assemblyElem.Name);
 					continue;
 				}
 
 				int offset = getAttributeValueInt32(assemblyElem, "offset");
 				if (offset < 0) {
-					Log.w("Could not find offset attribute");
+					Logger.w("Could not find offset attribute");
 					continue;
 				}
 
 				var assemblyData = DeobUtils.inflate(data, offset, data.Length - offset, true);
-				var mod = ModuleDefinition.ReadModule(new MemoryStream(assemblyData));
+				var mod = ModuleDefMD.Load(assemblyData);
 				infos.Add(new AssemblyInfo(mod.Assembly.FullName, DeobUtils.getExtension(mod.Kind), assemblyData));
 			}
 		}
@@ -167,14 +168,14 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return value;
 		}
 
-		TypeDefinition findBundleType() {
+		TypeDef findBundleType() {
 			foreach (var type in module.Types) {
 				if (type.Namespace != "")
 					continue;
 				if (type.Fields.Count != 2)
 					continue;
 
-				var ctor = DotNetUtils.getMethod(type, ".ctor");
+				var ctor = type.FindMethod(".ctor");
 				if (ctor == null || !ctor.IsPrivate)
 					continue;
 				if (!DotNetUtils.isMethod(ctor, "System.Void", "(System.Reflection.Assembly)"))
@@ -193,7 +194,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return null;
 		}
 
-		MethodDefinition findInitMethod(TypeDefinition type) {
+		MethodDef findInitMethod(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
@@ -208,7 +209,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return null;
 		}
 
-		MethodDefinition findGetTempFilenameMethod(TypeDefinition type) {
+		MethodDef findGetTempFilenameMethod(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (method.IsStatic || method.Body == null)
 					continue;
@@ -234,7 +235,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 				return;
 
 			foreach (var field in bundleType.Fields) {
-				var type = field.FieldType as TypeDefinition;
+				var type = field.FieldSig.GetFieldType().TryGetTypeDef();
 				if (type == null)
 					continue;
 				if (type == bundleType)
@@ -242,10 +243,13 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 				if (type.Fields.Count != 2)
 					continue;
 
-				var ctor = DotNetUtils.getMethod(type, ".ctor");
-				if (ctor == null || ctor.Parameters.Count != 2)
+				var ctor = type.FindMethod(".ctor");
+				if (ctor == null)
 					continue;
-				var iface = ctor.Parameters[1].ParameterType as TypeDefinition;
+				var sig = ctor.MethodSig;
+				if (sig == null || sig.Params.Count != 2)
+					continue;
+				var iface = sig.Params[1].TryGetTypeDef();
 				if (iface == null || !iface.IsInterface)
 					continue;
 
@@ -259,22 +263,22 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			if (assemblyManagerType == null)
 				return;
 			foreach (var field in assemblyManagerType.Fields) {
-				var type = field.FieldType as TypeDefinition;
+				var type = field.FieldSig.GetFieldType().TryGetTypeDef();
 				if (type == null || type.IsInterface)
 					continue;
-				var ctor = DotNetUtils.getMethod(type, ".ctor");
+				var ctor = type.FindMethod(".ctor");
 				if (!DotNetUtils.isMethod(ctor, "System.Void", "()"))
 					continue;
 				if (type.Fields.Count != 1)
 					continue;
-				var git = type.Fields[0].FieldType as GenericInstanceType;
+				var git = type.Fields[0].FieldSig.GetFieldType().ToGenericInstSig();
 				if (git == null)
 					continue;
-				if (git.ElementType.FullName != "System.Collections.Generic.List`1")
+				if (git.GenericType.FullName != "System.Collections.Generic.List`1")
 					continue;
 				if (git.GenericArguments.Count != 1)
 					continue;
-				var type2 = git.GenericArguments[0] as TypeDefinition;
+				var type2 = git.GenericArguments[0].TryGetTypeDef();
 				if (type2 == null)
 					continue;
 
@@ -287,13 +291,13 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 		void findStreamProviderType() {
 			if (bundleType == null)
 				return;
-			var ctor = DotNetUtils.getMethod(bundleType, ".ctor");
+			var ctor = bundleType.FindMethod(".ctor");
 			if (!DotNetUtils.isMethod(ctor, "System.Void", "(System.Reflection.Assembly)"))
 				return;
 			foreach (var instr in ctor.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Newobj)
 					continue;
-				var newobjCtor = instr.Operand as MethodDefinition;
+				var newobjCtor = instr.Operand as MethodDef;
 				if (newobjCtor == null)
 					continue;
 				if (newobjCtor.DeclaringType == assemblyManagerType)
@@ -303,7 +307,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 				var type = newobjCtor.DeclaringType;
 				if (type.Interfaces.Count != 1)
 					continue;
-				if (type.Interfaces[0] != bundleStreamProviderIFace)
+				if (type.Interfaces[0].Interface != bundleStreamProviderIFace)
 					continue;
 
 				streamProviderType = type;
diff --git a/de4dot.code/deobfuscators/CodeVeil/Deobfuscator.cs b/de4dot.code/deobfuscators/CodeVeil/Deobfuscator.cs
index f50b9868..cd036737 100644
--- a/de4dot.code/deobfuscators/CodeVeil/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/CodeVeil/Deobfuscator.cs
@@ -19,8 +19,7 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.MyStuff;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.CodeVeil {
@@ -62,7 +61,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 		ProxyCallFixer proxyCallFixer;
 		StringDecrypter stringDecrypter;
 		AssemblyResolver assemblyResolver;
-		TypeDefinition killType;
+		TypeDef killType;
 		ResourceDecrypter resourceDecrypter;
 
 		internal class Options : OptionsBase {
@@ -161,7 +160,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return true;
 		}
 
-		public override IDeobfuscator moduleReloaded(ModuleDefinition module) {
+		public override IDeobfuscator moduleReloaded(ModuleDefMD module) {
 			var newOne = new Deobfuscator(options);
 			newOne.setModule(module);
 			newOne.mainType = new MainType(module, mainType);
@@ -279,7 +278,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 		public override IEnumerable<int> getStringDecrypterMethods() {
 			var list = new List<int>();
 			if (stringDecrypter.DecryptMethod != null)
-				list.Add(stringDecrypter.DecryptMethod.MetadataToken.ToInt32());
+				list.Add(stringDecrypter.DecryptMethod.MDToken.ToInt32());
 			return list;
 		}
 	}
diff --git a/de4dot.code/deobfuscators/CodeVeil/ErexResourceReader.cs b/de4dot.code/deobfuscators/CodeVeil/ErexResourceReader.cs
index 49ddba94..80eb5c7d 100644
--- a/de4dot.code/deobfuscators/CodeVeil/ErexResourceReader.cs
+++ b/de4dot.code/deobfuscators/CodeVeil/ErexResourceReader.cs
@@ -19,14 +19,15 @@
 
 using System;
 using System.IO;
+using dot10.IO;
 
 namespace de4dot.code.deobfuscators.CodeVeil {
 	class ErexResourceReader {
-		BinaryReader reader;
+		IBinaryReader reader;
 		uint[] key;
 
-		public ErexResourceReader(Stream stream) {
-			reader = new BinaryReader(stream);
+		public ErexResourceReader(IBinaryReader reader) {
+			this.reader = reader;
 		}
 
 		public byte[] decrypt() {
@@ -47,10 +48,10 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 				readKey();
 
 			if (isDeflated)
-				reader = new BinaryReader(inflate(length));
+				reader = inflate(length);
 
 			if (isEncrypted)
-				reader = new BinaryReader(decrypt(length));
+				reader = decrypt(length);
 
 			return reader.ReadBytes(length);
 		}
@@ -61,17 +62,17 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 				key[i] = reader.ReadUInt32();
 		}
 
-		Stream inflate(int length) {
-			var data = reader.ReadBytes((int)(reader.BaseStream.Length - reader.BaseStream.Position));
-			return new MemoryStream(DeobUtils.inflate(data, true));
+		IBinaryReader inflate(int length) {
+			var data = reader.ReadRemainingBytes();
+			return MemoryImageStream.Create(DeobUtils.inflate(data, true));
 		}
 
-		Stream decrypt(int length) {
+		IBinaryReader decrypt(int length) {
 			var block = new uint[4];
 			var decrypted = new byte[16];
 
 			var outStream = new MemoryStream(length);
-			while (reader.BaseStream.Position < reader.BaseStream.Length) {
+			while (reader.Position < reader.Length) {
 				block[0] = reader.ReadUInt32();
 				block[1] = reader.ReadUInt32();
 				block[2] = reader.ReadUInt32();
@@ -81,8 +82,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 				outStream.Write(decrypted, 0, decrypted.Length);
 			}
 
-			outStream.Position = 0;
-			return outStream;
+			return MemoryImageStream.Create(outStream.ToArray());
 		}
 	}
 }
diff --git a/de4dot.code/deobfuscators/CodeVeil/InvalidMethodsFinder.cs b/de4dot.code/deobfuscators/CodeVeil/InvalidMethodsFinder.cs
index 880f08d9..b78569bb 100644
--- a/de4dot.code/deobfuscators/CodeVeil/InvalidMethodsFinder.cs
+++ b/de4dot.code/deobfuscators/CodeVeil/InvalidMethodsFinder.cs
@@ -18,12 +18,12 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace de4dot.code.deobfuscators.CodeVeil {
 	class InvalidMethodsFinder {
-		public static List<MethodDefinition> findAll(ModuleDefinition module) {
-			var list = new List<MethodDefinition>();
+		public static List<MethodDef> findAll(ModuleDefMD module) {
+			var list = new List<MethodDef>();
 			foreach (var type in module.GetTypes()) {
 				foreach (var method in type.Methods) {
 					if (isInvalidMethod(method))
@@ -33,18 +33,20 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return list;
 		}
 
-		public static bool isInvalidMethod(MethodDefinition method) {
-			if (method == null)
+		public static bool isInvalidMethod(MethodDef method) {
+			if (method == null || method.IsStatic)
 				return false;
-			if (method.IsStatic)
+			var sig = method.MethodSig;
+			if (sig == null || sig.Params.Count != 0)
 				return false;
-			if (method.Parameters.Count != 0)
-				return false;
-			var retType = method.MethodReturnType.ReturnType as GenericParameter;
+			var retType = sig.RetType as GenericSig;
 			if (retType == null)
 				return false;
 
-			return retType.Owner == null;
+			if (retType.IsMethodVar)
+				return retType.Number >= sig.GenParamCount;
+			var dt = method.DeclaringType;
+			return dt == null || retType.Number >= dt.GenericParameters.Count;
 		}
 	}
 }
diff --git a/de4dot.code/deobfuscators/CodeVeil/MainType.cs b/de4dot.code/deobfuscators/CodeVeil/MainType.cs
index d5f3e32a..7c79ae46 100644
--- a/de4dot.code/deobfuscators/CodeVeil/MainType.cs
+++ b/de4dot.code/deobfuscators/CodeVeil/MainType.cs
@@ -18,21 +18,20 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.Cecil.Metadata;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.CodeVeil {
 	// Detects the type CV adds to the assembly that gets called from <Module>::.cctor.
 	class MainType {
-		ModuleDefinition module;
-		TypeDefinition theType;
-		MethodDefinition initMethod;
-		MethodDefinition tamperCheckMethod;
+		ModuleDefMD module;
+		TypeDef theType;
+		MethodDef initMethod;
+		MethodDef tamperCheckMethod;
 		ObfuscatorVersion obfuscatorVersion = ObfuscatorVersion.Unknown;
-		List<int> rvas = new List<int>();	// _stub and _executive
-		List<MethodDefinition> otherInitMethods = new List<MethodDefinition>();
+		List<uint> rvas = new List<uint>();	// _stub and _executive
+		List<MethodDef> otherInitMethods = new List<MethodDef>();
 
 		public bool Detected {
 			get { return theType != null; }
@@ -42,31 +41,31 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			get { return obfuscatorVersion; }
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return theType; }
 		}
 
-		public MethodDefinition InitMethod {
+		public MethodDef InitMethod {
 			get { return initMethod; }
 		}
 
-		public List<MethodDefinition> OtherInitMethods {
+		public List<MethodDef> OtherInitMethods {
 			get { return otherInitMethods; }
 		}
 
-		public MethodDefinition TamperCheckMethod {
+		public MethodDef TamperCheckMethod {
 			get { return tamperCheckMethod; }
 		}
 
-		public List<int> Rvas {
+		public List<uint> Rvas {
 			get { return rvas; }
 		}
 
-		public MainType(ModuleDefinition module) {
+		public MainType(ModuleDefMD module) {
 			this.module = module;
 		}
 
-		public MainType(ModuleDefinition module, MainType oldOne) {
+		public MainType(ModuleDefMD module, MainType oldOne) {
 			this.module = module;
 			this.theType = lookup(oldOne.theType, "Could not find main type");
 			this.initMethod = lookup(oldOne.initMethod, "Could not find main type init method");
@@ -77,7 +76,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 				otherInitMethods.Add(lookup(otherInitMethod, "Could not find otherInitMethod"));
 		}
 
-		T lookup<T>(T def, string errorMessage) where T : MemberReference {
+		T lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
 			return DeobUtils.lookup(module, def, errorMessage);
 		}
 
@@ -89,17 +88,17 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			var instrs = cctor.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 2; i++) {
 				var ldci4_1 = instrs[i];
-				if (!DotNetUtils.isLdcI4(ldci4_1))
+				if (!ldci4_1.IsLdcI4())
 					continue;
 
 				var ldci4_2 = instrs[i + 1];
-				if (!DotNetUtils.isLdcI4(ldci4_2))
+				if (!ldci4_2.IsLdcI4())
 					continue;
 
 				var call = instrs[i + 2];
 				if (call.OpCode.Code != Code.Call)
 					continue;
-				var initMethodTmp = call.Operand as MethodDefinition;
+				var initMethodTmp = call.Operand as MethodDef;
 				ObfuscatorVersion obfuscatorVersionTmp;
 				if (!checkInitMethod(initMethodTmp, out obfuscatorVersionTmp))
 					continue;
@@ -118,7 +117,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			"System.Collections.Generic.List`1<System.Delegate>",
 			"System.Runtime.InteropServices.GCHandle",
 		};
-		bool checkInitMethod(MethodDefinition initMethod, out ObfuscatorVersion obfuscatorVersionTmp) {
+		bool checkInitMethod(MethodDef initMethod, out ObfuscatorVersion obfuscatorVersionTmp) {
 			obfuscatorVersionTmp = ObfuscatorVersion.Unknown;
 
 			if (initMethod == null)
@@ -146,7 +145,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return true;
 		}
 
-		static bool hasCodeString(MethodDefinition method, string str) {
+		static bool hasCodeString(MethodDef method, string str) {
 			foreach (var s in DotNetUtils.getCodeStrings(method)) {
 				if (s == str)
 					return true;
@@ -154,22 +153,23 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return false;
 		}
 
-		bool checkMethodsType(TypeDefinition type) {
-			rvas = new List<int>();
+		bool checkMethodsType(TypeDef type) {
+			rvas = new List<uint>();
 
 			var fields = getRvaFields(type);
 			if (fields.Count < 2)	// RVAs for executive and stub are always present if encrypted methods
 				return true;
 
 			foreach (var field in fields)
-				rvas.Add(field.RVA);
+				rvas.Add((uint)field.RVA);
 			return true;
 		}
 
-		static List<FieldDefinition> getRvaFields(TypeDefinition type) {
-			var fields = new List<FieldDefinition>();
+		static List<FieldDef> getRvaFields(TypeDef type) {
+			var fields = new List<FieldDef>();
 			foreach (var field in type.Fields) {
-				if (field.FieldType.EType != ElementType.U1 && field.FieldType.EType != ElementType.U4)
+				var etype = field.FieldSig.GetFieldType().GetElementType();
+				if (etype != ElementType.U1 && etype != ElementType.U4)
 					continue;
 				if (field.RVA == 0)
 					continue;
@@ -187,7 +187,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			otherInitMethods = findOtherInitMethods();
 		}
 
-		MethodDefinition findTamperCheckMethod() {
+		MethodDef findTamperCheckMethod() {
 			foreach (var method in theType.Methods) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
@@ -200,8 +200,8 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return null;
 		}
 
-		List<MethodDefinition> findOtherInitMethods() {
-			var list = new List<MethodDefinition>();
+		List<MethodDef> findOtherInitMethods() {
+			var list = new List<MethodDef>();
 			foreach (var method in theType.Methods) {
 				if (!method.IsStatic)
 					continue;
@@ -215,7 +215,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return list;
 		}
 
-		public MethodDefinition getInitStringDecrypterMethod(MethodDefinition stringDecrypterInitMethod) {
+		public MethodDef getInitStringDecrypterMethod(MethodDef stringDecrypterInitMethod) {
 			if (stringDecrypterInitMethod == null)
 				return null;
 			if (theType == null)
@@ -230,7 +230,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return null;
 		}
 
-		bool callsMethod(MethodDefinition methodToCheck, MethodDefinition calledMethod) {
+		bool callsMethod(MethodDef methodToCheck, MethodDef calledMethod) {
 			foreach (var method in DotNetUtils.getCalledMethods(module, methodToCheck)) {
 				if (method == calledMethod)
 					return true;
diff --git a/de4dot.code/deobfuscators/CodeVeil/MethodsDecrypter.cs b/de4dot.code/deobfuscators/CodeVeil/MethodsDecrypter.cs
index b4520ede..dc6e1af7 100644
--- a/de4dot.code/deobfuscators/CodeVeil/MethodsDecrypter.cs
+++ b/de4dot.code/deobfuscators/CodeVeil/MethodsDecrypter.cs
@@ -20,10 +20,8 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.Cecil.Metadata;
-using Mono.MyStuff;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 using de4dot.PE;
 
@@ -162,6 +160,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 
 				var dm = new DumpedMethod();
 				dm.token = (uint)(0x06000001 + i);
+				dm.mdRVA = peImage.offsetRead(methodDefOffset + (uint)methodDef.fields[0].offset, methodDef.fields[0].size);
 				dm.mdImplFlags = peImage.offsetReadUInt16(methodDefOffset + (uint)methodDef.fields[1].offset);
 				dm.mdFlags = peImage.offsetReadUInt16(methodDefOffset + (uint)methodDef.fields[2].offset);
 				dm.mdName = peImage.offsetRead(methodDefOffset + (uint)methodDef.fields[3].offset, methodDef.fields[3].size);
@@ -225,7 +224,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 					return null;
 
 				// rva is 0 when the assembly has been embedded
-				int rva = BitConverter.ToInt32(fileData, offset + RVA_EXECUTIVE_OFFSET);
+				uint rva = BitConverter.ToUInt32(fileData, offset + RVA_EXECUTIVE_OFFSET);
 				if (rva != 0 && mainType.Rvas.IndexOf(rva) < 0)
 					continue;
 
diff --git a/de4dot.code/deobfuscators/CodeVeil/ProxyCallFixer.cs b/de4dot.code/deobfuscators/CodeVeil/ProxyCallFixer.cs
index e5d3bc1f..e9310f17 100644
--- a/de4dot.code/deobfuscators/CodeVeil/ProxyCallFixer.cs
+++ b/de4dot.code/deobfuscators/CodeVeil/ProxyCallFixer.cs
@@ -20,24 +20,24 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.Cecil.Metadata;
+using dot10.IO;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.CodeVeil {
 	class ProxyCallFixer : ProxyCallFixer1 {
 		MainType mainType;
 		Info info = new Info();
-		BinaryReader reader;
+		IBinaryReader reader;
 
 		class Info {
-			public TypeDefinition proxyType;
-			public MethodDefinition initMethod;
-			public FieldDefinition dataField;
-			public TypeDefinition ilgeneratorType;
-			public TypeDefinition fieldInfoType;
-			public TypeDefinition methodInfoType;
+			public TypeDef proxyType;
+			public MethodDef initMethod;
+			public FieldDef dataField;
+			public TypeDef ilgeneratorType;
+			public TypeDef fieldInfoType;
+			public TypeDef methodInfoType;
 		}
 
 		class Context {
@@ -61,24 +61,24 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			}
 		}
 
-		public TypeDefinition IlGeneratorType {
+		public TypeDef IlGeneratorType {
 			get { return info.ilgeneratorType; }
 		}
 
-		public TypeDefinition FieldInfoType {
+		public TypeDef FieldInfoType {
 			get { return info.fieldInfoType; }
 		}
 
-		public TypeDefinition MethodInfoType {
+		public TypeDef MethodInfoType {
 			get { return info.methodInfoType; }
 		}
 
-		public ProxyCallFixer(ModuleDefinition module, MainType mainType)
+		public ProxyCallFixer(ModuleDefMD module, MainType mainType)
 			: base(module) {
 			this.mainType = mainType;
 		}
 
-		public ProxyCallFixer(ModuleDefinition module, MainType mainType, ProxyCallFixer oldOne)
+		public ProxyCallFixer(ModuleDefMD module, MainType mainType, ProxyCallFixer oldOne)
 			: base(module, oldOne) {
 			this.mainType = mainType;
 			info.proxyType = lookup(oldOne.info.proxyType, "Could not find proxyType");
@@ -89,11 +89,11 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			info.methodInfoType = lookup(oldOne.info.methodInfoType, "Could not find methodInfoType");
 		}
 
-		protected override object checkCctor(ref TypeDefinition type, MethodDefinition cctor) {
+		protected override object checkCctor(ref TypeDef type, MethodDef cctor) {
 			var instrs = cctor.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 1; i++) {
 				var ldci4 = instrs[i];
-				if (!DotNetUtils.isLdcI4(ldci4))
+				if (!ldci4.IsLdcI4())
 					continue;
 
 				var call = instrs[i + 1];
@@ -102,27 +102,27 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 				if (call.Operand != info.initMethod)
 					continue;
 
-				int offset = DotNetUtils.getLdcI4Value(ldci4);
-				reader.BaseStream.Position = offset;
-				int rid = DeobUtils.readVariableLengthInt32(reader);
-				if (rid != type.MetadataToken.RID)
+				int offset = ldci4.GetLdcI4Value();
+				reader.Position = offset;
+				uint rid = reader.ReadCompressedUInt32();
+				if (rid != type.Rid)
 					throw new ApplicationException("Invalid RID");
 				return string.Empty;	// It's non-null
 			}
 			return null;
 		}
 
-		protected override void getCallInfo(object context, FieldDefinition field, out MethodReference calledMethod, out OpCode callOpcode) {
+		protected override void getCallInfo(object context, FieldDef field, out IMethod calledMethod, out OpCode callOpcode) {
 			byte flags = reader.ReadByte();
 
-			int methodToken = 0x06000000 + ((flags & 0x3F) << 24) + DeobUtils.readVariableLengthInt32(reader);
-			int genericTypeToken = (flags & 0x40) == 0 ? -1 : 0x1B000000 + DeobUtils.readVariableLengthInt32(reader);
+			int methodToken = 0x06000000 + ((flags & 0x3F) << 24) + (int)reader.ReadCompressedUInt32();
+			int genericTypeToken = (flags & 0x40) == 0 ? -1 : 0x1B000000 + (int)reader.ReadCompressedUInt32();
 			callOpcode = (flags & 0x80) != 0 ? OpCodes.Callvirt : OpCodes.Call;
 
-			calledMethod = module.LookupToken(methodToken) as MethodReference;
+			calledMethod = module.ResolveToken(methodToken) as IMethod;
 			if (calledMethod == null)
 				throw new ApplicationException("Could not find method");
-			if (genericTypeToken != -1 && calledMethod.DeclaringType.MetadataToken.ToInt32() != genericTypeToken)
+			if (genericTypeToken != -1 && calledMethod.DeclaringType.MDToken.ToInt32() != genericTypeToken)
 				throw new ApplicationException("Invalid declaring type token");
 		}
 
@@ -138,9 +138,9 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			setDelegateCreatorMethod(info.initMethod);
 		}
 
-		bool initializeInfo(Info infoTmp, TypeDefinition type) {
+		bool initializeInfo(Info infoTmp, TypeDef type) {
 			foreach (var dtype in type.NestedTypes) {
-				var cctor = DotNetUtils.getMethod(dtype, ".cctor");
+				var cctor = dtype.FindMethod(".cctor");
 				if (cctor == null)
 					continue;
 				if (!initProxyType(infoTmp, cctor))
@@ -152,7 +152,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return false;
 		}
 
-		bool initProxyType(Info infoTmp, MethodDefinition method) {
+		bool initProxyType(Info infoTmp, MethodDef method) {
 			foreach (var calledMethod in DotNetUtils.getCalledMethods(module, method)) {
 				if (!calledMethod.IsStatic)
 					continue;
@@ -175,7 +175,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			"System.Reflection.Emit.OpCode",
 			"System.Reflection.Emit.OpCode[]",
 		};
-		bool checkProxyType(Info infoTmp, TypeDefinition type) {
+		bool checkProxyType(Info infoTmp, TypeDef type) {
 			if (type.NestedTypes.Count != 1)
 				return false;
 
@@ -186,7 +186,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			if (fields.Count != 1)
 				return false;
 			var field = fields[0];
-			var fieldType = DotNetUtils.getType(module, field.FieldType);
+			var fieldType = DotNetUtils.getType(module, field.FieldSig.GetFieldType());
 			if (type.NestedTypes.IndexOf(fieldType) < 0)
 				return false;
 			if (field.InitialValue == null || field.InitialValue.Length == 0)
@@ -196,8 +196,8 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return true;
 		}
 
-		static List<FieldDefinition> getRvaFields(TypeDefinition type) {
-			var fields = new List<FieldDefinition>();
+		static List<FieldDef> getRvaFields(TypeDef type) {
+			var fields = new List<FieldDef>();
 			foreach (var field in type.Fields) {
 				if (field.RVA != 0)
 					fields.Add(field);
@@ -205,9 +205,9 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return fields;
 		}
 
-		protected override IEnumerable<TypeDefinition> getDelegateTypes() {
+		protected override IEnumerable<TypeDef> getDelegateTypes() {
 			if (!mainType.Detected)
-				return new List<TypeDefinition>();
+				return new List<TypeDef>();
 			return mainType.Type.NestedTypes;
 		}
 
@@ -218,9 +218,10 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			findOtherTypes();
 
 			var decompressed = DeobUtils.inflate(info.dataField.InitialValue, true);
-			reader = new BinaryReader(new MemoryStream(decompressed));
-			info.dataField.FieldType = module.TypeSystem.Byte;
+			reader = MemoryImageStream.Create(decompressed);
+			info.dataField.FieldSig.Type = module.CorLibTypes.Byte;
 			info.dataField.InitialValue = new byte[1];
+			info.dataField.RVA = 0;
 		}
 
 		void findOtherTypes() {
@@ -228,14 +229,15 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 				return;
 
 			foreach (var method in info.proxyType.Methods) {
-				if (method.Parameters.Count != 4)
+				var sig = method.MethodSig;
+				if (sig == null || sig.Params.Count != 4)
 					continue;
 
-				if (method.Parameters[2].ParameterType.FullName != "System.Type[]")
+				if (sig.Params[2].GetFullName() != "System.Type[]")
 					continue;
-				var methodType = method.Parameters[0].ParameterType as TypeDefinition;
-				var fieldType = method.Parameters[1].ParameterType as TypeDefinition;
-				var ilgType = method.Parameters[3].ParameterType as TypeDefinition;
+				var methodType = sig.Params[0].TryGetTypeDef();
+				var fieldType = sig.Params[1].TryGetTypeDef();
+				var ilgType = sig.Params[3].TryGetTypeDef();
 				if (!checkMethodType(methodType))
 					continue;
 				if (!checkFieldType(fieldType))
@@ -249,8 +251,8 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			}
 		}
 
-		bool checkMethodType(TypeDefinition type) {
-			if (type == null || type.BaseType == null || type.BaseType.EType != ElementType.Object)
+		bool checkMethodType(TypeDef type) {
+			if (type == null || type.BaseType == null || type.BaseType.FullName != "System.Object")
 				return false;
 			if (type.Fields.Count != 1)
 				return false;
@@ -260,8 +262,8 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return true;
 		}
 
-		bool checkFieldType(TypeDefinition type) {
-			if (type == null || type.BaseType == null || type.BaseType.EType != ElementType.Object)
+		bool checkFieldType(TypeDef type) {
+			if (type == null || type.BaseType == null || type.BaseType.FullName != "System.Object")
 				return false;
 			if (DotNetUtils.getField(type, "System.Reflection.FieldInfo") == null)
 				return false;
@@ -269,8 +271,8 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return true;
 		}
 
-		bool checkIlGeneratorType(TypeDefinition type) {
-			if (type == null || type.BaseType == null || type.BaseType.EType != ElementType.Object)
+		bool checkIlGeneratorType(TypeDef type) {
+			if (type == null || type.BaseType == null || type.BaseType.FullName != "System.Object")
 				return false;
 			if (type.Fields.Count != 1)
 				return false;
diff --git a/de4dot.code/deobfuscators/CodeVeil/ResourceConverter.cs b/de4dot.code/deobfuscators/CodeVeil/ResourceConverter.cs
index 2c79c9f9..34d2c3cf 100644
--- a/de4dot.code/deobfuscators/CodeVeil/ResourceConverter.cs
+++ b/de4dot.code/deobfuscators/CodeVeil/ResourceConverter.cs
@@ -19,16 +19,17 @@
 
 using System;
 using System.IO;
-using Mono.Cecil;
+using dot10.IO;
+using dot10.DotNet;
 using de4dot.code.resources;
 
 namespace de4dot.code.deobfuscators.CodeVeil {
 	class ResourceConverter {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		ResourceInfo[] infos;
 		ResourceDataCreator dataCreator;
 
-		public ResourceConverter(ModuleDefinition module, ResourceInfo[] infos) {
+		public ResourceConverter(ModuleDefMD module, ResourceInfo[] infos) {
 			this.module = module;
 			this.dataCreator = new ResourceDataCreator(module);
 			this.infos = infos;
@@ -46,7 +47,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 
 		ResourceElement convert(ResourceInfo info) {
 			var reader = info.dataReader;
-			reader.BaseStream.Position = info.offset;
+			reader.Position = info.offset;
 
 			IResourceData resourceData;
 			int type = (info.flags & 0x7F);
diff --git a/de4dot.code/deobfuscators/CodeVeil/ResourceDecrypter.cs b/de4dot.code/deobfuscators/CodeVeil/ResourceDecrypter.cs
index c08dcfa2..29509ffa 100644
--- a/de4dot.code/deobfuscators/CodeVeil/ResourceDecrypter.cs
+++ b/de4dot.code/deobfuscators/CodeVeil/ResourceDecrypter.cs
@@ -19,23 +19,23 @@
 
 using System;
 using System.IO;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.Cecil.Metadata;
+using dot10.IO;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.CodeVeil {
 	class ResourceDecrypter {
-		ModuleDefinition module;
-		TypeDefinition encryptedResourceStreamType;
-		TypeDefinition encryptedResourceSetType;
-		MethodDefinition encryptedResourceSet_GetDefaultReader;
-		TypeDefinition encryptedResourceReaderType;
-		GenericInstanceType encryptedResourceReaderTypeDict;
-		TypeDefinition resType;
-		MethodDefinition resTypeCtor;
-		TypeDefinition resourceFlagsType;
-		TypeDefinition resourceEnumeratorType;
+		ModuleDefMD module;
+		TypeDef encryptedResourceStreamType;
+		TypeDef encryptedResourceSetType;
+		MethodDef encryptedResourceSet_GetDefaultReader;
+		TypeDef encryptedResourceReaderType;
+		GenericInstSig encryptedResourceReaderTypeDict;
+		TypeDef resType;
+		MethodDef resTypeCtor;
+		TypeDef resourceFlagsType;
+		TypeDef resourceEnumeratorType;
 		MethodCallRestorerBase methodsRestorer;
 
 		public bool CanRemoveTypes {
@@ -49,31 +49,31 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			}
 		}
 
-		public TypeDefinition EncryptedResourceStreamType {
+		public TypeDef EncryptedResourceStreamType {
 			get { return encryptedResourceStreamType; }
 		}
 
-		public TypeDefinition EncryptedResourceSetType {
+		public TypeDef EncryptedResourceSetType {
 			get { return encryptedResourceSetType; }
 		}
 
-		public TypeDefinition EncryptedResourceReaderType {
+		public TypeDef EncryptedResourceReaderType {
 			get { return encryptedResourceReaderType; }
 		}
 
-		public TypeDefinition ResType {
+		public TypeDef ResType {
 			get { return resType; }
 		}
 
-		public TypeDefinition ResourceFlagsType {
+		public TypeDef ResourceFlagsType {
 			get { return resourceFlagsType; }
 		}
 
-		public TypeDefinition ResourceEnumeratorType {
+		public TypeDef ResourceEnumeratorType {
 			get { return resourceEnumeratorType; }
 		}
 
-		public ResourceDecrypter(ModuleDefinition module) {
+		public ResourceDecrypter(ModuleDefMD module) {
 			this.module = module;
 		}
 
@@ -100,18 +100,19 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			foreach (var type in module.Types) {
 				if (type.Namespace != "")
 					continue;
-				if (type.BaseType == null || type.BaseType.EType != ElementType.Object)
+				if (type.BaseType == null || type.BaseType.FullName != "System.Object")
 					continue;
 				if (!hasInterface(type, "System.Collections.IDictionaryEnumerator"))
 					continue;
 				if (!new FieldTypes(type).all(resourceEnumeratorType_fields))
 					continue;
-				var ctor = DotNetUtils.getMethod(type, ".ctor");
+				var ctor = type.FindMethod(".ctor");
 				if (ctor == null)
 					continue;
-				if (ctor.Parameters.Count != 1)
+				var sig = ctor.MethodSig;
+				if (sig == null || sig.Params.Count != 1)
 					continue;
-				if (ctor.Parameters[0].ParameterType != encryptedResourceReaderType)
+				if (sig.Params[0].TryGetTypeDef() != encryptedResourceReaderType)
 					continue;
 
 				resourceEnumeratorType = type;
@@ -120,9 +121,12 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 		}
 
 		void findResourceFlags() {
-			if (resTypeCtor == null || resTypeCtor.Parameters.Count != 4)
+			if (resTypeCtor == null)
 				return;
-			var type = resTypeCtor.Parameters[2].ParameterType as TypeDefinition;
+			var sig = resTypeCtor.MethodSig;
+			if (sig == null || sig.Params.Count != 4)
+				return;
+			var type = sig.Params[2].TryGetTypeDef();
 			if (type == null || !type.IsEnum)
 				return;
 
@@ -137,13 +141,16 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 		void findResType() {
 			if (encryptedResourceReaderTypeDict == null)
 				return;
-			var type = encryptedResourceReaderTypeDict.GenericArguments[1] as TypeDefinition;
+			var type = encryptedResourceReaderTypeDict.GenericArguments[1].TryGetTypeDef();
 			if (type == null)
 				return;
-			if (type.BaseType == null || type.BaseType.EType != ElementType.Object)
+			if (type.BaseType == null || type.BaseType.FullName != "System.Object")
 				return;
-			var ctor = DotNetUtils.getMethod(type, ".ctor");
-			if (ctor == null || ctor.Parameters.Count != 4)
+			var ctor = type.FindMethod(".ctor");
+			if (ctor == null)
+				return;
+			var sig = ctor.MethodSig;
+			if (sig == null || sig.Params.Count != 4)
 				return;
 
 			resTypeCtor = ctor;
@@ -175,39 +182,39 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			encryptedResourceReaderTypeDict = dictType;
 		}
 
-		static bool hasInterface(TypeDefinition type, string interfaceFullName) {
+		static bool hasInterface(TypeDef type, string interfaceFullName) {
 			foreach (var iface in type.Interfaces) {
-				if (iface.FullName == interfaceFullName)
+				if (iface.Interface.FullName == interfaceFullName)
 					return true;
 			}
 			return false;
 		}
 
-		static GenericInstanceType getDlxResDict(TypeDefinition type) {
+		static GenericInstSig getDlxResDict(TypeDef type) {
 			foreach (var field in type.Fields) {
-				var fieldType = field.FieldType as GenericInstanceType;
+				var fieldType = field.FieldSig.GetFieldType().ToGenericInstSig();
 				if (fieldType == null)
 					continue;
-				if (fieldType.ElementType.FullName != "System.Collections.Generic.Dictionary`2")
+				if (fieldType.GenericType.FullName != "System.Collections.Generic.Dictionary`2")
 					continue;
 				if (fieldType.GenericArguments.Count != 2)
 					continue;
 				if (fieldType.GenericArguments[0].FullName != "System.String")
 					continue;
-				if (!(fieldType.GenericArguments[1] is TypeDefinition))
+				if (fieldType.GenericArguments[1].TryGetTypeDef() == null)
 					continue;
 				return fieldType;
 			}
 			return null;
 		}
 
-		static TypeDefinition getTypeFromCode(MethodDefinition method) {
+		static TypeDef getTypeFromCode(MethodDef method) {
 			if (method == null || method.Body == null)
 				return null;
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Ldtoken)
 					continue;
-				var type = instr.Operand as TypeDefinition;
+				var type = instr.Operand as TypeDef;
 				if (type != null)
 					return type;
 			}
@@ -221,10 +228,10 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 					continue;
 				if (type.BaseType == null || type.BaseType.FullName != "System.Resources.ResourceSet")
 					continue;
-				var ctor = DotNetUtils.getMethod(type, ".ctor");
+				var ctor = type.FindMethod(".ctor");
 				if (!DotNetUtils.isMethod(ctor, "System.Void", "(System.Resources.IResourceReader)"))
 					continue;
-				var method = DotNetUtils.getMethod(type, "GetDefaultReader");
+				var method = type.FindMethod("GetDefaultReader");
 				if (!DotNetUtils.isMethod(method, "System.Type", "()"))
 					continue;
 				if (method.Body == null || method.IsStatic || !method.IsVirtual)
@@ -252,7 +259,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 					continue;
 				if (type.BaseType == null || type.BaseType.FullName != "System.IO.Stream")
 					continue;
-				var ctor = DotNetUtils.getMethod(type, ".ctor");
+				var ctor = type.FindMethod(".ctor");
 				if (!DotNetUtils.isMethod(ctor, "System.Void", "(System.IO.Stream)"))
 					continue;
 				if (!new FieldTypes(type).all(encryptedResourceStreamType_fields))
@@ -260,7 +267,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 				if (findXxteaMethod(type) == null)
 					continue;
 
-				MethodDefinition getManifestResourceStreamMethodTmp1, getManifestResourceStreamMethodTmp2;
+				MethodDef getManifestResourceStreamMethodTmp1, getManifestResourceStreamMethodTmp2;
 				if (!findManifestResourceStreamMethods(type, out getManifestResourceStreamMethodTmp1, out getManifestResourceStreamMethodTmp2))
 					continue;
 
@@ -271,7 +278,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			}
 		}
 
-		static MethodDefinition findXxteaMethod(TypeDefinition type) {
+		static MethodDef findXxteaMethod(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (!method.IsPrivate || method.IsStatic || method.Body == null)
 					continue;
@@ -292,7 +299,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return null;
 		}
 
-		static bool findManifestResourceStreamMethods(TypeDefinition type, out MethodDefinition getManifestResourceStreamMethodTmp1, out MethodDefinition getManifestResourceStreamMethodTmp2) {
+		static bool findManifestResourceStreamMethods(TypeDef type, out MethodDef getManifestResourceStreamMethodTmp1, out MethodDef getManifestResourceStreamMethodTmp2) {
 			getManifestResourceStreamMethodTmp1 = null;
 			getManifestResourceStreamMethodTmp2 = null;
 			foreach (var method in type.Methods) {
@@ -312,21 +319,20 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 				if (resource == null)
 					continue;
 
-				var decrypted = decrypt(resource.GetResourceStream());
+				var decrypted = decrypt(resource.Data);
 				if (decrypted == null)
 					continue;
 
-				Log.v("Decrypted resource {0}", Utils.toCsharpString(resource.Name));
-				module.Resources[i] = new EmbeddedResource(resource.Name, resource.Attributes, decrypted);
+				Logger.v("Decrypted resource {0}", Utils.toCsharpString(resource.Name));
+				module.Resources[i] = new EmbeddedResource(resource.Name, decrypted, resource.Attributes);
 			}
 		}
 
-		byte[] decrypt(Stream stream) {
+		byte[] decrypt(IBinaryReader reader) {
 			try {
-				stream.Position = 0;
-				var reader = new BinaryReader(stream);
+				reader.Position = 0;
 				uint sig = reader.ReadUInt32();
-				stream.Position = 0;
+				reader.Position = 0;
 				if (sig == 0xBEEFCACE)
 					return decryptBeefcace(reader);
 				if (sig == 0x58455245)
@@ -337,18 +343,18 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 				return null;
 			}
 			catch (Exception ex) {
-				Log.w("Got an exception when decrypting resources: {0} - {1}", ex.GetType(), ex.Message);
+				Logger.w("Got an exception when decrypting resources: {0} - {1}", ex.GetType(), ex.Message);
 				return null;
 			}
 		}
 
-		byte[] decryptBeefcace(BinaryReader reader) {
+		byte[] decryptBeefcace(IBinaryReader reader) {
 			var resourceReader = new ResourceReader(reader);
 			return new ResourceConverter(module, resourceReader.read()).convert();
 		}
 
-		byte[] decryptErex(BinaryReader reader) {
-			return new ErexResourceReader(reader.BaseStream).decrypt();
+		byte[] decryptErex(IBinaryReader reader) {
+			return new ErexResourceReader(reader).decrypt();
 		}
 
 		public void deobfuscate(Blocks blocks) {
diff --git a/de4dot.code/deobfuscators/CodeVeil/ResourceInfo.cs b/de4dot.code/deobfuscators/CodeVeil/ResourceInfo.cs
index 291c5765..65698343 100644
--- a/de4dot.code/deobfuscators/CodeVeil/ResourceInfo.cs
+++ b/de4dot.code/deobfuscators/CodeVeil/ResourceInfo.cs
@@ -18,7 +18,7 @@
 */
 
 using System;
-using System.IO;
+using dot10.IO;
 
 namespace de4dot.code.deobfuscators.CodeVeil {
 	class ResourceInfo {
@@ -26,7 +26,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 		public byte flags;
 		public int offset;
 		public int length;
-		public BinaryReader dataReader;
+		public IBinaryReader dataReader;
 		public ResourceInfo(string name, byte flags, int offset, int length) {
 			this.name = name;
 			this.flags = flags;
diff --git a/de4dot.code/deobfuscators/CodeVeil/ResourceReader.cs b/de4dot.code/deobfuscators/CodeVeil/ResourceReader.cs
index 84b33378..ec286192 100644
--- a/de4dot.code/deobfuscators/CodeVeil/ResourceReader.cs
+++ b/de4dot.code/deobfuscators/CodeVeil/ResourceReader.cs
@@ -21,10 +21,11 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
+using dot10.IO;
 
 namespace de4dot.code.deobfuscators.CodeVeil {
 	class ResourceReader {
-		BinaryReader reader;
+		IBinaryReader reader;
 		string resourceReader;
 		string resourceSet;
 
@@ -36,12 +37,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			get { return resourceSet; }
 		}
 
-		public ResourceReader(Stream stream) {
-			stream.Position = 0;
-			reader = new BinaryReader(stream);
-		}
-
-		public ResourceReader(BinaryReader reader) {
+		public ResourceReader(IBinaryReader reader) {
 			this.reader = reader;
 		}
 
@@ -93,13 +89,13 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 				DeobUtils.xxteaDecrypt(encryptedData, key);
 				byte[] decryptedData = new byte[encryptedData.Length * 4];
 				Buffer.BlockCopy(encryptedData, 0, decryptedData, 0, decryptedData.Length);
-				dataReader = new BinaryReader(new MemoryStream(decryptedData));
+				dataReader = MemoryImageStream.Create(decryptedData);
 			}
 
 			if (inflateData) {
-				var data = dataReader.ReadBytes((int)(dataReader.BaseStream.Length - dataReader.BaseStream.Position));
+				var data = dataReader.ReadRemainingBytes();
 				data = DeobUtils.inflate(data, true);
-				dataReader = new BinaryReader(new MemoryStream(data));
+				dataReader = MemoryImageStream.Create(data);
 			}
 
 			foreach (var info in infos)
@@ -108,7 +104,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return infos;
 		}
 
-		static string readResourceName(BinaryReader reader, bool encrypted) {
+		static string readResourceName(IBinaryReader reader, bool encrypted) {
 			if (!encrypted)
 				return reader.ReadString();
 
diff --git a/de4dot.code/deobfuscators/CodeVeil/StringDecrypter.cs b/de4dot.code/deobfuscators/CodeVeil/StringDecrypter.cs
index c959bce4..12753dce 100644
--- a/de4dot.code/deobfuscators/CodeVeil/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/CodeVeil/StringDecrypter.cs
@@ -19,42 +19,43 @@
 
 using System;
 using System.IO;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.IO;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.CodeVeil {
 	class StringDecrypter {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		MainType mainType;
-		TypeDefinition decrypterType;
-		FieldDefinition stringDataField;
-		MethodDefinition initMethod;
-		MethodDefinition decrypterMethod;
+		TypeDef decrypterType;
+		FieldDef stringDataField;
+		MethodDef initMethod;
+		MethodDef decrypterMethod;
 		string[] decryptedStrings;
 
 		public bool Detected {
 			get { return decrypterType != null; }
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return decrypterType; }
 		}
 
-		public MethodDefinition InitMethod {
+		public MethodDef InitMethod {
 			get { return initMethod; }
 		}
 
-		public MethodDefinition DecryptMethod {
+		public MethodDef DecryptMethod {
 			get { return decrypterMethod; }
 		}
 
-		public StringDecrypter(ModuleDefinition module, MainType mainType) {
+		public StringDecrypter(ModuleDefMD module, MainType mainType) {
 			this.module = module;
 			this.mainType = mainType;
 		}
 
-		public StringDecrypter(ModuleDefinition module, MainType mainType, StringDecrypter oldOne) {
+		public StringDecrypter(ModuleDefMD module, MainType mainType, StringDecrypter oldOne) {
 			this.module = module;
 			this.mainType = mainType;
 			this.decrypterType = lookup(oldOne.decrypterType, "Could not find string decrypter type");
@@ -63,7 +64,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			this.decrypterMethod = lookup(oldOne.decrypterMethod, "Could not find string decrypter method");
 		}
 
-		T lookup<T>(T def, string errorMessage) where T : MemberReference {
+		T lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
 			return DeobUtils.lookup(module, def, errorMessage);
 		}
 
@@ -79,7 +80,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			findV5(cctor);
 		}
 
-		bool find(MethodDefinition method) {
+		bool find(MethodDef method) {
 			if (method == null || method.Body == null || !method.IsStatic)
 				return false;
 
@@ -88,7 +89,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 				var call = instrs[i];
 				if (call.OpCode.Code != Code.Call)
 					continue;
-				var initMethodTmp = call.Operand as MethodDefinition;
+				var initMethodTmp = call.Operand as MethodDef;
 				if (initMethodTmp == null || initMethodTmp.Body == null || !initMethodTmp.IsStatic)
 					continue;
 				if (!DotNetUtils.isMethod(initMethodTmp, "System.Void", "()"))
@@ -105,7 +106,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 		}
 
 		// The main decrypter type calls the string decrypter init method inside its init method
-		void findV5(MethodDefinition method) {
+		void findV5(MethodDef method) {
 			if (!mainType.Detected)
 				return;
 			foreach (var calledMethod in DotNetUtils.getCalledMethods(module, mainType.InitMethod)) {
@@ -114,14 +115,14 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			}
 		}
 
-		bool checkType(TypeDefinition type) {
+		bool checkType(TypeDef type) {
 			if (!type.HasNestedTypes)
 				return false;
 
 			var stringDataFieldTmp = checkFields(type);
 			if (stringDataFieldTmp == null)
 				return false;
-			var fieldType = DotNetUtils.getType(module, stringDataFieldTmp.FieldType);
+			var fieldType = DotNetUtils.getType(module, stringDataFieldTmp.FieldSig.GetFieldType());
 			if (fieldType == null || type.NestedTypes.IndexOf(fieldType) < 0)
 				return false;
 
@@ -134,8 +135,8 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return true;
 		}
 
-		static MethodDefinition getDecrypterMethod(TypeDefinition type) {
-			MethodDefinition foundMethod = null;
+		static MethodDef getDecrypterMethod(TypeDef type) {
+			MethodDef foundMethod = null;
 			foreach (var method in type.Methods) {
 				if (method.Body == null || !method.IsStatic)
 					continue;
@@ -155,11 +156,11 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			"System.String[]",
 			"System.UInt32[]",
 		};
-		FieldDefinition checkFields(TypeDefinition type) {
+		FieldDef checkFields(TypeDef type) {
 			if (!new FieldTypes(type).all(requiredFields))
 				return null;
 
-			FieldDefinition stringData = null;
+			FieldDef stringData = null;
 			foreach (var field in type.Fields) {
 				if (field.RVA != 0) {
 					if (stringData != null)
@@ -189,17 +190,18 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 
 			decryptStrings(key);
 
-			stringDataField.FieldType = module.TypeSystem.Byte;
+			stringDataField.FieldSig.Type = module.CorLibTypes.Byte;
 			stringDataField.InitialValue = new byte[1];
+			stringDataField.RVA = 0;
 		}
 
-		static uint[] getKey(MethodDefinition method) {
+		static uint[] getKey(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 1; i++) {
 				var ldci4 = instrs[i];
-				if (!DotNetUtils.isLdcI4(ldci4))
+				if (!ldci4.IsLdcI4())
 					continue;
-				if (DotNetUtils.getLdcI4Value(ldci4) != 4)
+				if (ldci4.GetLdcI4Value() != 4)
 					continue;
 
 				if (instrs[i + 1].OpCode.Code != Code.Newarr)
@@ -225,16 +227,16 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			Buffer.BlockCopy(encryptedData, 0, decryptedData, 0, data.Length);
 
 			var inflated = DeobUtils.inflate(decryptedData, 0, decryptedData.Length, true);
-			var reader = new BinaryReader(new MemoryStream(inflated));
-			int deflatedLength = DeobUtils.readVariableLengthInt32(reader);
-			int numStrings = DeobUtils.readVariableLengthInt32(reader);
+			var reader = MemoryImageStream.Create(inflated);
+			int deflatedLength = (int)reader.ReadCompressedUInt32();
+			int numStrings = (int)reader.ReadCompressedUInt32();
 			decryptedStrings = new string[numStrings];
 			var offsets = new int[numStrings];
 			for (int i = 0; i < numStrings; i++)
-				offsets[i] = DeobUtils.readVariableLengthInt32(reader);
-			int startOffset = (int)reader.BaseStream.Position;
+				offsets[i] = (int)reader.ReadCompressedUInt32();
+			int startOffset = (int)reader.Position;
 			for (int i = 0; i < numStrings; i++) {
-				reader.BaseStream.Position = startOffset + offsets[i];
+				reader.Position = startOffset + offsets[i];
 				decryptedStrings[i] = reader.ReadString();
 			}
 		}
diff --git a/de4dot.code/deobfuscators/CodeVeil/TamperDetection.cs b/de4dot.code/deobfuscators/CodeVeil/TamperDetection.cs
index b55245c9..8577517d 100644
--- a/de4dot.code/deobfuscators/CodeVeil/TamperDetection.cs
+++ b/de4dot.code/deobfuscators/CodeVeil/TamperDetection.cs
@@ -18,27 +18,26 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.Cecil.Metadata;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.CodeVeil {
 	class TamperDetection {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		MainType mainType;
-		TypeDefinition tamperDetectionType;
-		List<MethodDefinition> tamperDetectionMethods = new List<MethodDefinition>();
+		TypeDef tamperDetectionType;
+		List<MethodDef> tamperDetectionMethods = new List<MethodDef>();
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return tamperDetectionType; }
 		}
 
-		public List<MethodDefinition> Methods {
+		public List<MethodDef> Methods {
 			get { return tamperDetectionMethods; }
 		}
 
-		public TamperDetection(ModuleDefinition module, MainType mainType) {
+		public TamperDetection(ModuleDefMD module, MainType mainType) {
 			this.module = module;
 			this.mainType = mainType;
 		}
@@ -82,7 +81,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			}
 		}
 
-		bool checkTamperDetectionClasses(IEnumerable<TypeDefinition> types) {
+		bool checkTamperDetectionClasses(IEnumerable<TypeDef> types) {
 			foreach (var type in types) {
 				if (!isTamperDetectionClass(type))
 					return false;
@@ -90,13 +89,13 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return true;
 		}
 
-		bool isTamperDetectionClass(TypeDefinition type) {
-			if (type.BaseType == null || type.BaseType.EType != ElementType.Object)
+		bool isTamperDetectionClass(TypeDef type) {
+			if (type.BaseType == null || type.BaseType.FullName != "System.Object")
 				return false;
 			if ((type.Attributes & ~TypeAttributes.Sealed) != TypeAttributes.NestedAssembly)
 				return false;
 
-			MethodDefinition cctor = null, initMethod = null;
+			MethodDef cctor = null, initMethod = null;
 			foreach (var method in type.Methods) {
 				if (InvalidMethodsFinder.isInvalidMethod(method))
 					continue;
@@ -116,7 +115,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return true;
 		}
 
-		bool callsMainTypeTamperCheckMethod(MethodDefinition method) {
+		bool callsMainTypeTamperCheckMethod(MethodDef method) {
 			foreach (var calledMethod in DotNetUtils.getCalledMethods(module, method)) {
 				if (calledMethod == mainType.TamperCheckMethod)
 					return true;
@@ -142,7 +141,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 		}
 
 		static bool checkInvokeCall(Instruction instr, string returnType, string parameters) {
-			var method = instr.Operand as MethodDefinition;
+			var method = instr.Operand as MethodDef;
 			if (method == null)
 				return false;
 			if (method.Name != "Invoke")
diff --git a/de4dot.code/deobfuscators/CodeWall/AssemblyDecrypter.cs b/de4dot.code/deobfuscators/CodeWall/AssemblyDecrypter.cs
index 6d59bfa7..fd82771d 100644
--- a/de4dot.code/deobfuscators/CodeWall/AssemblyDecrypter.cs
+++ b/de4dot.code/deobfuscators/CodeWall/AssemblyDecrypter.cs
@@ -22,14 +22,14 @@ using System.Collections.Generic;
 using System.IO;
 using System.Security.Cryptography;
 using System.Text;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 using de4dot.code.resources;
 
 namespace de4dot.code.deobfuscators.CodeWall {
 	class AssemblyDecrypter {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		ISimpleDeobfuscator simpleDeobfuscator;
 		IDeobfuscator deob;
 		List<AssemblyInfo> assemblyInfos = new List<AssemblyInfo>();
@@ -37,7 +37,7 @@ namespace de4dot.code.deobfuscators.CodeWall {
 		string resourcePassword;
 		string resourceSalt;
 		EmbeddedResource assemblyResource;
-		ModuleDefinition resourceModule;
+		ModuleDefMD resourceModule;
 
 		public class AssemblyInfo {
 			public readonly byte[] data;
@@ -63,7 +63,7 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			get { return assemblyInfos; }
 		}
 
-		public AssemblyDecrypter(ModuleDefinition module, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
+		public AssemblyDecrypter(ModuleDefMD module, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
 			this.module = module;
 			this.simpleDeobfuscator = simpleDeobfuscator;
 			this.deob = deob;
@@ -74,13 +74,13 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			if (!checkEntryPoint(method))
 				return;
 
-			MethodDefinition decryptAssemblyMethod;
+			MethodDef decryptAssemblyMethod;
 			var mainKey = getMainResourceKey(method, out decryptAssemblyMethod);
 			if (mainKey == null)
 				return;
 
 			deobfuscateAll(decryptAssemblyMethod);
-			ModuleDefinition theResourceModule;
+			ModuleDefMD theResourceModule;
 			var resource = getResource(decryptAssemblyMethod, out theResourceModule);
 			if (resource == null)
 				return;
@@ -100,7 +100,7 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			"System.AppDomain",
 			"System.DateTime",
 		};
-		bool checkEntryPoint(MethodDefinition method) {
+		bool checkEntryPoint(MethodDef method) {
 			if (method == null)
 				return false;
 			if (!new LocalTypes(method).all(requiredLocals))
@@ -112,12 +112,12 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			return true;
 		}
 
-		void deobfuscateAll(MethodDefinition method) {
+		void deobfuscateAll(MethodDef method) {
 			simpleDeobfuscator.deobfuscate(method);
 			simpleDeobfuscator.decryptStrings(method, deob);
 		}
 
-		string getMainResourceKey(MethodDefinition method, out MethodDefinition decryptAssemblyMethod) {
+		string getMainResourceKey(MethodDef method, out MethodDef decryptAssemblyMethod) {
 			foreach (var calledMethod in DotNetUtils.getCalledMethods(module, method)) {
 				if (!calledMethod.IsStatic || calledMethod.Body == null)
 					continue;
@@ -135,7 +135,7 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			return null;
 		}
 
-		string getMainResourceKeyInfo(MethodDefinition method, out MethodDefinition decryptAssemblyMethod) {
+		string getMainResourceKeyInfo(MethodDef method, out MethodDef decryptAssemblyMethod) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 1; i++) {
 				var ldstr = instrs[i];
@@ -144,7 +144,7 @@ namespace de4dot.code.deobfuscators.CodeWall {
 				var call = instrs[i + 1];
 				if (call.OpCode.Code != Code.Call)
 					continue;
-				var calledMethod = call.Operand as MethodDefinition;
+				var calledMethod = call.Operand as MethodDef;
 				if (calledMethod == null)
 					continue;
 
@@ -155,7 +155,7 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			return null;
 		}
 
-		EmbeddedResource getResource(MethodDefinition method, out ModuleDefinition theResourceModule) {
+		EmbeddedResource getResource(MethodDef method, out ModuleDefMD theResourceModule) {
 			string resourceDllFileName = null;
 			theResourceModule = module;
 			foreach (var s in DotNetUtils.getCodeStrings(method)) {
@@ -182,17 +182,17 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			return null;
 		}
 
-		ModuleDefinition getResourceModule(string name) {
+		ModuleDefMD getResourceModule(string name) {
 			try {
-				var resourceDllFileName = Path.Combine(Path.GetDirectoryName(module.FullyQualifiedName), name.Substring(1));
-				return ModuleDefinition.ReadModule(resourceDllFileName);
+				var resourceDllFileName = Path.Combine(Path.GetDirectoryName(module.Location), name.Substring(1));
+				return ModuleDefMD.Load(resourceDllFileName);
 			}
 			catch {
 				return null;
 			}
 		}
 
-		bool getPassword(MethodDefinition method, out string password, out string salt) {
+		bool getPassword(MethodDef method, out string password, out string salt) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 1; i++) {
 				var ldstr1 = instrs[i];
@@ -217,15 +217,15 @@ namespace de4dot.code.deobfuscators.CodeWall {
 		void decryptAllAssemblies() {
 			if (assemblyResource == null)
 				return;
-			var resourceSet = ResourceReader.read(resourceModule, assemblyResource.GetResourceStream());
+			var resourceSet = ResourceReader.read(resourceModule, assemblyResource.Data);
 			foreach (var resourceElement in resourceSet.ResourceElements) {
 				if (resourceElement.ResourceData.Code != ResourceTypeCode.ByteArray)
 					throw new ApplicationException("Invalid resource");
 				var resourceData = (BuiltInResourceData)resourceElement.ResourceData;
 				var assemblyData = decrypt((byte[])resourceData.Data);
-				var theModule = ModuleDefinition.ReadModule(new MemoryStream(assemblyData));
+				var theModule = ModuleDefMD.Load(assemblyData);
 				bool isMain = resourceElement.Name == entryPointAssemblyKey;
-				assemblyInfos.Add(new AssemblyInfo(assemblyData, DeobUtils.getExtension(theModule.Kind), theModule.Assembly.FullName, theModule.Assembly.Name.Name, isMain));
+				assemblyInfos.Add(new AssemblyInfo(assemblyData, DeobUtils.getExtension(theModule.Kind), theModule.Assembly.FullName, theModule.Assembly.Name.String, isMain));
 			}
 		}
 
diff --git a/de4dot.code/deobfuscators/CodeWall/Deobfuscator.cs b/de4dot.code/deobfuscators/CodeWall/Deobfuscator.cs
index b98f1e71..f510de27 100644
--- a/de4dot.code/deobfuscators/CodeWall/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/CodeWall/Deobfuscator.cs
@@ -19,8 +19,7 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.MyStuff;
+using dot10.DotNet;
 using de4dot.blocks;
 using de4dot.PE;
 
@@ -194,7 +193,7 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			return asmInfo.data;
 		}
 
-		public override IDeobfuscator moduleReloaded(ModuleDefinition module) {
+		public override IDeobfuscator moduleReloaded(ModuleDefMD module) {
 			var newOne = new Deobfuscator(options);
 			newOne.setModule(module);
 			newOne.methodsDecrypter = new MethodsDecrypter(module);
@@ -209,7 +208,6 @@ namespace de4dot.code.deobfuscators.CodeWall {
 
 		public override void deobfuscateBegin() {
 			base.deobfuscateBegin();
-			addAssemblyReferenceToBeRemoved(methodsDecrypter.AssemblyNameReference, "Obfuscator decrypter DLL reference");
 
 			initializeStringDecrypter();
 			initializeAssemblyDecrypter();
@@ -263,7 +261,7 @@ namespace de4dot.code.deobfuscators.CodeWall {
 		public override IEnumerable<int> getStringDecrypterMethods() {
 			var list = new List<int>();
 			foreach (var info in stringDecrypter.Infos)
-				list.Add(info.Method.MetadataToken.ToInt32());
+				list.Add(info.Method.MDToken.ToInt32());
 			return list;
 		}
 	}
diff --git a/de4dot.code/deobfuscators/CodeWall/MethodsDecrypter.cs b/de4dot.code/deobfuscators/CodeWall/MethodsDecrypter.cs
index 672d3dd6..d979cb1d 100644
--- a/de4dot.code/deobfuscators/CodeWall/MethodsDecrypter.cs
+++ b/de4dot.code/deobfuscators/CodeWall/MethodsDecrypter.cs
@@ -18,9 +18,8 @@
 */
 
 using System;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.MyStuff;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.PE;
 using de4dot.blocks;
 
@@ -29,18 +28,14 @@ namespace de4dot.code.deobfuscators.CodeWall {
 		static readonly byte[] newCodeHeader = new byte[6] { 0x2B, 4, 0, 0, 0, 0 };
 		static readonly byte[] decryptKey = new byte[10] { 0x8D, 0xB5, 0x2C, 0x3A, 0x1F, 0xC7, 0x31, 0xC3, 0xCD, 0x47 };
 
-		ModuleDefinition module;
-		MethodReference initMethod;
+		ModuleDefMD module;
+		IMethod initMethod;
 
 		public bool Detected {
 			get { return initMethod != null; }
 		}
 
-		public AssemblyNameReference AssemblyNameReference {
-			get { return initMethod == null ? null : (AssemblyNameReference)initMethod.DeclaringType.Scope; }
-		}
-
-		public MethodsDecrypter(ModuleDefinition module) {
+		public MethodsDecrypter(ModuleDefMD module) {
 			this.module = module;
 		}
 
@@ -51,14 +46,14 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			}
 		}
 
-		bool checkCctor(MethodDefinition method) {
+		bool checkCctor(MethodDef method) {
 			if (method == null || method.Body == null)
 				return false;
 
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Call)
 					continue;
-				var calledMethod = instr.Operand as MethodReference;
+				var calledMethod = instr.Operand as IMethod;
 				if (calledMethod == null)
 					continue;
 				if (calledMethod.DeclaringType.Scope == module)
@@ -105,6 +100,7 @@ namespace de4dot.code.deobfuscators.CodeWall {
 				else
 					decrypt(code, seed);
 
+				dm.mdRVA = peImage.offsetRead(methodDefOffset + (uint)methodDef.fields[0].offset, methodDef.fields[0].size);
 				dm.mdImplFlags = peImage.offsetReadUInt16(methodDefOffset + (uint)methodDef.fields[1].offset);
 				dm.mdFlags = peImage.offsetReadUInt16(methodDefOffset + (uint)methodDef.fields[2].offset);
 				dm.mdName = peImage.offsetRead(methodDefOffset + (uint)methodDef.fields[3].offset, methodDef.fields[3].size);
@@ -146,8 +142,8 @@ namespace de4dot.code.deobfuscators.CodeWall {
 					var instr = instrs[i];
 					if (instr.OpCode.Code != Code.Call)
 						continue;
-					var calledMethod = instr.Operand as MethodReference;
-					if (!MemberReferenceHelper.compareMethodReferenceAndDeclaringType(calledMethod, initMethod))
+					var calledMethod = instr.Operand as IMethod;
+					if (!MethodEqualityComparer.CompareDeclaringTypes.Equals(calledMethod, initMethod))
 						continue;
 					block.remove(i, 1);
 					i--;
diff --git a/de4dot.code/deobfuscators/CodeWall/StringDecrypter.cs b/de4dot.code/deobfuscators/CodeWall/StringDecrypter.cs
index 1d555420..02016b69 100644
--- a/de4dot.code/deobfuscators/CodeWall/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/CodeWall/StringDecrypter.cs
@@ -21,13 +21,14 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.IO;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.CodeWall {
 	class StringDecrypter {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		MethodDefinitionAndDeclaringTypeDict<StringEncrypterInfo> stringEncrypterInfos = new MethodDefinitionAndDeclaringTypeDict<StringEncrypterInfo>();
 		Version version;
 
@@ -38,13 +39,13 @@ namespace de4dot.code.deobfuscators.CodeWall {
 		}
 
 		public class StringEncrypterInfo {
-			MethodDefinition method;
+			MethodDef method;
 
-			public TypeDefinition Type {
+			public TypeDef Type {
 				get { return method.DeclaringType; }
 			}
 
-			public MethodDefinition Method {
+			public MethodDef Method {
 				get { return method; }
 			}
 
@@ -52,16 +53,16 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			public int Magic1 { get; set; }
 			public int Magic2 { get; set; }
 			public int Magic3 { get; set; }
-			public BinaryReader Reader { get; set; }
+			public IBinaryReader Reader { get; set; }
 
-			public StringEncrypterInfo(MethodDefinition method) {
+			public StringEncrypterInfo(MethodDef method) {
 				this.method = method;
 			}
 
 			public string decrypt(int magic1, int magic2, int magic3) {
 				int dataLen = magic3 ^ Magic3;
 				var key = getKey(magic1 ^ Magic1, dataLen);
-				Reader.BaseStream.Position = getDataOffset(magic2);
+				Reader.Position = getDataOffset(magic2);
 				var data = Reader.ReadBytes(dataLen);
 				for (int i = 0; i < dataLen; i++)
 					data[i] ^= key[i];
@@ -85,16 +86,14 @@ namespace de4dot.code.deobfuscators.CodeWall {
 
 			byte[] getPublicKeyToken() {
 				var module = method.Module;
-				if (module.Assembly == null || module.Assembly.Name.PublicKeyToken == null)
+				if (module.Assembly == null || PublicKeyBase.IsNullOrEmpty2(module.Assembly.PublicKey))
 					return null;
-				if (module.Assembly.Name.PublicKeyToken.Length != 8)
-					return null;
-				return module.Assembly.Name.PublicKeyToken;
+				return module.Assembly.PublicKeyToken.Data;
 			}
 
 			public override string ToString() {
 				return string.Format("{0:X8} M1:{1:X8} M2:{2:X8} M3:{3:X8}",
-						Method.MetadataToken.ToInt32(),
+						Method.MDToken.ToInt32(),
 						Magic1, Magic2, Magic3);
 			}
 		}
@@ -118,13 +117,13 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			}
 		}
 
-		public StringDecrypter(ModuleDefinition module) {
+		public StringDecrypter(ModuleDefMD module) {
 			this.module = module;
 		}
 
 		public void find() {
 			foreach (var type in module.Types) {
-				MethodDefinition decrypterMethod;
+				MethodDef decrypterMethod;
 				var decrypterVersion = checkType(type, out decrypterMethod);
 				if (decrypterVersion == Version.Unknown)
 					continue;
@@ -133,8 +132,8 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			}
 		}
 
-		Version checkType(TypeDefinition type, out MethodDefinition decrypterMethod) {
-			MethodDefinition method;
+		Version checkType(TypeDef type, out MethodDef decrypterMethod) {
+			MethodDef method;
 
 			if ((method = checkType_v30(type)) != null) {
 				decrypterMethod = method;
@@ -161,8 +160,8 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			"System.Random",
 			"System.String",
 		};
-		MethodDefinition checkType_v30(TypeDefinition type) {
-			MethodDefinition decrypterMethod = checkMethods_v30(type);
+		MethodDef checkType_v30(TypeDef type) {
+			MethodDef decrypterMethod = checkMethods_v30(type);
 			if (decrypterMethod == null)
 				return null;
 			if (!new FieldTypes(type).exactly(requiredTypes_v30))
@@ -173,12 +172,12 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			return decrypterMethod;
 		}
 
-		static MethodDefinition checkMethods_v30(TypeDefinition type) {
+		static MethodDef checkMethods_v30(TypeDef type) {
 			if (type.Methods.Count < 1 || type.Methods.Count > 2)
 				return null;
 
-			MethodDefinition decrypterMethod = null;
-			MethodDefinition cctor = null;
+			MethodDef decrypterMethod = null;
+			MethodDef cctor = null;
 			foreach (var method in type.Methods) {
 				if (method.Name == ".cctor") {
 					cctor = method;
@@ -208,8 +207,8 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			"System.String",
 			"System.Object",
 		};
-		MethodDefinition checkType_v36(TypeDefinition type) {
-			MethodDefinition decrypterMethod = checkMethods_v36(type);
+		MethodDef checkType_v36(TypeDef type) {
+			MethodDef decrypterMethod = checkMethods_v36(type);
 			if (decrypterMethod == null)
 				return null;
 			if (!new FieldTypes(type).exactly(requiredTypes_v36))
@@ -220,12 +219,12 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			return decrypterMethod;
 		}
 
-		static MethodDefinition checkMethods_v36(TypeDefinition type) {
+		static MethodDef checkMethods_v36(TypeDef type) {
 			if (type.Methods.Count != 2)
 				return null;
 
-			MethodDefinition decrypterMethod = null;
-			MethodDefinition cctor = null;
+			MethodDef decrypterMethod = null;
+			MethodDef cctor = null;
 			foreach (var method in type.Methods) {
 				if (method.Name == ".cctor") {
 					cctor = method;
@@ -249,69 +248,69 @@ namespace de4dot.code.deobfuscators.CodeWall {
 				simpleDeobfuscator.deobfuscate(info.Method);
 				info.Resource = findResource(info.Method);
 				if (info.Resource == null) {
-					Log.w("Could not find encrypted strings resource (Method {0:X8})", info.Method.MetadataToken.ToInt32());
+					Logger.w("Could not find encrypted strings resource (Method {0:X8})", info.Method.MDToken.ToInt32());
 					continue;
 				}
 				info.Magic1 = findMagic1(info.Method);
 				info.Magic2 = findMagic2(info.Method);
 				info.Magic3 = findMagic3(info.Method);
-				info.Reader = new BinaryReader(info.Resource.GetResourceStream());
+				info.Reader = info.Resource.Data;
 			}
 		}
 
-		EmbeddedResource findResource(MethodDefinition method) {
+		EmbeddedResource findResource(MethodDef method) {
 			return DotNetUtils.getResource(module, DotNetUtils.getCodeStrings(method)) as EmbeddedResource;
 		}
 
-		static int findMagic1(MethodDefinition method) {
+		static int findMagic1(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 2; i++) {
 				var ldarg = instrs[i];
-				if (!DotNetUtils.isLdarg(ldarg) || DotNetUtils.getArgIndex(ldarg) != 0)
+				if (!ldarg.IsLdarg() || ldarg.GetParameterIndex() != 0)
 					continue;
 				var ldci4 = instrs[i + 1];
-				if (!DotNetUtils.isLdcI4(ldci4))
+				if (!ldci4.IsLdcI4())
 					continue;
 				if (instrs[i + 2].OpCode.Code != Code.Xor)
 					continue;
-				return DotNetUtils.getLdcI4Value(ldci4);
+				return ldci4.GetLdcI4Value();
 			}
 			throw new ApplicationException("Could not find magic1");
 		}
 
-		static int findMagic2(MethodDefinition method) {
+		static int findMagic2(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 2; i++) {
 				var ldloc = instrs[i];
-				if (!DotNetUtils.isLdloc(ldloc))
+				if (!ldloc.IsLdloc())
 					continue;
 				var ldci4 = instrs[i + 1];
-				if (!DotNetUtils.isLdcI4(ldci4))
+				if (!ldci4.IsLdcI4())
 					continue;
 				if (instrs[i + 2].OpCode.Code != Code.Xor)
 					continue;
-				return DotNetUtils.getLdcI4Value(ldci4);
+				return ldci4.GetLdcI4Value();
 			}
 			throw new ApplicationException("Could not find magic2");
 		}
 
-		static int findMagic3(MethodDefinition method) {
+		static int findMagic3(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 2; i++) {
 				var ldarg = instrs[i];
-				if (!DotNetUtils.isLdarg(ldarg) || DotNetUtils.getArgIndex(ldarg) != 2)
+				if (!ldarg.IsLdarg() || ldarg.GetParameterIndex() != 2)
 					continue;
 				var ldci4 = instrs[i + 1];
-				if (!DotNetUtils.isLdcI4(ldci4))
+				if (!ldci4.IsLdcI4())
 					continue;
 				if (instrs[i + 2].OpCode.Code != Code.Xor)
 					continue;
-				return DotNetUtils.getLdcI4Value(ldci4);
+				return ldci4.GetLdcI4Value();
 			}
 			throw new ApplicationException("Could not find magic3");
 		}
 
-		public string decrypt(MethodDefinition method, int magic1, int magic2, int magic3) {
+		public string decrypt(MethodDef method, int magic1, int magic2, int magic3) {
 			var info = stringEncrypterInfos.find(method);
 			return info.decrypt(magic1, magic2, magic3);
 		}
diff --git a/de4dot.code/deobfuscators/ConstantsReader.cs b/de4dot.code/deobfuscators/ConstantsReader.cs
index c8642e81..85ab4c45 100644
--- a/de4dot.code/deobfuscators/ConstantsReader.cs
+++ b/de4dot.code/deobfuscators/ConstantsReader.cs
@@ -18,18 +18,17 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.Cecil.Metadata;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators {
 	class ConstantsReader {
 		protected IInstructions instructions;
-		protected IList<VariableDefinition> locals;
-		protected Dictionary<VariableDefinition, int> localsValuesInt32 = new Dictionary<VariableDefinition, int>();
-		protected Dictionary<VariableDefinition, long> localsValuesInt64 = new Dictionary<VariableDefinition, long>();
-		protected Dictionary<VariableDefinition, double> localsValuesDouble = new Dictionary<VariableDefinition, double>();
+		protected IList<Local> locals;
+		protected Dictionary<Local, int> localsValuesInt32 = new Dictionary<Local, int>();
+		protected Dictionary<Local, long> localsValuesInt64 = new Dictionary<Local, long>();
+		protected Dictionary<Local, double> localsValuesDouble = new Dictionary<Local, double>();
 		bool emulateConvInstrs;
 
 		public interface IInstructions {
@@ -99,33 +98,33 @@ namespace de4dot.code.deobfuscators {
 			: this(new ListInstrs(instrs), emulateConvInstrs) {
 		}
 
-		public ConstantsReader(MethodDefinition method)
+		public ConstantsReader(MethodDef method)
 			: this(method.Body.Instructions) {
-			this.locals = method.Body.Variables;
+			this.locals = method.Body.LocalList;
 		}
 
-		public ConstantsReader(IList<Instr> instrs, IList<VariableDefinition> locals)
+		public ConstantsReader(IList<Instr> instrs, IList<Local> locals)
 			: this(instrs) {
 			this.locals = locals;
 		}
 
-		public void setConstantInt32(VariableDefinition local, int value) {
+		public void setConstantInt32(Local local, int value) {
 			localsValuesInt32[local] = value;
 		}
 
-		public void setConstantInt32(VariableDefinition local, uint value) {
+		public void setConstantInt32(Local local, uint value) {
 			setConstantInt32(local, (int)value);
 		}
 
-		public void setConstantInt64(VariableDefinition local, long value) {
+		public void setConstantInt64(Local local, long value) {
 			localsValuesInt64[local] = value;
 		}
 
-		public void setConstantInt64(VariableDefinition local, ulong value) {
+		public void setConstantInt64(Local local, ulong value) {
 			setConstantInt64(local, (long)value);
 		}
 
-		public void setConstantDouble(VariableDefinition local, double value) {
+		public void setConstantDouble(Local local, double value) {
 			localsValuesDouble[local] = value;
 		}
 
@@ -143,13 +142,13 @@ namespace de4dot.code.deobfuscators {
 		}
 
 		public bool isLoadConstantInt32(Instruction instr) {
-			if (DotNetUtils.isLdcI4(instr))
+			if (instr.IsLdcI4())
 				return true;
-			if (DotNetUtils.isLdloc(instr)) {
+			if (instr.IsLdloc()) {
 				int tmp;
 				return getLocalConstantInt32(instr, out tmp);
 			}
-			if (DotNetUtils.isLdarg(instr)) {
+			if (instr.IsLdarg()) {
 				int tmp;
 				return getArgConstantInt32(instr, out tmp);
 			}
@@ -159,11 +158,11 @@ namespace de4dot.code.deobfuscators {
 		public bool isLoadConstantInt64(Instruction instr) {
 			if (instr.OpCode.Code == Code.Ldc_I8)
 				return true;
-			if (DotNetUtils.isLdloc(instr)) {
+			if (instr.IsLdloc()) {
 				long tmp;
 				return getLocalConstantInt64(instr, out tmp);
 			}
-			if (DotNetUtils.isLdarg(instr)) {
+			if (instr.IsLdarg()) {
 				long tmp;
 				return getArgConstantInt64(instr, out tmp);
 			}
@@ -173,11 +172,11 @@ namespace de4dot.code.deobfuscators {
 		public bool isLoadConstantDouble(Instruction instr) {
 			if (instr.OpCode.Code == Code.Ldc_R8)
 				return true;
-			if (DotNetUtils.isLdloc(instr)) {
+			if (instr.IsLdloc()) {
 				double tmp;
 				return getLocalConstantDouble(instr, out tmp);
 			}
-			if (DotNetUtils.isLdarg(instr)) {
+			if (instr.IsLdarg()) {
 				double tmp;
 				return getArgConstantDouble(instr, out tmp);
 			}
@@ -309,7 +308,7 @@ namespace de4dot.code.deobfuscators {
 				case Code.Ldc_I4_7:
 				case Code.Ldc_I4_8:
 				case Code.Ldc_I4_M1:
-					stack.Push(new ConstantInfo<int>(index, DotNetUtils.getLdcI4Value(instr)));
+					stack.Push(new ConstantInfo<int>(index, instr.GetLdcI4Value()));
 					break;
 
 				case Code.Add:
@@ -698,10 +697,10 @@ done:
 			value = 0;
 			if (locals == null)
 				return false;
-			var local = DotNetUtils.getLocalVar(locals, instr);
+			var local = instr.GetLocal(locals);
 			if (local == null)
 				return false;
-			if (local.VariableType.EType != ElementType.I4 && local.VariableType.EType != ElementType.U4)
+			if (local.Type.ElementType != ElementType.I4 && local.Type.ElementType != ElementType.U4)
 				return false;
 			return localsValuesInt32.TryGetValue(local, out value);
 		}
@@ -715,10 +714,10 @@ done:
 			value = 0;
 			if (locals == null)
 				return false;
-			var local = DotNetUtils.getLocalVar(locals, instr);
+			var local = instr.GetLocal(locals);
 			if (local == null)
 				return false;
-			if (local.VariableType.EType != ElementType.I8 && local.VariableType.EType != ElementType.U8)
+			if (local.Type.ElementType != ElementType.I8 && local.Type.ElementType != ElementType.U8)
 				return false;
 			return localsValuesInt64.TryGetValue(local, out value);
 		}
@@ -732,10 +731,10 @@ done:
 			value = 0;
 			if (locals == null)
 				return false;
-			var local = DotNetUtils.getLocalVar(locals, instr);
+			var local = instr.GetLocal(locals);
 			if (local == null)
 				return false;
-			if (local.VariableType.EType != ElementType.R8)
+			if (local.Type.ElementType != ElementType.R8)
 				return false;
 			return localsValuesDouble.TryGetValue(local, out value);
 		}
diff --git a/de4dot.code/deobfuscators/CryptoObfuscator/AntiDebugger.cs b/de4dot.code/deobfuscators/CryptoObfuscator/AntiDebugger.cs
index 7b43c0ee..389c103e 100644
--- a/de4dot.code/deobfuscators/CryptoObfuscator/AntiDebugger.cs
+++ b/de4dot.code/deobfuscators/CryptoObfuscator/AntiDebugger.cs
@@ -17,26 +17,26 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.CryptoObfuscator {
 	class AntiDebugger {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		ISimpleDeobfuscator simpleDeobfuscator;
 		IDeobfuscator deob;
-		TypeDefinition antiDebuggerType;
-		MethodDefinition antiDebuggerMethod;
+		TypeDef antiDebuggerType;
+		MethodDef antiDebuggerMethod;
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return antiDebuggerType; }
 		}
 
-		public MethodDefinition Method {
+		public MethodDef Method {
 			get { return antiDebuggerMethod; }
 		}
 
-		public AntiDebugger(ModuleDefinition module, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
+		public AntiDebugger(ModuleDefMD module, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
 			this.module = module;
 			this.simpleDeobfuscator = simpleDeobfuscator;
 			this.deob = deob;
@@ -49,7 +49,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 				return;
 		}
 
-		bool find(MethodDefinition methodToCheck) {
+		bool find(MethodDef methodToCheck) {
 			if (methodToCheck == null)
 				return false;
 			foreach (var method in DotNetUtils.getCalledMethods(module, methodToCheck)) {
@@ -79,12 +79,12 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return false;
 		}
 
-		void deobfuscate(MethodDefinition method) {
+		void deobfuscate(MethodDef method) {
 			simpleDeobfuscator.deobfuscate(method);
 			simpleDeobfuscator.decryptStrings(method, deob);
 		}
 
-		bool containsString(MethodDefinition method, string part) {
+		bool containsString(MethodDef method, string part) {
 			foreach (var s in DotNetUtils.getCodeStrings(method)) {
 				if (s.Contains(part))
 					return true;
diff --git a/de4dot.code/deobfuscators/CryptoObfuscator/AssemblyResolver.cs b/de4dot.code/deobfuscators/CryptoObfuscator/AssemblyResolver.cs
index 1dcfc324..c2dd5bcb 100644
--- a/de4dot.code/deobfuscators/CryptoObfuscator/AssemblyResolver.cs
+++ b/de4dot.code/deobfuscators/CryptoObfuscator/AssemblyResolver.cs
@@ -20,15 +20,15 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.CryptoObfuscator {
 	class AssemblyResolver {
-		ModuleDefinition module;
-		TypeDefinition resolverType;
-		MethodDefinition resolverMethod;
+		ModuleDefMD module;
+		TypeDef resolverType;
+		MethodDef resolverMethod;
 		List<AssemblyInfo> assemblyInfos = new List<AssemblyInfo>();
 
 		public class AssemblyInfo {
@@ -54,15 +54,15 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			get { return assemblyInfos; }
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return resolverType; }
 		}
 
-		public MethodDefinition Method {
+		public MethodDef Method {
 			get { return resolverMethod; }
 		}
 
-		public AssemblyResolver(ModuleDefinition module) {
+		public AssemblyResolver(ModuleDefMD module) {
 			this.module = module;
 		}
 
@@ -81,7 +81,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			}
 		}
 
-		bool checkType(TypeDefinition type, MethodDefinition initMethod) {
+		bool checkType(TypeDef type, MethodDef initMethod) {
 			if (DotNetUtils.findFieldType(type, "System.Collections.Hashtable", true) == null)
 				return false;
 			if (!checkInitMethod(initMethod))
@@ -102,7 +102,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return true;
 		}
 
-		bool checkInitMethod(MethodDefinition initMethod) {
+		bool checkInitMethod(MethodDef initMethod) {
 			if (!initMethod.HasBody)
 				return false;
 
@@ -112,15 +112,15 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 				if (instrs == null)
 					continue;
 
-				MethodReference methodRef;
+				IMethod methodRef;
 				var ldftn = instrs[1];
 				var newobj = instrs[2];
 
-				methodRef = ldftn.Operand as MethodReference;
-				if (methodRef == null || !MemberReferenceHelper.compareTypes(initMethod.DeclaringType, methodRef.DeclaringType))
+				methodRef = ldftn.Operand as IMethod;
+				if (methodRef == null || !new SigComparer().Equals(initMethod.DeclaringType, methodRef.DeclaringType))
 					continue;
 
-				methodRef = newobj.Operand as MethodReference;
+				methodRef = newobj.Operand as IMethod;
 				if (methodRef == null || methodRef.FullName != "System.Void System.ResolveEventHandler::.ctor(System.Object,System.IntPtr)")
 					continue;
 
diff --git a/de4dot.code/deobfuscators/CryptoObfuscator/CoUtils.cs b/de4dot.code/deobfuscators/CryptoObfuscator/CoUtils.cs
index d3f37981..393ba849 100644
--- a/de4dot.code/deobfuscators/CryptoObfuscator/CoUtils.cs
+++ b/de4dot.code/deobfuscators/CryptoObfuscator/CoUtils.cs
@@ -20,18 +20,18 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.CryptoObfuscator {
 	static class CoUtils {
-		public static EmbeddedResource getResource(ModuleDefinition module, MethodDefinition method) {
+		public static EmbeddedResource getResource(ModuleDefMD module, MethodDef method) {
 			if (method == null || method.Body == null)
 				return null;
 			return getResource(module, DotNetUtils.getCodeStrings(method));
 		}
 
-		public static EmbeddedResource getResource(ModuleDefinition module, IEnumerable<string> names) {
+		public static EmbeddedResource getResource(ModuleDefMD module, IEnumerable<string> names) {
 			foreach (var name in names) {
 				var resource = DotNetUtils.getResource(module, name) as EmbeddedResource;
 				if (resource != null)
diff --git a/de4dot.code/deobfuscators/CryptoObfuscator/ConstantsDecrypter.cs b/de4dot.code/deobfuscators/CryptoObfuscator/ConstantsDecrypter.cs
index 2240e431..0a159641 100644
--- a/de4dot.code/deobfuscators/CryptoObfuscator/ConstantsDecrypter.cs
+++ b/de4dot.code/deobfuscators/CryptoObfuscator/ConstantsDecrypter.cs
@@ -20,21 +20,22 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
-using Mono.Cecil;
+using dot10.IO;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.CryptoObfuscator {
 	class ConstantsDecrypter {
-		ModuleDefinition module;
-		TypeDefinition decrypterType;
-		MethodDefinition methodI4;
-		MethodDefinition methodI8;
-		MethodDefinition methodR4;
-		MethodDefinition methodR8;
+		ModuleDefMD module;
+		TypeDef decrypterType;
+		MethodDef methodI4;
+		MethodDef methodI8;
+		MethodDef methodR4;
+		MethodDef methodR8;
 		EmbeddedResource encryptedResource;
 		byte[] constantsData;
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return decrypterType; }
 		}
 
@@ -42,19 +43,19 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			get { return encryptedResource; }
 		}
 
-		public MethodDefinition Int32Decrypter {
+		public MethodDef Int32Decrypter {
 			get { return methodI4; }
 		}
 
-		public MethodDefinition Int64Decrypter {
+		public MethodDef Int64Decrypter {
 			get { return methodI8; }
 		}
 
-		public MethodDefinition SingleDecrypter {
+		public MethodDef SingleDecrypter {
 			get { return methodR4; }
 		}
 
-		public MethodDefinition DoubleDecrypter {
+		public MethodDef DoubleDecrypter {
 			get { return methodR8; }
 		}
 
@@ -62,7 +63,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			get { return decrypterType != null; }
 		}
 
-		public ConstantsDecrypter(ModuleDefinition module) {
+		public ConstantsDecrypter(ModuleDefMD module) {
 			this.module = module;
 		}
 
@@ -79,7 +80,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 		static readonly string[] requiredTypes = new string[] {
 			"System.Byte[]",
 		};
-		bool checkType(TypeDefinition type) {
+		bool checkType(TypeDef type) {
 			if (type.Methods.Count != 7)
 				return false;
 			if (type.Fields.Count < 1 || type.Fields.Count > 2)
@@ -92,7 +93,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return true;
 		}
 
-		bool checkMethods(TypeDefinition type) {
+		bool checkMethods(TypeDef type) {
 			methodI4 = DotNetUtils.getMethod(type, "System.Int32", "(System.Int32)");
 			methodI8 = DotNetUtils.getMethod(type, "System.Int64", "(System.Int32)");
 			methodR4 = DotNetUtils.getMethod(type, "System.Single", "(System.Int32)");
@@ -106,8 +107,8 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			if (decrypterType == null)
 				return;
 
-			encryptedResource = CoUtils.getResource(module, DotNetUtils.getCodeStrings(DotNetUtils.getMethod(decrypterType, ".cctor")));
-			constantsData = resourceDecrypter.decrypt(encryptedResource.GetResourceStream());
+			encryptedResource = CoUtils.getResource(module, DotNetUtils.getCodeStrings(decrypterType.FindStaticConstructor()));
+			constantsData = resourceDecrypter.decrypt(encryptedResource.Data.CreateStream());
 		}
 
 		public int decryptInt32(int index) {
diff --git a/de4dot.code/deobfuscators/CryptoObfuscator/Deobfuscator.cs b/de4dot.code/deobfuscators/CryptoObfuscator/Deobfuscator.cs
index 6d440bad..94dd2999 100644
--- a/de4dot.code/deobfuscators/CryptoObfuscator/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/CryptoObfuscator/Deobfuscator.cs
@@ -20,7 +20,7 @@
 using System;
 using System.Collections.Generic;
 using System.Text.RegularExpressions;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.CryptoObfuscator {
@@ -105,7 +105,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			StringFeatures = StringFeatures.AllowStaticDecryption | StringFeatures.AllowDynamicDecryption;
 		}
 
-		public override void init(ModuleDefinition module) {
+		public override void init(ModuleDefMD module) {
 			base.init(module);
 		}
 
@@ -146,10 +146,10 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			tamperDetection.find();
 			constantsDecrypter = new ConstantsDecrypter(module);
 			constantsDecrypter.find();
-			foundObfuscatorUserString = Utils.StartsWith(module.GetUserString(0x70000001), "\u0011\"3D9B94A98B-76A8-4810-B1A0-4BE7C4F9C98D", StringComparison.Ordinal);
+			foundObfuscatorUserString = Utils.StartsWith(module.ReadUserString(0x70000001), "\u0011\"3D9B94A98B-76A8-4810-B1A0-4BE7C4F9C98D", StringComparison.Ordinal);
 		}
 
-		void initializeVersion(TypeDefinition attr) {
+		void initializeVersion(TypeDef attr) {
 			var s = DotNetUtils.getCustomArgAsString(getAssemblyAttribute(attr), 0);
 			if (s == null)
 				return;
@@ -166,9 +166,9 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			foreach (var type in module.Types) {
 				if (type.Namespace != "A")
 					continue;
-				if (Regex.IsMatch(type.Name, "^c[0-9a-f]{32}$"))
+				if (Regex.IsMatch(type.Name.String, "^c[0-9a-f]{32}$"))
 					return true;
-				else if (Regex.IsMatch(type.Name, "^A[A-Z]*$")) {
+				else if (Regex.IsMatch(type.Name.String, "^A[A-Z]*$")) {
 					if (++matched >= 10)
 						return true;
 				}
@@ -282,7 +282,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 		public override IEnumerable<int> getStringDecrypterMethods() {
 			var list = new List<int>();
 			if (stringDecrypter.Method != null)
-				list.Add(stringDecrypter.Method.MetadataToken.ToInt32());
+				list.Add(stringDecrypter.Method.MDToken.ToInt32());
 			return list;
 		}
 	}
diff --git a/de4dot.code/deobfuscators/CryptoObfuscator/MethodBodyReader.cs b/de4dot.code/deobfuscators/CryptoObfuscator/MethodBodyReader.cs
index 22860f01..5a60d4f4 100644
--- a/de4dot.code/deobfuscators/CryptoObfuscator/MethodBodyReader.cs
+++ b/de4dot.code/deobfuscators/CryptoObfuscator/MethodBodyReader.cs
@@ -19,27 +19,27 @@
 
 using System;
 using System.Collections.Generic;
-using System.IO;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.IO;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.CryptoObfuscator {
 	class MethodBodyReader : MethodBodyReaderBase {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		ushort maxStackSize;
 
-		public MethodBodyReader(ModuleDefinition module, BinaryReader reader)
+		public MethodBodyReader(ModuleDefMD module, IBinaryReader reader)
 			: base(reader) {
 			this.module = module;
 		}
 
-		public void read(MethodDefinition method) {
-			this.parameters = getParameters(method);
-			this.Locals = getLocals(method);
+		public void read(MethodDef method) {
+			this.parameters = method.Parameters;
+			this.locals = getLocals(method);
 
 			maxStackSize = (ushort)reader.ReadInt32();
-			readInstructionsNumBytes(reader.ReadUInt32());
+			ReadInstructionsNumBytes(reader.ReadUInt32());
 			readExceptionHandlers();
 		}
 
@@ -51,73 +51,76 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			readExceptionHandlers((totalSize - 4) / 24);
 		}
 
-		static IList<ParameterDefinition> getParameters(MethodReference method) {
-			return DotNetUtils.getParameters(method);
-		}
-
-		static IList<VariableDefinition> getLocals(MethodDefinition method) {
+		static IList<Local> getLocals(MethodDef method) {
 			if (method.Body == null)
-				return new List<VariableDefinition>();
-			return new List<VariableDefinition>(method.Body.Variables);
+				return new List<Local>();
+			return method.Body.LocalList;
 		}
 
-		protected override FieldReference readInlineField(Instruction instr) {
-			return (FieldReference)module.LookupToken(reader.ReadInt32());
+		protected override IField ReadInlineField(Instruction instr) {
+			return module.ResolveToken(reader.ReadUInt32()) as IField;
 		}
 
-		protected override MethodReference readInlineMethod(Instruction instr) {
-			return (MethodReference)module.LookupToken(reader.ReadInt32());
+		protected override IMethod ReadInlineMethod(Instruction instr) {
+			return module.ResolveToken(reader.ReadUInt32()) as IMethod;
 		}
 
-		protected override CallSite readInlineSig(Instruction instr) {
-			return module.ReadCallSite(new MetadataToken(reader.ReadUInt32()));
+		protected override MethodSig ReadInlineSig(Instruction instr) {
+			var sas = module.ResolveStandAloneSig(MDToken.ToRID(reader.ReadUInt32()));
+			return sas == null ? null : sas.MethodSig;
 		}
 
-		protected override string readInlineString(Instruction instr) {
-			return module.GetUserString(reader.ReadUInt32());
+		protected override string ReadInlineString(Instruction instr) {
+			return module.ReadUserString(reader.ReadUInt32());
 		}
 
-		protected override MemberReference readInlineTok(Instruction instr) {
-			return (MemberReference)module.LookupToken(reader.ReadInt32());
+		protected override ITokenOperand ReadInlineTok(Instruction instr) {
+			return module.ResolveToken(reader.ReadUInt32()) as ITokenOperand;
 		}
 
-		protected override TypeReference readInlineType(Instruction instr) {
-			return (TypeReference)module.LookupToken(reader.ReadInt32());
+		protected override ITypeDefOrRef ReadInlineType(Instruction instr) {
+			return module.ResolveToken(reader.ReadUInt32()) as ITypeDefOrRef;
 		}
 
-		protected override ExceptionHandler readExceptionHandler() {
-			var eh = new ExceptionHandler((ExceptionHandlerType)reader.ReadInt32());
+		void readExceptionHandlers(int numExceptionHandlers) {
+			exceptionHandlers = new ExceptionHandler[numExceptionHandlers];
+			for (int i = 0; i < exceptionHandlers.Count; i++)
+				exceptionHandlers[i] = readExceptionHandler();
+		}
 
-			int tryOffset = reader.ReadInt32();
-			eh.TryStart = getInstruction(tryOffset);
-			eh.TryEnd = getInstructionOrNull(tryOffset + reader.ReadInt32());
+		ExceptionHandler readExceptionHandler() {
+			var eh = new ExceptionHandler((ExceptionHandlerType)reader.ReadUInt32());
 
-			int handlerOffset = reader.ReadInt32();
-			eh.HandlerStart = getInstruction(handlerOffset);
-			eh.HandlerEnd = getInstructionOrNull(handlerOffset + reader.ReadInt32());
+			uint tryOffset = reader.ReadUInt32();
+			eh.TryStart = GetInstructionThrow(tryOffset);
+			eh.TryEnd = GetInstruction(tryOffset + reader.ReadUInt32());
+
+			uint handlerOffset = reader.ReadUInt32();
+			eh.HandlerStart = GetInstructionThrow(handlerOffset);
+			eh.HandlerEnd = GetInstruction(handlerOffset + reader.ReadUInt32());
 
 			switch (eh.HandlerType) {
 			case ExceptionHandlerType.Catch:
-				eh.CatchType = (TypeReference)module.LookupToken(reader.ReadInt32());
+				eh.CatchType = module.ResolveToken(reader.ReadUInt32()) as ITypeDefOrRef;
 				break;
 
 			case ExceptionHandlerType.Filter:
-				eh.FilterStart = getInstruction(reader.ReadInt32());
+				eh.FilterStart = GetInstructionThrow(reader.ReadUInt32());
 				break;
 
 			case ExceptionHandlerType.Finally:
 			case ExceptionHandlerType.Fault:
 			default:
-				reader.ReadInt32();
+				reader.ReadUInt32();
 				break;
 			}
 
 			return eh;
 		}
 
-		public override void restoreMethod(MethodDefinition method) {
-			base.restoreMethod(method);
-			method.Body.MaxStackSize = maxStackSize;
+		public override void RestoreMethod(MethodDef method) {
+			base.RestoreMethod(method);
+			method.Body.MaxStack = maxStackSize;
 		}
 	}
 }
diff --git a/de4dot.code/deobfuscators/CryptoObfuscator/MethodsDecrypter.cs b/de4dot.code/deobfuscators/CryptoObfuscator/MethodsDecrypter.cs
index d55cd744..452ee694 100644
--- a/de4dot.code/deobfuscators/CryptoObfuscator/MethodsDecrypter.cs
+++ b/de4dot.code/deobfuscators/CryptoObfuscator/MethodsDecrypter.cs
@@ -19,25 +19,25 @@
 
 using System;
 using System.Collections.Generic;
-using System.IO;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.IO;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.CryptoObfuscator {
 	class MethodsDecrypter {
-		ModuleDefinition module;
-		TypeDefinition decrypterType;
-		MethodDefinition decryptMethod;
-		MethodDefinition decrypterCctor;
+		ModuleDefMD module;
+		TypeDef decrypterType;
+		MethodDef decryptMethod;
+		MethodDef decrypterCctor;
 		EmbeddedResource resource;
-		List<TypeDefinition> delegateTypes = new List<TypeDefinition>();
+		List<TypeDef> delegateTypes = new List<TypeDef>();
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return decrypterType; }
 		}
 
-		public IEnumerable<TypeDefinition> DelegateTypes {
+		public IEnumerable<TypeDef> DelegateTypes {
 			get { return delegateTypes; }
 		}
 
@@ -49,7 +49,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			get { return decrypterType != null; }
 		}
 
-		public MethodsDecrypter(ModuleDefinition module) {
+		public MethodsDecrypter(ModuleDefMD module) {
 			this.module = module;
 		}
 
@@ -65,7 +65,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			"System.Collections.Generic.Dictionary`2<System.Int32,System.Int32>",
 			"System.ModuleHandle",
 		};
-		bool check(TypeDefinition type) {
+		bool check(TypeDef type) {
 			if (type.NestedTypes.Count != 1)
 				return false;
 			if (type.Fields.Count != 3)
@@ -73,7 +73,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			if (!new FieldTypes(type).all(requiredFields))
 				return false;
 
-			var cctor = DotNetUtils.getMethod(type, ".cctor");
+			var cctor = type.FindStaticConstructor();
 			if (cctor == null)
 				return false;
 			var decryptMethodTmp = findDecryptMethod(type);
@@ -98,7 +98,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			"System.Type",
 			"System.Type[]",
 		};
-		static MethodDefinition findDecryptMethod(TypeDefinition type) {
+		static MethodDef findDecryptMethod(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
@@ -120,23 +120,23 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			if (resource == null)
 				return;
 			var decrypted = resourceDecrypter.decrypt(resource.GetResourceStream());
-			var reader = new BinaryReader(new MemoryStream(decrypted));
+			var reader = MemoryImageStream.Create(decrypted);
 			int numEncrypted = reader.ReadInt32();
-			Log.v("Restoring {0} encrypted methods", numEncrypted);
-			Log.indent();
+			Logger.v("Restoring {0} encrypted methods", numEncrypted);
+			Logger.Instance.indent();
 			for (int i = 0; i < numEncrypted; i++) {
 				int delegateTypeToken = reader.ReadInt32();
 				uint codeOffset = reader.ReadUInt32();
-				var origOffset = reader.BaseStream.Position;
-				reader.BaseStream.Position = codeOffset;
+				var origOffset = reader.Position;
+				reader.Position = codeOffset;
 				decrypt(reader, delegateTypeToken);
-				reader.BaseStream.Position = origOffset;
+				reader.Position = origOffset;
 			}
-			Log.deIndent();
+			Logger.Instance.deIndent();
 		}
 
-		void decrypt(BinaryReader reader, int delegateTypeToken) {
-			var delegateType = module.LookupToken(delegateTypeToken) as TypeDefinition;
+		void decrypt(IBinaryReader reader, int delegateTypeToken) {
+			var delegateType = module.ResolveToken(delegateTypeToken) as TypeDef;
 			if (delegateType == null)
 				throw new ApplicationException("Couldn't find delegate type");
 
@@ -145,57 +145,57 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 				throw new ApplicationException("Could not find encrypted method tokens");
 			if (delToken != delegateTypeToken)
 				throw new ApplicationException("Invalid delegate type token");
-			var encType = module.LookupToken(encDeclToken) as TypeReference;
+			var encType = module.ResolveToken(encDeclToken) as ITypeDefOrRef;
 			if (encType == null)
 				throw new ApplicationException("Invalid declaring type token");
-			var encMethod = module.LookupToken(encMethToken) as MethodDefinition;
+			var encMethod = module.ResolveToken(encMethToken) as MethodDef;
 			if (encMethod == null)
 				throw new ApplicationException("Invalid encrypted method token");
 
 			var bodyReader = new MethodBodyReader(module, reader);
 			bodyReader.read(encMethod);
-			bodyReader.restoreMethod(encMethod);
-			Log.v("Restored method {0} ({1:X8}). Instrs:{2}, Locals:{3}, Exceptions:{4}",
+			bodyReader.RestoreMethod(encMethod);
+			Logger.v("Restored method {0} ({1:X8}). Instrs:{2}, Locals:{3}, Exceptions:{4}",
 					Utils.removeNewlines(encMethod.FullName),
-					encMethod.MetadataToken.ToInt32(),
+					encMethod.MDToken.ToInt32(),
 					encMethod.Body.Instructions.Count,
-					encMethod.Body.Variables.Count,
+					encMethod.Body.LocalList.Count,
 					encMethod.Body.ExceptionHandlers.Count);
 			delegateTypes.Add(delegateType);
 		}
 
-		bool getTokens(TypeDefinition delegateType, out int delegateToken, out int encMethodToken, out int encDeclaringTypeToken) {
+		bool getTokens(TypeDef delegateType, out int delegateToken, out int encMethodToken, out int encDeclaringTypeToken) {
 			delegateToken = 0;
 			encMethodToken = 0;
 			encDeclaringTypeToken = 0;
 
-			var cctor = DotNetUtils.getMethod(delegateType, ".cctor");
+			var cctor = delegateType.FindStaticConstructor();
 			if (cctor == null)
 				return false;
 
 			var instrs = cctor.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 3; i++) {
 				var ldci4_1 = instrs[i];
-				if (!DotNetUtils.isLdcI4(ldci4_1))
+				if (!ldci4_1.IsLdcI4())
 					continue;
 				var ldci4_2 = instrs[i + 1];
-				if (!DotNetUtils.isLdcI4(ldci4_2))
+				if (!ldci4_2.IsLdcI4())
 					continue;
 				var ldci4_3 = instrs[i + 2];
-				if (!DotNetUtils.isLdcI4(ldci4_3))
+				if (!ldci4_3.IsLdcI4())
 					continue;
 				var call = instrs[i + 3];
 				if (call.OpCode.Code != Code.Call)
 					continue;
-				var calledMethod = call.Operand as MethodDefinition;
+				var calledMethod = call.Operand as MethodDef;
 				if (calledMethod == null)
 					continue;
 				if (calledMethod != decryptMethod)
 					continue;
 
-				delegateToken = DotNetUtils.getLdcI4Value(ldci4_1);
-				encMethodToken = DotNetUtils.getLdcI4Value(ldci4_2);
-				encDeclaringTypeToken = DotNetUtils.getLdcI4Value(ldci4_3);
+				delegateToken = ldci4_1.GetLdcI4Value();
+				encMethodToken = ldci4_2.GetLdcI4Value();
+				encDeclaringTypeToken = ldci4_3.GetLdcI4Value();
 				return true;
 			}
 
diff --git a/de4dot.code/deobfuscators/CryptoObfuscator/ProxyCallFixer.cs b/de4dot.code/deobfuscators/CryptoObfuscator/ProxyCallFixer.cs
index 36110571..1d68495e 100644
--- a/de4dot.code/deobfuscators/CryptoObfuscator/ProxyCallFixer.cs
+++ b/de4dot.code/deobfuscators/CryptoObfuscator/ProxyCallFixer.cs
@@ -19,15 +19,15 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.CryptoObfuscator {
 	class ProxyCallFixer : ProxyCallFixer2 {
-		Dictionary<MethodDefinition, ProxyCreatorType> methodToType = new Dictionary<MethodDefinition, ProxyCreatorType>();
+		Dictionary<MethodDef, ProxyCreatorType> methodToType = new Dictionary<MethodDef, ProxyCreatorType>();
 
-		public ProxyCallFixer(ModuleDefinition module)
+		public ProxyCallFixer(ModuleDefMD module)
 			: base(module) {
 		}
 
@@ -39,11 +39,11 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 		}
 
 		class Context {
-			public int typeToken;
-			public int methodToken;
-			public int declaringTypeToken;
+			public uint typeToken;
+			public uint methodToken;
+			public uint declaringTypeToken;
 			public ProxyCreatorType proxyCreatorType;
-			public Context(int typeToken, int methodToken, int declaringTypeToken, ProxyCreatorType proxyCreatorType) {
+			public Context(uint typeToken, uint methodToken, uint declaringTypeToken, ProxyCreatorType proxyCreatorType) {
 				this.typeToken = typeToken;
 				this.methodToken = methodToken;
 				this.declaringTypeToken = declaringTypeToken;
@@ -51,17 +51,17 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			}
 		}
 
-		protected override object checkCctor(TypeDefinition type, MethodDefinition cctor) {
+		protected override object checkCctor(TypeDef type, MethodDef cctor) {
 			var instructions = cctor.Body.Instructions;
 			for (int i = 0; i < instructions.Count; i++) {
 				var instrs = DotNetUtils.getInstructions(instructions, i, OpCodes.Ldc_I4, OpCodes.Ldc_I4, OpCodes.Ldc_I4, OpCodes.Call);
 				if (instrs == null)
 					continue;
 
-				int typeToken = (int)instrs[0].Operand;
-				int methodToken = (int)instrs[1].Operand;
-				int declaringTypeToken = (int)instrs[2].Operand;
-				var createMethod = instrs[3].Operand as MethodDefinition;
+				uint typeToken = (uint)(int)instrs[0].Operand;
+				uint methodToken = (uint)(int)instrs[1].Operand;
+				uint declaringTypeToken = (uint)(int)instrs[2].Operand;
+				var createMethod = instrs[3].Operand as MethodDef;
 
 				ProxyCreatorType proxyCreatorType;
 				if (!methodToType.TryGetValue(createMethod, out proxyCreatorType))
@@ -73,7 +73,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return null;
 		}
 
-		protected override void getCallInfo(object context, FieldDefinition field, out MethodReference calledMethod, out OpCode callOpcode) {
+		protected override void getCallInfo(object context, FieldDef field, out IMethod calledMethod, out OpCode callOpcode) {
 			var ctx = (Context)context;
 
 			switch (ctx.proxyCreatorType) {
@@ -90,7 +90,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 				throw new ApplicationException(string.Format("Invalid proxy creator type: {0}", ctx.proxyCreatorType));
 			}
 
-			calledMethod = module.LookupToken(ctx.methodToken) as MethodReference;
+			calledMethod = module.ResolveToken(ctx.methodToken) as IMethod;
 		}
 
 		public void findDelegateCreator() {
@@ -107,13 +107,13 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			}
 		}
 
-		MethodDefinition getProxyCreateMethod(TypeDefinition type) {
+		MethodDef getProxyCreateMethod(TypeDef type) {
 			if (DotNetUtils.findFieldType(type, "System.ModuleHandle", true) == null)
 				return null;
 			if (type.Fields.Count < 1 || type.Fields.Count > 12)
 				return null;
 
-			MethodDefinition createMethod = null;
+			MethodDef createMethod = null;
 			foreach (var m in type.Methods) {
 				if (m.Name == ".ctor" || m.Name == ".cctor")
 					continue;
@@ -131,12 +131,12 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return createMethod;
 		}
 
-		ProxyCreatorType getProxyCreatorType(TypeDefinition type, MethodDefinition createMethod) {
+		ProxyCreatorType getProxyCreatorType(TypeDef type, MethodDef createMethod) {
 			int numCalls = 0, numCallvirts = 0, numNewobjs = 0;
 			foreach (var instr in createMethod.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Ldsfld)
 					continue;
-				var field = instr.Operand as FieldReference;
+				var field = instr.Operand as IField;
 				if (field == null)
 					continue;
 				switch (field.FullName) {
diff --git a/de4dot.code/deobfuscators/CryptoObfuscator/ResourceDecrypter.cs b/de4dot.code/deobfuscators/CryptoObfuscator/ResourceDecrypter.cs
index 406c9804..d0f5308c 100644
--- a/de4dot.code/deobfuscators/CryptoObfuscator/ResourceDecrypter.cs
+++ b/de4dot.code/deobfuscators/CryptoObfuscator/ResourceDecrypter.cs
@@ -22,15 +22,15 @@ using System.Collections.Generic;
 using System.IO;
 using System.IO.Compression;
 using System.Security.Cryptography;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.CryptoObfuscator {
 	class ResourceDecrypter {
 		const int BUFLEN = 0x8000;
-		ModuleDefinition module;
-		TypeDefinition resourceDecrypterType;
+		ModuleDefMD module;
+		TypeDef resourceDecrypterType;
 		byte[] buffer1 = new byte[BUFLEN];
 		byte[] buffer2 = new byte[BUFLEN];
 		byte desEncryptedFlag;
@@ -40,7 +40,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 		bool flipFlagsBits;
 		int skipBytes;
 
-		public ResourceDecrypter(ModuleDefinition module, ISimpleDeobfuscator simpleDeobfuscator) {
+		public ResourceDecrypter(ModuleDefMD module, ISimpleDeobfuscator simpleDeobfuscator) {
 			this.module = module;
 			frameworkType = DotNetUtils.getFrameworkType(module);
 			find(simpleDeobfuscator);
@@ -49,7 +49,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 		void find(ISimpleDeobfuscator simpleDeobfuscator) {
 			switch (frameworkType) {
 			case FrameworkType.Desktop:
-				if (module.Runtime >= TargetRuntime.Net_2_0)
+				if (!module.IsClr1x)
 					findDesktopOrCompactFramework();
 				else
 					findDesktopOrCompactFrameworkV1();
@@ -60,7 +60,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 				break;
 
 			case FrameworkType.CompactFramework:
-				if (module.Runtime >= TargetRuntime.Net_2_0) {
+				if (!module.IsClr1x) {
 					if (findDesktopOrCompactFramework())
 						break;
 				}
@@ -84,7 +84,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 				if (!new FieldTypes(type).exactly(requiredTypes))
 					continue;
 
-				var cctor = DotNetUtils.getMethod(type, ".cctor");
+				var cctor = type.FindStaticConstructor();
 				if (cctor == null)
 					continue;
 
@@ -97,14 +97,14 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return false;
 		}
 
-		bool checkCctor(MethodDefinition cctor) {
+		bool checkCctor(MethodDef cctor) {
 			if (cctor.Body == null)
 				return false;
 			int stsfldCount = 0;
 			foreach (var instr in cctor.Body.Instructions) {
 				if (instr.OpCode.Code == Code.Stsfld) {
-					var field = instr.Operand as FieldReference;
-					if (!MemberReferenceHelper.compareTypes(cctor.DeclaringType, field.DeclaringType))
+					var field = instr.Operand as IField;
+					if (!new SigComparer().Equals(cctor.DeclaringType, field.DeclaringType))
 						return false;
 					stsfldCount++;
 				}
@@ -182,14 +182,14 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			bitwiseNotEncryptedFlag = 4;
 		}
 
-		static bool checkFlipBits(MethodDefinition method) {
+		static bool checkFlipBits(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 1; i++) {
 				var ldloc = instrs[i];
-				if (!DotNetUtils.isLdloc(ldloc))
+				if (!ldloc.IsLdloc())
 					continue;
-				var local = DotNetUtils.getLocalVar(method.Body.Variables, ldloc);
-				if (local == null || !local.VariableType.IsPrimitive)
+				var local = ldloc.GetLocal(method.Body.LocalList);
+				if (local == null || local.Type.GetElementType().GetPrimitiveSize() < 0)
 					continue;
 
 				var not = instrs[i + 1];
@@ -202,7 +202,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return false;
 		}
 
-		bool updateFlags(MethodDefinition method, ISimpleDeobfuscator simpleDeobfuscator) {
+		bool updateFlags(MethodDef method, ISimpleDeobfuscator simpleDeobfuscator) {
 			if (method == null || method.Body == null)
 				return false;
 
@@ -214,16 +214,16 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 				if (and.OpCode.Code != Code.And)
 					continue;
 				var ldci4 = instructions[i - 1];
-				if (!DotNetUtils.isLdcI4(ldci4))
+				if (!ldci4.IsLdcI4())
 					continue;
-				int flagValue = DotNetUtils.getLdcI4Value(ldci4);
+				int flagValue = ldci4.GetLdcI4Value();
 				if (!isFlag(flagValue))
 					continue;
 				var ldloc = instructions[i - 2];
-				if (!DotNetUtils.isLdloc(ldloc))
+				if (!ldloc.IsLdloc())
 					continue;
-				var local = DotNetUtils.getLocalVar(method.Body.Variables, ldloc);
-				if (!local.VariableType.IsPrimitive)
+				var local = ldloc.GetLocal(method.Body.LocalList);
+				if (local.Type.GetElementType().GetPrimitiveSize() < 0)
 					continue;
 				constants.Add(flagValue);
 			}
@@ -233,7 +233,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 
 			switch (frameworkType) {
 			case FrameworkType.Desktop:
-				if (module.Runtime >= TargetRuntime.Net_2_0) {
+				if (!module.IsClr1x) {
 					if (constants.Count == 2) {
 						desEncryptedFlag = (byte)constants[0];
 						deflatedFlag = (byte)constants[1];
@@ -266,13 +266,13 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return false;
 		}
 
-		static int getHeaderSkipBytes(MethodDefinition method) {
+		static int getHeaderSkipBytes(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 1; i++) {
 				var ldci4 = instrs[i];
-				if (!DotNetUtils.isLdcI4(ldci4))
+				if (!ldci4.IsLdcI4())
 					continue;
-				int loopCount = DotNetUtils.getLdcI4Value(ldci4);
+				int loopCount = ldci4.GetLdcI4Value();
 				if (loopCount < 2 || loopCount > 3)
 					continue;
 				var blt = instrs[i + 1];
@@ -291,11 +291,11 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return false;
 		}
 
-		MethodDefinition getDecrypterMethod() {
+		MethodDef getDecrypterMethod() {
 			return getDecrypterMethod(resourceDecrypterType);
 		}
 
-		static MethodDefinition getDecrypterMethod(TypeDefinition type) {
+		static MethodDef getDecrypterMethod(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (DotNetUtils.isMethod(method, "System.Byte[]", "(System.IO.Stream)"))
 					return method;
@@ -328,7 +328,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 
 			byte allFlags = (byte)(desEncryptedFlag | deflatedFlag | bitwiseNotEncryptedFlag);
 			if ((flags & ~allFlags) != 0)
-				Log.w("Found unknown resource encryption flags: 0x{0:X2}", flags);
+				Logger.w("Found unknown resource encryption flags: 0x{0:X2}", flags);
 
 			if ((flags & desEncryptedFlag) != 0) {
 				var memStream = new MemoryStream((int)resourceStream.Length);
@@ -402,7 +402,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 				if (key[i] != 0)
 					return key;
 			}
-			key = module.Assembly.Name.PublicKeyToken;
+			key = PublicKeyBase.GetRawData(module.Assembly.PublicKeyToken);
 			if (key == null)
 				throw new ApplicationException("PublicKeyToken is null, can't decrypt resources");
 			return key;
diff --git a/de4dot.code/deobfuscators/CryptoObfuscator/ResourceResolver.cs b/de4dot.code/deobfuscators/CryptoObfuscator/ResourceResolver.cs
index e73f4194..6a75f9c7 100644
--- a/de4dot.code/deobfuscators/CryptoObfuscator/ResourceResolver.cs
+++ b/de4dot.code/deobfuscators/CryptoObfuscator/ResourceResolver.cs
@@ -19,16 +19,17 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.IO;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.CryptoObfuscator {
 	class ResourceResolver {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		ResourceDecrypter resourceDecrypter;
-		TypeDefinition resolverType;
-		MethodDefinition resolverMethod;
+		TypeDef resolverType;
+		MethodDef resolverMethod;
 		ResolverVersion resolverVersion = ResolverVersion.V1;
 		bool mergedIt = false;
 
@@ -38,15 +39,15 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			V2,
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return resolverType; }
 		}
 
-		public MethodDefinition Method {
+		public MethodDef Method {
 			get { return resolverMethod; }
 		}
 
-		public ResourceResolver(ModuleDefinition module, ResourceDecrypter resourceDecrypter) {
+		public ResourceResolver(ModuleDefMD module, ResourceDecrypter resourceDecrypter) {
 			this.module = module;
 			this.resourceDecrypter = resourceDecrypter;
 		}
@@ -74,7 +75,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			if (resource == null)
 				return null;
 
-			DeobUtils.decryptAndAddResources(module, resource.Name, () => resourceDecrypter.decrypt(resource.GetResourceStream()));
+			DeobUtils.decryptAndAddResources(module, resource.Name.String, () => resourceDecrypter.decrypt(resource.Data.CreateStream()));
 			mergedIt = true;
 			return resource;
 		}
@@ -84,12 +85,12 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 
 			switch (resolverVersion) {
 			case ResolverVersion.V1:
-				names.Add(module.Assembly.Name.Name);
+				names.Add(module.Assembly.Name.String);
 				break;
 
 			case ResolverVersion.V2:
-				names.Add(string.Format("{0}{0}{0}", module.Assembly.Name.Name));
-				names.Add(string.Format("{0}&", module.Assembly.Name.Name));
+				names.Add(string.Format("{0}{0}{0}", module.Assembly.Name.String));
+				names.Add(string.Format("{0}&", module.Assembly.Name.String));
 				break;
 
 			default:
@@ -99,7 +100,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return names;
 		}
 
-		bool checkType(MethodDefinition initMethod) {
+		bool checkType(MethodDef initMethod) {
 			if (!initMethod.HasBody)
 				return false;
 			if (DotNetUtils.findFieldType(initMethod.DeclaringType, "System.Reflection.Assembly", true) == null)
@@ -107,7 +108,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 
 			resolverVersion = checkSetupMethod(initMethod);
 			if (resolverVersion == ResolverVersion.None)
-				resolverVersion = checkSetupMethod(DotNetUtils.getMethod(initMethod.DeclaringType, ".cctor"));
+				resolverVersion = checkSetupMethod(initMethod.DeclaringType.FindStaticConstructor());
 			if (resolverVersion == ResolverVersion.None)
 				return false;
 
@@ -116,7 +117,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return true;
 		}
 
-		ResolverVersion checkSetupMethod(MethodDefinition setupMethod) {
+		ResolverVersion checkSetupMethod(MethodDef setupMethod) {
 			var instructions = setupMethod.Body.Instructions;
 			int foundCount = 0;
 			for (int i = 0; i < instructions.Count; i++) {
@@ -124,15 +125,15 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 				if (instrs == null)
 					continue;
 
-				MethodReference methodRef;
+				IMethod methodRef;
 				var ldftn = instrs[1];
 				var newobj = instrs[2];
 
-				methodRef = ldftn.Operand as MethodReference;
-				if (methodRef == null || !MemberReferenceHelper.compareTypes(setupMethod.DeclaringType, methodRef.DeclaringType))
+				methodRef = ldftn.Operand as IMethod;
+				if (methodRef == null || !new SigComparer().Equals(setupMethod.DeclaringType, methodRef.DeclaringType))
 					continue;
 
-				methodRef = newobj.Operand as MethodReference;
+				methodRef = newobj.Operand as IMethod;
 				if (methodRef == null || methodRef.FullName != "System.Void System.ResolveEventHandler::.ctor(System.Object,System.IntPtr)")
 					continue;
 
diff --git a/de4dot.code/deobfuscators/CryptoObfuscator/StringDecrypter.cs b/de4dot.code/deobfuscators/CryptoObfuscator/StringDecrypter.cs
index a2fbfa0f..41ef5a78 100644
--- a/de4dot.code/deobfuscators/CryptoObfuscator/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/CryptoObfuscator/StringDecrypter.cs
@@ -19,26 +19,26 @@
 
 using System;
 using System.Text;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.CryptoObfuscator {
 	class StringDecrypter {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		EmbeddedResource stringResource;
-		TypeDefinition stringDecrypterType;
-		MethodDefinition stringDecrypterMethod;
+		TypeDef stringDecrypterType;
+		MethodDef stringDecrypterMethod;
 		byte[] decryptedData;
 
 		public bool Detected {
 			get { return stringDecrypterType != null; }
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return stringDecrypterType; }
 		}
 
-		public MethodDefinition Method {
+		public MethodDef Method {
 			get { return stringDecrypterMethod; }
 		}
 
@@ -46,13 +46,13 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			get { return stringResource; }
 		}
 
-		public StringDecrypter(ModuleDefinition module) {
+		public StringDecrypter(ModuleDefMD module) {
 			this.module = module;
 		}
 
 		public void find() {
-			TypeDefinition type;
-			MethodDefinition method;
+			TypeDef type;
+			MethodDef method;
 			if (!findStringDecrypterType(out type, out method))
 				return;
 
@@ -68,15 +68,15 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			stringResource = DotNetUtils.getResource(module, resourceName) as EmbeddedResource;
 			if (stringResource == null)
 				return;
-			Log.v("Adding string decrypter. Resource: {0}", Utils.toCsharpString(stringResource.Name));
+			Logger.v("Adding string decrypter. Resource: {0}", Utils.toCsharpString(stringResource.Name));
 
 			decryptedData = resourceDecrypter.decrypt(stringResource.GetResourceStream());
 		}
 
 		string getResourceName() {
-			var defaultName = module.Assembly.Name.Name + module.Assembly.Name.Name;
+			var defaultName = module.Assembly.Name.String + module.Assembly.Name.String;
 
-			var cctor = DotNetUtils.getMethod(stringDecrypterType, ".cctor");
+			var cctor = stringDecrypterType.FindStaticConstructor();
 			if (cctor == null)
 				return defaultName;
 
@@ -98,7 +98,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return Encoding.Unicode.GetString(decryptedData, index, len);
 		}
 
-		bool findStringDecrypterType(out TypeDefinition theType, out MethodDefinition theMethod) {
+		bool findStringDecrypterType(out TypeDef theType, out MethodDef theMethod) {
 			theType = null;
 			theMethod = null;
 
@@ -114,7 +114,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 				if (type.NestedTypes.Count > 0)
 					continue;
 
-				MethodDefinition method = null;
+				MethodDef method = null;
 				foreach (var m in type.Methods) {
 					if (m.Name == ".ctor" || m.Name == ".cctor")
 						continue;
diff --git a/de4dot.code/deobfuscators/CryptoObfuscator/TamperDetection.cs b/de4dot.code/deobfuscators/CryptoObfuscator/TamperDetection.cs
index be7f0e6e..5d109be5 100644
--- a/de4dot.code/deobfuscators/CryptoObfuscator/TamperDetection.cs
+++ b/de4dot.code/deobfuscators/CryptoObfuscator/TamperDetection.cs
@@ -17,29 +17,29 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.CryptoObfuscator {
 	class TamperDetection {
-		ModuleDefinition module;
-		TypeDefinition tamperType;
-		MethodDefinition tamperMethod;
+		ModuleDefMD module;
+		TypeDef tamperType;
+		MethodDef tamperMethod;
 		FrameworkType frameworkType;
 
 		public bool Detected {
 			get { return tamperMethod != null; }
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return tamperType; }
 		}
 
-		public MethodDefinition Method {
+		public MethodDef Method {
 			get { return tamperMethod; }
 		}
 
-		public TamperDetection(ModuleDefinition module) {
+		public TamperDetection(ModuleDefMD module) {
 			this.module = module;
 			frameworkType = DotNetUtils.getFrameworkType(module);
 		}
@@ -51,7 +51,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 				return;
 		}
 
-		bool find(MethodDefinition methodToCheck) {
+		bool find(MethodDef methodToCheck) {
 			if (methodToCheck == null)
 				return false;
 
@@ -79,7 +79,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return false;
 		}
 
-		bool findDesktop(MethodDefinition method) {
+		bool findDesktop(MethodDef method) {
 			var type = method.DeclaringType;
 
 			if (!method.IsStatic || !DotNetUtils.isMethod(method, "System.Void", "()"))
@@ -107,7 +107,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			"System.Reflection.AssemblyName",
 			"System.String",
 		};
-		bool findSilverlight(MethodDefinition method) {
+		bool findSilverlight(MethodDef method) {
 			if (!new LocalTypes(method).exactly(requiredLocals_sl))
 				return false;
 			if (!DotNetUtils.callsMethod(method, "System.Int32 System.String::get_Length()"))
@@ -136,7 +136,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			"System.Int32",
 			"System.String",
 		};
-		bool findCompactFramework(MethodDefinition method) {
+		bool findCompactFramework(MethodDef method) {
 			if (!new LocalTypes(method).exactly(requiredLocals_cf))
 				return false;
 			if (!DotNetUtils.callsMethod(method, "System.Int32 System.String::get_Length()"))
diff --git a/de4dot.code/deobfuscators/DeepSea/ArrayBlockDeobfuscator.cs b/de4dot.code/deobfuscators/DeepSea/ArrayBlockDeobfuscator.cs
index 79bf6340..c757bd9e 100644
--- a/de4dot.code/deobfuscators/DeepSea/ArrayBlockDeobfuscator.cs
+++ b/de4dot.code/deobfuscators/DeepSea/ArrayBlockDeobfuscator.cs
@@ -18,15 +18,15 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 using de4dot.blocks.cflow;
 
 namespace de4dot.code.deobfuscators.DeepSea {
 	class ArrayBlockDeobfuscator : BlockDeobfuscator {
 		ArrayBlockState arrayBlockState;
-		Dictionary<VariableDefinition, ArrayBlockState.FieldInfo> localToInfo = new Dictionary<VariableDefinition, ArrayBlockState.FieldInfo>();
+		Dictionary<Local, ArrayBlockState.FieldInfo> localToInfo = new Dictionary<Local, ArrayBlockState.FieldInfo>();
 		DsConstantsReader constantsReader;
 
 		public ArrayBlockDeobfuscator(ArrayBlockState arrayBlockState) {
@@ -51,10 +51,10 @@ namespace de4dot.code.deobfuscators.DeepSea {
 					if (!stloc.isStloc())
 						continue;
 
-					var info = arrayBlockState.getFieldInfo((FieldReference)ldsfld.Operand);
+					var info = arrayBlockState.getFieldInfo((IField)ldsfld.Operand);
 					if (info == null)
 						continue;
-					var local = DotNetUtils.getLocalVar(blocks.Locals, stloc.Instruction);
+					var local = stloc.Instruction.GetLocal(blocks.Locals);
 					if (local == null)
 						continue;
 
@@ -99,7 +99,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			var ldloc = instrs[i];
 			if (!ldloc.isLdloc())
 				return false;
-			var local = DotNetUtils.getLocalVar(blocks.Locals, ldloc.Instruction);
+			var local = ldloc.Instruction.GetLocal(blocks.Locals);
 			if (local == null)
 				return false;
 			ArrayBlockState.FieldInfo info;
@@ -115,7 +115,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return false;
 
 			block.remove(i, 3 - 1);
-			instrs[i] = new Instr(DotNetUtils.createLdci4(info.array[ldci4.getLdcI4Value()]));
+			instrs[i] = new Instr(Instruction.CreateLdcI4(info.array[ldci4.getLdcI4Value()]));
 			return true;
 		}
 
@@ -127,7 +127,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			var ldsfld = instrs[i];
 			if (ldsfld.OpCode.Code != Code.Ldsfld)
 				return false;
-			var info = arrayBlockState.getFieldInfo(ldsfld.Operand as FieldReference);
+			var info = arrayBlockState.getFieldInfo(ldsfld.Operand as IField);
 			if (info == null)
 				return false;
 
@@ -140,7 +140,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return false;
 
 			block.remove(i, 3 - 1);
-			instrs[i] = new Instr(DotNetUtils.createLdci4(info.array[ldci4.getLdcI4Value()]));
+			instrs[i] = new Instr(Instruction.CreateLdcI4(info.array[ldci4.getLdcI4Value()]));
 			return true;
 		}
 
@@ -153,7 +153,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			var ldsfld = instrs[i];
 			if (ldsfld.OpCode.Code != Code.Ldsfld)
 				return false;
-			var info = arrayBlockState.getFieldInfo(ldsfld.Operand as FieldReference);
+			var info = arrayBlockState.getFieldInfo(ldsfld.Operand as IField);
 			if (info == null)
 				return false;
 
diff --git a/de4dot.code/deobfuscators/DeepSea/ArrayBlockState.cs b/de4dot.code/deobfuscators/DeepSea/ArrayBlockState.cs
index 383129ee..b0156011 100644
--- a/de4dot.code/deobfuscators/DeepSea/ArrayBlockState.cs
+++ b/de4dot.code/deobfuscators/DeepSea/ArrayBlockState.cs
@@ -18,22 +18,21 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.Cecil.Metadata;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.DeepSea {
 	class ArrayBlockState {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		FieldDefinitionAndDeclaringTypeDict<FieldInfo> fieldToInfo = new FieldDefinitionAndDeclaringTypeDict<FieldInfo>();
 
 		public class FieldInfo {
-			public readonly FieldDefinition field;
-			public readonly FieldDefinition arrayInitField;
+			public readonly FieldDef field;
+			public readonly FieldDef arrayInitField;
 			public readonly byte[] array;
 
-			public FieldInfo(FieldDefinition field, FieldDefinition arrayInitField) {
+			public FieldInfo(FieldDef field, FieldDef arrayInitField) {
 				this.field = field;
 				this.arrayInitField = arrayInitField;
 				this.array = (byte[])arrayInitField.InitialValue.Clone();
@@ -44,7 +43,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			get { return fieldToInfo.Count != 0; }
 		}
 
-		public ArrayBlockState(ModuleDefinition module) {
+		public ArrayBlockState(ModuleDefMD module) {
 			this.module = module;
 		}
 
@@ -52,39 +51,39 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			initializeArrays(simpleDeobfuscator, DotNetUtils.getModuleTypeCctor(module));
 		}
 
-		void initializeArrays(ISimpleDeobfuscator simpleDeobfuscator, MethodDefinition method) {
+		void initializeArrays(ISimpleDeobfuscator simpleDeobfuscator, MethodDef method) {
 			if (method == null || method.Body == null)
 				return;
 			while (initializeArrays2(simpleDeobfuscator, method)) {
 			}
 		}
 
-		bool initializeArrays2(ISimpleDeobfuscator simpleDeobfuscator, MethodDefinition method) {
+		bool initializeArrays2(ISimpleDeobfuscator simpleDeobfuscator, MethodDef method) {
 			bool foundField = false;
 			simpleDeobfuscator.deobfuscate(method, true);
 			var instructions = method.Body.Instructions;
 			for (int i = 0; i < instructions.Count; i++) {
 				var ldci4 = instructions[i];
-				if (!DotNetUtils.isLdcI4(ldci4))
+				if (!ldci4.IsLdcI4())
 					continue;
 				i++;
 				var instrs = DotNetUtils.getInstructions(instructions, i, OpCodes.Newarr, OpCodes.Dup, OpCodes.Ldtoken, OpCodes.Call, OpCodes.Stsfld);
 				if (instrs == null)
 					continue;
 
-				var arrayType = instrs[0].Operand as TypeReference;
-				if (arrayType == null || arrayType.EType != ElementType.U1)
+				var arrayType = instrs[0].Operand as ITypeDefOrRef;
+				if (arrayType == null || (arrayType.FullName != "System.Byte" && !arrayType.DefinitionAssembly.IsCorLib()))
 					continue;
 
-				var arrayInitField = instrs[2].Operand as FieldDefinition;
+				var arrayInitField = instrs[2].Operand as FieldDef;
 				if (arrayInitField == null || arrayInitField.InitialValue == null || arrayInitField.InitialValue.Length == 0)
 					continue;
 
-				var calledMethod = instrs[3].Operand as MethodReference;
+				var calledMethod = instrs[3].Operand as IMethod;
 				if (calledMethod == null || calledMethod.FullName != "System.Void System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(System.Array,System.RuntimeFieldHandle)")
 					continue;
 
-				var targetField = instrs[4].Operand as FieldDefinition;
+				var targetField = instrs[4].Operand as FieldDef;
 				if (targetField == null)
 					continue;
 
@@ -96,14 +95,14 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return foundField;
 		}
 
-		public FieldInfo getFieldInfo(FieldReference fieldRef) {
+		public FieldInfo getFieldInfo(IField fieldRef) {
 			if (fieldRef == null)
 				return null;
 			return fieldToInfo.find(fieldRef);
 		}
 
-		public IEnumerable<FieldDefinition> cleanUp() {
-			var removedFields = new List<FieldDefinition>();
+		public IEnumerable<FieldDef> cleanUp() {
+			var removedFields = new List<FieldDef>();
 			var moduleCctor = DotNetUtils.getModuleTypeCctor(module);
 			if (moduleCctor == null)
 				return removedFields;
@@ -118,7 +117,8 @@ namespace de4dot.code.deobfuscators.DeepSea {
 					removedFields.Add(fieldInfo.arrayInitField);
 				}
 				fieldInfo.arrayInitField.InitialValue = new byte[1];
-				fieldInfo.arrayInitField.FieldType = module.TypeSystem.Byte;
+				fieldInfo.arrayInitField.FieldSig.Type = module.CorLibTypes.Byte;
+				fieldInfo.arrayInitField.RVA = 0;
 			}
 
 			IList<Instruction> allInstructions;
@@ -148,7 +148,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 					var call = instrs[i + 4];
 					if (call.OpCode.Code != Code.Call)
 						continue;
-					var calledMethod = call.Operand as MethodReference;
+					var calledMethod = call.Operand as IMethod;
 					if (calledMethod == null || calledMethod.FullName != "System.Void System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(System.Array,System.RuntimeFieldHandle)")
 						continue;
 					var stsfld = instrs[i + 5];
@@ -174,7 +174,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 						continue;
 
 					foreach (var instr in method.Body.Instructions) {
-						var field = instr.Operand as FieldReference;
+						var field = instr.Operand as IField;
 						if (field == null)
 							continue;
 						var fieldInfo = fieldToInfo.find(field);
diff --git a/de4dot.code/deobfuscators/DeepSea/AssemblyResolver.cs b/de4dot.code/deobfuscators/DeepSea/AssemblyResolver.cs
index 49e0a041..587acfb2 100644
--- a/de4dot.code/deobfuscators/DeepSea/AssemblyResolver.cs
+++ b/de4dot.code/deobfuscators/DeepSea/AssemblyResolver.cs
@@ -21,15 +21,15 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Text.RegularExpressions;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.DeepSea {
 	class AssemblyResolver : ResolverBase {
 		Version version;
 		List<FieldInfo> fieldInfos;
-		MethodDefinition decryptMethod;
+		MethodDef decryptMethod;
 
 		enum Version {
 			Unknown,
@@ -62,20 +62,20 @@ namespace de4dot.code.deobfuscators.DeepSea {
 		}
 
 		class FieldInfo {
-			public FieldDefinition field;
+			public FieldDef field;
 			public int magic;
 
-			public FieldInfo(FieldDefinition field, int magic) {
+			public FieldInfo(FieldDef field, int magic) {
 				this.field = field;
 				this.magic = magic;
 			}
 		}
 
-		public MethodDefinition DecryptMethod {
+		public MethodDef DecryptMethod {
 			get { return decryptMethod; }
 		}
 
-		public AssemblyResolver(ModuleDefinition module, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob)
+		public AssemblyResolver(ModuleDefMD module, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob)
 			: base(module, simpleDeobfuscator, deob) {
 		}
 
@@ -86,7 +86,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			"System.Security.Cryptography.SHA1Managed",
 			"System.Windows.AssemblyPart",
 		};
-		protected override bool checkResolverInitMethodSilverlight(MethodDefinition resolverInitMethod) {
+		protected override bool checkResolverInitMethodSilverlight(MethodDef resolverInitMethod) {
 			if (resolverInitMethod.Body.ExceptionHandlers.Count != 1)
 				return false;
 
@@ -110,7 +110,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return false;
 		}
 
-		void updateVersion(MethodDefinition handler) {
+		void updateVersion(MethodDef handler) {
 			if (isV3Old(handler)) {
 				version = Version.V3Old;
 				return;
@@ -125,14 +125,14 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			}
 		}
 
-		static bool isV3SL(MethodDefinition handler) {
+		static bool isV3SL(MethodDef handler) {
 			var instrs = handler.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 3; i++) {
-				if (!DotNetUtils.isLdloc(instrs[i]))
+				if (!instrs[i].IsLdloc())
 					continue;
 				if (instrs[i + 1].OpCode.Code != Code.Add)
 					continue;
-				if (!DotNetUtils.isLdcI4(instrs[i + 2]))
+				if (!instrs[i + 2].IsLdcI4())
 					continue;
 				if (instrs[i + 3].OpCode.Code != Code.And)
 					continue;
@@ -141,14 +141,14 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return false;
 		}
 
-		static bool isV41SL(MethodDefinition handler) {
+		static bool isV41SL(MethodDef handler) {
 			var instrs = handler.Body.Instructions;
 			for (int i = 0; i < instrs.Count; i++) {
-				if (!DotNetUtils.isLdcI4(instrs[i]) || DotNetUtils.getLdcI4Value(instrs[i]) != 5)
+				if (!instrs[i].IsLdcI4() || instrs[i].GetLdcI4Value() != 5)
 					continue;
 				if (instrs[i + 1].OpCode.Code != Code.And)
 					continue;
-				if (!DotNetUtils.isLdcI4(instrs[i + 2]) || DotNetUtils.getLdcI4Value(instrs[i + 2]) != 0x1F)
+				if (!instrs[i + 2].IsLdcI4() || instrs[i + 2].GetLdcI4Value() != 0x1F)
 					continue;
 				if (instrs[i + 3].OpCode.Code != Code.And)
 					continue;
@@ -157,18 +157,18 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return false;
 		}
 
-		static bool isV3Old(MethodDefinition method) {
+		static bool isV3Old(MethodDef method) {
 			return DotNetUtils.callsMethod(method, "System.Int32 System.IO.Stream::Read(System.Byte[],System.Int32,System.Int32)") &&
 				!DotNetUtils.callsMethod(method, "System.Int32 System.IO.Stream::ReadByte()") &&
 				// Obfuscated System.Int32 System.IO.Stream::ReadByte()
 				!DotNetUtils.callsMethod(method, "System.Int32", "(System.IO.Stream,System.Int32,System.Int32)");
 		}
 
-		protected override bool checkResolverInitMethodInternal(MethodDefinition resolverInitMethod) {
+		protected override bool checkResolverInitMethodInternal(MethodDef resolverInitMethod) {
 			return DotNetUtils.callsMethod(resolverInitMethod, "System.Void System.AppDomain::add_AssemblyResolve(System.ResolveEventHandler)");
 		}
 
-		protected override bool checkHandlerMethodDesktopInternal(MethodDefinition handler) {
+		protected override bool checkHandlerMethodDesktopInternal(MethodDef handler) {
 			if (checkHandlerV3(handler) || checkHandlerSL(handler)) {
 				updateVersion(handler);
 				return true;
@@ -176,7 +176,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 
 			simpleDeobfuscator.deobfuscate(handler);
 			List<FieldInfo> fieldInfosTmp;
-			MethodDefinition decryptMethodTmp;
+			MethodDef decryptMethodTmp;
 			if (checkHandlerV4(handler, out fieldInfosTmp, out decryptMethodTmp)) {
 				version = Version.V4;
 				fieldInfos = fieldInfosTmp;
@@ -204,7 +204,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			"System.Security.Cryptography.SHA1CryptoServiceProvider",
 			"System.String",
 		};
-		static bool checkHandlerV3(MethodDefinition handler) {
+		static bool checkHandlerV3(MethodDef handler) {
 			return new LocalTypes(handler).all(handlerLocalTypes_NET);
 		}
 
@@ -216,12 +216,12 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			"System.String",
 			"System.Windows.AssemblyPart",
 		};
-		static bool checkHandlerSL(MethodDefinition handler) {
+		static bool checkHandlerSL(MethodDef handler) {
 			return new LocalTypes(handler).all(handlerLocalTypes_SL);
 		}
 
 		// 4.0.1.18 .. 4.0.3
-		bool checkHandlerV4(MethodDefinition handler, out List<FieldInfo> fieldInfos, out MethodDefinition decryptMethod) {
+		bool checkHandlerV4(MethodDef handler, out List<FieldInfo> fieldInfos, out MethodDef decryptMethod) {
 			fieldInfos = new List<FieldInfo>();
 			decryptMethod = null;
 
@@ -232,27 +232,27 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				var ldtoken = instrs[index++];
 				if (ldtoken.OpCode.Code != Code.Ldtoken)
 					continue;
-				var field = ldtoken.Operand as FieldDefinition;
+				var field = ldtoken.Operand as FieldDef;
 				if (field == null || field.InitialValue == null || field.InitialValue.Length == 0)
 					return false;
 
 				var ldci4_len = instrs[index++];
-				if (!DotNetUtils.isLdcI4(ldci4_len))
+				if (!ldci4_len.IsLdcI4())
 					return false;
-				if (DotNetUtils.getLdcI4Value(ldci4_len) != field.InitialValue.Length)
+				if (ldci4_len.GetLdcI4Value() != field.InitialValue.Length)
 					return false;
 
 				var ldci4_magic = instrs[index++];
-				if (!DotNetUtils.isLdcI4(ldci4_magic))
+				if (!ldci4_magic.IsLdcI4())
 					return false;
-				int magic = DotNetUtils.getLdcI4Value(ldci4_magic);
+				int magic = ldci4_magic.GetLdcI4Value();
 
 				var call = instrs[index++];
-				if (call.OpCode.Code == Code.Tail)
+				if (call.OpCode.Code == Code.Tailcall)
 					call = instrs[index++];
 				if (call.OpCode.Code != Code.Call)
 					return false;
-				var decryptMethodTmp = call.Operand as MethodDefinition;
+				var decryptMethodTmp = call.Operand as MethodDef;
 				if (!DotNetUtils.isMethod(decryptMethodTmp, "System.Reflection.Assembly", "(System.RuntimeFieldHandle,System.Int32,System.Int32)"))
 					return false;
 
@@ -264,7 +264,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 		}
 
 		// 4.0.4, 4.1+
-		Version checkHandlerV404_41(MethodDefinition handler, out List<FieldInfo> fieldInfos, out MethodDefinition decryptMethod) {
+		Version checkHandlerV404_41(MethodDef handler, out List<FieldInfo> fieldInfos, out MethodDef decryptMethod) {
 			Version version = Version.Unknown;
 			fieldInfos = new List<FieldInfo>();
 			decryptMethod = null;
@@ -274,26 +274,26 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				int index = i;
 
 				var ldci4_len = instrs[index++];
-				if (!DotNetUtils.isLdcI4(ldci4_len))
+				if (!ldci4_len.IsLdcI4())
 					continue;
 				if (instrs[index++].OpCode.Code != Code.Newarr)
 					continue;
-				if (!DotNetUtils.isStloc(instrs[index++]))
+				if (!instrs[index++].IsStloc())
 					continue;
-				if (!DotNetUtils.isLdloc(instrs[index++]))
+				if (!instrs[index++].IsLdloc())
 					continue;
 
 				var ldtoken = instrs[index++];
 				if (ldtoken.OpCode.Code != Code.Ldtoken)
 					continue;
-				var field = ldtoken.Operand as FieldDefinition;
+				var field = ldtoken.Operand as FieldDef;
 				if (field == null || field.InitialValue == null || field.InitialValue.Length == 0)
 					continue;
 
 				var call1 = instrs[index++];
 				if (call1.OpCode.Code != Code.Call)
 					continue;
-				if (!DotNetUtils.isMethod(call1.Operand as MethodReference, "System.Void", "(System.Array,System.RuntimeFieldHandle)"))
+				if (!DotNetUtils.isMethod(call1.Operand as IMethod, "System.Void", "(System.Array,System.RuntimeFieldHandle)"))
 					continue;
 
 				int callIndex = getCallDecryptMethodIndex(instrs, index);
@@ -302,7 +302,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				var args = DsUtils.getArgValues(instrs, callIndex);
 				if (args == null)
 					continue;
-				var decryptMethodTmp = instrs[callIndex].Operand as MethodDefinition;
+				var decryptMethodTmp = instrs[callIndex].Operand as MethodDef;
 				if (decryptMethodTmp == null)
 					continue;
 				int magic;
@@ -317,7 +317,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return version;
 		}
 
-		static bool getMagic(MethodDefinition method, IList<object> args, out Version version, out int magic) {
+		static bool getMagic(MethodDef method, IList<object> args, out Version version, out int magic) {
 			magic = 0;
 			int magicIndex = getMagicIndex(method, out version);
 			if (magicIndex < 0 || magicIndex >= args.Count)
@@ -330,7 +330,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return true;
 		}
 
-		static int getMagicIndex(MethodDefinition method, out Version version) {
+		static int getMagicIndex(MethodDef method, out Version version) {
 			int magicIndex = getMagicIndex404(method);
 			if (magicIndex >= 0) {
 				version = Version.V404;
@@ -347,44 +347,44 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return -1;
 		}
 
-		static int getMagicIndex404(MethodDefinition method) {
+		static int getMagicIndex404(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 4; i++) {
 				int index = i;
-				if (!DotNetUtils.isLdloc(instrs[index++]))
+				if (!instrs[index++].IsLdloc())
 					continue;
 				var ldarg = instrs[index++];
-				if (!DotNetUtils.isLdarg(ldarg))
+				if (!ldarg.IsLdarg())
 					continue;
 				if (instrs[index++].OpCode.Code != Code.Add)
 					continue;
 				var ldci4 = instrs[index++];
-				if (!DotNetUtils.isLdcI4(ldci4))
+				if (!ldci4.IsLdcI4())
 					continue;
-				if (DotNetUtils.getLdcI4Value(ldci4) != 0xFF)
+				if (ldci4.GetLdcI4Value() != 0xFF)
 					continue;
-				return DotNetUtils.getArgIndex(ldarg);
+				return ldarg.GetParameterIndex();
 			}
 			return -1;
 		}
 
-		static int getMagicIndex41Trial(MethodDefinition method) {
+		static int getMagicIndex41Trial(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 4; i++) {
 				int index = i;
 				if (instrs[index++].OpCode.Code != Code.Div)
 					continue;
 				var ldarg = instrs[index++];
-				if (!DotNetUtils.isLdarg(ldarg))
+				if (!ldarg.IsLdarg())
 					continue;
 				if (instrs[index++].OpCode.Code != Code.Add)
 					continue;
 				var ldci4 = instrs[index++];
-				if (!DotNetUtils.isLdcI4(ldci4))
+				if (!ldci4.IsLdcI4())
 					continue;
-				if (DotNetUtils.getLdcI4Value(ldci4) != 0xFF)
+				if (ldci4.GetLdcI4Value() != 0xFF)
 					continue;
-				return DotNetUtils.getArgIndex(ldarg);
+				return ldarg.GetParameterIndex();
 			}
 			return -1;
 		}
@@ -399,8 +399,8 @@ namespace de4dot.code.deobfuscators.DeepSea {
 					break;
 				if (instr.OpCode.Code != Code.Call)
 					continue;
-				var calledMethod = instr.Operand as MethodReference;
-				if (calledMethod == null || calledMethod.Parameters.Count < 2)
+				var calledMethod = instr.Operand as IMethod;
+				if (calledMethod == null || calledMethod.MethodSig.GetParamCount() < 2)
 					continue;
 
 				return i;
@@ -457,7 +457,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				var resource = tmp as EmbeddedResource;
 				if (resource == null)
 					continue;
-				if (!Regex.IsMatch(resource.Name, @"^[0-9A-F]{40}$"))
+				if (!Regex.IsMatch(resource.Name.String, @"^[0-9A-F]{40}$"))
 					continue;
 				var info = getAssemblyInfo(resource, decrypter);
 				if (info == null)
@@ -479,9 +479,9 @@ namespace de4dot.code.deobfuscators.DeepSea {
 		}
 
 		AssemblyInfo getAssemblyInfo(byte[] decryptedData, EmbeddedResource resource) {
-			var asm = AssemblyDefinition.ReadAssembly(new MemoryStream(decryptedData));
-			var fullName = asm.Name.FullName;
-			var simpleName = asm.Name.Name;
+			var asm = AssemblyDef.Load(decryptedData);
+			var fullName = asm.FullName;
+			var simpleName = asm.Name.String;
 			var extension = DeobUtils.getExtension(asm.Modules[0].Kind);
 			return new AssemblyInfo(decryptedData, fullName, simpleName, extension, resource);
 		}
@@ -496,7 +496,8 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				var decrypted = decrypter(fieldInfo.field.InitialValue, fieldInfo.magic);
 				infos.Add(getAssemblyInfo(decrypted, null));
 				fieldInfo.field.InitialValue = new byte[1];
-				fieldInfo.field.FieldType = module.TypeSystem.Byte;
+				fieldInfo.field.FieldSig.Type = module.CorLibTypes.Byte;
+				fieldInfo.field.RVA = 0;
 			}
 
 			return infos;
diff --git a/de4dot.code/deobfuscators/DeepSea/CastDeobfuscator.cs b/de4dot.code/deobfuscators/DeepSea/CastDeobfuscator.cs
index 1bb9c5f6..798debcc 100644
--- a/de4dot.code/deobfuscators/DeepSea/CastDeobfuscator.cs
+++ b/de4dot.code/deobfuscators/DeepSea/CastDeobfuscator.cs
@@ -21,20 +21,20 @@ using System;
 using System.Collections.Generic;
 using de4dot.blocks;
 using de4dot.blocks.cflow;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 
 namespace de4dot.code.deobfuscators.DeepSea {
 	class CastDeobfuscator : IBlocksDeobfuscator {
 		Blocks blocks;
-		Dictionary<VariableDefinition, LocalInfo> localInfos = new Dictionary<VariableDefinition, LocalInfo>();
+		Dictionary<Local, LocalInfo> localInfos = new Dictionary<Local, LocalInfo>();
 
 		class LocalInfo {
-			public readonly VariableDefinition local;
-			TypeReference type;
+			public readonly Local local;
+			ITypeDefOrRef type;
 			bool isValid;
 
-			public TypeReference CastType {
+			public ITypeDefOrRef CastType {
 				get { return type; }
 				set {
 					if (!isValid)
@@ -45,7 +45,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 						return;
 					}
 
-					if (type != null && !MemberReferenceHelper.compareTypes(type, value)) {
+					if (type != null && !new SigComparer().Equals(type, value)) {
 						invalid();
 						return;
 					}
@@ -54,7 +54,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				}
 			}
 
-			public LocalInfo(VariableDefinition local) {
+			public LocalInfo(Local local) {
 				this.local = local;
 				this.isValid = true;
 			}
@@ -67,7 +67,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			public override string ToString() {
 				if (type == null)
 					return string.Format("{0} - INVALID", local);
-				return string.Format("{0} - {1:X8} {2}", local, type.MetadataToken.ToInt32(), type.FullName);
+				return string.Format("{0} - {1:X8} {2}", local, type.MDToken.ToInt32(), type.FullName);
 			}
 		}
 
@@ -92,13 +92,13 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				for (int i = 0; i < instrs.Count - 1; i++) {
 					var instr = instrs[i];
 					if (instr.OpCode.Code == Code.Ldloca || instr.OpCode.Code == Code.Ldloca_S) {
-						var local = instr.Operand as VariableDefinition;
+						var local = instr.Operand as Local;
 						if (local == null)
 							continue;
 						localInfos[local].invalid();
 					}
 					else if (instr.isLdloc()) {
-						var local = DotNetUtils.getLocalVar(blocks.Locals, instr.Instruction);
+						var local = instr.Instruction.GetLocal(blocks.Locals);
 						if (local == null)
 							continue;
 						var localInfo = localInfos[local];
@@ -120,7 +120,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			foreach (var info in localInfos.Values) {
 				if (info.CastType == null)
 					continue;
-				info.local.VariableType = info.CastType;
+				info.local.Type = info.CastType.ToTypeSig();
 			}
 
 			if (changed) {
@@ -137,18 +137,18 @@ namespace de4dot.code.deobfuscators.DeepSea {
 						}
 
 						if (instr.isLdarg())
-							addCast(block, castIndex, i + 1, DotNetUtils.getArgType(blocks.Method, instr.Instruction));
+							addCast(block, castIndex, i + 1, instr.Instruction.GetArgumentType(blocks.Method.MethodSig, blocks.Method.DeclaringType));
 						else if (instr.OpCode.Code == Code.Ldfld || instr.OpCode.Code == Code.Ldsfld) {
-							var field = instr.Operand as FieldReference;
+							var field = instr.Operand as IField;
 							if (field == null)
 								continue;
-							addCast(block, castIndex, i + 1, field.FieldType);
+							addCast(block, castIndex, i + 1, field.FieldSig.GetFieldType());
 						}
 						else if (instr.OpCode.Code == Code.Call || instr.OpCode.Code == Code.Callvirt) {
-							var calledMethod = instr.Operand as MethodReference;
+							var calledMethod = instr.Operand as IMethod;
 							if (calledMethod == null || !DotNetUtils.hasReturnValue(calledMethod))
 								continue;
-							addCast(block, castIndex, i + 1, calledMethod.MethodReturnType.ReturnType);
+							addCast(block, castIndex, i + 1, calledMethod.MethodSig.GetRetType());
 						}
 					}
 				}
@@ -157,7 +157,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return changed;
 		}
 
-		bool addCast(Block block, int castIndex, int index, TypeReference type) {
+		bool addCast(Block block, int castIndex, int index, TypeSig type) {
 			if (type == null)
 				return false;
 			if (castIndex >= block.Instructions.Count || index >= block.Instructions.Count)
@@ -165,14 +165,14 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			var stloc = block.Instructions[index];
 			if (!stloc.isStloc())
 				return false;
-			var local = DotNetUtils.getLocalVar(blocks.Locals, stloc.Instruction);
+			var local = stloc.Instruction.GetLocal(blocks.Locals);
 			if (local == null)
 				return false;
 			var localInfo = localInfos[local];
 			if (localInfo.CastType == null)
 				return false;
 
-			if (!MemberReferenceHelper.compareTypes(localInfo.CastType, type))
+			if (!new SigComparer().Equals(localInfo.CastType, type))
 				block.insert(castIndex, new Instruction(OpCodes.Castclass, localInfo.CastType));
 			return true;
 		}
@@ -190,7 +190,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 					var ldloc = instrs[i];
 					if (!ldloc.isLdloc())
 						continue;
-					var local = DotNetUtils.getLocalVar(blocks.Locals, ldloc.Instruction);
+					var local = ldloc.Instruction.GetLocal(blocks.Locals);
 					if (local == null)
 						continue;
 					var localInfo = localInfos[local];
@@ -204,10 +204,10 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return instr.OpCode.Code == Code.Castclass || instr.OpCode.Code == Code.Isinst;
 		}
 
-		static TypeReference getCastType(Instr instr) {
+		static ITypeDefOrRef getCastType(Instr instr) {
 			if (!isCast(instr))
 				return null;
-			return instr.Operand as TypeReference;
+			return instr.Operand as ITypeDefOrRef;
 		}
 	}
 }
diff --git a/de4dot.code/deobfuscators/DeepSea/Deobfuscator.cs b/de4dot.code/deobfuscators/DeepSea/Deobfuscator.cs
index 0a3bede0..9d9e45c5 100644
--- a/de4dot.code/deobfuscators/DeepSea/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/DeepSea/Deobfuscator.cs
@@ -18,7 +18,7 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 using de4dot.blocks.cflow;
 
@@ -266,7 +266,7 @@ done:
 		}
 
 		public override void deobfuscateEnd() {
-			if (options.RestoreFields)
+			if (options.RestoreFields && CanRemoveTypes)
 				fieldsRestorer.cleanUp();
 			removeInlinedMethods();
 
@@ -292,7 +292,7 @@ done:
 		public override IEnumerable<int> getStringDecrypterMethods() {
 			var list = new List<int>();
 			foreach (var method in stringDecrypter.DecrypterMethods)
-				list.Add(method.MetadataToken.ToInt32());
+				list.Add(method.MDToken.ToInt32());
 			return list;
 		}
 	}
diff --git a/de4dot.code/deobfuscators/DeepSea/DsConstantsReader.cs b/de4dot.code/deobfuscators/DeepSea/DsConstantsReader.cs
index b42aa156..02b94d18 100644
--- a/de4dot.code/deobfuscators/DeepSea/DsConstantsReader.cs
+++ b/de4dot.code/deobfuscators/DeepSea/DsConstantsReader.cs
@@ -18,7 +18,7 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil.Cil;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.DeepSea {
diff --git a/de4dot.code/deobfuscators/DeepSea/DsInlinedMethodsFinder.cs b/de4dot.code/deobfuscators/DeepSea/DsInlinedMethodsFinder.cs
index 57e92ae5..c4c5f5b5 100644
--- a/de4dot.code/deobfuscators/DeepSea/DsInlinedMethodsFinder.cs
+++ b/de4dot.code/deobfuscators/DeepSea/DsInlinedMethodsFinder.cs
@@ -18,16 +18,16 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace de4dot.code.deobfuscators.DeepSea {
 	static class DsInlinedMethodsFinder {
-		public static List<MethodDefinition> find(ModuleDefinition module, IEnumerable<MethodDefinition> notInlinedMethods) {
-			var notInlinedMethodsDict = new Dictionary<MethodDefinition, bool>();
+		public static List<MethodDef> find(ModuleDefMD module, IEnumerable<MethodDef> notInlinedMethods) {
+			var notInlinedMethodsDict = new Dictionary<MethodDef, bool>();
 			foreach (var method in notInlinedMethods)
 				notInlinedMethodsDict[method] = true;
 
-			var inlinedMethods = new List<MethodDefinition>();
+			var inlinedMethods = new List<MethodDef>();
 
 			foreach (var type in module.GetTypes()) {
 				foreach (var method in type.Methods) {
diff --git a/de4dot.code/deobfuscators/DeepSea/DsMethodCallInliner.cs b/de4dot.code/deobfuscators/DeepSea/DsMethodCallInliner.cs
index 8d3deefe..1fab08f5 100644
--- a/de4dot.code/deobfuscators/DeepSea/DsMethodCallInliner.cs
+++ b/de4dot.code/deobfuscators/DeepSea/DsMethodCallInliner.cs
@@ -18,19 +18,18 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.Cecil.Metadata;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 using de4dot.blocks.cflow;
 
 namespace de4dot.code.deobfuscators.DeepSea {
 	class DsMethodCallInliner : MethodCallInlinerBase {
 		InstructionEmulator instructionEmulator = new InstructionEmulator();
-		List<ParameterDefinition> parameters;
-		ParameterDefinition arg1, arg2;
+		IList<Parameter> parameters;
+		Parameter arg1, arg2;
 		Value returnValue;
-		MethodDefinition methodToInline;
+		MethodDef methodToInline;
 		CachedCflowDeobfuscator cflowDeobfuscator;
 
 		public DsMethodCallInliner(CachedCflowDeobfuscator cflowDeobfuscator) {
@@ -51,7 +50,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 		}
 
 		bool inlineMethod(Instruction callInstr, int instrIndex) {
-			var method = callInstr.Operand as MethodDefinition;
+			var method = callInstr.Operand as MethodDef;
 			if (method == null)
 				return false;
 			if (!canInline(method))
@@ -70,17 +69,19 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return true;
 		}
 
-		bool inlineMethod(MethodDefinition methodToInline, int instrIndex, int const1, int const2) {
+		bool inlineMethod(MethodDef methodToInline, int instrIndex, int const1, int const2) {
 			this.methodToInline = methodToInline = cflowDeobfuscator.deobfuscate(methodToInline);
 
-			parameters = DotNetUtils.getParameters(methodToInline);
+			parameters = methodToInline.Parameters;
 			arg1 = parameters[parameters.Count - 2];
 			arg2 = parameters[parameters.Count - 1];
 			returnValue = null;
 
 			instructionEmulator.init(methodToInline);
 			foreach (var arg in parameters) {
-				if (arg.ParameterType.EType >= ElementType.Boolean && arg.ParameterType.EType <= ElementType.U4)
+				if (!arg.IsNormalMethodParameter)
+					continue;
+				if (arg.Type.ElementType >= ElementType.Boolean && arg.Type.ElementType <= ElementType.U4)
 					instructionEmulator.setArg(arg, new Int32Value(0));
 			}
 			instructionEmulator.setArg(arg1, new Int32Value(const1));
@@ -157,7 +158,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				case Code.Ldarg_1:
 				case Code.Ldarg_2:
 				case Code.Ldarg_3:
-					var arg = DotNetUtils.getParameter(parameters, instr);
+					var arg = instr.GetParameter(parameters);
 					if (arg != arg1 && arg != arg2) {
 						if (!allowUnknownArgs)
 							goto done;
@@ -269,7 +270,7 @@ done:
 
 		bool emulateToReturn(int index, Instruction lastInstr) {
 			int pushes, pops;
-			DotNetUtils.calculateStackUsage(lastInstr, false, out pushes, out pops);
+			lastInstr.CalculateStackUsage(false, out pushes, out pops);
 			for (int i = 0; i < pops; i++)
 				instructionEmulator.pop();
 
@@ -294,7 +295,7 @@ done:
 			return instructionEmulator.stackSize() == 0;
 		}
 
-		public static bool canInline(MethodDefinition method) {
+		public static bool canInline(MethodDef method) {
 			if (method == null || method.Body == null)
 				return false;
 			if (method.Attributes != (MethodAttributes.Assembly | MethodAttributes.Static))
@@ -304,15 +305,15 @@ done:
 			if (method.Body.ExceptionHandlers.Count > 0)
 				return false;
 
-			var parameters = method.Parameters;
+			var parameters = method.MethodSig.GetParams();
 			int paramCount = parameters.Count;
 			if (paramCount < 2)
 				return false;
 			var param1 = parameters[paramCount - 1];
 			var param2 = parameters[paramCount - 2];
-			if (!isIntType(param1.ParameterType.EType))
+			if (!isIntType(param1.ElementType))
 				return false;
-			if (!isIntType(param2.ParameterType.EType))
+			if (!isIntType(param2.ElementType))
 				return false;
 
 			return true;
@@ -322,7 +323,7 @@ done:
 			return etype == ElementType.Char || etype == ElementType.I2 || etype == ElementType.I4;
 		}
 
-		protected override bool isReturn(MethodDefinition methodToInline, int instrIndex) {
+		protected override bool isReturn(MethodDef methodToInline, int instrIndex) {
 			int oldIndex = instrIndex;
 			if (base.isReturn(methodToInline, oldIndex))
 				return true;
diff --git a/de4dot.code/deobfuscators/DeepSea/DsUtils.cs b/de4dot.code/deobfuscators/DeepSea/DsUtils.cs
index 3366a669..f3734d15 100644
--- a/de4dot.code/deobfuscators/DeepSea/DsUtils.cs
+++ b/de4dot.code/deobfuscators/DeepSea/DsUtils.cs
@@ -18,8 +18,8 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.DeepSea {
@@ -40,7 +40,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return args;
 		}
 
-		public static bool getArgValue(MethodDefinition method, int index, out object arg) {
+		public static bool getArgValue(MethodDef method, int index, out object arg) {
 			return getArgValue(method.Body.Instructions[index], out arg);
 		}
 
diff --git a/de4dot.code/deobfuscators/DeepSea/FieldsRestorer.cs b/de4dot.code/deobfuscators/DeepSea/FieldsRestorer.cs
index dfb5b30f..14073906 100644
--- a/de4dot.code/deobfuscators/DeepSea/FieldsRestorer.cs
+++ b/de4dot.code/deobfuscators/DeepSea/FieldsRestorer.cs
@@ -19,22 +19,21 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.Cecil.Metadata;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.DeepSea {
 	// DS 4.x can move fields from a class to a struct. This class restores the fields.
 	class FieldsRestorer {
-		ModuleDefinition module;
-		TypeDefinitionDict<List<TypeDefinition>> structToOwners = new TypeDefinitionDict<List<TypeDefinition>>();
+		ModuleDefMD module;
+		TypeDefinitionDict<List<TypeDef>> structToOwners = new TypeDefinitionDict<List<TypeDef>>();
 		FieldDefinitionAndDeclaringTypeDict<bool> structFieldsToFix = new FieldDefinitionAndDeclaringTypeDict<bool>();
-		TypeDefinitionDict<FieldDefinitionAndDeclaringTypeDict<FieldDefinition>> typeToFieldsDict = new TypeDefinitionDict<FieldDefinitionAndDeclaringTypeDict<FieldDefinition>>();
+		TypeDefinitionDict<FieldDefinitionAndDeclaringTypeDict<FieldDef>> typeToFieldsDict = new TypeDefinitionDict<FieldDefinitionAndDeclaringTypeDict<FieldDef>>();
 
-		public List<TypeDefinition> FieldStructs {
+		public List<TypeDef> FieldStructs {
 			get {
-				var list = new List<TypeDefinition>(structToOwners.Count);
+				var list = new List<TypeDef>(structToOwners.Count);
 				foreach (var structType in structToOwners.getKeys()) {
 					if (!hasNoMethods(structType))
 						continue;
@@ -45,22 +44,22 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			}
 		}
 
-		static bool hasNoMethods(TypeDefinition type) {
+		static bool hasNoMethods(TypeDef type) {
 			if (type.Methods.Count == 0)
 				return true;
 			if (type.BaseType == null)
 				return false;
-			if (type.BaseType.EType != ElementType.Object)
+			if (type.BaseType.FullName != "System.Object")
 				return false;
 			if (type.Methods.Count != 1)
 				return false;
 			var ctor = type.Methods[0];
-			if (ctor.Name != ".ctor" || ctor.Parameters.Count != 0)
+			if (ctor.Name != ".ctor" || ctor.MethodSig.GetParamCount() != 0)
 				return false;
 			return true;
 		}
 
-		public FieldsRestorer(ModuleDefinition module) {
+		public FieldsRestorer(ModuleDefMD module) {
 			this.module = module;
 		}
 
@@ -71,16 +70,16 @@ namespace de4dot.code.deobfuscators.DeepSea {
 
 				foreach (var ownerType in kv.Value) {
 					foreach (var ownerField in ownerType.Fields) {
-						if (DotNetUtils.getType(module, ownerField.FieldType) != structType)
+						if (DotNetUtils.getType(module, ownerField.FieldSig.GetFieldType()) != structType)
 							continue;
 						structFieldsToFix.add(ownerField, true);
 						break;
 					}
 
-					var fieldsDict = new FieldDefinitionAndDeclaringTypeDict<FieldDefinition>();
+					var fieldsDict = new FieldDefinitionAndDeclaringTypeDict<FieldDef>();
 					typeToFieldsDict.add(ownerType, fieldsDict);
 					foreach (var structField in structType.Fields) {
-						var newField = DotNetUtils.createFieldDefinition(structField.Name, structField.Attributes, structField.FieldType);
+						var newField = module.UpdateRowId(new FieldDefUser(structField.Name, structField.FieldSig.Clone(), structField.Attributes));
 						ownerType.Fields.Add(newField);
 						fieldsDict.add(structField, newField);
 					}
@@ -88,12 +87,12 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			}
 		}
 
-		Dictionary<TypeDefinition, List<TypeDefinition>> getMovedTypes() {
-			var candidates = new Dictionary<TypeDefinition, List<TypeDefinition>>();
-			var typeToStruct = new Dictionary<TypeDefinition, TypeDefinition>();
+		Dictionary<TypeDef, List<TypeDef>> getMovedTypes() {
+			var candidates = new Dictionary<TypeDef, List<TypeDef>>();
+			var typeToStruct = new Dictionary<TypeDef, TypeDef>();
 			foreach (var type in module.GetTypes()) {
 				foreach (var field in getPossibleFields(type)) {
-					var fieldType = DotNetUtils.getType(module, field.FieldType);
+					var fieldType = DotNetUtils.getType(module, field.FieldSig.GetFieldType());
 					if (fieldType == null)
 						continue;
 					if (!checkBaseType(fieldType))
@@ -113,9 +112,9 @@ namespace de4dot.code.deobfuscators.DeepSea {
 					if (!checkFields(fieldType))
 						continue;
 
-					List<TypeDefinition> list;
+					List<TypeDef> list;
 					if (!candidates.TryGetValue(fieldType, out list))
-						candidates[fieldType] = list = new List<TypeDefinition>();
+						candidates[fieldType] = list = new List<TypeDef>();
 					list.Add(type);
 					typeToStruct[type] = fieldType;
 					break;
@@ -123,20 +122,20 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			}
 
 			foreach (var type in module.GetTypes()) {
-				TypeDefinition structType;
+				TypeDef structType;
 				typeToStruct.TryGetValue(type, out structType);
 
 				foreach (var field in type.Fields) {
-					if (field.IsStatic || field.FieldType != structType)
-						removeType(candidates, field.FieldType);
+					if (field.IsStatic || field.FieldSig.GetFieldType().TryGetTypeDef() != structType)
+						removeType(candidates, field.FieldSig.GetFieldType());
 				}
 				foreach (var method in type.Methods) {
-					removeType(candidates, method.MethodReturnType.ReturnType);
-					foreach (var parameter in method.Parameters)
-						removeType(candidates, parameter.ParameterType);
+					removeType(candidates, method.MethodSig.GetRetType());
+					foreach (var parameter in method.MethodSig.GetParams())
+						removeType(candidates, parameter);
 					if (method.Body != null) {
-						foreach (var local in method.Body.Variables)
-							removeType(candidates, local.VariableType);
+						foreach (var local in method.Body.LocalList)
+							removeType(candidates, local.Type);
 					}
 				}
 			}
@@ -144,19 +143,19 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return candidates;
 		}
 
-		IEnumerable<FieldDefinition> getPossibleFields(TypeDefinition type) {
-			var typeToFields = new TypeDefinitionDict<List<FieldDefinition>>();
+		IEnumerable<FieldDef> getPossibleFields(TypeDef type) {
+			var typeToFields = new TypeDefinitionDict<List<FieldDef>>();
 			foreach (var field in type.Fields) {
 				if (field.Attributes != FieldAttributes.Private)
 					continue;
-				var fieldType = DotNetUtils.getType(module, field.FieldType);
+				var fieldType = DotNetUtils.getType(module, field.FieldSig.GetFieldType());
 				if (fieldType == null)
 					continue;
 				if (!checkBaseType(fieldType))
 					continue;
 				var list = typeToFields.find(fieldType);
 				if (list == null)
-					typeToFields.add(fieldType, list = new List<FieldDefinition>());
+					typeToFields.add(fieldType, list = new List<FieldDef>());
 				list.Add(field);
 			}
 
@@ -166,24 +165,25 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			}
 		}
 
-		static bool checkBaseType(TypeDefinition type) {
+		static bool checkBaseType(TypeDef type) {
 			if (type == null || type.BaseType == null)
 				return false;
-			return type.BaseType.FullName == "System.ValueType" || type.BaseType.EType == ElementType.Object;
+			var fn = type.BaseType.FullName;
+			return fn == "System.ValueType" || fn == "System.Object";
 		}
 
-		void removeType(Dictionary<TypeDefinition, List<TypeDefinition>> candidates, TypeReference type) {
+		void removeType(Dictionary<TypeDef, List<TypeDef>> candidates, TypeSig type) {
 			var typeDef = DotNetUtils.getType(module, type);
 			if (typeDef == null)
 				return;
 			candidates.Remove(typeDef);
 		}
 
-		static bool checkMethods(TypeDefinition type) {
+		static bool checkMethods(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (method.Name == ".cctor")
 					continue;
-				if (type.BaseType != null && type.BaseType.EType == ElementType.Object && method.Name == ".ctor" && method.Parameters.Count == 0)
+				if (type.BaseType != null && type.BaseType.FullName == "System.Object" && method.Name == ".ctor" && method.MethodSig.GetParamCount() == 0)
 					continue;
 				if (!method.IsStatic)
 					return true;
@@ -191,13 +191,13 @@ namespace de4dot.code.deobfuscators.DeepSea {
 					return true;
 				if (method.Body == null)
 					return true;
-				if (method.HasPInvokeInfo || method.PInvokeInfo != null)
+				if (method.ImplMap != null)
 					return true;
 			}
 			return false;
 		}
 
-		static bool checkFields(TypeDefinition type) {
+		static bool checkFields(TypeDef type) {
 			if (type.Fields.Count == 0)
 				return false;
 			foreach (var field in type.Fields) {
@@ -223,12 +223,12 @@ namespace de4dot.code.deobfuscators.DeepSea {
 					var instr = instrs[i];
 					if (instr.OpCode.Code != Code.Ldflda && instr.OpCode.Code != Code.Ldfld)
 						continue;
-					var structField = instr.Operand as FieldReference;
+					var structField = instr.Operand as IField;
 					if (structField == null || !structFieldsToFix.find(structField))
 						continue;
 
 					var ldStFld = instrs[findLdStFieldIndex(instrs, i + 1)];
-					ldStFld.Operand = getNewField(structField, ldStFld.Operand as FieldReference);
+					ldStFld.Operand = getNewField(structField, ldStFld.Operand as IField);
 					instrsToRemove.Add(i);
 				}
 				if (instrsToRemove.Count > 0)
@@ -246,7 +246,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 					var stfld = instrs[i];
 					if (stfld.OpCode.Code != Code.Stfld)
 						continue;
-					var field = stfld.Operand as FieldReference;
+					var field = stfld.Operand as IField;
 					if (field == null)
 						continue;
 					if (!structFieldsToFix.find(field))
@@ -270,7 +270,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return newInstrs;
 		}
 
-		FieldDefinition getNewField(FieldReference structField, FieldReference oldFieldRef) {
+		FieldDef getNewField(IField structField, IField oldFieldRef) {
 			var fieldsDict = typeToFieldsDict.find(structField.DeclaringType);
 			if (fieldsDict == null)
 				throw new ApplicationException("Could not find structField declaringType");
@@ -291,7 +291,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 					return i;
 
 				int pushes, pops;
-				DotNetUtils.calculateStackUsage(instr.Instruction, false, out pushes, out pops);
+				instr.Instruction.CalculateStackUsage(false, out pushes, out pops);
 				stack -= pops;
 				if (stack < 0)
 					break;
diff --git a/de4dot.code/deobfuscators/DeepSea/ResolverBase.cs b/de4dot.code/deobfuscators/DeepSea/ResolverBase.cs
index 6648e6fe..ea764de2 100644
--- a/de4dot.code/deobfuscators/DeepSea/ResolverBase.cs
+++ b/de4dot.code/deobfuscators/DeepSea/ResolverBase.cs
@@ -19,24 +19,24 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.DeepSea {
 	abstract class ResolverBase {
-		protected ModuleDefinition module;
+		protected ModuleDefMD module;
 		protected ISimpleDeobfuscator simpleDeobfuscator;
 		protected IDeobfuscator deob;
-		protected MethodDefinition initMethod;
-		protected MethodDefinition resolveHandler;
+		protected MethodDef initMethod;
+		protected MethodDef resolveHandler;
 		protected FrameworkType frameworkType;
 
-		public MethodDefinition InitMethod {
+		public MethodDef InitMethod {
 			get { return initMethod; }
 		}
 
-		public MethodDefinition HandlerMethod {
+		public MethodDef HandlerMethod {
 			get { return resolveHandler; }
 		}
 
@@ -44,7 +44,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			get { return initMethod != null; }
 		}
 
-		public ResolverBase(ModuleDefinition module, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
+		public ResolverBase(ModuleDefMD module, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
 			this.module = module;
 			this.frameworkType = DotNetUtils.getFrameworkType(module);
 			this.simpleDeobfuscator = simpleDeobfuscator;
@@ -58,7 +58,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return;
 		}
 
-		bool checkCalledMethods(MethodDefinition checkMethod) {
+		bool checkCalledMethods(MethodDef checkMethod) {
 			if (checkMethod == null || checkMethod.Body == null)
 				return false;
 
@@ -75,7 +75,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return false;
 		}
 
-		bool checkResolverInitMethod(MethodDefinition resolverInitMethod) {
+		bool checkResolverInitMethod(MethodDef resolverInitMethod) {
 			if (resolverInitMethod == null || resolverInitMethod.Body == null)
 				return false;
 			if (resolverInitMethod.Body.ExceptionHandlers.Count != 1)
@@ -89,7 +89,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			}
 		}
 
-		bool checkResolverInitMethodDesktop(MethodDefinition resolverInitMethod) {
+		bool checkResolverInitMethodDesktop(MethodDef resolverInitMethod) {
 			simpleDeobfuscator.deobfuscate(resolverInitMethod);
 			if (!checkResolverInitMethodInternal(resolverInitMethod))
 				return false;
@@ -106,25 +106,25 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return false;
 		}
 
-		protected virtual bool checkResolverInitMethodSilverlight(MethodDefinition resolverInitMethod) {
+		protected virtual bool checkResolverInitMethodSilverlight(MethodDef resolverInitMethod) {
 			return false;
 		}
 
-		protected abstract bool checkResolverInitMethodInternal(MethodDefinition resolverInitMethod);
+		protected abstract bool checkResolverInitMethodInternal(MethodDef resolverInitMethod);
 
-		IEnumerable<MethodDefinition> getLdftnMethods(MethodDefinition method) {
-			var list = new List<MethodDefinition>();
+		IEnumerable<MethodDef> getLdftnMethods(MethodDef method) {
+			var list = new List<MethodDef>();
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Ldftn)
 					continue;
-				var loadedMethod = instr.Operand as MethodDefinition;
+				var loadedMethod = instr.Operand as MethodDef;
 				if (loadedMethod != null)
 					list.Add(loadedMethod);
 			}
 			return list;
 		}
 
-		bool checkHandlerMethodDesktop(MethodDefinition handler) {
+		bool checkHandlerMethodDesktop(MethodDef handler) {
 			if (handler == null || handler.Body == null || !handler.IsStatic)
 				return false;
 			if (!DotNetUtils.isMethod(handler, "System.Reflection.Assembly", "(System.Object,System.ResolveEventArgs)"))
@@ -132,7 +132,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return checkHandlerMethodDesktopInternal(handler);
 		}
 
-		protected abstract bool checkHandlerMethodDesktopInternal(MethodDefinition handler);
+		protected abstract bool checkHandlerMethodDesktopInternal(MethodDef handler);
 
 		// 3.0.3.41 - 3.0.4.44
 		protected static byte[] decryptResourceV3Old(EmbeddedResource resource) {
diff --git a/de4dot.code/deobfuscators/DeepSea/ResourceResolver.cs b/de4dot.code/deobfuscators/DeepSea/ResourceResolver.cs
index aeeeb64a..2b419051 100644
--- a/de4dot.code/deobfuscators/DeepSea/ResourceResolver.cs
+++ b/de4dot.code/deobfuscators/DeepSea/ResourceResolver.cs
@@ -19,8 +19,8 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.DeepSea {
@@ -42,30 +42,30 @@ namespace de4dot.code.deobfuscators.DeepSea {
 		}
 
 		class Data40 {
-			public FieldDefinition resourceField;
-			public MethodDefinition resolveHandler2;
-			public MethodDefinition getDataMethod;
+			public FieldDef resourceField;
+			public MethodDef resolveHandler2;
+			public MethodDef getDataMethod;
 			public int magic;
 		}
 
 		class Data41 {
-			public FieldDefinition resourceField;
-			public MethodDefinition resolveHandler2;
+			public FieldDef resourceField;
+			public MethodDef resolveHandler2;
 			public int magic;
 			public bool isTrial;
 		}
 
 		class HandlerInfo {
-			public MethodDefinition handler;
+			public MethodDef handler;
 			public IList<object> args;
 
-			public HandlerInfo(MethodDefinition handler, IList<object> args) {
+			public HandlerInfo(MethodDef handler, IList<object> args) {
 				this.handler = handler;
 				this.args = args;
 			}
 		}
 
-		public MethodDefinition InitMethod2 {
+		public MethodDef InitMethod2 {
 			get {
 				if (data40 != null)
 					return data40.resolveHandler2;
@@ -75,7 +75,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			}
 		}
 
-		public MethodDefinition GetDataMethod {
+		public MethodDef GetDataMethod {
 			get { return data40 != null ? data40.getDataMethod : null; }
 		}
 
@@ -83,15 +83,15 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			get { return data30 != null ? data30.resource : null; }
 		}
 
-		public ResourceResolver(ModuleDefinition module, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob)
+		public ResourceResolver(ModuleDefMD module, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob)
 			: base(module, simpleDeobfuscator, deob) {
 		}
 
-		protected override bool checkResolverInitMethodInternal(MethodDefinition resolverInitMethod) {
+		protected override bool checkResolverInitMethodInternal(MethodDef resolverInitMethod) {
 			return DotNetUtils.callsMethod(resolverInitMethod, "System.Void System.AppDomain::add_ResourceResolve(System.ResolveEventHandler)");
 		}
 
-		protected override bool checkHandlerMethodDesktopInternal(MethodDefinition handler) {
+		protected override bool checkHandlerMethodDesktopInternal(MethodDef handler) {
 			if (checkHandlerV3(handler)) {
 				version = ResourceVersion.V3;
 				return true;
@@ -114,13 +114,13 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return false;
 		}
 
-		HandlerInfo getHandlerArgs41(MethodDefinition handler) {
+		HandlerInfo getHandlerArgs41(MethodDef handler) {
 			var instrs = handler.Body.Instructions;
 			for (int i = 0; i < instrs.Count; i++) {
 				var instr = instrs[i];
 				if (instr.OpCode.Code != Code.Call)
 					continue;
-				var calledMethod = instr.Operand as MethodDefinition;
+				var calledMethod = instr.Operand as MethodDef;
 				if (calledMethod == null)
 					continue;
 				if (getLdtokenField(calledMethod) == null)
@@ -145,7 +145,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				magicArgIndex = getMagicArgIndex41Trial(info.handler);
 				data41.isTrial = true;
 			}
-			var asmVer = module.Assembly.Name.Version;
+			var asmVer = module.Assembly.Version;
 			if (magicArgIndex < 0 || magicArgIndex >= info.args.Count)
 				return false;
 			var val = info.args[magicArgIndex];
@@ -158,48 +158,48 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return true;
 		}
 
-		static int getMagicArgIndex41Retail(MethodDefinition method) {
+		static int getMagicArgIndex41Retail(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 3; i++) {
 				var add = instrs[i];
 				if (add.OpCode.Code != Code.Add)
 					continue;
 				var ldarg = instrs[i + 1];
-				if (!DotNetUtils.isLdarg(ldarg))
+				if (!ldarg.IsLdarg())
 					continue;
 				var sub = instrs[i + 2];
 				if (sub.OpCode.Code != Code.Sub)
 					continue;
 				var ldci4 = instrs[i + 3];
-				if (!DotNetUtils.isLdcI4(ldci4) || DotNetUtils.getLdcI4Value(ldci4) != 0xFF)
+				if (!ldci4.IsLdcI4() || ldci4.GetLdcI4Value() != 0xFF)
 					continue;
 
-				return DotNetUtils.getArgIndex(ldarg);
+				return ldarg.GetParameterIndex();
 			}
 			return -1;
 		}
 
-		static int getMagicArgIndex41Trial(MethodDefinition method) {
+		static int getMagicArgIndex41Trial(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 2; i++) {
 				var ldarg = instrs[i];
-				if (!DotNetUtils.isLdarg(ldarg))
+				if (!ldarg.IsLdarg())
 					continue;
-				if (!DotNetUtils.isLdcI4(instrs[i + 1]))
+				if (!instrs[i + 1].IsLdcI4())
 					continue;
 				if (instrs[i + 2].OpCode.Code != Code.Shr)
 					continue;
 
-				return DotNetUtils.getArgIndex(ldarg);
+				return ldarg.GetParameterIndex();
 			}
 			return -1;
 		}
 
-		static FieldDefinition getLdtokenField(MethodDefinition method) {
+		static FieldDef getLdtokenField(MethodDef method) {
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Ldtoken)
 					continue;
-				var field = instr.Operand as FieldDefinition;
+				var field = instr.Operand as FieldDef;
 				if (field == null || field.InitialValue == null || field.InitialValue.Length == 0)
 					continue;
 
@@ -219,11 +219,11 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			"System.String",
 			"System.String[]",
 		};
-		static bool checkHandlerV3(MethodDefinition handler) {
+		static bool checkHandlerV3(MethodDef handler) {
 			return new LocalTypes(handler).all(handlerLocalTypes_V3);
 		}
 
-		static Data40 checkHandlerV40(MethodDefinition handler) {
+		static Data40 checkHandlerV40(MethodDef handler) {
 			var data40 = new Data40();
 
 			var instrs = handler.Body.Instructions;
@@ -236,10 +236,10 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				var ldtoken = instrs[index++];
 				if (ldtoken.OpCode.Code != Code.Ldtoken)
 					continue;
-				var field = ldtoken.Operand as FieldDefinition;
+				var field = ldtoken.Operand as FieldDef;
 
 				string methodSig = "(System.ResolveEventArgs,System.RuntimeFieldHandle,System.Int32,System.String,System.Int32)";
-				var method = ldtoken.Operand as MethodDefinition;
+				var method = ldtoken.Operand as MethodDef;
 				if (method != null) {
 					// >= 4.0.4
 					if (!DotNetUtils.isMethod(method, "System.Byte[]", "()"))
@@ -255,25 +255,25 @@ namespace de4dot.code.deobfuscators.DeepSea {
 					continue;
 
 				var ldci4_len = instrs[index++];
-				if (!DotNetUtils.isLdcI4(ldci4_len))
+				if (!ldci4_len.IsLdcI4())
 					continue;
-				if (DotNetUtils.getLdcI4Value(ldci4_len) != field.InitialValue.Length)
+				if (ldci4_len.GetLdcI4Value() != field.InitialValue.Length)
 					continue;
 
 				if (instrs[index++].OpCode.Code != Code.Ldstr)
 					continue;
 
 				var ldci4_magic = instrs[index++];
-				if (!DotNetUtils.isLdcI4(ldci4_magic))
+				if (!ldci4_magic.IsLdcI4())
 					continue;
-				data40.magic = DotNetUtils.getLdcI4Value(ldci4_magic);
+				data40.magic = ldci4_magic.GetLdcI4Value();
 
 				var call = instrs[index++];
-				if (call.OpCode.Code == Code.Tail)
+				if (call.OpCode.Code == Code.Tailcall)
 					call = instrs[index++];
 				if (call.OpCode.Code != Code.Call)
 					continue;
-				var resolveHandler2 = call.Operand as MethodDefinition;
+				var resolveHandler2 = call.Operand as MethodDef;
 				if (!DotNetUtils.isMethod(resolveHandler2, "System.Reflection.Assembly", methodSig))
 					continue;
 
@@ -286,11 +286,11 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return null;
 		}
 
-		static FieldDefinition getResourceField(MethodDefinition method) {
+		static FieldDef getResourceField(MethodDef method) {
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Ldtoken)
 					continue;
-				var field = instr.Operand as FieldDefinition;
+				var field = instr.Operand as FieldDef;
 				if (field == null || field.InitialValue == null || field.InitialValue.Length == 0)
 					continue;
 				return field;
@@ -308,7 +308,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				data30 = new Data30();
 				data30.resource = DeobUtils.getEmbeddedResourceFromCodeStrings(module, resolveHandler);
 				if (data30.resource == null) {
-					Log.w("Could not find resource of encrypted resources");
+					Logger.w("Could not find resource of encrypted resources");
 					return;
 				}
 			}
@@ -322,7 +322,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				if (data30.resource == null)
 					return false;
 
-				DeobUtils.decryptAndAddResources(module, data30.resource.Name, () => decryptResourceV3(data30.resource));
+				DeobUtils.decryptAndAddResources(module, data30.resource.Name.String, () => decryptResourceV3(data30.resource));
 				rsrc = data30.resource;
 				return true;
 
@@ -337,14 +337,15 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			}
 		}
 
-		bool decryptResource(FieldDefinition resourceField, int magic) {
+		bool decryptResource(FieldDef resourceField, int magic) {
 			if (resourceField == null)
 				return false;
 
-			string name = string.Format("Embedded data field {0:X8} RVA {1:X8}", resourceField.MetadataToken.ToInt32(), resourceField.RVA);
+			string name = string.Format("Embedded data field {0:X8} RVA {1:X8}", resourceField.MDToken.ToInt32(), (uint)resourceField.RVA);
 			DeobUtils.decryptAndAddResources(module, name, () => decryptResourceV4(resourceField.InitialValue, magic));
 			resourceField.InitialValue = new byte[1];
-			resourceField.FieldType = module.TypeSystem.Byte;
+			resourceField.FieldSig.Type = module.CorLibTypes.Byte;
+			resourceField.RVA = 0;
 			return true;
 		}
 	}
diff --git a/de4dot.code/deobfuscators/DeepSea/StringDecrypter.cs b/de4dot.code/deobfuscators/DeepSea/StringDecrypter.cs
index 0399f891..f1410077 100644
--- a/de4dot.code/deobfuscators/DeepSea/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/DeepSea/StringDecrypter.cs
@@ -20,14 +20,13 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.Cecil.Metadata;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.DeepSea {
 	class StringDecrypter {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		MethodDefinitionAndDeclaringTypeDict<IDecrypterInfo> methodToInfo = new MethodDefinitionAndDeclaringTypeDict<IDecrypterInfo>();
 		DecrypterVersion version = DecrypterVersion.Unknown;
 
@@ -40,22 +39,22 @@ namespace de4dot.code.deobfuscators.DeepSea {
 
 		interface IDecrypterInfo {
 			DecrypterVersion Version { get; }
-			MethodDefinition Method { get; }
+			MethodDef Method { get; }
 			string decrypt(object[] args);
 			void cleanup();
 		}
 
-		static short[] findKey(MethodDefinition initMethod, FieldDefinition keyField) {
+		static short[] findKey(MethodDef initMethod, FieldDef keyField) {
 			var fields = new FieldDefinitionAndDeclaringTypeDict<bool>();
 			fields.add(keyField, true);
 			return findKey(initMethod, fields);
 		}
 
-		static short[] findKey(MethodDefinition initMethod, FieldDefinitionAndDeclaringTypeDict<bool> fields) {
+		static short[] findKey(MethodDef initMethod, FieldDefinitionAndDeclaringTypeDict<bool> fields) {
 			var instrs = initMethod.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 2; i++) {
 				var ldci4 = instrs[i];
-				if (!DotNetUtils.isLdcI4(ldci4))
+				if (!ldci4.IsLdcI4())
 					continue;
 				var newarr = instrs[i + 1];
 				if (newarr.OpCode.Code != Code.Newarr)
@@ -64,13 +63,13 @@ namespace de4dot.code.deobfuscators.DeepSea {
 					continue;
 
 				var stloc = instrs[i + 2];
-				if (!DotNetUtils.isStloc(stloc))
+				if (!stloc.IsStloc())
 					continue;
-				var local = DotNetUtils.getLocalVar(initMethod.Body.Variables, stloc);
+				var local = stloc.GetLocal(initMethod.Body.LocalList);
 
 				int startInitIndex = i;
 				i++;
-				var array = ArrayFinder.getInitializedInt16Array(DotNetUtils.getLdcI4Value(ldci4), initMethod, ref i);
+				var array = ArrayFinder.getInitializedInt16Array(ldci4.GetLdcI4Value(), initMethod, ref i);
 				if (array == null)
 					continue;
 
@@ -84,42 +83,42 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return null;
 		}
 
-		static FieldDefinition getStoreField(MethodDefinition method, int startIndex, VariableDefinition local) {
+		static FieldDef getStoreField(MethodDef method, int startIndex, Local local) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 1; i++) {
 				var ldloc = instrs[i];
-				if (!DotNetUtils.isLdloc(ldloc))
+				if (!ldloc.IsLdloc())
 					continue;
-				if (DotNetUtils.getLocalVar(method.Body.Variables, ldloc) != local)
+				if (ldloc.GetLocal(method.Body.LocalList) != local)
 					continue;
 
 				var stsfld = instrs[i + 1];
 				if (stsfld.OpCode.Code != Code.Stsfld)
 					continue;
-				return stsfld.Operand as FieldDefinition;
+				return stsfld.Operand as FieldDef;
 			}
 
 			return null;
 		}
 
-		static bool findMagic(MethodDefinition method, out int magic) {
+		static bool findMagic(MethodDef method, out int magic) {
 			int arg1, arg2;
 			return findMagic(method, out arg1, out arg2, out magic);
 		}
 
-		static bool findMagic(MethodDefinition method, out int arg1, out int arg2, out int magic) {
+		static bool findMagic(MethodDef method, out int arg1, out int arg2, out int magic) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 3; i++) {
-				if ((arg1 = DotNetUtils.getArgIndex(instrs[i])) < 0)
+				if ((arg1 = instrs[i].GetParameterIndex()) < 0)
 					continue;
 				var ldci4 = instrs[i + 1];
-				if (!DotNetUtils.isLdcI4(ldci4))
+				if (!ldci4.IsLdcI4())
 					continue;
 				if (instrs[i + 2].OpCode.Code != Code.Xor)
 					continue;
-				if ((arg2 = DotNetUtils.getArgIndex(instrs[i + 3])) < 0)
+				if ((arg2 = instrs[i + 3].GetParameterIndex()) < 0)
 					continue;
-				magic = DotNetUtils.getLdcI4Value(ldci4);
+				magic = ldci4.GetLdcI4Value();
 				return true;
 			}
 			arg1 = arg2 = 0;
@@ -127,7 +126,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return false;
 		}
 
-		static void removeInitializeArrayCall(MethodDefinition method, FieldDefinition field) {
+		static void removeInitializeArrayCall(MethodDef method, FieldDef field) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 1; i++) {
 				var ldtoken = instrs[i];
@@ -139,7 +138,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				var call = instrs[i + 1];
 				if (call.OpCode.Code != Code.Call)
 					continue;
-				var calledMethod = call.Operand as MethodReference;
+				var calledMethod = call.Operand as IMethod;
 				if (calledMethod == null)
 					continue;
 				if (calledMethod.ToString() != "System.Void System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(System.Array,System.RuntimeFieldHandle)")
@@ -151,7 +150,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 		}
 
 		class DecrypterInfo41 : IDecrypterInfo {
-			MethodDefinition cctor;
+			MethodDef cctor;
 			int magic;
 			int arg1, arg2;
 			FieldDefinitionAndDeclaringTypeDict<bool> fields;
@@ -163,11 +162,11 @@ namespace de4dot.code.deobfuscators.DeepSea {
 
 			class ArrayInfo {
 				public int sizeInElems;
-				public TypeReference elementType;
-				public FieldDefinition initField;
-				public FieldDefinition field;
+				public ITypeDefOrRef elementType;
+				public FieldDef initField;
+				public FieldDef field;
 
-				public ArrayInfo(int sizeInElems, TypeReference elementType, FieldDefinition initField, FieldDefinition field) {
+				public ArrayInfo(int sizeInElems, ITypeDefOrRef elementType, FieldDef initField, FieldDef field) {
 					this.sizeInElems = sizeInElems;
 					this.elementType = elementType;
 					this.initField = initField;
@@ -179,14 +178,14 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				get { return DecrypterVersion.V4_1; }
 			}
 
-			public MethodDefinition Method { get; private set; }
+			public MethodDef Method { get; private set; }
 
-			public DecrypterInfo41(MethodDefinition cctor, MethodDefinition method) {
+			public DecrypterInfo41(MethodDef cctor, MethodDef method) {
 				this.cctor = cctor;
 				Method = method;
 			}
 
-			public static bool isPossibleDecrypterMethod(MethodDefinition method) {
+			public static bool isPossibleDecrypterMethod(MethodDef method, bool firstTime) {
 				if (!checkMethodSignature(method))
 					return false;
 				var fields = getFields(method);
@@ -196,23 +195,23 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return true;
 			}
 
-			static bool checkMethodSignature(MethodDefinition method) {
-				if (method.MethodReturnType.ReturnType.EType != ElementType.String)
+			static bool checkMethodSignature(MethodDef method) {
+				if (method.MethodSig.GetRetType().GetElementType() != ElementType.String)
 					return false;
 				int count = 0;
-				foreach (var arg in method.Parameters) {
-					if (arg.ParameterType.EType == ElementType.I4)
+				foreach (var arg in method.MethodSig.GetParams()) {
+					if (arg.ElementType == ElementType.I4)
 						count++;
 				}
 				return count >= 2;
 			}
 
-			static FieldDefinitionAndDeclaringTypeDict<bool> getFields(MethodDefinition method) {
+			static FieldDefinitionAndDeclaringTypeDict<bool> getFields(MethodDef method) {
 				var fields = new FieldDefinitionAndDeclaringTypeDict<bool>();
 				foreach (var instr in method.Body.Instructions) {
 					if (instr.OpCode.Code != Code.Ldsfld && instr.OpCode.Code != Code.Stsfld)
 						continue;
-					var field = instr.Operand as FieldDefinition;
+					var field = instr.Operand as FieldDef;
 					if (field == null)
 						continue;
 					if (field.DeclaringType != method.DeclaringType)
@@ -248,15 +247,15 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return true;
 			}
 
-			int findKeyShift(MethodDefinition method) {
+			int findKeyShift(MethodDef method) {
 				var instrs = method.Body.Instructions;
 				for (int i = 0; i < instrs.Count - 3; i++) {
 					int index = i;
 
 					var ldci4 = instrs[index++];
-					if (!DotNetUtils.isLdcI4(ldci4))
+					if (!ldci4.IsLdcI4())
 						continue;
-					if (DotNetUtils.getLdcI4Value(ldci4) != 0xFF)
+					if (ldci4.GetLdcI4Value() != 0xFF)
 						continue;
 
 					if (instrs[index++].OpCode.Code != Code.And)
@@ -265,24 +264,24 @@ namespace de4dot.code.deobfuscators.DeepSea {
 						continue;
 
 					var ldci4_2 = instrs[index++];
-					if (!DotNetUtils.isLdcI4(ldci4_2))
+					if (!ldci4_2.IsLdcI4())
 						continue;
 
 					if (findNextFieldUse(method, index) < 0)
 						continue;
 
-					return DotNetUtils.getLdcI4Value(ldci4_2);
+					return ldci4_2.GetLdcI4Value();
 				}
 				return -1;
 			}
 
-			int findNextFieldUse(MethodDefinition method, int index) {
+			int findNextFieldUse(MethodDef method, int index) {
 				var instrs = method.Body.Instructions;
 				for (int i = index; i < instrs.Count; i++) {
 					var instr = instrs[i];
 					if (instr.OpCode.Code != Code.Ldsfld && instr.OpCode.Code != Code.Stsfld)
 						continue;
-					var field = instr.Operand as FieldReference;
+					var field = instr.Operand as IField;
 					if (!fields.find(field))
 						return -1;
 
@@ -291,21 +290,21 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return -1;
 			}
 
-			ArrayInfo getArrayInfo(MethodDefinition method) {
+			ArrayInfo getArrayInfo(MethodDef method) {
 				var instructions = method.Body.Instructions;
 				for (int i = 0; i < instructions.Count; i++) {
 					var ldci4_arraySizeInBytes = instructions[i];
-					if (!DotNetUtils.isLdcI4(ldci4_arraySizeInBytes))
+					if (!ldci4_arraySizeInBytes.IsLdcI4())
 						continue;
 					i++;
 					var instrs = DotNetUtils.getInstructions(instructions, i, OpCodes.Newarr, OpCodes.Dup, OpCodes.Ldtoken, OpCodes.Call, OpCodes.Stsfld);
 					if (instrs == null)
 						continue;
 
-					int sizeInBytes = DotNetUtils.getLdcI4Value(ldci4_arraySizeInBytes);
-					var elementType = instrs[0].Operand as TypeReference;
-					var initField = instrs[2].Operand as FieldDefinition;
-					var field = instrs[4].Operand as FieldDefinition;
+					int sizeInBytes = ldci4_arraySizeInBytes.GetLdcI4Value();
+					var elementType = instrs[0].Operand as ITypeDefOrRef;
+					var initField = instrs[2].Operand as FieldDef;
+					var field = instrs[4].Operand as FieldDef;
 					if (elementType == null)
 						continue;
 					if (initField == null || initField.InitialValue == null || initField.InitialValue.Length == 0)
@@ -321,13 +320,13 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			short[] findKey() {
 				if (cctor.Module.Assembly == null)
 					return null;
-				var pkt = cctor.Module.Assembly.Name.PublicKeyToken;
-				if (pkt != null && pkt.Length > 0)
-					return getPublicKeyTokenKey(pkt);
+				var pkt = cctor.Module.Assembly.PublicKeyToken;
+				if (!PublicKeyBase.IsNullOrEmpty2(pkt))
+					return getPublicKeyTokenKey(pkt.Data);
 				return findKey(cctor);
 			}
 
-			short[] findKey(MethodDefinition initMethod) {
+			short[] findKey(MethodDef initMethod) {
 				return StringDecrypter.findKey(initMethod, fields);
 			}
 
@@ -380,34 +379,35 @@ namespace de4dot.code.deobfuscators.DeepSea {
 
 			public void cleanup() {
 				arrayInfo.initField.InitialValue = new byte[1];
-				arrayInfo.initField.FieldType = arrayInfo.initField.Module.TypeSystem.Byte;
+				arrayInfo.initField.FieldSig.Type = arrayInfo.initField.Module.CorLibTypes.Byte;
+				arrayInfo.initField.RVA = 0;
 				removeInitializeArrayCall(cctor, arrayInfo.initField);
 			}
 		}
 
 		class DecrypterInfo40 : IDecrypterInfo {
-			MethodDefinition cctor;
+			MethodDef cctor;
 			int magic;
-			FieldDefinition cachedStringsField;
-			FieldDefinition keyField;
-			FieldDefinition encryptedStringsField;
-			FieldDefinition encryptedDataField;
+			FieldDef cachedStringsField;
+			FieldDef keyField;
+			FieldDef encryptedStringsField;
+			FieldDef encryptedDataField;
 			short[] key;
 			ushort[] encryptedData;
 
-			public MethodDefinition Method { get; private set; }
+			public MethodDef Method { get; private set; }
 
 			public DecrypterVersion Version {
 				get { return DecrypterVersion.V4_0; }
 			}
 
-			public DecrypterInfo40(MethodDefinition cctor, MethodDefinition method) {
+			public DecrypterInfo40(MethodDef cctor, MethodDef method) {
 				this.cctor = cctor;
 				this.Method = method;
 			}
 
-			public static bool isPossibleDecrypterMethod(MethodDefinition method) {
-				if (!checkFields(method.DeclaringType.Fields))
+			public static bool isPossibleDecrypterMethod(MethodDef method, bool firstTime) {
+				if (!firstTime || !checkFields(method.DeclaringType.Fields))
 					return false;
 				return DotNetUtils.isMethod(method, "System.String", "(System.Int32,System.Int32)");
 			}
@@ -438,18 +438,18 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return true;
 			}
 
-			List<FieldDefinition> findFields() {
-				var charArrayFields = new List<FieldDefinition>();
+			List<FieldDef> findFields() {
+				var charArrayFields = new List<FieldDef>();
 
 				foreach (var instr in Method.Body.Instructions) {
 					if (instr.OpCode.Code != Code.Stsfld && instr.OpCode.Code != Code.Ldsfld)
 						continue;
-					var field = instr.Operand as FieldDefinition;
+					var field = instr.Operand as FieldDef;
 					if (field == null)
 						continue;
-					if (!MemberReferenceHelper.compareTypes(Method.DeclaringType, field.DeclaringType))
+					if (!new SigComparer().Equals(Method.DeclaringType, field.DeclaringType))
 						continue;
-					switch (field.FieldType.FullName) {
+					switch (field.FieldSig.GetFieldType().GetFullName()) {
 					case "System.Char[]":
 						if (!charArrayFields.Contains(field))
 							charArrayFields.Add(field);
@@ -472,17 +472,17 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return charArrayFields;
 			}
 
-			static FieldDefinition findEncryptedStrings(MethodDefinition initMethod, List<FieldDefinition> ourFields, out FieldDefinition dataField) {
+			static FieldDef findEncryptedStrings(MethodDef initMethod, List<FieldDef> ourFields, out FieldDef dataField) {
 				for (int i = 0; i < initMethod.Body.Instructions.Count; i++) {
 					var instrs = DotNetUtils.getInstructions(initMethod.Body.Instructions, i, OpCodes.Ldtoken, OpCodes.Call, OpCodes.Stsfld);
 					if (instrs == null)
 						continue;
 
-					dataField = instrs[0].Operand as FieldDefinition;
+					dataField = instrs[0].Operand as FieldDef;
 					if (dataField == null || dataField.InitialValue == null || dataField.InitialValue.Length == 0)
 						continue;
 
-					var savedField = instrs[2].Operand as FieldDefinition;
+					var savedField = instrs[2].Operand as FieldDef;
 					if (savedField == null || !matches(ourFields, savedField))
 						continue;
 
@@ -493,9 +493,9 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return null;
 			}
 
-			static bool matches(IEnumerable<FieldDefinition> ourFields, FieldReference field) {
+			static bool matches(IEnumerable<FieldDef> ourFields, FieldDef field) {
 				foreach (var ourField in ourFields) {
-					if (MemberReferenceHelper.compareFieldReferenceAndDeclaringType(ourField, field))
+					if (FieldEqualityComparer.CompareDeclaringTypes.Equals(ourField, field))
 						return true;
 				}
 				return false;
@@ -504,13 +504,13 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			short[] findKey() {
 				if (cctor.Module.Assembly == null)
 					return null;
-				var pkt = cctor.Module.Assembly.Name.PublicKeyToken;
-				if (pkt != null && pkt.Length > 0)
-					return getPublicKeyTokenKey(pkt);
+				var pkt = cctor.Module.Assembly.PublicKeyToken;
+				if (!PublicKeyBase.IsNullOrEmpty2(pkt))
+					return getPublicKeyTokenKey(pkt.Data);
 				return findKey(cctor);
 			}
 
-			short[] findKey(MethodDefinition initMethod) {
+			short[] findKey(MethodDef initMethod) {
 				return StringDecrypter.findKey(initMethod, keyField);
 			}
 
@@ -539,32 +539,33 @@ namespace de4dot.code.deobfuscators.DeepSea {
 
 			public void cleanup() {
 				encryptedDataField.InitialValue = new byte[1];
-				encryptedDataField.FieldType = encryptedDataField.Module.TypeSystem.Byte;
+				encryptedDataField.FieldSig.Type = encryptedDataField.Module.CorLibTypes.Byte;
+				encryptedDataField.RVA = 0;
 				removeInitializeArrayCall(cctor, encryptedDataField);
 			}
 		}
 
 		class DecrypterInfo13 : IDecrypterInfo {
-			MethodDefinition cctor;
-			FieldDefinition cachedStringsField;
-			FieldDefinition keyField;
+			MethodDef cctor;
+			FieldDef cachedStringsField;
+			FieldDef keyField;
 			int magic;
 			string[] encryptedStrings;
 			short[] key;
 
-			public MethodDefinition Method { get; private set; }
+			public MethodDef Method { get; private set; }
 
 			public DecrypterVersion Version {
 				get { return DecrypterVersion.V1_3; }
 			}
 
-			public static bool isPossibleDecrypterMethod(MethodDefinition method) {
-				if (!checkFields(method.DeclaringType.Fields))
+			public static bool isPossibleDecrypterMethod(MethodDef method, bool firstTime) {
+				if (!firstTime || !checkFields(method.DeclaringType.Fields))
 					return false;
 				return DotNetUtils.isMethod(method, "System.String", "(System.Int32)");
 			}
 
-			public DecrypterInfo13(MethodDefinition cctor, MethodDefinition method) {
+			public DecrypterInfo13(MethodDef cctor, MethodDef method) {
 				this.cctor = cctor;
 				this.Method = method;
 			}
@@ -602,12 +603,12 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				foreach (var instr in Method.Body.Instructions) {
 					if (instr.OpCode.Code != Code.Stsfld && instr.OpCode.Code != Code.Ldsfld)
 						continue;
-					var field = instr.Operand as FieldDefinition;
+					var field = instr.Operand as FieldDef;
 					if (field == null)
 						continue;
-					if (!MemberReferenceHelper.compareTypes(Method.DeclaringType, field.DeclaringType))
+					if (!new SigComparer().Equals(Method.DeclaringType, field.DeclaringType))
 						continue;
-					switch (field.FieldType.FullName) {
+					switch (field.FieldSig.GetFieldType().GetFullName()) {
 					case "System.Char[]":
 						if (keyField != null && keyField != field)
 							return false;
@@ -631,13 +632,13 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			short[] findKey() {
 				if (cctor.Module.Assembly == null)
 					return null;
-				var pkt = cctor.Module.Assembly.Name.PublicKeyToken;
-				if (pkt != null && pkt.Length > 0)
-					return getPublicKeyTokenKey(pkt);
+				var pkt = cctor.Module.Assembly.PublicKeyToken;
+				if (!PublicKeyBase.IsNullOrEmpty2(pkt))
+					return getPublicKeyTokenKey(pkt.Data);
 				return findKey(cctor);
 			}
 
-			short[] findKey(MethodDefinition initMethod) {
+			short[] findKey(MethodDef initMethod) {
 				return StringDecrypter.findKey(initMethod, keyField);
 			}
 
@@ -650,25 +651,25 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return key;
 			}
 
-			static bool findMagic(MethodDefinition method, out int magic) {
+			static bool findMagic(MethodDef method, out int magic) {
 				var instrs = method.Body.Instructions;
 				for (int i = 0; i < instrs.Count - 2; i++) {
 					var ldarg = instrs[i];
-					if (DotNetUtils.getArgIndex(ldarg) < 0)
+					if (ldarg.GetParameterIndex() < 0)
 						continue;
 					var ldci4 = instrs[i + 1];
-					if (!DotNetUtils.isLdcI4(ldci4))
+					if (!ldci4.IsLdcI4())
 						continue;
 					if (instrs[i + 2].OpCode.Code != Code.Xor)
 						continue;
-					magic = DotNetUtils.getLdcI4Value(ldci4);
+					magic = ldci4.GetLdcI4Value();
 					return true;
 				}
 				magic = 0;
 				return false;
 			}
 
-			bool findEncryptedStrings(MethodDefinition method) {
+			bool findEncryptedStrings(MethodDef method) {
 				var switchInstr = getOnlySwitchInstruction(method);
 				if (switchInstr == null)
 					return false;
@@ -683,7 +684,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return true;
 			}
 
-			static Instruction getOnlySwitchInstruction(MethodDefinition method) {
+			static Instruction getOnlySwitchInstruction(MethodDef method) {
 				Instruction switchInstr = null;
 				foreach (var instr in method.Body.Instructions) {
 					if (instr.OpCode.Code != Code.Switch)
@@ -711,16 +712,16 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			get { return version; }
 		}
 
-		public List<MethodDefinition> DecrypterMethods {
+		public List<MethodDef> DecrypterMethods {
 			get {
-				var methods = new List<MethodDefinition>(methodToInfo.Count);
+				var methods = new List<MethodDef>(methodToInfo.Count);
 				foreach (var info in methodToInfo.getValues())
 					methods.Add(info.Method);
 				return methods;
 			}
 		}
 
-		public StringDecrypter(ModuleDefinition module) {
+		public StringDecrypter(ModuleDefMD module) {
 			this.module = module;
 		}
 
@@ -728,34 +729,37 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			if (module.Assembly == null)
 				return;
 
-			bool hasPublicKeyToken = module.Assembly.Name.PublicKeyToken != null && module.Assembly.Name.PublicKeyToken.Length != 0;
+			var pkt = module.Assembly.PublicKeyToken;
+			bool hasPublicKeyToken = !PublicKeyBase.IsNullOrEmpty2(pkt);
 			foreach (var type in module.GetTypes()) {
-				var cctor = DotNetUtils.getMethod(type, ".cctor");
+				var cctor = type.FindStaticConstructor();
 				if (cctor == null)
 					continue;
 
 				bool deobfuscatedCctor = false;
+				bool firstTime = true;
 				foreach (var method in type.Methods) {
 					if (!method.IsStatic || method.Body == null)
 						continue;
 
 					IDecrypterInfo info = null;
 
-					if (DecrypterInfo13.isPossibleDecrypterMethod(method)) {
+					if (DecrypterInfo13.isPossibleDecrypterMethod(method, firstTime)) {
 						deobfuscateCctor(simpleDeobfuscator, cctor, ref deobfuscatedCctor, hasPublicKeyToken);
 						simpleDeobfuscator.deobfuscate(method);
 						info = getInfoV13(cctor, method);
 					}
-					else if (DecrypterInfo40.isPossibleDecrypterMethod(method)) {
+					else if (DecrypterInfo40.isPossibleDecrypterMethod(method, firstTime)) {
 						deobfuscateCctor(simpleDeobfuscator, cctor, ref deobfuscatedCctor, hasPublicKeyToken);
 						simpleDeobfuscator.deobfuscate(method);
 						info = getInfoV40(cctor, method);
 					}
-					else if (DecrypterInfo41.isPossibleDecrypterMethod(method)) {
+					else if (DecrypterInfo41.isPossibleDecrypterMethod(method, firstTime)) {
 						deobfuscateCctor(simpleDeobfuscator, cctor, ref deobfuscatedCctor, hasPublicKeyToken);
 						simpleDeobfuscator.deobfuscate(method);
 						info = getInfoV41(cctor, method);
 					}
+					firstTime = false;
 
 					if (info == null)
 						continue;
@@ -765,19 +769,19 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			}
 		}
 
-		static void deobfuscateCctor(ISimpleDeobfuscator simpleDeobfuscator, MethodDefinition cctor, ref bool deobfuscatedCctor, bool hasPublicKeyToken) {
+		static void deobfuscateCctor(ISimpleDeobfuscator simpleDeobfuscator, MethodDef cctor, ref bool deobfuscatedCctor, bool hasPublicKeyToken) {
 			if (deobfuscatedCctor || hasPublicKeyToken)
 				return;
 			simpleDeobfuscator.deobfuscate(cctor);
 			deobfuscatedCctor = true;
 		}
 
-		static bool checkFields(IEnumerable<FieldDefinition> fields) {
+		static bool checkFields(IEnumerable<FieldDef> fields) {
 			bool foundCharAry = false, foundStringAry = false;
 			foreach (var field in fields) {
 				if (foundCharAry && foundStringAry)
 					break;
-				switch (field.FieldType.FullName) {
+				switch (field.FieldSig.GetFieldType().GetFullName()) {
 				case "System.Char[]":
 					foundCharAry = true;
 					break;
@@ -789,28 +793,28 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return foundCharAry && foundStringAry;
 		}
 
-		DecrypterInfo13 getInfoV13(MethodDefinition cctor, MethodDefinition method) {
+		DecrypterInfo13 getInfoV13(MethodDef cctor, MethodDef method) {
 			var info = new DecrypterInfo13(cctor, method);
 			if (!info.initialize())
 				return null;
 			return info;
 		}
 
-		DecrypterInfo40 getInfoV40(MethodDefinition cctor, MethodDefinition method) {
+		DecrypterInfo40 getInfoV40(MethodDef cctor, MethodDef method) {
 			var info = new DecrypterInfo40(cctor, method);
 			if (!info.initialize())
 				return null;
 			return info;
 		}
 
-		DecrypterInfo41 getInfoV41(MethodDefinition cctor, MethodDefinition method) {
+		DecrypterInfo41 getInfoV41(MethodDef cctor, MethodDef method) {
 			var info = new DecrypterInfo41(cctor, method);
 			if (!info.initialize())
 				return null;
 			return info;
 		}
 
-		public string decrypt(MethodReference method, object[] args) {
+		public string decrypt(IMethod method, object[] args) {
 			var info = methodToInfo.find(method);
 			return info.decrypt(args);
 		}
diff --git a/de4dot.code/deobfuscators/DeobUtils.cs b/de4dot.code/deobfuscators/DeobUtils.cs
index d7b8f272..b83a17ec 100644
--- a/de4dot.code/deobfuscators/DeobUtils.cs
+++ b/de4dot.code/deobfuscators/DeobUtils.cs
@@ -22,49 +22,39 @@ using System.Collections.Generic;
 using System.IO;
 using System.IO.Compression;
 using System.Security.Cryptography;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using ICSharpCode.SharpZipLib.Zip.Compression;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators {
 	static class DeobUtils {
-		public static void decryptAndAddResources(ModuleDefinition module, string encryptedName, Func<byte[]> decryptResource) {
-			Log.v("Decrypting resources, name: {0}", Utils.toCsharpString(encryptedName));
+		public static void decryptAndAddResources(ModuleDef module, string encryptedName, Func<byte[]> decryptResource) {
+			Logger.v("Decrypting resources, name: {0}", Utils.toCsharpString(encryptedName));
 			var decryptedResourceData = decryptResource();
 			if (decryptedResourceData == null)
 				throw new ApplicationException("decryptedResourceData is null");
-			var resourceModule = ModuleDefinition.ReadModule(new MemoryStream(decryptedResourceData));
+			var resourceModule = ModuleDefMD.Load(decryptedResourceData);
 
-			Log.indent();
+			Logger.Instance.indent();
 			foreach (var rsrc in resourceModule.Resources) {
-				Log.v("Adding decrypted resource {0}", Utils.toCsharpString(rsrc.Name));
+				Logger.v("Adding decrypted resource {0}", Utils.toCsharpString(rsrc.Name));
 				module.Resources.Add(rsrc);
 			}
-			Log.deIndent();
+			Logger.Instance.deIndent();
 		}
 
-		public static T lookup<T>(ModuleDefinition module, T def, string errorMessage) where T : MemberReference {
+		public static T lookup<T>(ModuleDefMD module, T def, string errorMessage) where T : class, ICodedToken {
 			if (def == null)
 				return null;
-			var newDef = module.LookupToken(def.MetadataToken.ToInt32()) as T;
+			var newDef = module.ResolveToken(def.MDToken.Raw) as T;
 			if (newDef == null)
 				throw new ApplicationException(errorMessage);
 			return newDef;
 		}
 
-		public static ModuleReference lookup(ModuleDefinition module, ModuleReference other, string errorMessage) {
-			if (other == null)
-				return null;
-			foreach (var modRef in module.ModuleReferences) {
-				if (modRef.MetadataToken.ToInt32() == other.MetadataToken.ToInt32())
-					return modRef;
-			}
-			throw new ApplicationException(errorMessage);
-		}
-
-		public static byte[] readModule(ModuleDefinition module) {
-			return Utils.readFile(module.FullyQualifiedName);
+		public static byte[] readModule(ModuleDef module) {
+			return Utils.readFile(module.Location);
 		}
 
 		public static bool isCode(short[] nativeCode, byte[] code) {
@@ -190,7 +180,7 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		public static EmbeddedResource getEmbeddedResourceFromCodeStrings(ModuleDefinition module, MethodDefinition method) {
+		public static EmbeddedResource getEmbeddedResourceFromCodeStrings(ModuleDef module, MethodDef method) {
 			foreach (var s in DotNetUtils.getCodeStrings(method)) {
 				var resource = DotNetUtils.getResource(module, s) as EmbeddedResource;
 				if (resource != null)
@@ -199,6 +189,7 @@ namespace de4dot.code.deobfuscators {
 			return null;
 		}
 
+		//TODO: Remove this method
 		public static int readVariableLengthInt32(BinaryReader reader) {
 			byte b = reader.ReadByte();
 			if ((b & 0x80) == 0)
@@ -217,50 +208,50 @@ namespace de4dot.code.deobfuscators {
 				return b;
 			if ((b & 0x40) == 0)
 				return (((int)b & 0x3F) << 8) + data[index++];
-			return (((int)b & 0x3F) << 24) +
+			return (((int)b & 0x1F) << 24) +
 					((int)data[index++] << 16) +
 					((int)data[index++] << 8) +
 					data[index++];
 		}
 
-		public static bool hasInteger(MethodDefinition method, uint value) {
+		public static bool hasInteger(MethodDef method, uint value) {
 			return hasInteger(method, (int)value);
 		}
 
-		public static bool hasInteger(MethodDefinition method, int value) {
+		public static bool hasInteger(MethodDef method, int value) {
 			return indexOfLdci4Instruction(method, value) >= 0;
 		}
 
-		public static int indexOfLdci4Instruction(MethodDefinition method, int value) {
+		public static int indexOfLdci4Instruction(MethodDef method, int value) {
 			if (method == null || method.Body == null)
 				return -1;
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count; i++) {
 				var instr = instrs[i];
-				if (!DotNetUtils.isLdcI4(instr))
+				if (!instr.IsLdcI4())
 					continue;
-				if (DotNetUtils.getLdcI4Value(instr) == value)
+				if (instr.GetLdcI4Value() == value)
 					return i;
 			}
 			return -1;
 		}
 
-		public static IEnumerable<MethodDefinition> getInitCctors(ModuleDefinition module, int maxCctors) {
+		public static IEnumerable<MethodDef> getInitCctors(ModuleDef module, int maxCctors) {
 			var cctor = DotNetUtils.getModuleTypeCctor(module);
 			if (cctor != null)
 				yield return cctor;
 
 			var entryPoint = module.EntryPoint;
 			if (entryPoint != null) {
-				cctor = DotNetUtils.getMethod(entryPoint.DeclaringType, ".cctor");
+				cctor = entryPoint.DeclaringType.FindStaticConstructor();
 				if (cctor != null)
 					yield return cctor;
 			}
 
 			foreach (var type in module.GetTypes()) {
-				if (type == DotNetUtils.getModuleType(module))
+				if (type == module.GlobalType)
 					continue;
-				cctor = DotNetUtils.getMethod(type, ".cctor");
+				cctor = type.FindStaticConstructor();
 				if (cctor == null)
 					continue;
 				yield return cctor;
@@ -269,14 +260,14 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		public static List<MethodDefinition> getAllResolveHandlers(MethodDefinition method) {
-			var list = new List<MethodDefinition>();
+		public static List<MethodDef> getAllResolveHandlers(MethodDef method) {
+			var list = new List<MethodDef>();
 			if (method == null || method.Body == null)
 				return list;
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Ldftn && instr.OpCode.Code != Code.Ldvirtftn)
 					continue;
-				var handler = instr.Operand as MethodDefinition;
+				var handler = instr.Operand as MethodDef;
 				if (handler == null)
 					continue;
 				if (!DotNetUtils.isMethod(handler, "System.Reflection.Assembly", "(System.Object,System.ResolveEventArgs)"))
@@ -286,7 +277,7 @@ namespace de4dot.code.deobfuscators {
 			return list;
 		}
 
-		public static MethodDefinition getResolveMethod(MethodDefinition method) {
+		public static MethodDef getResolveMethod(MethodDef method) {
 			var handlers = DeobUtils.getAllResolveHandlers(method);
 			if (handlers.Count == 0)
 				return null;
diff --git a/de4dot.code/deobfuscators/DeobfuscatorBase.cs b/de4dot.code/deobfuscators/DeobfuscatorBase.cs
index 90f15741..e3579fae 100644
--- a/de4dot.code/deobfuscators/DeobfuscatorBase.cs
+++ b/de4dot.code/deobfuscators/DeobfuscatorBase.cs
@@ -19,15 +19,15 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.MyStuff;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
+using dot10.DotNet.Writer;
+using dot10.PE;
 using de4dot.blocks;
 using de4dot.blocks.cflow;
-using de4dot.PE;
 
 namespace de4dot.code.deobfuscators {
-	abstract class DeobfuscatorBase : IDeobfuscator, IWriterListener {
+	abstract class DeobfuscatorBase : IDeobfuscator, IModuleWriterListener {
 		public const string DEFAULT_VALID_NAME_REGEX = @"^[a-zA-Z_<{$][a-zA-Z_0-9<>{}$.`-]*$";
 
 		class RemoveInfo<T> {
@@ -40,15 +40,13 @@ namespace de4dot.code.deobfuscators {
 		}
 
 		OptionsBase optionsBase;
-		protected ModuleDefinition module;
+		protected ModuleDefMD module;
 		protected StaticStringInliner staticStringInliner = new StaticStringInliner();
-		IList<RemoveInfo<TypeDefinition>> typesToRemove = new List<RemoveInfo<TypeDefinition>>();
-		IList<RemoveInfo<MethodDefinition>> methodsToRemove = new List<RemoveInfo<MethodDefinition>>();
-		IList<RemoveInfo<FieldDefinition>> fieldsToRemove = new List<RemoveInfo<FieldDefinition>>();
-		IList<RemoveInfo<TypeDefinition>> attrsToRemove = new List<RemoveInfo<TypeDefinition>>();
+		IList<RemoveInfo<TypeDef>> typesToRemove = new List<RemoveInfo<TypeDef>>();
+		IList<RemoveInfo<MethodDef>> methodsToRemove = new List<RemoveInfo<MethodDef>>();
+		IList<RemoveInfo<FieldDef>> fieldsToRemove = new List<RemoveInfo<FieldDef>>();
+		IList<RemoveInfo<TypeDef>> attrsToRemove = new List<RemoveInfo<TypeDef>>();
 		IList<RemoveInfo<Resource>> resourcesToRemove = new List<RemoveInfo<Resource>>();
-		IList<RemoveInfo<ModuleReference>> modrefsToRemove = new List<RemoveInfo<ModuleReference>>();
-		IList<RemoveInfo<AssemblyNameReference>> asmrefsToRemove = new List<RemoveInfo<AssemblyNameReference>>();
 		List<string> namesToPossiblyRemove = new List<string>();
 		MethodCallRemover methodCallRemover = new MethodCallRemover();
 		byte[] moduleBytes;
@@ -91,6 +89,10 @@ namespace de4dot.code.deobfuscators {
 			get { return false; }
 		}
 
+		protected bool CanRemoveTypes {
+			get { return !Operations.KeepObfuscatorTypes && !KeepTypes; }
+		}
+
 		protected bool CanRemoveStringDecrypterType {
 			get { return Operations.DecryptStrings != OpDecryptString.None && staticStringInliner.InlinedAllCalls; }
 		}
@@ -110,15 +112,15 @@ namespace de4dot.code.deobfuscators {
 			DefaultDecrypterType = DecrypterType.Static;
 		}
 
-		public virtual byte[] unpackNativeFile(PeImage peImage) {
+		public virtual byte[] unpackNativeFile(IPEImage peImage) {
 			return null;
 		}
 
-		public virtual void init(ModuleDefinition module) {
+		public virtual void init(ModuleDefMD module) {
 			setModule(module);
 		}
 
-		protected void setModule(ModuleDefinition module) {
+		protected void setModule(ModuleDefMD module) {
 			this.module = module;
 			initializedDataCreator = new InitializedDataCreator(module);
 		}
@@ -139,7 +141,7 @@ namespace de4dot.code.deobfuscators {
 			return false;
 		}
 
-		public virtual IDeobfuscator moduleReloaded(ModuleDefinition module) {
+		public virtual IDeobfuscator moduleReloaded(ModuleDefMD module) {
 			throw new ApplicationException("moduleReloaded() must be overridden by the deobfuscator");
 		}
 
@@ -163,7 +165,7 @@ namespace de4dot.code.deobfuscators {
 		}
 
 		public virtual void deobfuscateEnd() {
-			if (!Operations.KeepObfuscatorTypes && !KeepTypes) {
+			if (CanRemoveTypes) {
 				removeTypesWithInvalidBaseTypes();
 
 				deleteEmptyCctors();
@@ -171,21 +173,14 @@ namespace de4dot.code.deobfuscators {
 				deleteFields();
 				deleteCustomAttributes();
 				deleteOtherAttributes();
-
-				// Delete types after removing methods, fields, and attributes. The reason is
-				// that the Scope property will be null if we remove a type. Comparing a
-				// typeref with a typedef will then fail.
 				deleteTypes();
-
 				deleteDllResources();
-				deleteModuleReferences();
-				deleteAssemblyReferences();
 			}
 
 			restoreBaseType();
 		}
 
-		static bool isTypeWithInvalidBaseType(TypeDefinition moduleType, TypeDefinition type) {
+		static bool isTypeWithInvalidBaseType(TypeDef moduleType, TypeDef type) {
 			return type.BaseType == null && !type.IsInterface && type != moduleType;
 		}
 
@@ -194,10 +189,10 @@ namespace de4dot.code.deobfuscators {
 			foreach (var type in module.GetTypes()) {
 				if (!isTypeWithInvalidBaseType(moduleType, type))
 					continue;
-				Log.v("Adding System.Object as base type: {0} ({1:X8})",
+				Logger.v("Adding System.Object as base type: {0} ({1:X8})",
 							Utils.removeNewlines(type),
-							type.MetadataToken.ToInt32());
-				type.BaseType = module.TypeSystem.Object;
+							type.MDToken.ToInt32());
+				type.BaseType = module.CorLibTypes.Object.TypeDefOrRef;
 			}
 		}
 
@@ -237,14 +232,15 @@ namespace de4dot.code.deobfuscators {
 			Dictionary<string, MethodDefinitionAndDeclaringTypeDict<bool>> methodNameInfos = new Dictionary<string, MethodDefinitionAndDeclaringTypeDict<bool>>();
 			MethodDefinitionAndDeclaringTypeDict<MethodDefinitionAndDeclaringTypeDict<bool>> methodRefInfos = new MethodDefinitionAndDeclaringTypeDict<MethodDefinitionAndDeclaringTypeDict<bool>>();
 
-			void checkMethod(MethodReference methodToBeRemoved) {
-				if (methodToBeRemoved.Parameters.Count != 0)
+			void checkMethod(IMethod methodToBeRemoved) {
+				var sig = methodToBeRemoved.MethodSig;
+				if (sig.Params.Count != 0)
 					throw new ApplicationException(string.Format("Method takes params: {0}", methodToBeRemoved));
-				if (DotNetUtils.hasReturnValue(methodToBeRemoved))
+				if (sig.RetType.ElementType != ElementType.Void)
 					throw new ApplicationException(string.Format("Method has a return value: {0}", methodToBeRemoved));
 			}
 
-			public void add(string method, MethodDefinition methodToBeRemoved) {
+			public void add(string method, MethodDef methodToBeRemoved) {
 				if (methodToBeRemoved == null)
 					return;
 				checkMethod(methodToBeRemoved);
@@ -255,7 +251,7 @@ namespace de4dot.code.deobfuscators {
 				dict.add(methodToBeRemoved, true);
 			}
 
-			public void add(MethodDefinition method, MethodDefinition methodToBeRemoved) {
+			public void add(MethodDef method, MethodDef methodToBeRemoved) {
 				if (method == null || methodToBeRemoved == null)
 					return;
 				checkMethod(methodToBeRemoved);
@@ -269,7 +265,7 @@ namespace de4dot.code.deobfuscators {
 			public void removeAll(Blocks blocks) {
 				var allBlocks = blocks.MethodBlocks.getAllBlocks();
 
-				removeAll(allBlocks, blocks, blocks.Method.Name);
+				removeAll(allBlocks, blocks, blocks.Method.Name.String);
 				removeAll(allBlocks, blocks, blocks.Method);
 			}
 
@@ -281,7 +277,7 @@ namespace de4dot.code.deobfuscators {
 				removeCalls(allBlocks, blocks, info);
 			}
 
-			void removeAll(IList<Block> allBlocks, Blocks blocks, MethodDefinition method) {
+			void removeAll(IList<Block> allBlocks, Blocks blocks, MethodDef method) {
 				var info = methodRefInfos.find(method);
 				if (info == null)
 					return;
@@ -297,12 +293,12 @@ namespace de4dot.code.deobfuscators {
 						var instr = block.Instructions[i];
 						if (instr.OpCode != OpCodes.Call)
 							continue;
-						var destMethod = instr.Operand as MethodReference;
+						var destMethod = instr.Operand as IMethod;
 						if (destMethod == null)
 							continue;
 
 						if (info.find(destMethod)) {
-							Log.v("Removed call to {0}", Utils.removeNewlines(destMethod));
+							Logger.v("Removed call to {0}", Utils.removeNewlines(destMethod));
 							instrsToDelete.Add(i);
 						}
 					}
@@ -311,19 +307,19 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		public void addCctorInitCallToBeRemoved(MethodDefinition methodToBeRemoved) {
+		public void addCctorInitCallToBeRemoved(MethodDef methodToBeRemoved) {
 			methodCallRemover.add(".cctor", methodToBeRemoved);
 		}
 
-		public void addModuleCctorInitCallToBeRemoved(MethodDefinition methodToBeRemoved) {
+		public void addModuleCctorInitCallToBeRemoved(MethodDef methodToBeRemoved) {
 			methodCallRemover.add(DotNetUtils.getModuleTypeCctor(module), methodToBeRemoved);
 		}
 
-		public void addCtorInitCallToBeRemoved(MethodDefinition methodToBeRemoved) {
+		public void addCtorInitCallToBeRemoved(MethodDef methodToBeRemoved) {
 			methodCallRemover.add(".ctor", methodToBeRemoved);
 		}
 
-		public void addCallToBeRemoved(MethodDefinition method, MethodDefinition methodToBeRemoved) {
+		public void addCallToBeRemoved(MethodDef method, MethodDef methodToBeRemoved) {
 			methodCallRemover.add(method, methodToBeRemoved);
 		}
 
@@ -331,46 +327,46 @@ namespace de4dot.code.deobfuscators {
 			methodCallRemover.removeAll(blocks);
 		}
 
-		protected void addMethodsToBeRemoved(IEnumerable<MethodDefinition> methods, string reason) {
+		protected void addMethodsToBeRemoved(IEnumerable<MethodDef> methods, string reason) {
 			foreach (var method in methods)
 				addMethodToBeRemoved(method, reason);
 		}
 
-		protected void addMethodToBeRemoved(MethodDefinition method, string reason) {
+		protected void addMethodToBeRemoved(MethodDef method, string reason) {
 			if (method != null)
-				methodsToRemove.Add(new RemoveInfo<MethodDefinition>(method, reason));
+				methodsToRemove.Add(new RemoveInfo<MethodDef>(method, reason));
 		}
 
-		protected void addFieldsToBeRemoved(IEnumerable<FieldDefinition> fields, string reason) {
+		protected void addFieldsToBeRemoved(IEnumerable<FieldDef> fields, string reason) {
 			foreach (var field in fields)
 				addFieldToBeRemoved(field, reason);
 		}
 
-		protected void addFieldToBeRemoved(FieldDefinition field, string reason) {
+		protected void addFieldToBeRemoved(FieldDef field, string reason) {
 			if (field != null)
-				fieldsToRemove.Add(new RemoveInfo<FieldDefinition>(field, reason));
+				fieldsToRemove.Add(new RemoveInfo<FieldDef>(field, reason));
 		}
 
-		protected void addAttributesToBeRemoved(IEnumerable<TypeDefinition> attrs, string reason) {
+		protected void addAttributesToBeRemoved(IEnumerable<TypeDef> attrs, string reason) {
 			foreach (var attr in attrs)
 				addAttributeToBeRemoved(attr, reason);
 		}
 
-		protected void addAttributeToBeRemoved(TypeDefinition attr, string reason) {
+		protected void addAttributeToBeRemoved(TypeDef attr, string reason) {
 			if (attr == null)
 				return;
 			addTypeToBeRemoved(attr, reason);
-			attrsToRemove.Add(new RemoveInfo<TypeDefinition>(attr, reason));
+			attrsToRemove.Add(new RemoveInfo<TypeDef>(attr, reason));
 		}
 
-		protected void addTypesToBeRemoved(IEnumerable<TypeDefinition> types, string reason) {
+		protected void addTypesToBeRemoved(IEnumerable<TypeDef> types, string reason) {
 			foreach (var type in types)
 				addTypeToBeRemoved(type, reason);
 		}
 
-		protected void addTypeToBeRemoved(TypeDefinition type, string reason) {
+		protected void addTypeToBeRemoved(TypeDef type, string reason) {
 			if (type != null)
-				typesToRemove.Add(new RemoveInfo<TypeDefinition>(type, reason));
+				typesToRemove.Add(new RemoveInfo<TypeDef>(type, reason));
 		}
 
 		protected void addResourceToBeRemoved(Resource resource, string reason) {
@@ -378,25 +374,10 @@ namespace de4dot.code.deobfuscators {
 				resourcesToRemove.Add(new RemoveInfo<Resource>(resource, reason));
 		}
 
-		protected void addModuleReferencesToBeRemoved(IEnumerable<ModuleReference> modrefs, string reason) {
-			foreach (var modref in modrefs)
-				addModuleReferenceToBeRemoved(modref, reason);
-		}
-
-		protected void addModuleReferenceToBeRemoved(ModuleReference modref, string reason) {
-			if (modref != null)
-				modrefsToRemove.Add(new RemoveInfo<ModuleReference>(modref, reason));
-		}
-
-		protected void addAssemblyReferenceToBeRemoved(AssemblyNameReference asmRef, string reason) {
-			if (asmRef != null)
-				asmrefsToRemove.Add(new RemoveInfo<AssemblyNameReference>(asmRef, reason));
-		}
-
 		void deleteEmptyCctors() {
-			var emptyCctorsToRemove = new List<MethodDefinition>();
+			var emptyCctorsToRemove = new List<MethodDef>();
 			foreach (var type in module.GetTypes()) {
-				var cctor = DotNetUtils.getMethod(type, ".cctor");
+				var cctor = type.FindStaticConstructor();
 				if (cctor != null && DotNetUtils.isEmpty(cctor))
 					emptyCctorsToRemove.Add(cctor);
 			}
@@ -404,27 +385,27 @@ namespace de4dot.code.deobfuscators {
 			if (emptyCctorsToRemove.Count == 0)
 				return;
 
-			Log.v("Removing empty .cctor methods");
-			Log.indent();
+			Logger.v("Removing empty .cctor methods");
+			Logger.Instance.indent();
 			foreach (var cctor in emptyCctorsToRemove) {
 				var type = cctor.DeclaringType;
 				if (type == null)
 					continue;
 				if (type.Methods.Remove(cctor))
-					Log.v("{0:X8}, type: {1} ({2:X8})",
-								cctor.MetadataToken.ToUInt32(),
+					Logger.v("{0:X8}, type: {1} ({2:X8})",
+								cctor.MDToken.ToUInt32(),
 								Utils.removeNewlines(type),
-								type.MetadataToken.ToUInt32());
+								type.MDToken.ToUInt32());
 			}
-			Log.deIndent();
+			Logger.Instance.deIndent();
 		}
 
 		void deleteMethods() {
 			if (methodsToRemove.Count == 0)
 				return;
 
-			Log.v("Removing methods");
-			Log.indent();
+			Logger.v("Removing methods");
+			Logger.Instance.indent();
 			foreach (var info in methodsToRemove) {
 				var method = info.obj;
 				if (method == null)
@@ -433,21 +414,21 @@ namespace de4dot.code.deobfuscators {
 				if (type == null)
 					continue;
 				if (type.Methods.Remove(method))
-					Log.v("Removed method {0} ({1:X8}) (Type: {2}) (reason: {3})",
+					Logger.v("Removed method {0} ({1:X8}) (Type: {2}) (reason: {3})",
 								Utils.removeNewlines(method),
-								method.MetadataToken.ToUInt32(),
+								method.MDToken.ToUInt32(),
 								Utils.removeNewlines(type),
 								info.reason);
 			}
-			Log.deIndent();
+			Logger.Instance.deIndent();
 		}
 
 		void deleteFields() {
 			if (fieldsToRemove.Count == 0)
 				return;
 
-			Log.v("Removing fields");
-			Log.indent();
+			Logger.v("Removing fields");
+			Logger.Instance.indent();
 			foreach (var info in fieldsToRemove) {
 				var field = info.obj;
 				if (field == null)
@@ -456,13 +437,13 @@ namespace de4dot.code.deobfuscators {
 				if (type == null)
 					continue;
 				if (type.Fields.Remove(field))
-					Log.v("Removed field {0} ({1:X8}) (Type: {2}) (reason: {3})",
+					Logger.v("Removed field {0} ({1:X8}) (Type: {2}) (reason: {3})",
 								Utils.removeNewlines(field),
-								field.MetadataToken.ToUInt32(),
+								field.MDToken.ToUInt32(),
 								Utils.removeNewlines(type),
 								info.reason);
 			}
-			Log.deIndent();
+			Logger.Instance.deIndent();
 		}
 
 		void deleteTypes() {
@@ -470,37 +451,37 @@ namespace de4dot.code.deobfuscators {
 			if (types == null || typesToRemove.Count == 0)
 				return;
 
-			Log.v("Removing types");
-			Log.indent();
+			Logger.v("Removing types");
+			Logger.Instance.indent();
 			var moduleType = DotNetUtils.getModuleType(module);
 			foreach (var info in typesToRemove) {
 				var typeDef = info.obj;
 				if (typeDef == null || typeDef == moduleType)
 					continue;
 				bool removed;
-				if (typeDef.IsNested)
+				if (typeDef.DeclaringType != null)
 					removed = typeDef.DeclaringType.NestedTypes.Remove(typeDef);
 				else
 					removed = types.Remove(typeDef);
 				if (removed)
-					Log.v("Removed type {0} ({1:X8}) (reason: {2})",
+					Logger.v("Removed type {0} ({1:X8}) (reason: {2})",
 								Utils.removeNewlines(typeDef),
-								typeDef.MetadataToken.ToUInt32(),
+								typeDef.MDToken.ToUInt32(),
 								info.reason);
 			}
-			Log.deIndent();
+			Logger.Instance.deIndent();
 		}
 
 		void deleteCustomAttributes() {
 			if (attrsToRemove.Count == 0)
 				return;
 
-			Log.v("Removing custom attributes");
-			Log.indent();
+			Logger.v("Removing custom attributes");
+			Logger.Instance.indent();
 			deleteCustomAttributes(module.CustomAttributes);
 			if (module.Assembly != null)
 				deleteCustomAttributes(module.Assembly.CustomAttributes);
-			Log.deIndent();
+			Logger.Instance.deIndent();
 		}
 
 		void deleteCustomAttributes(IList<CustomAttribute> customAttrs) {
@@ -511,11 +492,12 @@ namespace de4dot.code.deobfuscators {
 				if (typeDef == null)
 					continue;
 				for (int i = 0; i < customAttrs.Count; i++) {
-					if (MemberReferenceHelper.compareTypes(customAttrs[i].AttributeType, typeDef)) {
+					if (new SigComparer().Equals(typeDef, customAttrs[i].AttributeType)) {
 						customAttrs.RemoveAt(i);
-						Log.v("Removed custom attribute {0} ({1:X8}) (reason: {2})",
+						i--;
+						Logger.v("Removed custom attribute {0} ({1:X8}) (reason: {2})",
 									Utils.removeNewlines(typeDef),
-									typeDef.MetadataToken.ToUInt32(),
+									typeDef.MDToken.ToUInt32(),
 									info.reason);
 						break;
 					}
@@ -524,19 +506,19 @@ namespace de4dot.code.deobfuscators {
 		}
 
 		void deleteOtherAttributes() {
-			Log.v("Removing other attributes");
-			Log.indent();
+			Logger.v("Removing other attributes");
+			Logger.Instance.indent();
 			deleteOtherAttributes(module.CustomAttributes);
 			if (module.Assembly != null)
 				deleteOtherAttributes(module.Assembly.CustomAttributes);
-			Log.deIndent();
+			Logger.Instance.deIndent();
 		}
 
 		void deleteOtherAttributes(IList<CustomAttribute> customAttributes) {
 			for (int i = customAttributes.Count - 1; i >= 0; i--) {
-				var attr = customAttributes[i].AttributeType;
-				if (attr.FullName == "System.Runtime.CompilerServices.SuppressIldasmAttribute") {
-					Log.v("Removed attribute {0}", Utils.removeNewlines(attr.FullName));
+				var attr = customAttributes[i].TypeFullName;
+				if (attr == "System.Runtime.CompilerServices.SuppressIldasmAttribute") {
+					Logger.v("Removed attribute {0}", Utils.removeNewlines(attr));
 					customAttributes.RemoveAt(i);
 				}
 			}
@@ -546,48 +528,16 @@ namespace de4dot.code.deobfuscators {
 			if (!module.HasResources || resourcesToRemove.Count == 0)
 				return;
 
-			Log.v("Removing resources");
-			Log.indent();
+			Logger.v("Removing resources");
+			Logger.Instance.indent();
 			foreach (var info in resourcesToRemove) {
 				var resource = info.obj;
 				if (resource == null)
 					continue;
 				if (module.Resources.Remove(resource))
-					Log.v("Removed resource {0} (reason: {1})", Utils.toCsharpString(resource.Name), info.reason);
+					Logger.v("Removed resource {0} (reason: {1})", Utils.toCsharpString(resource.Name), info.reason);
 			}
-			Log.deIndent();
-		}
-
-		void deleteModuleReferences() {
-			if (!module.HasModuleReferences || modrefsToRemove.Count == 0)
-				return;
-
-			Log.v("Removing module references");
-			Log.indent();
-			foreach (var info in modrefsToRemove) {
-				var modref = info.obj;
-				if (modref == null)
-					continue;
-				if (module.ModuleReferences.Remove(modref))
-					Log.v("Removed module reference {0} (reason: {1})", modref, info.reason);
-			}
-			Log.deIndent();
-		}
-
-		void deleteAssemblyReferences() {
-			if (!module.HasAssemblyReferences || asmrefsToRemove.Count == 0)
-				return;
-
-			Log.v("Removing assembly references");
-			Log.indent();
-			foreach (var info in asmrefsToRemove) {
-				var asmRef = info.obj;
-				if (asmRef == null)
-					continue;
-				if (module.AssemblyReferences.Remove(asmRef))
-					Log.v("Removed assembly reference {0} (reason: {1})", asmRef, info.reason);
-			}
-			Log.deIndent();
+			Logger.Instance.deIndent();
 		}
 
 		protected void setInitLocals() {
@@ -599,13 +549,13 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		static bool isFatHeader(MethodDefinition method) {
+		static bool isFatHeader(MethodDef method) {
 			if (method == null || method.Body == null)
 				return false;
 			var body = method.Body;
-			if (body.InitLocals || body.MaxStackSize > 8)
+			if (body.InitLocals || body.MaxStack > 8)
 				return true;
-			if (body.Variables.Count > 0)
+			if (body.LocalList.Count > 0)
 				return true;
 			if (body.ExceptionHandlers.Count > 0)
 				return true;
@@ -615,7 +565,7 @@ namespace de4dot.code.deobfuscators {
 			return false;
 		}
 
-		static int getCodeSize(MethodDefinition method) {
+		static int getCodeSize(MethodDef method) {
 			if (method == null || method.Body == null)
 				return 0;
 			int size = 0;
@@ -628,7 +578,7 @@ namespace de4dot.code.deobfuscators {
 			return Name;
 		}
 
-		protected void findPossibleNamesToRemove(MethodDefinition method) {
+		protected void findPossibleNamesToRemove(MethodDef method) {
 			if (method == null || !method.HasBody)
 				return;
 
@@ -652,25 +602,13 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		protected void addModuleReferences(string reason) {
-			if (!module.HasModuleReferences)
-				return;
-
-			foreach (var name in namesToPossiblyRemove) {
-				foreach (var moduleRef in module.ModuleReferences) {
-					if (Utils.StartsWith(moduleRef.Name, name, StringComparison.OrdinalIgnoreCase))
-						addModuleReferenceToBeRemoved(moduleRef, reason);
-				}
-			}
-		}
-
 		protected bool removeProxyDelegates(ProxyCallFixerBase proxyCallFixer) {
 			return removeProxyDelegates(proxyCallFixer, true);
 		}
 
 		protected bool removeProxyDelegates(ProxyCallFixerBase proxyCallFixer, bool removeCreators) {
 			if (proxyCallFixer.Errors != 0) {
-				Log.v("Not removing proxy delegates and creator type since errors were detected.");
+				Logger.v("Not removing proxy delegates and creator type since errors were detected.");
 				return false;
 			}
 			addTypesToBeRemoved(proxyCallFixer.DelegateTypes, "Proxy delegate type");
@@ -686,25 +624,25 @@ namespace de4dot.code.deobfuscators {
 			return DotNetUtils.getResource(module, strings);
 		}
 
-		protected CustomAttribute getAssemblyAttribute(TypeReference attr) {
-			var list = new List<CustomAttribute>(DotNetUtils.findAttributes(module.Assembly, attr));
-			return list.Count == 0 ? null : list[0];
+		protected CustomAttribute getAssemblyAttribute(IType attr) {
+			if (module.Assembly == null)
+				return null;
+			return module.Assembly.CustomAttributes.Find(attr);
 		}
 
-		protected CustomAttribute getModuleAttribute(TypeReference attr) {
-			var list = new List<CustomAttribute>(DotNetUtils.findAttributes(module, attr));
-			return list.Count == 0 ? null : list[0];
+		protected CustomAttribute getModuleAttribute(IType attr) {
+			return module.CustomAttributes.Find(attr);
 		}
 
 		protected bool hasMetadataStream(string name) {
-			foreach (var stream in module.MetadataStreams) {
+			foreach (var stream in module.MetaData.AllStreams) {
 				if (stream.Name == name)
 					return true;
 			}
 			return false;
 		}
 
-		List<T> getObjectsToRemove<T>(IList<RemoveInfo<T>> removeThese) where T : MemberReference {
+		List<T> getObjectsToRemove<T>(IList<RemoveInfo<T>> removeThese) where T : class, ICodedToken {
 			var list = new List<T>(removeThese.Count);
 			foreach (var info in removeThese) {
 				if (info.obj != null)
@@ -713,11 +651,11 @@ namespace de4dot.code.deobfuscators {
 			return list;
 		}
 
-		protected List<TypeDefinition> getTypesToRemove() {
+		protected List<TypeDef> getTypesToRemove() {
 			return getObjectsToRemove(typesToRemove);
 		}
 
-		protected List<MethodDefinition> getMethodsToRemove() {
+		protected List<MethodDef> getMethodsToRemove() {
 			return getObjectsToRemove(methodsToRemove);
 		}
 
@@ -759,18 +697,22 @@ namespace de4dot.code.deobfuscators {
 			return name != null && checkValidName(name);
 		}
 
+		public virtual bool isValidMethodReturnArgName(string name) {
+			return string.IsNullOrEmpty(name) || checkValidName(name);
+		}
+
 		public virtual bool isValidResourceKeyName(string name) {
 			return name != null && checkValidName(name);
 		}
 
-		public virtual void OnBeforeAddingResources(MetadataBuilder builder) {
+		public virtual void OnWriterEvent(ModuleWriterBase writer, ModuleWriterEvent evt) {
 		}
 
 		protected void findAndRemoveInlinedMethods() {
 			removeInlinedMethods(InlinedMethodsFinder.find(module));
 		}
 
-		protected void removeInlinedMethods(List<MethodDefinition> inlinedMethods) {
+		protected void removeInlinedMethods(List<MethodDef> inlinedMethods) {
 			addMethodsToBeRemoved(new UnusedMethodsFinder(module, inlinedMethods, getRemovedMethods()).find(), "Inlined method");
 		}
 
@@ -781,7 +723,7 @@ namespace de4dot.code.deobfuscators {
 			return removedMethods;
 		}
 
-		protected bool isTypeCalled(TypeDefinition decrypterType) {
+		protected bool isTypeCalled(TypeDef decrypterType) {
 			if (decrypterType == null)
 				return false;
 
@@ -804,7 +746,7 @@ namespace de4dot.code.deobfuscators {
 						case Code.Call:
 						case Code.Callvirt:
 						case Code.Newobj:
-							var calledMethod = instr.Operand as MethodReference;
+							var calledMethod = instr.Operand as IMethod;
 							if (calledMethod == null)
 								break;
 							if (decrypterMethods.exists(calledMethod))
@@ -821,7 +763,23 @@ namespace de4dot.code.deobfuscators {
 			return false;
 		}
 
-		public static int toInt32(bool b) {
+		protected bool hasNativeMethods() {
+			if (module.VTableFixups != null)
+				return true;
+			foreach (var type in module.GetTypes()) {
+				foreach (var method in type.Methods) {
+					var mb = method.MethodBody;
+					if (mb == null)
+						continue;
+					if (mb is CilBody)
+						continue;
+					return true;
+				}
+			}
+			return false;
+		}
+
+		protected static int toInt32(bool b) {
 			return b ? 1 : 0;
 		}
 	}
diff --git a/de4dot.code/deobfuscators/Dotfuscator/Deobfuscator.cs b/de4dot.code/deobfuscators/Dotfuscator/Deobfuscator.cs
index d5ab2230..25f19d15 100644
--- a/de4dot.code/deobfuscators/Dotfuscator/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/Dotfuscator/Deobfuscator.cs
@@ -18,7 +18,7 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Dotfuscator {
@@ -101,7 +101,7 @@ namespace de4dot.code.deobfuscators.Dotfuscator {
 			}
 		}
 
-		void initializeVersion(TypeDefinition attr) {
+		void initializeVersion(TypeDef attr) {
 			var s = DotNetUtils.getCustomArgAsString(getAssemblyAttribute(attr), 0);
 			if (s == null)
 				return;
@@ -129,7 +129,7 @@ namespace de4dot.code.deobfuscators.Dotfuscator {
 		public override IEnumerable<int> getStringDecrypterMethods() {
 			var list = new List<int>();
 			foreach (var method in stringDecrypter.StringDecrypters)
-				list.Add(method.MetadataToken.ToInt32());
+				list.Add(method.MDToken.ToInt32());
 			return list;
 		}
 	}
diff --git a/de4dot.code/deobfuscators/Dotfuscator/StringDecrypter.cs b/de4dot.code/deobfuscators/Dotfuscator/StringDecrypter.cs
index 4c707b59..92f5c1a9 100644
--- a/de4dot.code/deobfuscators/Dotfuscator/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/Dotfuscator/StringDecrypter.cs
@@ -18,19 +18,19 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Dotfuscator {
 	class StringDecrypter {
-		ModuleDefinition module;
-		Dictionary<MethodReference, StringDecrypterInfo> stringDecrypterMethods = new Dictionary<MethodReference, StringDecrypterInfo>();
+		ModuleDefMD module;
+		MethodDefinitionAndDeclaringTypeDict<StringDecrypterInfo> stringDecrypterMethods = new MethodDefinitionAndDeclaringTypeDict<StringDecrypterInfo>();
 
 		public class StringDecrypterInfo {
-			public MethodDefinition method;
+			public MethodDef method;
 			public int magic;
-			public StringDecrypterInfo(MethodDefinition method, int magic) {
+			public StringDecrypterInfo(MethodDef method, int magic) {
 				this.method = method;
 				this.magic = magic;
 			}
@@ -40,20 +40,20 @@ namespace de4dot.code.deobfuscators.Dotfuscator {
 			get { return stringDecrypterMethods.Count > 0; }
 		}
 
-		public IEnumerable<MethodDefinition> StringDecrypters {
+		public IEnumerable<MethodDef> StringDecrypters {
 			get {
-				var list = new List<MethodDefinition>(stringDecrypterMethods.Count);
-				foreach (var info in stringDecrypterMethods)
-					list.Add(info.Value.method);
+				var list = new List<MethodDef>(stringDecrypterMethods.Count);
+				foreach (var info in stringDecrypterMethods.getValues())
+					list.Add(info.method);
 				return list;
 			}
 		}
 
 		public IEnumerable<StringDecrypterInfo> StringDecrypterInfos {
-			get { return stringDecrypterMethods.Values; }
+			get { return stringDecrypterMethods.getValues(); }
 		}
 
-		public StringDecrypter(ModuleDefinition module) {
+		public StringDecrypter(ModuleDefMD module) {
 			this.module = module;
 		}
 
@@ -62,38 +62,37 @@ namespace de4dot.code.deobfuscators.Dotfuscator {
 				findStringDecrypterMethods(type, simpleDeobfuscator);
 		}
 
-		void findStringDecrypterMethods(TypeDefinition type, ISimpleDeobfuscator simpleDeobfuscator) {
+		void findStringDecrypterMethods(TypeDef type, ISimpleDeobfuscator simpleDeobfuscator) {
 			foreach (var method in DotNetUtils.findMethods(type.Methods, "System.String", new string[] { "System.String", "System.Int32" })) {
 				if (method.Body.HasExceptionHandlers)
 					continue;
 
-				var methodCalls = DotNetUtils.getMethodCallCounts(method);
-				if (methodCalls.count("System.Char[] System.String::ToCharArray()") != 1)
+				if (DotNetUtils.getMethodCalls(method, "System.Char[] System.String::ToCharArray()") != 1)
 					continue;
-				if (methodCalls.count("System.String System.String::Intern(System.String)") != 1)
+				if (DotNetUtils.getMethodCalls(method, "System.String System.String::Intern(System.String)") != 1)
 					continue;
 
 				simpleDeobfuscator.deobfuscate(method);
 				var instructions = method.Body.Instructions;
 				for (int i = 0; i <= instructions.Count - 3; i++) {
 					var ldci4 = method.Body.Instructions[i];
-					if (!DotNetUtils.isLdcI4(ldci4))
+					if (!ldci4.IsLdcI4())
 						continue;
 					if (instructions[i + 1].OpCode.Code != Code.Ldarg_1)
 						continue;
 					if (instructions[i + 2].OpCode.Code != Code.Add)
 						continue;
 
-					var info = new StringDecrypterInfo(method, DotNetUtils.getLdcI4Value(ldci4));
-					stringDecrypterMethods[info.method] = info;
-					Log.v("Found string decrypter method: {0}, magic: 0x{1:X8}", Utils.removeNewlines(info.method), info.magic);
+					var info = new StringDecrypterInfo(method, ldci4.GetLdcI4Value());
+					stringDecrypterMethods.add(info.method, info);
+					Logger.v("Found string decrypter method: {0}, magic: 0x{1:X8}", Utils.removeNewlines(info.method), info.magic);
 					break;
 				}
 			}
 		}
 
-		public string decrypt(MethodReference method, string encrypted, int value) {
-			var info = stringDecrypterMethods[method];
+		public string decrypt(IMethod method, string encrypted, int value) {
+			var info = stringDecrypterMethods.findAny(method);
 			char[] chars = encrypted.ToCharArray();
 			byte key = (byte)(info.magic + value);
 			for (int i = 0; i < chars.Length; i++) {
diff --git a/de4dot.code/deobfuscators/Eazfuscator_NET/AssemblyResolver.cs b/de4dot.code/deobfuscators/Eazfuscator_NET/AssemblyResolver.cs
index 767a7b26..f32f0be2 100644
--- a/de4dot.code/deobfuscators/Eazfuscator_NET/AssemblyResolver.cs
+++ b/de4dot.code/deobfuscators/Eazfuscator_NET/AssemblyResolver.cs
@@ -22,19 +22,19 @@ using System.Collections.Generic;
 using System.IO;
 using System.Text;
 using System.Text.RegularExpressions;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 	class AssemblyResolver {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		DecrypterType decrypterType;
-		TypeDefinition resolverType;
-		MethodDefinition initMethod;
-		MethodDefinition handlerMethod;
-		MethodDefinition decryptMethod;
-		TypeDefinition otherType;
+		TypeDef resolverType;
+		MethodDef initMethod;
+		MethodDef handlerMethod;
+		MethodDef decryptMethod;
+		TypeDef otherType;
 		List<AssemblyInfo> assemblyInfos = new List<AssemblyInfo>();
 		FrameworkType frameworkType;
 		byte[] decryptKey;
@@ -56,15 +56,15 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			}
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return resolverType; }
 		}
 
-		public TypeDefinition OtherType {
+		public TypeDef OtherType {
 			get { return otherType; }
 		}
 
-		public MethodDefinition InitMethod {
+		public MethodDef InitMethod {
 			get { return initMethod; }
 		}
 
@@ -76,7 +76,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			get { return resolverType != null; }
 		}
 
-		public AssemblyResolver(ModuleDefinition module, DecrypterType decrypterType) {
+		public AssemblyResolver(ModuleDefMD module, DecrypterType decrypterType) {
 			this.module = module;
 			this.frameworkType = DotNetUtils.getFrameworkType(module);
 			this.decrypterType = decrypterType;
@@ -87,7 +87,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			checkCalledMethods(DotNetUtils.getModuleTypeCctor(module));
 		}
 
-		bool checkCalledMethods(MethodDefinition method) {
+		bool checkCalledMethods(MethodDef method) {
 			if (method == null || method.Body == null)
 				return false;
 
@@ -95,7 +95,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				if (instr.OpCode.Code != Code.Call)
 					continue;
 
-				var calledMethod = instr.Operand as MethodDefinition;
+				var calledMethod = instr.Operand as MethodDef;
 				if (calledMethod == null || !calledMethod.IsStatic || calledMethod.Body == null)
 					continue;
 				if (!DotNetUtils.isMethod(calledMethod, "System.Void", "()"))
@@ -119,7 +119,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return false;
 		}
 
-		bool checkInitMethodSilverlight(MethodDefinition method) {
+		bool checkInitMethodSilverlight(MethodDef method) {
 			var type = method.DeclaringType;
 			if (type.NestedTypes.Count != 2)
 				return false;
@@ -134,11 +134,11 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return true;
 		}
 
-		static MethodDefinition getResolveMethodSilverlight(MethodDefinition initMethod) {
+		static MethodDef getResolveMethodSilverlight(MethodDef initMethod) {
 			foreach (var instr in initMethod.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Call)
 					continue;
-				var calledMethod = instr.Operand as MethodDefinition;
+				var calledMethod = instr.Operand as MethodDef;
 				if (calledMethod == null)
 					continue;
 				if (!DotNetUtils.isMethod(calledMethod, "System.Void", "()"))
@@ -153,7 +153,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return null;
 		}
 
-		bool checkInitMethod(MethodDefinition method) {
+		bool checkInitMethod(MethodDef method) {
 			var type = method.DeclaringType;
 			if (type.NestedTypes.Count < 2 || type.NestedTypes.Count > 6)
 				return false;
@@ -173,7 +173,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return true;
 		}
 
-		MethodDefinition getDecryptMethod() {
+		MethodDef getDecryptMethod() {
 			foreach (var method in resolverType.Methods) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
@@ -198,14 +198,14 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				throw new ApplicationException("Could not initialize decrypterType");
 		}
 
-		TypeDefinition getDecrypterType(MethodDefinition method) {
+		TypeDef getDecrypterType(MethodDef method) {
 			if (method == null || method.Body == null)
 				return null;
 
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Call)
 					continue;
-				var calledMethod = instr.Operand as MethodDefinition;
+				var calledMethod = instr.Operand as MethodDef;
 				if (calledMethod == null || !calledMethod.IsStatic || calledMethod.DeclaringType == resolverType)
 					continue;
 				if (!DotNetUtils.isMethod(calledMethod, "System.Void", "(System.Byte[])"))
@@ -356,15 +356,15 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 
 		static void initializeNameAndExtension(AssemblyInfo info) {
 			try {
-				var mod = ModuleDefinition.ReadModule(new MemoryStream(info.Data));
+				var mod = ModuleDefMD.Load(info.Data);
 				info.AssemblyFullName = mod.Assembly.FullName;
-				info.SimpleName = mod.Assembly.Name.Name;
+				info.SimpleName = mod.Assembly.Name.String;
 				info.Extension = DeobUtils.getExtension(mod.Kind);
 				return;
 			}
 			catch {
 			}
-			Log.w("Could not load assembly from decrypted resource {0}", Utils.toCsharpString(info.ResourceName));
+			Logger.w("Could not load assembly from decrypted resource {0}", Utils.toCsharpString(info.ResourceName));
 			int index = info.Filename.LastIndexOf('.');
 			if (index < 0) {
 				info.SimpleName = info.Filename;
@@ -467,8 +467,8 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			}
 		}
 
-		static MethodDefinition getTheOnlyMethod(TypeDefinition type, string typeName, string methodName, string returnType, string parameters) {
-			MethodDefinition foundMethod = null;
+		static MethodDef getTheOnlyMethod(TypeDef type, string typeName, string methodName, string returnType, string parameters) {
+			MethodDef foundMethod = null;
 
 			foreach (var method in type.Methods) {
 				if (!method.IsStatic || method.Body == null || method.HasGenericParameters)
diff --git a/de4dot.code/deobfuscators/Eazfuscator_NET/CodeCompilerMethodCallRestorer.cs b/de4dot.code/deobfuscators/Eazfuscator_NET/CodeCompilerMethodCallRestorer.cs
index 1f52459f..7dc9e406 100644
--- a/de4dot.code/deobfuscators/Eazfuscator_NET/CodeCompilerMethodCallRestorer.cs
+++ b/de4dot.code/deobfuscators/Eazfuscator_NET/CodeCompilerMethodCallRestorer.cs
@@ -17,101 +17,101 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 	class CodeCompilerMethodCallRestorer : MethodCallRestorerBase {
-		TypeReference CodeDomProvider {
+		ITypeDefOrRef CodeDomProvider {
 			get {
-				return builder.type("System.CodeDom.Compiler", "CodeDomProvider", "System");
+				return builder.type("System.CodeDom.Compiler", "CodeDomProvider", "System").ToTypeDefOrRef();
 			}
 		}
 
-		TypeReference ICodeCompiler {
+		ITypeDefOrRef ICodeCompiler {
 			get {
-				return builder.type("System.CodeDom.Compiler", "ICodeCompiler", "System");
+				return builder.type("System.CodeDom.Compiler", "ICodeCompiler", "System").ToTypeDefOrRef();
 			}
 		}
 
-		TypeReference CompilerResults {
+		TypeSig CompilerResults {
 			get {
 				return builder.type("System.CodeDom.Compiler", "CompilerResults", "System");
 			}
 		}
 
-		TypeReference CompilerParameters {
+		TypeSig CompilerParameters {
 			get {
 				return builder.type("System.CodeDom.Compiler", "CompilerParameters", "System");
 			}
 		}
 
-		TypeReference CodeCompileUnit {
+		TypeSig CodeCompileUnit {
 			get {
 				return builder.type("System.CodeDom", "CodeCompileUnit", "System");
 			}
 		}
 
-		TypeReference CodeCompileUnitArray {
+		TypeSig CodeCompileUnitArray {
 			get { return builder.array(CodeCompileUnit); }
 		}
 
-		TypeReference StringArray {
+		TypeSig StringArray {
 			get { return builder.array(builder.String); }
 		}
 
-		public CodeCompilerMethodCallRestorer(ModuleDefinition module)
+		public CodeCompilerMethodCallRestorer(ModuleDefMD module)
 			: base(module) {
 		}
 
-		public void add_CodeDomProvider_CompileAssemblyFromDom(MethodDefinition oldMethod) {
+		public void add_CodeDomProvider_CompileAssemblyFromDom(MethodDef oldMethod) {
 			if (oldMethod == null)
 				return;
 			add(oldMethod, builder.instanceMethod("CompileAssemblyFromDom", CodeDomProvider, CompilerResults, CompilerParameters, CodeCompileUnitArray));
 		}
 
-		public void add_CodeDomProvider_CompileAssemblyFromFile(MethodDefinition oldMethod) {
+		public void add_CodeDomProvider_CompileAssemblyFromFile(MethodDef oldMethod) {
 			if (oldMethod == null)
 				return;
 			add(oldMethod, builder.instanceMethod("CompileAssemblyFromFile", CodeDomProvider, CompilerResults, CompilerParameters, StringArray));
 		}
 
-		public void add_CodeDomProvider_CompileAssemblyFromSource(MethodDefinition oldMethod) {
+		public void add_CodeDomProvider_CompileAssemblyFromSource(MethodDef oldMethod) {
 			if (oldMethod == null)
 				return;
 			add(oldMethod, builder.instanceMethod("CompileAssemblyFromSource", CodeDomProvider, CompilerResults, CompilerParameters, StringArray));
 		}
 
-		public void add_ICodeCompiler_CompileAssemblyFromDom(MethodDefinition oldMethod) {
+		public void add_ICodeCompiler_CompileAssemblyFromDom(MethodDef oldMethod) {
 			if (oldMethod == null)
 				return;
 			add(oldMethod, builder.instanceMethod("CompileAssemblyFromDom", ICodeCompiler, CompilerResults, CompilerParameters, CodeCompileUnit));
 		}
 
-		public void add_ICodeCompiler_CompileAssemblyFromDomBatch(MethodDefinition oldMethod) {
+		public void add_ICodeCompiler_CompileAssemblyFromDomBatch(MethodDef oldMethod) {
 			if (oldMethod == null)
 				return;
 			add(oldMethod, builder.instanceMethod("CompileAssemblyFromDomBatch", ICodeCompiler, CompilerResults, CompilerParameters, CodeCompileUnitArray));
 		}
 
-		public void add_ICodeCompiler_CompileAssemblyFromFile(MethodDefinition oldMethod) {
+		public void add_ICodeCompiler_CompileAssemblyFromFile(MethodDef oldMethod) {
 			if (oldMethod == null)
 				return;
 			add(oldMethod, builder.instanceMethod("CompileAssemblyFromFile", ICodeCompiler, CompilerResults, CompilerParameters, builder.String));
 		}
 
-		public void add_ICodeCompiler_CompileAssemblyFromFileBatch(MethodDefinition oldMethod) {
+		public void add_ICodeCompiler_CompileAssemblyFromFileBatch(MethodDef oldMethod) {
 			if (oldMethod == null)
 				return;
 			add(oldMethod, builder.instanceMethod("CompileAssemblyFromFileBatch", ICodeCompiler, CompilerResults, CompilerParameters, StringArray));
 		}
 
-		public void add_ICodeCompiler_CompileAssemblyFromSource(MethodDefinition oldMethod) {
+		public void add_ICodeCompiler_CompileAssemblyFromSource(MethodDef oldMethod) {
 			if (oldMethod == null)
 				return;
 			add(oldMethod, builder.instanceMethod("CompileAssemblyFromSource", ICodeCompiler, CompilerResults, CompilerParameters, builder.String));
 		}
 
-		public void add_ICodeCompiler_CompileAssemblyFromSourceBatch(MethodDefinition oldMethod) {
+		public void add_ICodeCompiler_CompileAssemblyFromSourceBatch(MethodDef oldMethod) {
 			if (oldMethod == null)
 				return;
 			add(oldMethod, builder.instanceMethod("CompileAssemblyFromSourceBatch", ICodeCompiler, CompilerResults, CompilerParameters, StringArray));
diff --git a/de4dot.code/deobfuscators/Eazfuscator_NET/DecrypterType.cs b/de4dot.code/deobfuscators/Eazfuscator_NET/DecrypterType.cs
index f113dfa0..b05a931f 100644
--- a/de4dot.code/deobfuscators/Eazfuscator_NET/DecrypterType.cs
+++ b/de4dot.code/deobfuscators/Eazfuscator_NET/DecrypterType.cs
@@ -20,23 +20,23 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 	class DecrypterType {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		ISimpleDeobfuscator simpleDeobfuscator;
-		TypeDefinition type;
-		MethodDefinition int64Method;
+		TypeDef type;
+		MethodDef int64Method;
 		bool initialized;
 		ulong l1;
 		int i1, i2, i3;
 		int m1_i1, m2_i1, m2_i2, m3_i1;
-		MethodDefinition[] efConstMethods;
+		MethodDef[] efConstMethods;
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return type; }
 			set {
 				if (type == null)
@@ -50,7 +50,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			get { return type != null; }
 		}
 
-		public DecrypterType(ModuleDefinition module, ISimpleDeobfuscator simpleDeobfuscator) {
+		public DecrypterType(ModuleDefMD module, ISimpleDeobfuscator simpleDeobfuscator) {
 			this.module = module;
 			this.simpleDeobfuscator = simpleDeobfuscator;
 		}
@@ -80,7 +80,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			if (type == null)
 				return false;
 
-			efConstMethods = new MethodDefinition[6];
+			efConstMethods = new MethodDef[6];
 
 			efConstMethods[0] = findEfConstMethodCall(int64Method);
 			efConstMethods[5] = findEfConstMethodCall(efConstMethods[0]);
@@ -105,7 +105,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return true;
 		}
 
-		static int getNumberOfTypeofs(MethodDefinition method) {
+		static int getNumberOfTypeofs(MethodDef method) {
 			if (method == null)
 				return 0;
 			int count = 0;
@@ -116,21 +116,21 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return count;
 		}
 
-		MethodDefinition findEfConstMethodCall(MethodDefinition method) {
+		MethodDef findEfConstMethodCall(MethodDef method) {
 			var list = findEfConstMethodCalls(method);
 			if (list == null || list.Count != 1)
 				return null;
 			return list[0];
 		}
 
-		List<MethodDefinition> findEfConstMethodCalls(MethodDefinition method) {
+		List<MethodDef> findEfConstMethodCalls(MethodDef method) {
 			if (method == null)
 				return null;
-			var list = new List<MethodDefinition>();
+			var list = new List<MethodDef>();
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Call)
 					continue;
-				var calledMethod = instr.Operand as MethodDefinition;
+				var calledMethod = instr.Operand as MethodDef;
 				if (calledMethod == null || !calledMethod.IsStatic || calledMethod.Body == null)
 					continue;
 				if (!DotNetUtils.isMethod(calledMethod, "System.Int32", "()"))
@@ -143,7 +143,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return list;
 		}
 
-		MethodDefinition findInt64Method() {
+		MethodDef findInt64Method() {
 			if (type == null)
 				return null;
 			foreach (var method in type.Methods) {
@@ -160,7 +160,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return null;
 		}
 
-		bool findInt64(MethodDefinition method) {
+		bool findInt64(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 1; i++) {
 				var ldci8 = instrs[i];
@@ -212,8 +212,8 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return false;
 		}
 
-		static List<MethodDefinition> getBinaryIntMethods(TypeDefinition type) {
-			var list = new List<MethodDefinition>();
+		static List<MethodDef> getBinaryIntMethods(TypeDef type) {
+			var list = new List<MethodDef>();
 			foreach (var method in type.Methods) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
@@ -225,7 +225,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return list;
 		}
 
-		bool findMethod1Int(IEnumerable<MethodDefinition> methods) {
+		bool findMethod1Int(IEnumerable<MethodDef> methods) {
 			foreach (var method in methods) {
 				if (countInstructions(method, Code.Ldarg_0) != 1)
 					continue;
@@ -239,7 +239,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return false;
 		}
 
-		bool findMethod2Int(IEnumerable<MethodDefinition> methods) {
+		bool findMethod2Int(IEnumerable<MethodDef> methods) {
 			foreach (var method in methods) {
 				var constants = getConstants(method);
 				if (constants.Count != 2)
@@ -252,7 +252,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return false;
 		}
 
-		bool findMethod3Int(IEnumerable<MethodDefinition> methods) {
+		bool findMethod3Int(IEnumerable<MethodDef> methods) {
 			foreach (var method in methods) {
 				if (countInstructions(method, Code.Ldarg_0) != 2)
 					continue;
@@ -266,7 +266,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return false;
 		}
 
-		static int countInstructions(MethodDefinition method, Code code) {
+		static int countInstructions(MethodDef method, Code code) {
 			int count = 0;
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code == code)
@@ -275,7 +275,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return count;
 		}
 
-		static List<int> getConstants(MethodDefinition method) {
+		static List<int> getConstants(MethodDef method) {
 			var list = new List<int>();
 
 			if (method == null)
@@ -309,27 +309,27 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 		}
 
 		int constMethod1() {
-			return binOp3(binOp2(efConstMethods[1].DeclaringType.MetadataToken.ToInt32(), binOp3(efConstMethods[0].DeclaringType.MetadataToken.ToInt32(), efConstMethods[4].DeclaringType.MetadataToken.ToInt32())), constMethod6());
+			return binOp3(binOp2(efConstMethods[1].DeclaringType.MDToken.ToInt32(), binOp3(efConstMethods[0].DeclaringType.MDToken.ToInt32(), efConstMethods[4].DeclaringType.MDToken.ToInt32())), constMethod6());
 		}
 
 		int constMethod2() {
-			return binOp1(efConstMethods[2].DeclaringType.MetadataToken.ToInt32(), efConstMethods[3].DeclaringType.MetadataToken.ToInt32() ^ binOp2(efConstMethods[1].DeclaringType.MetadataToken.ToInt32(), binOp3(efConstMethods[5].DeclaringType.MetadataToken.ToInt32(), constMethod4())));
+			return binOp1(efConstMethods[2].DeclaringType.MDToken.ToInt32(), efConstMethods[3].DeclaringType.MDToken.ToInt32() ^ binOp2(efConstMethods[1].DeclaringType.MDToken.ToInt32(), binOp3(efConstMethods[5].DeclaringType.MDToken.ToInt32(), constMethod4())));
 		}
 
 		int constMethod3() {
-			return binOp3(binOp1(constMethod2() ^ i1, efConstMethods[3].DeclaringType.MetadataToken.ToInt32()), binOp2(efConstMethods[0].DeclaringType.MetadataToken.ToInt32() ^ efConstMethods[5].DeclaringType.MetadataToken.ToInt32(), i2));
+			return binOp3(binOp1(constMethod2() ^ i1, efConstMethods[3].DeclaringType.MDToken.ToInt32()), binOp2(efConstMethods[0].DeclaringType.MDToken.ToInt32() ^ efConstMethods[5].DeclaringType.MDToken.ToInt32(), i2));
 		}
 
 		int constMethod4() {
-			return binOp3(efConstMethods[3].DeclaringType.MetadataToken.ToInt32(), binOp1(efConstMethods[0].DeclaringType.MetadataToken.ToInt32(), binOp2(efConstMethods[1].DeclaringType.MetadataToken.ToInt32(), binOp3(efConstMethods[2].DeclaringType.MetadataToken.ToInt32(), binOp1(efConstMethods[4].DeclaringType.MetadataToken.ToInt32(), efConstMethods[5].DeclaringType.MetadataToken.ToInt32())))));
+			return binOp3(efConstMethods[3].DeclaringType.MDToken.ToInt32(), binOp1(efConstMethods[0].DeclaringType.MDToken.ToInt32(), binOp2(efConstMethods[1].DeclaringType.MDToken.ToInt32(), binOp3(efConstMethods[2].DeclaringType.MDToken.ToInt32(), binOp1(efConstMethods[4].DeclaringType.MDToken.ToInt32(), efConstMethods[5].DeclaringType.MDToken.ToInt32())))));
 		}
 
 		int constMethod5() {
-			return binOp2(binOp2(constMethod3(), binOp1(efConstMethods[4].DeclaringType.MetadataToken.ToInt32(), constMethod2())), efConstMethods[5].DeclaringType.MetadataToken.ToInt32());
+			return binOp2(binOp2(constMethod3(), binOp1(efConstMethods[4].DeclaringType.MDToken.ToInt32(), constMethod2())), efConstMethods[5].DeclaringType.MDToken.ToInt32());
 		}
 
 		int constMethod6() {
-			return binOp1(efConstMethods[5].DeclaringType.MetadataToken.ToInt32(), binOp3(binOp2(efConstMethods[4].DeclaringType.MetadataToken.ToInt32(), efConstMethods[0].DeclaringType.MetadataToken.ToInt32()), binOp3(efConstMethods[2].DeclaringType.MetadataToken.ToInt32() ^ i3, constMethod5())));
+			return binOp1(efConstMethods[5].DeclaringType.MDToken.ToInt32(), binOp3(binOp2(efConstMethods[4].DeclaringType.MDToken.ToInt32(), efConstMethods[0].DeclaringType.MDToken.ToInt32()), binOp3(efConstMethods[2].DeclaringType.MDToken.ToInt32() ^ i3, constMethod5())));
 		}
 
 		public ulong getMagic() {
@@ -338,18 +338,18 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 
 			var bytes = new List<byte>();
 			if (module.Assembly != null) {
-				if (module.Assembly.Name.PublicKeyToken != null)
-					bytes.AddRange(module.Assembly.Name.PublicKeyToken);
-				bytes.AddRange(Encoding.Unicode.GetBytes(module.Assembly.Name.Name));
+				if (!PublicKeyBase.IsNullOrEmpty2(module.Assembly.PublicKey))
+					bytes.AddRange(module.Assembly.PublicKeyToken.Data);
+				bytes.AddRange(Encoding.Unicode.GetBytes(module.Assembly.Name.String));
 			}
 			int cm1 = constMethod1();
-			bytes.Add((byte)(type.MetadataToken.ToInt32() >> 24));
+			bytes.Add((byte)(type.MDToken.ToInt32() >> 24));
 			bytes.Add((byte)(cm1 >> 16));
-			bytes.Add((byte)(type.MetadataToken.ToInt32() >> 8));
+			bytes.Add((byte)(type.MDToken.ToInt32() >> 8));
 			bytes.Add((byte)cm1);
-			bytes.Add((byte)(type.MetadataToken.ToInt32() >> 16));
+			bytes.Add((byte)(type.MDToken.ToInt32() >> 16));
 			bytes.Add((byte)(cm1 >> 8));
-			bytes.Add((byte)type.MetadataToken.ToInt32());
+			bytes.Add((byte)type.MDToken.ToInt32());
 			bytes.Add((byte)(cm1 >> 24));
 
 			ulong magic = 0;
diff --git a/de4dot.code/deobfuscators/Eazfuscator_NET/Deobfuscator.cs b/de4dot.code/deobfuscators/Eazfuscator_NET/Deobfuscator.cs
index d4f39652..3bdde714 100644
--- a/de4dot.code/deobfuscators/Eazfuscator_NET/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/Eazfuscator_NET/Deobfuscator.cs
@@ -18,7 +18,7 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Eazfuscator_NET {
@@ -167,7 +167,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 		public override IEnumerable<int> getStringDecrypterMethods() {
 			var list = new List<int>();
 			if (stringDecrypter.Method != null)
-				list.Add(stringDecrypter.Method.MetadataToken.ToInt32());
+				list.Add(stringDecrypter.Method.MDToken.ToInt32());
 			return list;
 		}
 	}
diff --git a/de4dot.code/deobfuscators/Eazfuscator_NET/EfConstantsReader.cs b/de4dot.code/deobfuscators/Eazfuscator_NET/EfConstantsReader.cs
index e3b2e3f6..952535f6 100644
--- a/de4dot.code/deobfuscators/Eazfuscator_NET/EfConstantsReader.cs
+++ b/de4dot.code/deobfuscators/Eazfuscator_NET/EfConstantsReader.cs
@@ -17,13 +17,12 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil;
-using Mono.Cecil.Metadata;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 	class EfConstantsReader : ConstantsReader {
-		public EfConstantsReader(MethodDefinition method)
+		public EfConstantsReader(MethodDef method)
 			: base(method) {
 			initialize();
 		}
@@ -38,10 +37,10 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				if (!getInt32(ref index, out value))
 					break;
 				var stloc = instructions[index];
-				if (!DotNetUtils.isStloc(stloc))
+				if (!stloc.IsStloc())
 					break;
-				var local = DotNetUtils.getLocalVar(locals, stloc);
-				if (local == null || local.VariableType.EType != ElementType.I4)
+				var local = stloc.GetLocal(locals);
+				if (local == null || local.Type.GetElementType() != ElementType.I4)
 					break;
 				localsValuesInt32[local] = value;
 				index++;
diff --git a/de4dot.code/deobfuscators/Eazfuscator_NET/EfUtils.cs b/de4dot.code/deobfuscators/Eazfuscator_NET/EfUtils.cs
index fd3af58a..4829a456 100644
--- a/de4dot.code/deobfuscators/Eazfuscator_NET/EfUtils.cs
+++ b/de4dot.code/deobfuscators/Eazfuscator_NET/EfUtils.cs
@@ -18,13 +18,13 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 	static class EfUtils {
-		public static int findOpCodeIndex(MethodDefinition method, int index, Code code) {
+		public static int findOpCodeIndex(MethodDef method, int index, Code code) {
 			for (; index < method.Body.Instructions.Count; index++) {
 				var instr = method.Body.Instructions[index];
 				if (instr.OpCode.Code != code)
@@ -35,7 +35,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return -1;
 		}
 
-		public static int findOpCodeIndex(MethodDefinition method, int index, Code code, string operandString) {
+		public static int findOpCodeIndex(MethodDef method, int index, Code code, string operandString) {
 			while (index < method.Body.Instructions.Count) {
 				index = findOpCodeIndex(method, index, code);
 				if (index < 0)
@@ -49,14 +49,14 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return -1;
 		}
 
-		public static Instruction getNextStore(MethodDefinition method, ref int index) {
+		public static Instruction getNextStore(MethodDef method, ref int index) {
 			for (; index < method.Body.Instructions.Count; index++) {
 				var instr = method.Body.Instructions[index];
 
 				switch (instr.OpCode.Code) {
 				case Code.Starg:
 				case Code.Starg_S:
-				case Code.Stelem_Any:
+				case Code.Stelem:
 				case Code.Stelem_I:
 				case Code.Stelem_I1:
 				case Code.Stelem_I2:
diff --git a/de4dot.code/deobfuscators/Eazfuscator_NET/ResourceMethodsRestorer.cs b/de4dot.code/deobfuscators/Eazfuscator_NET/ResourceMethodsRestorer.cs
index 12377401..81808c06 100644
--- a/de4dot.code/deobfuscators/Eazfuscator_NET/ResourceMethodsRestorer.cs
+++ b/de4dot.code/deobfuscators/Eazfuscator_NET/ResourceMethodsRestorer.cs
@@ -17,15 +17,15 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 	class ResourceMethodsRestorer : MethodCallRestorerBase {
-		TypeDefinition getManifestResourceStreamType;
+		TypeDef getManifestResourceStreamType;
 		EmbeddedResource getManifestResourceStreamTypeResource;
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return getManifestResourceStreamType; }
 		}
 
@@ -33,7 +33,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			get { return getManifestResourceStreamTypeResource; }
 		}
 
-		public ResourceMethodsRestorer(ModuleDefinition module)
+		public ResourceMethodsRestorer(ModuleDefMD module)
 			: base(module) {
 		}
 
@@ -45,7 +45,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 					continue;
 				if (DotNetUtils.getField(type, "System.Reflection.Assembly") == null)
 					continue;
-				if (DotNetUtils.getMethod(type, ".cctor") == null)
+				if (type.FindStaticConstructor() == null)
 					continue;
 
 				var getStream2 = getTheOnlyMethod(type, "System.IO.Stream", "(System.Reflection.Assembly,System.Type,System.String)");
@@ -69,7 +69,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			}
 		}
 
-		EmbeddedResource findGetManifestResourceStreamTypeResource(TypeDefinition type, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
+		EmbeddedResource findGetManifestResourceStreamTypeResource(TypeDef type, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
 			foreach (var method in type.Methods) {
 				if (!method.IsPrivate || !method.IsStatic || method.Body == null)
 					continue;
@@ -86,8 +86,8 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return null;
 		}
 
-		static MethodDefinition getTheOnlyMethod(TypeDefinition type, string returnType, string parameters) {
-			MethodDefinition foundMethod = null;
+		static MethodDef getTheOnlyMethod(TypeDef type, string returnType, string parameters) {
+			MethodDef foundMethod = null;
 
 			foreach (var method in type.Methods) {
 				if (!method.IsStatic || method.Body == null || method.HasGenericParameters)
diff --git a/de4dot.code/deobfuscators/Eazfuscator_NET/ResourceResolver.cs b/de4dot.code/deobfuscators/Eazfuscator_NET/ResourceResolver.cs
index 37343c7e..812b9614 100644
--- a/de4dot.code/deobfuscators/Eazfuscator_NET/ResourceResolver.cs
+++ b/de4dot.code/deobfuscators/Eazfuscator_NET/ResourceResolver.cs
@@ -20,24 +20,24 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 	class ResourceResolver {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		AssemblyResolver assemblyResolver;
-		TypeDefinition resolverType;
-		MethodDefinition initMethod;
-		MethodDefinition handlerMethod;
+		TypeDef resolverType;
+		MethodDef initMethod;
+		MethodDef handlerMethod;
 		List<string> resourceInfos = new List<string>();
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return resolverType; }
 		}
 
-		public MethodDefinition InitMethod {
+		public MethodDef InitMethod {
 			get { return initMethod; }
 		}
 
@@ -45,7 +45,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			get { return resolverType != null; }
 		}
 
-		public ResourceResolver(ModuleDefinition module, AssemblyResolver assemblyResolver) {
+		public ResourceResolver(ModuleDefMD module, AssemblyResolver assemblyResolver) {
 			this.module = module;
 			this.assemblyResolver = assemblyResolver;
 		}
@@ -56,14 +56,14 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			checkCalledMethods(DotNetUtils.getModuleTypeCctor(module));
 		}
 
-		bool checkCalledMethods(MethodDefinition method) {
+		bool checkCalledMethods(MethodDef method) {
 			if (method == null || method.Body == null)
 				return false;
 
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Call)
 					continue;
-				if (!checkInitMethod(instr.Operand as MethodDefinition))
+				if (!checkInitMethod(instr.Operand as MethodDef))
 					continue;
 
 				return true;
@@ -72,7 +72,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return false;
 		}
 
-		bool checkInitMethod(MethodDefinition method) {
+		bool checkInitMethod(MethodDef method) {
 			if (method == null || !method.IsStatic || method.Body == null)
 				return false;
 			if (!DotNetUtils.isMethod(method, "System.Void", "()"))
@@ -121,7 +121,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return false;
 		}
 
-		bool initializeInfos(MethodDefinition method) {
+		bool initializeInfos(MethodDef method) {
 			foreach (var s in DotNetUtils.getCodeStrings(method)) {
 				if (string.IsNullOrEmpty(s))
 					continue;
diff --git a/de4dot.code/deobfuscators/Eazfuscator_NET/StringDecrypter.cs b/de4dot.code/deobfuscators/Eazfuscator_NET/StringDecrypter.cs
index 6590dc48..6b646683 100644
--- a/de4dot.code/deobfuscators/Eazfuscator_NET/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/Eazfuscator_NET/StringDecrypter.cs
@@ -21,17 +21,16 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.Cecil.Metadata;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 	class StringDecrypter {
-		ModuleDefinition module;
-		TypeDefinition stringType;
-		MethodDefinition stringMethod;
-		TypeDefinition dataDecrypterType;
+		ModuleDefMD module;
+		TypeDef stringType;
+		MethodDef stringMethod;
+		TypeDef dataDecrypterType;
 		short s1, s2, s3;
 		int i1, i2, i3, i4, i5, i6;
 		bool checkMinus2;
@@ -48,10 +47,10 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 		bool isV32OrLater;
 
 		class StreamHelperType {
-			public TypeDefinition type;
-			public MethodDefinition readInt16Method;
-			public MethodDefinition readInt32Method;
-			public MethodDefinition readBytesMethod;
+			public TypeDef type;
+			public MethodDef readInt16Method;
+			public MethodDef readInt32Method;
+			public MethodDef readBytesMethod;
 
 			public bool Detected {
 				get {
@@ -61,7 +60,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				}
 			}
 
-			public StreamHelperType(TypeDefinition type) {
+			public StreamHelperType(TypeDef type) {
 				this.type = type;
 
 				foreach (var method in type.Methods) {
@@ -77,7 +76,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			}
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return stringType; }
 		}
 
@@ -85,16 +84,16 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			get { return encryptedResource; }
 		}
 
-		public IEnumerable<TypeDefinition> Types {
+		public IEnumerable<TypeDef> Types {
 			get {
-				return new List<TypeDefinition> {
+				return new List<TypeDef> {
 					stringType,
 					dataDecrypterType,
 				};
 			}
 		}
 
-		public MethodDefinition Method {
+		public MethodDef Method {
 			get { return stringMethod; }
 		}
 
@@ -102,15 +101,15 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			get { return stringType != null; }
 		}
 
-		public StringDecrypter(ModuleDefinition module, DecrypterType decrypterType) {
+		public StringDecrypter(ModuleDefMD module, DecrypterType decrypterType) {
 			this.module = module;
 			this.decrypterType = decrypterType;
 		}
 
-		static bool checkIfV32OrLater(TypeDefinition type) {
+		static bool checkIfV32OrLater(TypeDef type) {
 			int numInts = 0;
 			foreach (var field in type.Fields) {
-				if (field.FieldType.EType == ElementType.I4)
+				if (field.FieldSig.GetFieldType().GetElementType() == ElementType.I4)
 					numInts++;
 			}
 			return numInts >= 2;
@@ -137,7 +136,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			"System.Byte[]",
 			"System.Int16",
 		};
-		bool checkType(TypeDefinition type) {
+		bool checkType(TypeDef type) {
 			if (!new FieldTypes(type).all(requiredFieldTypes))
 				return false;
 			if (type.NestedTypes.Count == 0) {
@@ -159,9 +158,9 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			"System.IO.Stream",
 			"System.Byte[]",
 		};
-		static StreamHelperType findStreamHelperType(TypeDefinition type) {
+		static StreamHelperType findStreamHelperType(TypeDef type) {
 			foreach (var field in type.Fields) {
-				var nested = field.FieldType as TypeDefinition;
+				var nested = field.FieldSig.GetFieldType().TryGetTypeDef();
 				if (nested == null)
 					continue;
 				if (nested.DeclaringType != type)
@@ -186,7 +185,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			"System.Reflection.Assembly",
 			"System.String",
 		};
-		static bool checkDecrypterMethod(MethodDefinition method) {
+		static bool checkDecrypterMethod(MethodDef method) {
 			if (method == null || !method.IsStatic || method.Body == null)
 				return false;
 			if (!DotNetUtils.isMethod(method, "System.String", "(System.Int32)"))
@@ -197,7 +196,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode != OpCodes.Callvirt)
 					continue;
-				var calledMethod = instr.Operand as MethodReference;
+				var calledMethod = instr.Operand as IMethod;
 				if (calledMethod != null && calledMethod.FullName == "System.IO.Stream System.Reflection.Assembly::GetManifestResourceStream(System.String)")
 					return true;
 			}
@@ -210,9 +209,9 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 
 			if (!findConstants(simpleDeobfuscator)) {
 				if (encryptedResource == null)
-					Log.w("Could not find encrypted resource. Strings cannot be decrypted.");
+					Logger.w("Could not find encrypted resource. Strings cannot be decrypted.");
 				else
-					Log.w("Can't decrypt strings. Possibly a new Eazfuscator.NET version.");
+					Logger.w("Can't decrypt strings. Possibly a new Eazfuscator.NET version.");
 				return;
 			}
 		}
@@ -248,7 +247,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				if (!findInts(out initializedAll))
 					return false;
 
-				var cctor = DotNetUtils.getMethod(stringType, ".cctor");
+				var cctor = stringType.FindStaticConstructor();
 				if (!initializedAll && cctor != null) {
 					simpleDeobfuscator.deobfuscate(cctor);
 					if (!findIntsCctor(cctor))
@@ -292,10 +291,10 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 		}
 
 		class FlagsInfo {
-			public VariableDefinition Local { get; set; }
+			public Local Local { get; set; }
 			public uint Value { get; set; }
 			public int Offset { get; set; }
-			public FlagsInfo(VariableDefinition local, uint value, int offset) {
+			public FlagsInfo(Local local, uint value, int offset) {
 				Local = local;
 				Value = value;
 				Offset = offset;
@@ -307,7 +306,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			if (flags == null)
 				return false;
 
-			flags.Sort((a, b) => Utils.compareInt32(a.Offset, b.Offset));
+			flags.Sort((a, b) => a.Offset.CompareTo(b.Offset));
 
 			rldFlag = flags[0].Value;
 			bytesFlag = flags[1].Value;
@@ -344,13 +343,13 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return null;
 		}
 
-		static int getFlagsOffset(MethodDefinition method, int index, VariableDefinition local) {
+		static int getFlagsOffset(MethodDef method, int index, Local local) {
 			var instrs = method.Body.Instructions;
 			for (; index < instrs.Count; index++) {
 				var ldloc = instrs[index];
-				if (!DotNetUtils.isLdloc(ldloc))
+				if (!ldloc.IsLdloc())
 					continue;
-				if (DotNetUtils.getLocalVar(method.Body.Variables, ldloc) != local)
+				if (ldloc.GetLocal(method.Body.LocalList) != local)
 					continue;
 
 				return index;
@@ -358,7 +357,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return -1;
 		}
 
-		static VariableDefinition getFlagsLocal(MethodDefinition method, int index) {
+		static Local getFlagsLocal(MethodDef method, int index) {
 			var instrs = method.Body.Instructions;
 			if (index + 5 >= instrs.Count)
 				return null;
@@ -373,9 +372,9 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			if (instrs[index++].OpCode.Code != Code.Ceq)
 				return null;
 			var stloc = instrs[index++];
-			if (!DotNetUtils.isStloc(stloc))
+			if (!stloc.IsStloc())
 				return null;
-			return DotNetUtils.getLocalVar(method.Body.Variables, stloc);
+			return stloc.GetLocal(method.Body.LocalList);
 		}
 
 		void initialize() {
@@ -415,10 +414,10 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 
 				var bytes = reader.ReadBytes(flags & 0x1FFFFFFF);
 				decrypt1(bytes, tmpKey);
-				var pkt = module.Assembly.Name.PublicKeyToken;
-				if (usePublicKeyToken && pkt != null && pkt.Length != 0) {
+				var pkt = PublicKeyBase.ToPublicKeyToken(module.Assembly.PublicKey);
+				if (usePublicKeyToken && !PublicKeyBase.IsNullOrEmpty2(pkt)) {
 					for (int i = 0; i < bytes.Length; i++)
-						bytes[i] ^= (byte)((pkt[i & 7] >> 5) + (pkt[i & 7] << 3));
+						bytes[i] ^= (byte)((pkt.Data[i & 7] >> 5) + (pkt.Data[i & 7] << 3));
 				}
 
 				if ((flags & rldFlag) != 0)
@@ -485,17 +484,17 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return lcg * 214013 + 2531011;
 		}
 
-		bool findResource(MethodDefinition method) {
+		bool findResource(MethodDef method) {
 			encryptedResource = findResourceFromCodeString(method) ??
 								findResourceFromStringBuilder(method);
 			return encryptedResource != null;
 		}
 
-		EmbeddedResource findResourceFromCodeString(MethodDefinition method) {
+		EmbeddedResource findResourceFromCodeString(MethodDef method) {
 			return DotNetUtils.getResource(module, DotNetUtils.getCodeStrings(method)) as EmbeddedResource;
 		}
 
-		EmbeddedResource findResourceFromStringBuilder(MethodDefinition method) {
+		EmbeddedResource findResourceFromStringBuilder(MethodDef method) {
 			int startIndex = EfUtils.findOpCodeIndex(method, 0, Code.Newobj, "System.Void System.Text.StringBuilder::.ctor()");
 			if (startIndex < 0)
 				return null;
@@ -532,11 +531,11 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return DotNetUtils.getResource(module, sb.ToString()) as EmbeddedResource;
 		}
 
-		static MethodDefinition findInt64Method(MethodDefinition method) {
+		static MethodDef findInt64Method(MethodDef method) {
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Call)
 					continue;
-				var calledMethod = instr.Operand as MethodDefinition;
+				var calledMethod = instr.Operand as MethodDef;
 				if (calledMethod == null)
 					continue;
 				if (!DotNetUtils.isMethod(calledMethod, "System.Int64", "()"))
@@ -547,11 +546,11 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return null;
 		}
 
-		static TypeDefinition findDataDecrypterType(MethodDefinition method) {
+		static TypeDef findDataDecrypterType(MethodDef method) {
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Call)
 					continue;
-				var calledMethod = instr.Operand as MethodDefinition;
+				var calledMethod = instr.Operand as MethodDef;
 				if (calledMethod == null)
 					continue;
 				if (!DotNetUtils.isMethod(calledMethod, "System.Byte[]", "(System.Byte[],System.Byte[])"))
@@ -605,9 +604,9 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				int tmp;
 				if (!stringMethodConsts.getNextInt32(ref i, out tmp))
 					continue;
-				if ((instrs[i - 1].OpCode.Code == Code.Xor && DotNetUtils.isStloc(instrs[i])) ||
-					(instrs[i].OpCode.Code == Code.Xor && DotNetUtils.isStloc(instrs[i + 1])) ||
-					DotNetUtils.isLdloc(instrs[i])) {
+				if ((instrs[i - 1].OpCode.Code == Code.Xor && instrs[i].IsStloc()) ||
+					(instrs[i].OpCode.Code == Code.Xor && instrs[i + 1].IsStloc()) ||
+					instrs[i].IsLdloc()) {
 					i2 ^= tmp;
 					returnValue = true;
 				}
@@ -617,7 +616,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return returnValue;
 		}
 
-		static int findInitIntsIndex(MethodDefinition method, out bool initializedAll) {
+		static int findInitIntsIndex(MethodDef method, out bool initializedAll) {
 			initializedAll = false;
 
 			var instrs = method.Body.Instructions;
@@ -630,17 +629,17 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				if (stsfld.OpCode.Code != Code.Stsfld)
 					continue;
 
-				var storeField = stsfld.Operand as FieldDefinition;
+				var storeField = stsfld.Operand as FieldDef;
 				if (storeField == null || storeField.FieldType.FullName != "System.Byte[]")
 					continue;
 
 				var instr = instrs[i + 2];
 				if (instr.OpCode.Code == Code.Ldsfld) {
-					var loadField = instr.Operand as FieldDefinition;
-					if (loadField == null || loadField.FieldType.EType != ElementType.I4)
+					var loadField = instr.Operand as FieldDef;
+					if (loadField == null || loadField.FieldType.GetElementType() != ElementType.I4)
 						continue;
 				}
-				else if (DotNetUtils.isLdcI4(instr)) {
+				else if (instr.IsLdcI4()) {
 					initializedAll = true;
 				}
 				else
@@ -652,7 +651,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return -1;
 		}
 
-		bool findIntsCctor(MethodDefinition cctor) {
+		bool findIntsCctor(MethodDef cctor) {
 			int index = 0;
 			if (!findCallGetFrame(cctor, ref index))
 				return findIntsCctor2(cctor);
@@ -674,7 +673,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				int tmp4;
 				if (!constantsReader.getNextInt32(ref index, out tmp4))
 					break;
-				if (index < instrs.Count && DotNetUtils.isLdloc(instrs[index]))
+				if (index < instrs.Count && instrs[index].IsLdloc())
 					tmp3 = tmp4;
 			}
 
@@ -683,7 +682,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 		}
 
 		// Compact Framework doesn't have StackFrame
-		bool findIntsCctor2(MethodDefinition cctor) {
+		bool findIntsCctor2(MethodDef cctor) {
 			int index = 0;
 			var instrs = cctor.Body.Instructions;
 			var constantsReader = new EfConstantsReader(cctor);
@@ -715,7 +714,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 					continue;
 
 				var ldci4 = instrs[i + 1];
-				if (!DotNetUtils.isLdcI4(ldci4))
+				if (!ldci4.IsLdcI4())
 					continue;
 
 				int index = i + 1;
@@ -755,7 +754,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				if (instrs[index++].OpCode.Code != Code.Xor)
 					continue;
 
-				if (!DotNetUtils.isLdloc(instrs[index++]))
+				if (!instrs[index++].IsLdloc())
 					continue;
 
 				if (instrs[index++].OpCode.Code != Code.Xor)
@@ -811,9 +810,9 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				if (index <= 0)
 					continue;
 				var ldci4 = stringMethod.Body.Instructions[index - 1];
-				if (!DotNetUtils.isLdcI4(ldci4))
+				if (!ldci4.IsLdcI4())
 					continue;
-				if (DotNetUtils.getLdcI4Value(ldci4) != 4)
+				if (ldci4.GetLdcI4Value() != 4)
 					continue;
 				if (!stringMethodConsts.getNextInt32(ref index, out i5))
 					return false;
@@ -822,7 +821,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			}
 		}
 
-		static bool callsGetPublicKeyToken(MethodDefinition method) {
+		static bool callsGetPublicKeyToken(MethodDef method) {
 			int index = 0;
 			return findCall(method, ref index, "System.Byte[] System.Reflection.AssemblyName::GetPublicKeyToken()");
 		}
@@ -839,16 +838,16 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return findCall(stringMethod, ref index, streamHelperType == null ? "System.Byte[] System.IO.BinaryReader::ReadBytes(System.Int32)" : streamHelperType.readBytesMethod.FullName);
 		}
 
-		static bool findCallGetFrame(MethodDefinition method, ref int index) {
+		static bool findCallGetFrame(MethodDef method, ref int index) {
 			return findCall(method, ref index, "System.Diagnostics.StackFrame System.Diagnostics.StackTrace::GetFrame(System.Int32)");
 		}
 
-		static bool findCall(MethodDefinition method, ref int index, string methodFullName) {
+		static bool findCall(MethodDef method, ref int index, string methodFullName) {
 			for (; index < method.Body.Instructions.Count; index++) {
 				if (!findCallvirt(method, ref index))
 					return false;
 
-				var calledMethod = method.Body.Instructions[index].Operand as MethodReference;
+				var calledMethod = method.Body.Instructions[index].Operand as IMethod;
 				if (calledMethod == null)
 					continue;
 				if (calledMethod.ToString() != methodFullName)
@@ -859,7 +858,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return false;
 		}
 
-		static bool findCallvirt(MethodDefinition method, ref int index) {
+		static bool findCallvirt(MethodDef method, ref int index) {
 			var instrs = method.Body.Instructions;
 			for (; index < instrs.Count; index++) {
 				var instr = instrs[index];
diff --git a/de4dot.code/deobfuscators/Eazfuscator_NET/VersionDetector.cs b/de4dot.code/deobfuscators/Eazfuscator_NET/VersionDetector.cs
index c195d22b..878aaf37 100644
--- a/de4dot.code/deobfuscators/Eazfuscator_NET/VersionDetector.cs
+++ b/de4dot.code/deobfuscators/Eazfuscator_NET/VersionDetector.cs
@@ -19,7 +19,7 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Eazfuscator_NET {
@@ -27,7 +27,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 		StringDecrypter stringDecrypter;
 		FrameworkType frameworkType;
 
-		public VersionDetector(ModuleDefinition module, StringDecrypter stringDecrypter) {
+		public VersionDetector(ModuleDefMD module, StringDecrypter stringDecrypter) {
 			this.stringDecrypter = stringDecrypter;
 			this.frameworkType = DotNetUtils.getFrameworkType(module);
 		}
@@ -38,8 +38,8 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			if (decryptStringType == null || decryptStringMethod == null)
 				return null;
 
-			var otherMethods = new List<MethodDefinition>();
-			MethodDefinition cctor = null;
+			var otherMethods = new List<MethodDef>();
+			MethodDef cctor = null;
 			foreach (var method in decryptStringType.Methods) {
 				if (method == decryptStringMethod)
 					continue;
@@ -52,7 +52,6 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				return null;
 
 			bool hasConstantM2 = DeobUtils.hasInteger(decryptStringMethod, -2);
-			var frameworkType = DotNetUtils.getFrameworkType(decryptStringType.Module);
 
 			/////////////////////////////////////////////////////////////////
 			/////////////////////////////////////////////////////////////////
@@ -77,11 +76,11 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			if (otherMethods.Count == 0 &&
 				decryptStringType.NestedTypes.Count == 0 &&
 				!hasConstantM2 &&
-				!decryptStringMethod.NoInlining &&
+				!decryptStringMethod.IsNoInlining &&
 				decryptStringMethod.IsPublic &&
 				decryptStringMethod.IsSynchronized &&
-				decryptStringMethod.Body.MaxStackSize >= 35 &&
-				decryptStringMethod.Body.MaxStackSize <= 50 &&
+				decryptStringMethod.Body.MaxStack >= 35 &&
+				decryptStringMethod.Body.MaxStack <= 50 &&
 				decryptStringMethod.Body.ExceptionHandlers.Count == 0 &&
 				new LocalTypes(decryptStringMethod).exactly(locals11) &&
 				checkTypeFields(fields11)) {
@@ -113,11 +112,11 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			if (otherMethods.Count == 0 &&
 				decryptStringType.NestedTypes.Count == 0 &&
 				!hasConstantM2 &&
-				!decryptStringMethod.NoInlining &&
+				!decryptStringMethod.IsNoInlining &&
 				decryptStringMethod.IsPublic &&
 				decryptStringMethod.IsSynchronized &&
-				decryptStringMethod.Body.MaxStackSize >= 35 &&
-				decryptStringMethod.Body.MaxStackSize <= 50 &&
+				decryptStringMethod.Body.MaxStack >= 35 &&
+				decryptStringMethod.Body.MaxStack <= 50 &&
 				decryptStringMethod.Body.ExceptionHandlers.Count == 0 &&
 				new LocalTypes(decryptStringMethod).exactly(locals13) &&
 				checkTypeFields(fields13)) {
@@ -149,11 +148,11 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			if (otherMethods.Count == 0 &&
 				decryptStringType.NestedTypes.Count == 0 &&
 				!hasConstantM2 &&
-				!decryptStringMethod.NoInlining &&
+				!decryptStringMethod.IsNoInlining &&
 				decryptStringMethod.IsPublic &&
 				decryptStringMethod.IsSynchronized &&
-				decryptStringMethod.Body.MaxStackSize >= 150 &&
-				decryptStringMethod.Body.MaxStackSize <= 200 &&
+				decryptStringMethod.Body.MaxStack >= 150 &&
+				decryptStringMethod.Body.MaxStack <= 200 &&
 				decryptStringMethod.Body.ExceptionHandlers.Count == 0 &&
 				new LocalTypes(decryptStringMethod).exactly(locals14) &&
 				checkTypeFields(fields14)) {
@@ -186,11 +185,11 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			if (otherMethods.Count == 0 &&
 				decryptStringType.NestedTypes.Count == 0 &&
 				!hasConstantM2 &&
-				!decryptStringMethod.NoInlining &&
+				!decryptStringMethod.IsNoInlining &&
 				decryptStringMethod.IsPublic &&
 				decryptStringMethod.IsSynchronized &&
-				decryptStringMethod.Body.MaxStackSize >= 1 &&
-				decryptStringMethod.Body.MaxStackSize <= 8 &&
+				decryptStringMethod.Body.MaxStack >= 1 &&
+				decryptStringMethod.Body.MaxStack <= 8 &&
 				decryptStringMethod.Body.ExceptionHandlers.Count == 0 &&
 				new LocalTypes(decryptStringMethod).exactly(locals24) &&
 				checkTypeFields(fields24)) {
@@ -224,11 +223,11 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			if (otherMethods.Count == 0 &&
 				decryptStringType.NestedTypes.Count == 0 &&
 				!hasConstantM2 &&
-				!decryptStringMethod.NoInlining &&
+				!decryptStringMethod.IsNoInlining &&
 				decryptStringMethod.IsPublic &&
 				!decryptStringMethod.IsSynchronized &&
-				decryptStringMethod.Body.MaxStackSize >= 1 &&
-				decryptStringMethod.Body.MaxStackSize <= 8 &&
+				decryptStringMethod.Body.MaxStack >= 1 &&
+				decryptStringMethod.Body.MaxStack <= 8 &&
 				decryptStringMethod.Body.ExceptionHandlers.Count == 1 &&
 				new LocalTypes(decryptStringMethod).exactly(locals26) &&
 				checkTypeFields(fields26)) {
@@ -262,11 +261,11 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			if (otherMethods.Count == 0 &&
 				decryptStringType.NestedTypes.Count == 0 &&
 				!hasConstantM2 &&
-				decryptStringMethod.NoInlining &&
+				decryptStringMethod.IsNoInlining &&
 				decryptStringMethod.IsPublic &&
 				!decryptStringMethod.IsSynchronized &&
-				decryptStringMethod.Body.MaxStackSize >= 1 &&
-				decryptStringMethod.Body.MaxStackSize <= 8 &&
+				decryptStringMethod.Body.MaxStack >= 1 &&
+				decryptStringMethod.Body.MaxStack <= 8 &&
 				decryptStringMethod.Body.ExceptionHandlers.Count == 1 &&
 				new LocalTypes(decryptStringMethod).exactly(locals27) &&
 				checkTypeFields(fields27)) {
@@ -301,11 +300,11 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			if (otherMethods.Count == 0 &&
 				decryptStringType.NestedTypes.Count == 0 &&
 				!hasConstantM2 &&
-				decryptStringMethod.NoInlining &&
+				decryptStringMethod.IsNoInlining &&
 				decryptStringMethod.IsAssembly &&
 				!decryptStringMethod.IsSynchronized &&
-				decryptStringMethod.Body.MaxStackSize >= 1 &&
-				decryptStringMethod.Body.MaxStackSize <= 8 &&
+				decryptStringMethod.Body.MaxStack >= 1 &&
+				decryptStringMethod.Body.MaxStack <= 8 &&
 				decryptStringMethod.Body.ExceptionHandlers.Count == 1 &&
 				new LocalTypes(decryptStringMethod).exactly(locals28) &&
 				checkTypeFields(fields28)) {
@@ -344,11 +343,11 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			if (otherMethods.Count == 0 &&
 				decryptStringType.NestedTypes.Count == 0 &&
 				!hasConstantM2 &&
-				decryptStringMethod.NoInlining &&
+				decryptStringMethod.IsNoInlining &&
 				decryptStringMethod.IsAssembly &&
 				!decryptStringMethod.IsSynchronized &&
-				decryptStringMethod.Body.MaxStackSize >= 1 &&
-				decryptStringMethod.Body.MaxStackSize <= 8 &&
+				decryptStringMethod.Body.MaxStack >= 1 &&
+				decryptStringMethod.Body.MaxStack <= 8 &&
 				(decryptStringMethod.Body.ExceptionHandlers.Count == 1 || decryptStringMethod.Body.ExceptionHandlers.Count == 2) &&
 				new LocalTypes(decryptStringMethod).exactly(locals29) &&
 				checkTypeFields(fields29)) {
@@ -394,11 +393,11 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				otherMethods[0].IsStatic &&
 				new LocalTypes(otherMethods[0]).exactly(olocals30) &&
 				!hasConstantM2 &&
-				decryptStringMethod.NoInlining &&
+				decryptStringMethod.IsNoInlining &&
 				decryptStringMethod.IsAssembly &&
 				!decryptStringMethod.IsSynchronized &&
-				decryptStringMethod.Body.MaxStackSize >= 1 &&
-				decryptStringMethod.Body.MaxStackSize <= 8 &&
+				decryptStringMethod.Body.MaxStack >= 1 &&
+				decryptStringMethod.Body.MaxStack <= 8 &&
 				(decryptStringMethod.Body.ExceptionHandlers.Count == 1 || decryptStringMethod.Body.ExceptionHandlers.Count == 2) &&
 				new LocalTypes(decryptStringMethod).exactly(locals30) &&
 				checkTypeFields(fields30)) {
@@ -444,11 +443,11 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				otherMethods[0].IsStatic &&
 				new LocalTypes(otherMethods[0]).exactly(olocals31) &&
 				hasConstantM2 &&
-				decryptStringMethod.NoInlining &&
+				decryptStringMethod.IsNoInlining &&
 				decryptStringMethod.IsAssembly &&
 				!decryptStringMethod.IsSynchronized &&
-				decryptStringMethod.Body.MaxStackSize >= 1 &&
-				decryptStringMethod.Body.MaxStackSize <= 8 &&
+				decryptStringMethod.Body.MaxStack >= 1 &&
+				decryptStringMethod.Body.MaxStack <= 8 &&
 				(decryptStringMethod.Body.ExceptionHandlers.Count == 1 || decryptStringMethod.Body.ExceptionHandlers.Count == 2) &&
 				new LocalTypes(decryptStringMethod).exactly(locals31) &&
 				checkTypeFields(fields31)) {
@@ -496,11 +495,11 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				otherMethods[0].IsStatic &&
 				new LocalTypes(otherMethods[0]).exactly(olocals32) &&
 				hasConstantM2 &&
-				decryptStringMethod.NoInlining &&
+				decryptStringMethod.IsNoInlining &&
 				decryptStringMethod.IsAssembly &&
 				!decryptStringMethod.IsSynchronized &&
-				decryptStringMethod.Body.MaxStackSize >= 1 &&
-				decryptStringMethod.Body.MaxStackSize <= 8 &&
+				decryptStringMethod.Body.MaxStack >= 1 &&
+				decryptStringMethod.Body.MaxStack <= 8 &&
 				(decryptStringMethod.Body.ExceptionHandlers.Count == 1 || decryptStringMethod.Body.ExceptionHandlers.Count == 2) &&
 				new LocalTypes(decryptStringMethod).exactly(locals32) &&
 				checkTypeFields(fields32)) {
@@ -551,11 +550,11 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 					otherMethods[0].IsStatic &&
 					new LocalTypes(otherMethods[0]).exactly(olocals33) &&
 					hasConstantM2 &&
-					decryptStringMethod.NoInlining &&
+					decryptStringMethod.IsNoInlining &&
 					decryptStringMethod.IsAssembly &&
 					!decryptStringMethod.IsSynchronized &&
-					decryptStringMethod.Body.MaxStackSize >= 1 &&
-					decryptStringMethod.Body.MaxStackSize <= 8 &&
+					decryptStringMethod.Body.MaxStack >= 1 &&
+					decryptStringMethod.Body.MaxStack <= 8 &&
 					(decryptStringMethod.Body.ExceptionHandlers.Count == 1 || decryptStringMethod.Body.ExceptionHandlers.Count == 2) &&
 					new LocalTypes(decryptStringMethod).exactly(locals33) &&
 					checkTypeFields(fields33)) {
@@ -606,11 +605,11 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 					otherMethods[0].IsPrivate &&
 					otherMethods[0].IsStatic &&
 					new LocalTypes(otherMethods[0]).exactly(olocals33) &&
-					decryptStringMethod.NoInlining &&
+					decryptStringMethod.IsNoInlining &&
 					decryptStringMethod.IsAssembly &&
 					!decryptStringMethod.IsSynchronized &&
-					decryptStringMethod.Body.MaxStackSize >= 1 &&
-					decryptStringMethod.Body.MaxStackSize <= 8 &&
+					decryptStringMethod.Body.MaxStack >= 1 &&
+					decryptStringMethod.Body.MaxStack <= 8 &&
 					(decryptStringMethod.Body.ExceptionHandlers.Count == 1 || decryptStringMethod.Body.ExceptionHandlers.Count == 2) &&
 					new LocalTypes(decryptStringMethod).exactly(locals33) &&
 					checkTypeFields(fields33)) {
@@ -656,11 +655,11 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 					otherMethods[0].IsPrivate &&
 					otherMethods[0].IsStatic &&
 					new LocalTypes(otherMethods[0]).exactly(olocals33_149) &&
-					decryptStringMethod.NoInlining &&
+					decryptStringMethod.IsNoInlining &&
 					decryptStringMethod.IsAssembly &&
 					!decryptStringMethod.IsSynchronized &&
-					decryptStringMethod.Body.MaxStackSize >= 1 &&
-					decryptStringMethod.Body.MaxStackSize <= 8 &&
+					decryptStringMethod.Body.MaxStack >= 1 &&
+					decryptStringMethod.Body.MaxStack <= 8 &&
 					(decryptStringMethod.Body.ExceptionHandlers.Count == 1 || decryptStringMethod.Body.ExceptionHandlers.Count == 2) &&
 					new LocalTypes(decryptStringMethod).exactly(locals33_149) &&
 					checkTypeFields(fields33_149)) {
@@ -671,7 +670,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return null;
 		}
 
-		TypeDefinition getNestedType(int n) {
+		TypeDef getNestedType(int n) {
 			var type = stringDecrypter.Type;
 
 			int fieldIndex;
@@ -684,7 +683,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 
 			if (fieldIndex >= type.Fields.Count)
 				return null;
-			var nestedType = type.Fields[fieldIndex].FieldType as TypeDefinition;
+			var nestedType = type.Fields[fieldIndex].FieldType.TryGetTypeDef();
 			if (nestedType == null || type.NestedTypes.IndexOf(nestedType) < 0)
 				return null;
 
diff --git a/de4dot.code/deobfuscators/ExceptionLoggerRemover.cs b/de4dot.code/deobfuscators/ExceptionLoggerRemover.cs
index d3b204c9..5a8d13f9 100644
--- a/de4dot.code/deobfuscators/ExceptionLoggerRemover.cs
+++ b/de4dot.code/deobfuscators/ExceptionLoggerRemover.cs
@@ -18,8 +18,8 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators {
@@ -28,7 +28,7 @@ namespace de4dot.code.deobfuscators {
 
 		public int NumRemovedExceptionLoggers { get; set; }
 
-		public void add(MethodDefinition exceptionLogger) {
+		public void add(MethodDef exceptionLogger) {
 			exceptionLoggerMethods.add(exceptionLogger, true);
 		}
 
@@ -74,7 +74,7 @@ namespace de4dot.code.deobfuscators {
 				}
 				if (failed || calls != 1 || callInstr.OpCode.Code != Code.Call)
 					continue;
-				var calledMethod = callInstr.Operand as MethodReference;
+				var calledMethod = callInstr.Operand as IMethod;
 				if (calledMethod == null)
 					continue;
 				if (!isExceptionLogger(calledMethod))
@@ -86,7 +86,7 @@ namespace de4dot.code.deobfuscators {
 			return false;
 		}
 
-		protected virtual bool isExceptionLogger(MethodReference method) {
+		protected virtual bool isExceptionLogger(IMethod method) {
 			return exceptionLoggerMethods.find(method);
 		}
 
diff --git a/de4dot.code/deobfuscators/Goliath_NET/ArrayDecrypter.cs b/de4dot.code/deobfuscators/Goliath_NET/ArrayDecrypter.cs
index cff22fdc..e09c31b5 100644
--- a/de4dot.code/deobfuscators/Goliath_NET/ArrayDecrypter.cs
+++ b/de4dot.code/deobfuscators/Goliath_NET/ArrayDecrypter.cs
@@ -18,12 +18,12 @@
 */
 
 using System;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Goliath_NET {
 	class ArrayDecrypter : DecrypterBase {
-		public ArrayDecrypter(ModuleDefinition module)
+		public ArrayDecrypter(ModuleDefMD module)
 			: base(module) {
 		}
 
@@ -31,15 +31,15 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			"System.Byte[]",
 			"System.Collections.Generic.Dictionary`2<System.Int32,System.Byte[]>",
 		};
-		protected override bool checkDecrypterType(TypeDefinition type) {
+		protected override bool checkDecrypterType(TypeDef type) {
 			return new FieldTypes(type).exactly(requiredFields);
 		}
 
-		protected override bool checkDelegateInvokeMethod(MethodDefinition invokeMethod) {
+		protected override bool checkDelegateInvokeMethod(MethodDef invokeMethod) {
 			return DotNetUtils.isMethod(invokeMethod, "System.Byte[]", "(System.Int32)");
 		}
 
-		public byte[] decrypt(MethodDefinition method) {
+		public byte[] decrypt(MethodDef method) {
 			var info = getInfo(method);
 			decryptedReader.BaseStream.Position = info.offset;
 			return decryptedReader.ReadBytes(decryptedReader.ReadInt32());
diff --git a/de4dot.code/deobfuscators/Goliath_NET/ArrayValueInliner.cs b/de4dot.code/deobfuscators/Goliath_NET/ArrayValueInliner.cs
index a1315ef9..109cdab5 100644
--- a/de4dot.code/deobfuscators/Goliath_NET/ArrayValueInliner.cs
+++ b/de4dot.code/deobfuscators/Goliath_NET/ArrayValueInliner.cs
@@ -19,16 +19,16 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Goliath_NET {
 	class ArrayValueInliner : ValueInlinerBase<byte[]> {
 		InitializedDataCreator initializedDataCreator;
-		ModuleDefinition module;
+		ModuleDefMD module;
 
-		public ArrayValueInliner(ModuleDefinition module, InitializedDataCreator initializedDataCreator) {
+		public ArrayValueInliner(ModuleDefMD module, InitializedDataCreator initializedDataCreator) {
 			this.module = module;
 			this.initializedDataCreator = initializedDataCreator;
 		}
@@ -39,8 +39,8 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 				int num = callResult.callEndIndex - callResult.callStartIndex + 1;
 
 				var arrayData = (byte[])callResult.returnValue;
-				initializedDataCreator.addInitializeArrayCode(block, callResult.callStartIndex, num, module.TypeSystem.Byte, arrayData);
-				Log.v("Decrypted array: {0} bytes", arrayData.Length);
+				initializedDataCreator.addInitializeArrayCode(block, callResult.callStartIndex, num, module.CorLibTypes.Byte.TypeDefOrRef, arrayData);
+				Logger.v("Decrypted array: {0} bytes", arrayData.Length);
 			}
 		}
 	}
diff --git a/de4dot.code/deobfuscators/Goliath_NET/DecrypterBase.cs b/de4dot.code/deobfuscators/Goliath_NET/DecrypterBase.cs
index 3a917bec..29111394 100644
--- a/de4dot.code/deobfuscators/Goliath_NET/DecrypterBase.cs
+++ b/de4dot.code/deobfuscators/Goliath_NET/DecrypterBase.cs
@@ -20,25 +20,25 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Goliath_NET {
 	abstract class DecrypterBase {
-		protected ModuleDefinition module;
+		protected ModuleDefMD module;
 		EmbeddedResource encryptedResource;
-		TypeDefinition decrypterType;
-		TypeDefinition delegateType;
-		TypeDefinition delegateInitType;
+		TypeDef decrypterType;
+		TypeDef delegateType;
+		TypeDef delegateInitType;
 		protected BinaryReader decryptedReader;
 		MethodDefinitionAndDeclaringTypeDict<Info> decrypterMethods = new MethodDefinitionAndDeclaringTypeDict<Info>();
 
 		protected class Info {
-			public MethodDefinition method;
+			public MethodDef method;
 			public int offset;
 			public bool referenced = false;
-			public Info(MethodDefinition method, int offset) {
+			public Info(MethodDef method, int offset) {
 				this.method = method;
 				this.offset = offset;
 			}
@@ -52,21 +52,21 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			get { return encryptedResource; }
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return decrypterType; }
 		}
 
-		public TypeDefinition DelegateInitType {
+		public TypeDef DelegateInitType {
 			get { return delegateInitType ?? findDelegateInitType();}
 		}
 
-		public TypeDefinition DelegateType {
+		public TypeDef DelegateType {
 			get { return delegateType; }
 		}
 
-		public IEnumerable<TypeDefinition> DecrypterTypes {
+		public IEnumerable<TypeDef> DecrypterTypes {
 			get {
-				var types = new TypeDefinitionDict<TypeDefinition>();
+				var types = new TypeDefinitionDict<TypeDef>();
 				foreach (var info in decrypterMethods.getValues()) {
 					if (info.referenced)
 						types.add(info.method.DeclaringType, info.method.DeclaringType);
@@ -75,11 +75,11 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			}
 		}
 
-		public DecrypterBase(ModuleDefinition module) {
+		public DecrypterBase(ModuleDefMD module) {
 			this.module = module;
 		}
 
-		protected Info getInfo(MethodDefinition method) {
+		protected Info getInfo(MethodDef method) {
 			var info = decrypterMethods.find(method);
 			if (info == null)
 				return null;
@@ -93,12 +93,11 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 				var resource = tmp as EmbeddedResource;
 				if (resource == null)
 					continue;
-				if (!resource.Name.EndsWith(".resources", StringComparison.Ordinal))
+				if (!resource.Name.String.EndsWith(".resources", StringComparison.Ordinal))
 					continue;
 				string ns, name;
-				splitTypeName(resource.Name.Substring(0, resource.Name.Length - 10), out ns, out name);
-				var typeRef = new TypeReference(ns, name, module, module);
-				var type = DotNetUtils.getType(module, typeRef);
+				splitTypeName(resource.Name.String.Substring(0, resource.Name.String.Length - 10), out ns, out name);
+				var type = new TypeRefUser(module, ns, name, module).Resolve();
 				if (type == null)
 					continue;
 				if (!checkDecrypterType(type))
@@ -110,7 +109,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			}
 		}
 
-		protected abstract bool checkDecrypterType(TypeDefinition type);
+		protected abstract bool checkDecrypterType(TypeDef type);
 
 		void splitTypeName(string fullName, out string ns, out string name) {
 			int index = fullName.LastIndexOf('.');
@@ -132,7 +131,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 
 			delegateType = null;
 			foreach (var type in module.GetTypes()) {
-				var cctor = DotNetUtils.getMethod(type, ".cctor");
+				var cctor = type.FindStaticConstructor();
 				if (cctor == null)
 					continue;
 
@@ -158,9 +157,10 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 						continue;
 					if (!method.IsStatic || method.Body == null)
 						continue;
-					if (method.Parameters.Count != 0)
+					var sig = method.MethodSig;
+					if (sig == null || sig.Params.Count != 0)
 						continue;
-					if (method.MethodReturnType.ReturnType.FullName == "System.Void")
+					if (sig.RetType.GetElementType() == ElementType.Void)
 						continue;
 					var info = getDecrypterInfo(method, field);
 					if (info == null)
@@ -171,23 +171,23 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			}
 		}
 
-		Info getDecrypterInfo(MethodDefinition method, FieldDefinition delegateField) {
+		Info getDecrypterInfo(MethodDef method, FieldDef delegateField) {
 			try {
 				int index = 0;
 				var instrs = method.Body.Instructions;
 				if (instrs[index].OpCode.Code != Code.Ldsfld)
 					return null;
-				var field = instrs[index++].Operand as FieldDefinition;
+				var field = instrs[index++].Operand as FieldDef;
 				if (field != delegateField)
 					return null;
 
-				if (!DotNetUtils.isLdcI4(instrs[index]))
+				if (!instrs[index].IsLdcI4())
 					return null;
-				int offset = DotNetUtils.getLdcI4Value(instrs[index++]);
+				int offset = instrs[index++].GetLdcI4Value();
 
 				if (instrs[index].OpCode.Code != Code.Call && instrs[index].OpCode.Code != Code.Callvirt)
 					return null;
-				var calledMethod = instrs[index++].Operand as MethodReference;
+				var calledMethod = instrs[index++].Operand as IMethod;
 				if (calledMethod.Name != "Invoke")
 					return null;
 
@@ -204,12 +204,12 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			}
 		}
 
-		bool checkCctor(MethodDefinition cctor) {
+		bool checkCctor(MethodDef cctor) {
 			var ldtokenType = getLdtokenType(cctor);
-			if (!MemberReferenceHelper.compareTypes(ldtokenType, cctor.DeclaringType))
+			if (!new SigComparer().Equals(ldtokenType, cctor.DeclaringType))
 				return false;
 
-			MethodDefinition initMethod = null;
+			MethodDef initMethod = null;
 			foreach (var method in DotNetUtils.getCalledMethods(module, cctor)) {
 				if (DotNetUtils.isMethod(method, "System.Void", "(System.Type)")) {
 					initMethod = method;
@@ -222,34 +222,34 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			return true;
 		}
 
-		static TypeReference getLdtokenType(MethodDefinition method) {
+		static ITypeDefOrRef getLdtokenType(MethodDef method) {
 			if (method == null || method.Body == null)
 				return null;
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Ldtoken)
 					continue;
-				return instr.Operand as TypeReference;
+				return instr.Operand as ITypeDefOrRef;
 			}
 			return null;
 		}
 
-		bool checkDelegateType(TypeDefinition type) {
+		bool checkDelegateType(TypeDef type) {
 			if (!DotNetUtils.derivesFromDelegate(type))
 				return false;
-			var invoke = DotNetUtils.getMethod(type, "Invoke");
+			var invoke = type.FindMethod("Invoke");
 			if (invoke == null)
 				return false;
 			return checkDelegateInvokeMethod(invoke);
 		}
 
-		protected abstract bool checkDelegateInvokeMethod(MethodDefinition invokeMethod);
+		protected abstract bool checkDelegateInvokeMethod(MethodDef invokeMethod);
 
 		byte[] decrypt(byte[] encryptedData) {
 			const int KEY_LEN = 0x100;
 			if (encryptedData.Length < KEY_LEN)
 				throw new ApplicationException("Invalid encrypted data length");
 			var decryptedData = new byte[encryptedData.Length - KEY_LEN];
-			var pkt = module.Assembly.Name.PublicKeyToken;
+			var pkt = PublicKey.GetRawData(PublicKeyBase.ToPublicKeyToken(module.Assembly.PublicKey));
 			if (pkt == null || pkt.Length == 0)
 				pkt = new byte[8];
 
@@ -265,7 +265,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			return decryptedData;
 		}
 
-		TypeDefinition findDelegateInitType() {
+		TypeDef findDelegateInitType() {
 			if (delegateType == null)
 				return null;
 
@@ -279,7 +279,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 					var ldtokenType = getLdtokenType(method);
 					if (ldtokenType == null)
 						continue;
-					if (!MemberReferenceHelper.compareTypes(ldtokenType, delegateType))
+					if (!new SigComparer().Equals(ldtokenType, delegateType))
 						continue;
 
 					delegateInitType = type;
@@ -290,8 +290,8 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			return null;
 		}
 
-		public IEnumerable<MethodDefinition> getMethods() {
-			var list = new List<MethodDefinition>(decrypterMethods.Count);
+		public IEnumerable<MethodDef> getMethods() {
+			var list = new List<MethodDef>(decrypterMethods.Count);
 			foreach (var info in decrypterMethods.getValues())
 				list.Add(info.method);
 			return list;
diff --git a/de4dot.code/deobfuscators/Goliath_NET/Deobfuscator.cs b/de4dot.code/deobfuscators/Goliath_NET/Deobfuscator.cs
index 1ae6dc3d..b77f1f3c 100644
--- a/de4dot.code/deobfuscators/Goliath_NET/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/Goliath_NET/Deobfuscator.cs
@@ -18,7 +18,7 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Goliath_NET {
@@ -162,7 +162,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			}
 		}
 
-		void initializeVersion(TypeDefinition attr) {
+		void initializeVersion(TypeDef attr) {
 			var s = DotNetUtils.getCustomArgAsString(getAssemblyAttribute(attr), 0);
 			if (s == null)
 				return;
@@ -232,7 +232,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 				localsRestorer.deobfuscate(blocks);
 			if (options.RemoveAntiStrongName) {
 				if (strongNameChecker.deobfuscate(blocks))
-					Log.v("Removed strong name checker code");
+					Logger.v("Removed strong name checker code");
 			}
 			logicalExpressionFixer.deobfuscate(blocks);
 			base.deobfuscateMethodEnd(blocks);
@@ -274,7 +274,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 		public override IEnumerable<int> getStringDecrypterMethods() {
 			var list = new List<int>();
 			foreach (var method in stringDecrypter.getMethods())
-				list.Add(method.MetadataToken.ToInt32());
+				list.Add(method.MDToken.ToInt32());
 			return list;
 		}
 	}
diff --git a/de4dot.code/deobfuscators/Goliath_NET/IntegerDecrypter.cs b/de4dot.code/deobfuscators/Goliath_NET/IntegerDecrypter.cs
index 694771fe..2b6f526e 100644
--- a/de4dot.code/deobfuscators/Goliath_NET/IntegerDecrypter.cs
+++ b/de4dot.code/deobfuscators/Goliath_NET/IntegerDecrypter.cs
@@ -18,12 +18,12 @@
 */
 
 using System;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Goliath_NET {
 	class IntegerDecrypter : DecrypterBase {
-		public IntegerDecrypter(ModuleDefinition module)
+		public IntegerDecrypter(ModuleDefMD module)
 			: base(module) {
 		}
 
@@ -31,15 +31,15 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			"System.Byte[]",
 			"System.Collections.Generic.Dictionary`2<System.Int32,System.Object>",
 		};
-		protected override bool checkDecrypterType(TypeDefinition type) {
+		protected override bool checkDecrypterType(TypeDef type) {
 			return new FieldTypes(type).exactly(requiredFields);
 		}
 
-		protected override bool checkDelegateInvokeMethod(MethodDefinition invokeMethod) {
+		protected override bool checkDelegateInvokeMethod(MethodDef invokeMethod) {
 			return DotNetUtils.isMethod(invokeMethod, "System.Object", "(System.Int32)");
 		}
 
-		public int decrypt(MethodDefinition method) {
+		public int decrypt(MethodDef method) {
 			var info = getInfo(method);
 			decryptedReader.BaseStream.Position = info.offset;
 			int len = decryptedReader.ReadInt32();
diff --git a/de4dot.code/deobfuscators/Goliath_NET/LocalsRestorer.cs b/de4dot.code/deobfuscators/Goliath_NET/LocalsRestorer.cs
index 9efb4791..7ec50b74 100644
--- a/de4dot.code/deobfuscators/Goliath_NET/LocalsRestorer.cs
+++ b/de4dot.code/deobfuscators/Goliath_NET/LocalsRestorer.cs
@@ -18,28 +18,28 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Goliath_NET {
 	class LocalsRestorer {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		TypeDefinitionDict<Info> typeToInfo = new TypeDefinitionDict<Info>();
 
 		class Info {
-			public TypeDefinition type;
-			public TypeReference localType;
+			public TypeDef type;
+			public TypeSig localType;
 			public bool referenced = false;
-			public Info(TypeDefinition type, TypeReference localType) {
+			public Info(TypeDef type, TypeSig localType) {
 				this.type = type;
 				this.localType = localType;
 			}
 		}
 
-		public List<TypeDefinition> Types {
+		public List<TypeDef> Types {
 			get {
-				var list = new List<TypeDefinition>(typeToInfo.Count);
+				var list = new List<TypeDef>(typeToInfo.Count);
 				foreach (var info in typeToInfo.getValues()) {
 					if (info.referenced)
 						list.Add(info.type);
@@ -48,7 +48,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			}
 		}
 
-		public LocalsRestorer(ModuleDefinition module) {
+		public LocalsRestorer(ModuleDefMD module) {
 			this.module = module;
 		}
 
@@ -57,7 +57,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 				initialize(type);
 		}
 
-		void initialize(TypeDefinition type) {
+		void initialize(TypeDef type) {
 			if (type.HasEvents || type.HasProperties)
 				return;
 
@@ -68,16 +68,17 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			var ctor = type.Methods[0];
 			if (ctor.Name != ".ctor" || ctor.Body == null || ctor.IsStatic)
 				return;
-			if (ctor.Parameters.Count != 1)
+			var sig = ctor.MethodSig;
+			if (sig == null || sig.Params.Count != 1)
 				return;
-			var ctorParam = ctor.Parameters[0];
+			var ctorParam = sig.Params[0];
 
 			if (type.Fields.Count != 1)
 				return;
 			var typeField = type.Fields[0];
 			if (typeField.IsStatic)
 				return;
-			if (!MemberReferenceHelper.compareTypes(ctorParam.ParameterType, typeField.FieldType))
+			if (!new SigComparer().Equals(ctorParam, typeField.FieldType))
 				return;
 
 			typeToInfo.add(ctor.DeclaringType, new Info(ctor.DeclaringType, typeField.FieldType));
@@ -91,13 +92,13 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 				for (int i = 0; i < instrs.Count; i++) {
 					var instr = instrs[i];
 					int indexToRemove;
-					TypeReference type;
-					VariableDefinition local = null;
+					ITypeDefOrRef type;
+					Local local = null;
 
 					if (instr.OpCode.Code == Code.Newobj) {
 						if (i + 1 >= instrs.Count)
 							continue;
-						var ctor = instr.Operand as MethodReference;
+						var ctor = instr.Operand as IMethod;
 						if (ctor == null || ctor.DeclaringType == null)
 							continue;
 						if (ctor.Name != ".ctor")
@@ -119,7 +120,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 						if (!ldloc.isLdloc())
 							continue;
 
-						var field = instr.Operand as FieldReference;
+						var field = instr.Operand as IField;
 						if (field == null || field.DeclaringType == null)
 							continue;
 
@@ -139,9 +140,10 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 					info.referenced = true;
 					instrsToRemove.Add(indexToRemove);
 					if (local != null)
-						local.VariableType = info.localType;
+						local.Type = info.localType;
 				}
-				block.remove(instrsToRemove);
+				if (instrsToRemove.Count > 0)
+					block.remove(instrsToRemove);
 			}
 		}
 	}
diff --git a/de4dot.code/deobfuscators/Goliath_NET/LogicalExpressionFixer.cs b/de4dot.code/deobfuscators/Goliath_NET/LogicalExpressionFixer.cs
index 20c7027e..f481781a 100644
--- a/de4dot.code/deobfuscators/Goliath_NET/LogicalExpressionFixer.cs
+++ b/de4dot.code/deobfuscators/Goliath_NET/LogicalExpressionFixer.cs
@@ -17,7 +17,7 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil.Cil;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Goliath_NET {
diff --git a/de4dot.code/deobfuscators/Goliath_NET/ProxyCallFixer.cs b/de4dot.code/deobfuscators/Goliath_NET/ProxyCallFixer.cs
index 9340b227..5417edea 100644
--- a/de4dot.code/deobfuscators/Goliath_NET/ProxyCallFixer.cs
+++ b/de4dot.code/deobfuscators/Goliath_NET/ProxyCallFixer.cs
@@ -19,27 +19,27 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Goliath_NET {
 	class ProxyCallFixer : ProxyCallFixer2 {
-		public ProxyCallFixer(ModuleDefinition module)
+		public ProxyCallFixer(ModuleDefMD module)
 			: base(module) {
 		}
 
 		class MyInfo {
-			public MethodDefinition method;
+			public MethodDef method;
 			public DelegateInfo delegateInfo;
-			public MyInfo(MethodDefinition method, DelegateInfo delegateInfo) {
+			public MyInfo(MethodDef method, DelegateInfo delegateInfo) {
 				this.method = method;
 				this.delegateInfo = delegateInfo;
 			}
 		}
 
 		public new void find() {
-			Log.v("Finding all proxy delegates");
+			Logger.v("Finding all proxy delegates");
 			var infos = new List<MyInfo>();
 			foreach (var type in module.GetTypes()) {
 				if (type.BaseType == null || type.BaseType.FullName != "System.MulticastDelegate")
@@ -56,24 +56,24 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 				if (infos.Count == 0)
 					continue;
 
-				Log.v("Found proxy delegate: {0} ({1:X8})", Utils.removeNewlines(type), type.MetadataToken.ToUInt32());
+				Logger.v("Found proxy delegate: {0} ({1:X8})", Utils.removeNewlines(type), type.MDToken.ToUInt32());
 				RemovedDelegateCreatorCalls++;
-				Log.indent();
+				Logger.Instance.indent();
 				foreach (var info in infos) {
 					var di = info.delegateInfo;
 					add(info.method, di);
-					Log.v("Field: {0}, Opcode: {1}, Method: {2} ({3:X8})",
+					Logger.v("Field: {0}, Opcode: {1}, Method: {2} ({3:X8})",
 								Utils.removeNewlines(di.field.Name),
 								di.callOpcode,
 								Utils.removeNewlines(di.methodRef),
-								di.methodRef.MetadataToken.ToUInt32());
+								di.methodRef.MDToken.ToUInt32());
 				}
-				Log.deIndent();
+				Logger.Instance.deIndent();
 				delegateTypesDict[type] = true;
 			}
 		}
 
-		bool checkProxyMethod(MethodDefinition method, out DelegateInfo info) {
+		bool checkProxyMethod(MethodDef method, out DelegateInfo info) {
 			info = null;
 			if (!method.IsStatic || method.Body == null)
 				return false;
@@ -86,36 +86,39 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 
 			if (instrs[index].OpCode.Code != Code.Ldsfld)
 				return false;
-			var field = instrs[index++].Operand as FieldDefinition;
+			var field = instrs[index++].Operand as FieldDef;
 			if (field == null || !field.IsStatic)
 				return false;
-			if (!MemberReferenceHelper.compareTypes(method.DeclaringType, field.DeclaringType))
+			if (!new SigComparer().Equals(method.DeclaringType, field.DeclaringType))
 				return false;
 
-			if (!DotNetUtils.isBrtrue(instrs[index++]))
+			if (!instrs[index++].IsBrtrue())
 				return false;
 			if (instrs[index++].OpCode.Code != Code.Ldnull)
 				return false;
 			if (instrs[index].OpCode.Code != Code.Ldftn)
 				return false;
-			var calledMethod = instrs[index++].Operand as MethodReference;
+			var calledMethod = instrs[index++].Operand as IMethod;
 			if (calledMethod == null)
 				return false;
 			if (instrs[index++].OpCode.Code != Code.Newobj)
 				return false;
 			if (instrs[index].OpCode.Code != Code.Stsfld)
 				return false;
-			if (!MemberReferenceHelper.compareFieldReference(field, instrs[index++].Operand as FieldReference))
+			if (!new SigComparer().Equals(field, instrs[index++].Operand as IField))
 				return false;
 			if (instrs[index].OpCode.Code != Code.Ldsfld)
 				return false;
-			if (!MemberReferenceHelper.compareFieldReference(field, instrs[index++].Operand as FieldReference))
+			if (!new SigComparer().Equals(field, instrs[index++].Operand as IField))
 				return false;
 
-			for (int i = 0; i < method.Parameters.Count; i++) {
+			var sig = method.MethodSig;
+			if (sig == null)
+				return false;
+			for (int i = 0; i < sig.Params.Count; i++) {
 				if (index >= instrs.Count)
 					return false;
-				if (DotNetUtils.getArgIndex(instrs[index++]) != i)
+				if (instrs[index++].GetParameterIndex() != i)
 					return false;
 			}
 
@@ -132,11 +135,11 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			return true;
 		}
 
-		protected override object checkCctor(TypeDefinition type, MethodDefinition cctor) {
+		protected override object checkCctor(TypeDef type, MethodDef cctor) {
 			throw new System.NotImplementedException();
 		}
 
-		protected override void getCallInfo(object context, FieldDefinition field, out MethodReference calledMethod, out OpCode callOpcode) {
+		protected override void getCallInfo(object context, FieldDef field, out IMethod calledMethod, out OpCode callOpcode) {
 			throw new System.NotImplementedException();
 		}
 	}
diff --git a/de4dot.code/deobfuscators/Goliath_NET/StringDecrypter.cs b/de4dot.code/deobfuscators/Goliath_NET/StringDecrypter.cs
index c444c8a2..45d823cc 100644
--- a/de4dot.code/deobfuscators/Goliath_NET/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/Goliath_NET/StringDecrypter.cs
@@ -19,20 +19,20 @@
 
 using System;
 using System.Text;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Goliath_NET {
 	class StringDecrypter : DecrypterBase {
-		TypeReference delegateReturnType;
-		FieldDefinition stringStructField;
+		IType delegateReturnType;
+		FieldDef stringStructField;
 
-		public TypeDefinition StringStruct {
+		public TypeDef StringStruct {
 			get { return Detected && stringStructField != null ? stringStructField.DeclaringType : null; }
 		}
 
-		public StringDecrypter(ModuleDefinition module)
+		public StringDecrypter(ModuleDefMD module)
 			: base(module) {
 		}
 
@@ -40,7 +40,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 				"System.Byte[]",
 				"System.Collections.Generic.Dictionary`2<System.Int32,System.String>",
 		};
-		protected override bool checkDecrypterType(TypeDefinition type) {
+		protected override bool checkDecrypterType(TypeDef type) {
 			var fields = type.Fields;
 			if (fields.Count != 2)
 				return false;
@@ -48,10 +48,10 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			if (fields[0].FieldType.FullName != "System.Byte[]")
 				return false;
 
-			var dict = fields[1].FieldType as GenericInstanceType;
+			var dict = fields[1].FieldType.ToGenericInstSig();
 			if (dict == null || dict.GenericArguments.Count != 2)
 				return false;
-			if (dict.ElementType.FullName != "System.Collections.Generic.Dictionary`2")
+			if (dict.GenericType.GetFullName() != "System.Collections.Generic.Dictionary`2")
 				return false;
 
 			if (dict.GenericArguments[0].FullName != "System.Int32")
@@ -80,11 +80,11 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			return true;
 		}
 
-		protected override bool checkDelegateInvokeMethod(MethodDefinition invokeMethod) {
+		protected override bool checkDelegateInvokeMethod(MethodDef invokeMethod) {
 			return DotNetUtils.isMethod(invokeMethod, delegateReturnType.FullName, "(System.Int32)");
 		}
 
-		public string decrypt(MethodDefinition method) {
+		public string decrypt(MethodDef method) {
 			var info = getInfo(method);
 			decryptedReader.BaseStream.Position = info.offset;
 			int len = decryptedReader.ReadInt32();
@@ -106,7 +106,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 					var ldfld = instrs[i + 1];
 					if (ldfld.OpCode.Code != Code.Ldfld)
 						continue;
-					if (!MemberReferenceHelper.compareFieldReferenceAndDeclaringType(stringStructField, ldfld.Operand as FieldReference))
+					if (!FieldEqualityComparer.CompareDeclaringTypes.Equals(stringStructField, ldfld.Operand as IField))
 						continue;
 					block.remove(i + 1, 1);
 				}
diff --git a/de4dot.code/deobfuscators/Goliath_NET/StrongNameChecker.cs b/de4dot.code/deobfuscators/Goliath_NET/StrongNameChecker.cs
index 6aafe804..6541873f 100644
--- a/de4dot.code/deobfuscators/Goliath_NET/StrongNameChecker.cs
+++ b/de4dot.code/deobfuscators/Goliath_NET/StrongNameChecker.cs
@@ -17,29 +17,29 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Goliath_NET {
 	class StrongNameChecker {
-		ModuleDefinition module;
-		TypeDefinition strongNameType;
-		MethodDefinition strongNameCheckMethod;
+		ModuleDefMD module;
+		TypeDef strongNameType;
+		MethodDef strongNameCheckMethod;
 
 		public bool Detected {
 			get { return strongNameType != null;}
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return strongNameType; }
 		}
 
-		public MethodDefinition CheckerMethod {
+		public MethodDef CheckerMethod {
 			get { return strongNameCheckMethod; }
 		}
 
-		public StrongNameChecker(ModuleDefinition module) {
+		public StrongNameChecker(ModuleDefMD module) {
 			this.module = module;
 		}
 
@@ -65,7 +65,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			}
 		}
 
-		MethodDefinition getAntiTamperingDetectionMethod(TypeDefinition type) {
+		MethodDef getAntiTamperingDetectionMethod(TypeDef type) {
 			var requiredLocals = new string[] {
 				"System.Reflection.Assembly",
 				"System.Collections.Generic.Stack`1<System.Int32>",
@@ -85,7 +85,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			return null;
 		}
 
-		static bool hasThrow(MethodDefinition method) {
+		static bool hasThrow(MethodDef method) {
 			if (method == null || method.Body == null)
 				return false;
 			foreach (var instr in method.Body.Instructions) {
@@ -108,13 +108,13 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 					var call1 = instrs[i + 1];
 					if (call1.OpCode.Code != Code.Call && call1.OpCode.Code != Code.Callvirt)
 						continue;
-					if (!DotNetUtils.isMethod(call1.Operand as MethodReference, "System.Type", "(System.RuntimeTypeHandle)"))
+					if (!DotNetUtils.isMethod(call1.Operand as IMethod, "System.Type", "(System.RuntimeTypeHandle)"))
 						continue;
 
 					var call2 = instrs[i + 2];
 					if (call2.OpCode.Code != Code.Call && call2.OpCode.Code != Code.Callvirt)
 						continue;
-					if (!MemberReferenceHelper.compareMethodReferenceAndDeclaringType(call2.Operand as MethodReference, strongNameCheckMethod))
+					if (!MethodEqualityComparer.CompareDeclaringTypes.Equals(call2.Operand as IMethod, strongNameCheckMethod))
 						continue;
 
 					block.remove(i, 3);
diff --git a/de4dot.code/deobfuscators/IDeobfuscator.cs b/de4dot.code/deobfuscators/IDeobfuscator.cs
index e13fe2ec..535f185e 100644
--- a/de4dot.code/deobfuscators/IDeobfuscator.cs
+++ b/de4dot.code/deobfuscators/IDeobfuscator.cs
@@ -19,12 +19,11 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.MyStuff;
+using dot10.DotNet;
+using dot10.PE;
 using de4dot.blocks;
 using de4dot.blocks.cflow;
 using de4dot.code.renamer;
-using de4dot.PE;
 
 namespace de4dot.code.deobfuscators {
 	public interface IDeobfuscatorOptions {
@@ -68,9 +67,9 @@ namespace de4dot.code.deobfuscators {
 		IDeobfuscatedFile DeobfuscatedFile { get; set; }
 
 		// Returns null or the unpacked .NET PE file
-		byte[] unpackNativeFile(PeImage peImage);
+		byte[] unpackNativeFile(IPEImage peImage);
 
-		void init(ModuleDefinition module);
+		void init(ModuleDefMD module);
 
 		// Returns 0 if it's not detected, or > 0 if detected (higher value => more likely true).
 		// This method is always called.
@@ -82,7 +81,7 @@ namespace de4dot.code.deobfuscators {
 
 		// This is only called if getDecryptedModule() != null, and after the module has been
 		// reloaded. Should return a new IDeobfuscator with the same options and the new module.
-		IDeobfuscator moduleReloaded(ModuleDefinition module);
+		IDeobfuscator moduleReloaded(ModuleDefMD module);
 
 		// Called before all other deobfuscation methods
 		void deobfuscateBegin();
diff --git a/de4dot.code/deobfuscators/ILProtector/Deobfuscator.cs b/de4dot.code/deobfuscators/ILProtector/Deobfuscator.cs
index ddd50ca1..45593e47 100644
--- a/de4dot.code/deobfuscators/ILProtector/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/ILProtector/Deobfuscator.cs
@@ -19,7 +19,7 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.ILProtector {
@@ -108,7 +108,6 @@ namespace de4dot.code.deobfuscators.ILProtector {
 			addFieldToBeRemoved(mainType.InvokerInstanceField, "Invoker delegate instance field");
 			foreach (var pm in mainType.ProtectMethods) {
 				addMethodToBeRemoved(pm, "Obfuscator 'Protect' init method");
-				addModuleReferenceToBeRemoved(pm.PInvokeInfo.Module, "Obfuscator native protection file");
 			}
 			mainType.cleanUp();
 		}
diff --git a/de4dot.code/deobfuscators/ILProtector/MainType.cs b/de4dot.code/deobfuscators/ILProtector/MainType.cs
index c12e9734..bcdbe4f9 100644
--- a/de4dot.code/deobfuscators/ILProtector/MainType.cs
+++ b/de4dot.code/deobfuscators/ILProtector/MainType.cs
@@ -18,26 +18,26 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.ILProtector {
 	class MainType {
-		ModuleDefinition module;
-		List<MethodDefinition> protectMethods;
-		TypeDefinition invokerDelegate;
-		FieldDefinition invokerInstanceField;
+		ModuleDefMD module;
+		List<MethodDef> protectMethods;
+		TypeDef invokerDelegate;
+		FieldDef invokerInstanceField;
 
-		public IEnumerable<MethodDefinition> ProtectMethods {
+		public IEnumerable<MethodDef> ProtectMethods {
 			get { return protectMethods; }
 		}
 
-		public TypeDefinition InvokerDelegate {
+		public TypeDef InvokerDelegate {
 			get { return invokerDelegate; }
 		}
 
-		public FieldDefinition InvokerInstanceField {
+		public FieldDef InvokerInstanceField {
 			get { return invokerInstanceField; }
 		}
 
@@ -45,7 +45,7 @@ namespace de4dot.code.deobfuscators.ILProtector {
 			get { return protectMethods != null; }
 		}
 
-		public MainType(ModuleDefinition module) {
+		public MainType(ModuleDefMD module) {
 			this.module = module;
 		}
 
@@ -58,7 +58,7 @@ namespace de4dot.code.deobfuscators.ILProtector {
 			"System.IntPtr",
 			"System.Object[]",
 		};
-		bool checkMethod(MethodDefinition cctor) {
+		bool checkMethod(MethodDef cctor) {
 			if (cctor == null || cctor.Body == null)
 				return false;
 			if (!new LocalTypes(cctor).exactly(ilpLocals))
@@ -74,7 +74,7 @@ namespace de4dot.code.deobfuscators.ILProtector {
 				return false;
 
 			var theField = type.Fields[0];
-			var theDelegate = theField.FieldType as TypeDefinition;
+			var theDelegate = theField.FieldType.TryGetTypeDef();
 			if (theDelegate == null || !DotNetUtils.derivesFromDelegate(theDelegate))
 				return false;
 
@@ -84,10 +84,10 @@ namespace de4dot.code.deobfuscators.ILProtector {
 			return true;
 		}
 
-		static List<MethodDefinition> getPinvokeMethods(TypeDefinition type, string name) {
-			var list = new List<MethodDefinition>();
+		static List<MethodDef> getPinvokeMethods(TypeDef type, string name) {
+			var list = new List<MethodDef>();
 			foreach (var method in type.Methods) {
-				if (method.PInvokeInfo != null && method.PInvokeInfo.EntryPoint == name)
+				if (method.ImplMap != null && method.ImplMap.Name == name)
 					list.Add(method);
 			}
 			return list;
@@ -97,7 +97,7 @@ namespace de4dot.code.deobfuscators.ILProtector {
 			var cctor = DotNetUtils.getModuleTypeCctor(module);
 			if (cctor != null) {
 				cctor.Body.InitLocals = false;
-				cctor.Body.Variables.Clear();
+				cctor.Body.LocalList.Clear();
 				cctor.Body.Instructions.Clear();
 				cctor.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
 				cctor.Body.ExceptionHandlers.Clear();
diff --git a/de4dot.code/deobfuscators/ILProtector/MethodReader.cs b/de4dot.code/deobfuscators/ILProtector/MethodReader.cs
index fbbab94d..b3d311c4 100644
--- a/de4dot.code/deobfuscators/ILProtector/MethodReader.cs
+++ b/de4dot.code/deobfuscators/ILProtector/MethodReader.cs
@@ -20,16 +20,17 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.Cecil.Metadata;
+using dot10.IO;
+using dot10.DotNet;
+using dot10.DotNet.MD;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.ILProtector {
 	class MethodReader : MethodBodyReaderBase {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		MethodFlags flags;
-		TypeDefinition delegateType;
+		TypeDef delegateType;
 
 		[Flags]
 		enum MethodFlags {
@@ -39,7 +40,7 @@ namespace de4dot.code.deobfuscators.ILProtector {
 			HasExceptionHandlers = 8,
 		}
 
-		public TypeDefinition DelegateType {
+		public TypeDef DelegateType {
 			get { return delegateType; }
 		}
 
@@ -59,23 +60,22 @@ namespace de4dot.code.deobfuscators.ILProtector {
 			get { return (flags & MethodFlags.HasExceptionHandlers) != 0; }
 		}
 
-		public MethodReader(ModuleDefinition module, byte[] data, IList<ParameterDefinition> parameters)
-			: base(new BinaryReader(new MemoryStream(data))) {
+		public MethodReader(ModuleDefMD module, byte[] data, IList<Parameter> parameters)
+			: base(MemoryImageStream.Create(data), parameters) {
 			this.module = module;
-			this.parameters = parameters;
 		}
 
 		public void read() {
 			flags = (MethodFlags)reader.ReadByte();
-			delegateType = resolve<TypeDefinition>(readTypeToken());
+			delegateType = resolve<TypeDef>(readTypeToken());
 			if (!DotNetUtils.derivesFromDelegate(delegateType))
 				throw new ApplicationException("Invalid delegate type");
 			if (HasLocals)
-				readLocals(Utils.readEncodedInt32(reader));
+				readLocals((int)reader.Read7BitEncodedUInt32());
 			if (HasInstructions)
-				readInstructions(Utils.readEncodedInt32(reader));
+				ReadInstructions((int)reader.Read7BitEncodedUInt32());
 			if (HasExceptionHandlers)
-				readExceptionHandlers(Utils.readEncodedInt32(reader));
+				readExceptionHandlers((int)reader.Read7BitEncodedUInt32());
 		}
 
 		int getTypeDefOrRefToken(uint token) {
@@ -88,123 +88,127 @@ namespace de4dot.code.deobfuscators.ILProtector {
 		}
 
 		void readLocals(int numLocals) {
-			var localsTypes = new List<TypeReference>();
+			var localsTypes = new List<TypeSig>();
 			for (int i = 0; i < numLocals; i++)
 				localsTypes.Add(readType());
-			setLocals(localsTypes);
+			SetLocals(localsTypes);
 		}
 
 		T resolve<T>(int token) {
-			return (T)module.LookupToken(token);
+			return (T)module.ResolveToken(token);
 		}
 
 		int readTypeToken() {
-			return getTypeDefOrRefToken(Utils.readEncodedUInt32(reader));
+			return getTypeDefOrRefToken(reader.Read7BitEncodedUInt32());
 		}
 
-		TypeReference readType() {
-			TypeReference elementType;
+		TypeSig readType() {
 			switch ((ElementType)reader.ReadByte()) {
-			case ElementType.Void: return module.TypeSystem.Void;
-			case ElementType.Boolean: return module.TypeSystem.Boolean;
-			case ElementType.Char: return module.TypeSystem.Char;
-			case ElementType.I1: return module.TypeSystem.SByte;
-			case ElementType.U1: return module.TypeSystem.Byte;
-			case ElementType.I2: return module.TypeSystem.Int16;
-			case ElementType.U2: return module.TypeSystem.UInt16;
-			case ElementType.I4: return module.TypeSystem.Int32;
-			case ElementType.U4: return module.TypeSystem.UInt32;
-			case ElementType.I8: return module.TypeSystem.Int64;
-			case ElementType.U8: return module.TypeSystem.UInt64;
-			case ElementType.R4: return module.TypeSystem.Single;
-			case ElementType.R8: return module.TypeSystem.Double;
-			case ElementType.String: return module.TypeSystem.String;
-			case ElementType.Ptr: return new PointerType(readType());
-			case ElementType.ByRef: return new ByReferenceType(readType());
-			case ElementType.TypedByRef: return module.TypeSystem.TypedReference;
-			case ElementType.I: return module.TypeSystem.IntPtr;
-			case ElementType.U: return module.TypeSystem.UIntPtr;
-			case ElementType.Object: return module.TypeSystem.Object;
-			case ElementType.SzArray: return new ArrayType(readType());
-			case ElementType.Sentinel: return new SentinelType(readType());
-			case ElementType.Pinned: return new PinnedType(readType());
+			case ElementType.Void: return module.CorLibTypes.Void;
+			case ElementType.Boolean: return module.CorLibTypes.Boolean;
+			case ElementType.Char: return module.CorLibTypes.Char;
+			case ElementType.I1: return module.CorLibTypes.SByte;
+			case ElementType.U1: return module.CorLibTypes.Byte;
+			case ElementType.I2: return module.CorLibTypes.Int16;
+			case ElementType.U2: return module.CorLibTypes.UInt16;
+			case ElementType.I4: return module.CorLibTypes.Int32;
+			case ElementType.U4: return module.CorLibTypes.UInt32;
+			case ElementType.I8: return module.CorLibTypes.Int64;
+			case ElementType.U8: return module.CorLibTypes.UInt64;
+			case ElementType.R4: return module.CorLibTypes.Single;
+			case ElementType.R8: return module.CorLibTypes.Double;
+			case ElementType.String: return module.CorLibTypes.String;
+			case ElementType.Ptr: return new PtrSig(readType());
+			case ElementType.ByRef: return new ByRefSig(readType());
+			case ElementType.TypedByRef: return module.CorLibTypes.TypedReference;
+			case ElementType.I: return module.CorLibTypes.IntPtr;
+			case ElementType.U: return module.CorLibTypes.UIntPtr;
+			case ElementType.Object: return module.CorLibTypes.Object;
+			case ElementType.SZArray: return new SZArraySig(readType());
+			case ElementType.Sentinel: readType(); return new SentinelSig();
+			case ElementType.Pinned: return new PinnedSig(readType());
 
 			case ElementType.ValueType:
 			case ElementType.Class:
-				return resolve<TypeReference>(readTypeToken());
+				return resolve<ITypeDefOrRef>(readTypeToken()).ToTypeSig();
 
 			case ElementType.Array:
-				elementType = readType();
-				int rank = Utils.readEncodedInt32(reader);
-				return new ArrayType(elementType, rank);
+				var arrayType = readType();
+				uint rank = reader.Read7BitEncodedUInt32();
+				return new ArraySig(arrayType, rank);
 
 			case ElementType.GenericInst:
 				reader.ReadByte();
-				elementType = resolve<TypeReference>(readTypeToken());
-				int numGenericArgs = Utils.readEncodedInt32(reader);
-				var git = new GenericInstanceType(elementType);
+				var genericType = resolve<ITypeDefOrRef>(readTypeToken());
+				int numGenericArgs = (int)reader.Read7BitEncodedUInt32();
+				var git = new GenericInstSig(genericType.ToTypeSig() as ClassOrValueTypeSig);
 				for (int i = 0; i < numGenericArgs; i++)
 					git.GenericArguments.Add(readType());
 				return git;
 
-			case ElementType.None:
 			case ElementType.Var:
 			case ElementType.MVar:
 			case ElementType.FnPtr:
-			case ElementType.CModReqD:
+			case ElementType.CModReqd:
 			case ElementType.CModOpt:
 			case ElementType.Internal:
-			case ElementType.Modifier:
-			case ElementType.Type:
-			case ElementType.Boxed:
-			case ElementType.Enum:
 			default:
 				throw new ApplicationException("Invalid local element type");
 			}
 		}
 
-		protected override FieldReference readInlineField(Instruction instr) {
-			return resolve<FieldReference>(reader.ReadInt32());
+		protected override IField ReadInlineField(Instruction instr) {
+			return resolve<IField>(reader.ReadInt32());
 		}
 
-		protected override MethodReference readInlineMethod(Instruction instr) {
-			return resolve<MethodReference>(reader.ReadInt32());
+		protected override IMethod ReadInlineMethod(Instruction instr) {
+			return resolve<IMethod>(reader.ReadInt32());
 		}
 
-		protected override CallSite readInlineSig(Instruction instr) {
-			return module.ReadCallSite(new MetadataToken(reader.ReadUInt32()));
+		protected override MethodSig ReadInlineSig(Instruction instr) {
+			var token = reader.ReadUInt32();
+			if (MDToken.ToTable(token) != Table.StandAloneSig)
+				return null;
+			var sas = module.ResolveStandAloneSig(MDToken.ToRID(token));
+			return sas == null ? null : sas.MethodSig;
 		}
 
-		protected override string readInlineString(Instruction instr) {
-			return module.GetUserString(reader.ReadUInt32());
+		protected override string ReadInlineString(Instruction instr) {
+			return module.ReadUserString(reader.ReadUInt32());
 		}
 
-		protected override MemberReference readInlineTok(Instruction instr) {
-			return resolve<MemberReference>(reader.ReadInt32());
+		protected override ITokenOperand ReadInlineTok(Instruction instr) {
+			return resolve<ITokenOperand>(reader.ReadInt32());
 		}
 
-		protected override TypeReference readInlineType(Instruction instr) {
-			return resolve<TypeReference>(reader.ReadInt32());
+		protected override ITypeDefOrRef ReadInlineType(Instruction instr) {
+			return resolve<ITypeDefOrRef>(reader.ReadInt32());
 		}
 
-		protected override ExceptionHandler readExceptionHandler() {
-			var eh = new ExceptionHandler((ExceptionHandlerType)(Utils.readEncodedInt32(reader) & 7));
+		void readExceptionHandlers(int numExceptionHandlers) {
+			exceptionHandlers = new List<ExceptionHandler>(numExceptionHandlers);
+			for (int i = 0; i < numExceptionHandlers; i++)
+				Add(readExceptionHandler());
+		}
 
-			int tryOffset = Utils.readEncodedInt32(reader);
-			eh.TryStart = getInstruction(tryOffset);
-			eh.TryEnd = getInstructionOrNull(tryOffset + Utils.readEncodedInt32(reader));
+		ExceptionHandler readExceptionHandler() {
+			var eh = new ExceptionHandler((ExceptionHandlerType)(reader.Read7BitEncodedUInt32() & 7));
 
-			int handlerOffset = Utils.readEncodedInt32(reader);
-			eh.HandlerStart = getInstruction(handlerOffset);
-			eh.HandlerEnd = getInstructionOrNull(handlerOffset + Utils.readEncodedInt32(reader));
+			uint tryOffset = reader.Read7BitEncodedUInt32();
+			eh.TryStart = GetInstructionThrow(tryOffset);
+			eh.TryEnd = GetInstruction(tryOffset + reader.Read7BitEncodedUInt32());
+
+			uint handlerOffset = reader.Read7BitEncodedUInt32();
+			eh.HandlerStart = GetInstructionThrow(handlerOffset);
+			eh.HandlerEnd = GetInstruction(handlerOffset + reader.Read7BitEncodedUInt32());
 
 			switch (eh.HandlerType) {
 			case ExceptionHandlerType.Catch:
-				eh.CatchType = resolve<TypeReference>(reader.ReadInt32());
+				eh.CatchType = resolve<ITypeDefOrRef>(reader.ReadInt32());
 				break;
 
 			case ExceptionHandlerType.Filter:
-				eh.FilterStart = getInstruction(reader.ReadInt32());
+				eh.FilterStart = GetInstructionThrow(reader.ReadUInt32());
 				break;
 
 			case ExceptionHandlerType.Finally:
diff --git a/de4dot.code/deobfuscators/ILProtector/MethodsDecrypter.cs b/de4dot.code/deobfuscators/ILProtector/MethodsDecrypter.cs
index 15324013..bc40d6cc 100644
--- a/de4dot.code/deobfuscators/ILProtector/MethodsDecrypter.cs
+++ b/de4dot.code/deobfuscators/ILProtector/MethodsDecrypter.cs
@@ -19,9 +19,9 @@
 
 using System;
 using System.Collections.Generic;
-using System.IO;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.IO;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.ILProtector {
@@ -31,12 +31,12 @@ namespace de4dot.code.deobfuscators.ILProtector {
 		// This is the first four bytes of ILProtector's public key token
 		const uint RESOURCE_MAGIC = 0xC0D31220;
 
-		ModuleDefinition module;
+		ModuleDefMD module;
 		MainType mainType;
 		EmbeddedResource methodsResource;
 		Version ilpVersion;
 		Dictionary<int, MethodInfo2> methodInfos = new Dictionary<int, MethodInfo2>();
-		List<TypeDefinition> delegateTypes = new List<TypeDefinition>();
+		List<TypeDef> delegateTypes = new List<TypeDef>();
 		int startOffset;
 		byte[] decryptionKey;
 		int decryptionKeyMod;
@@ -60,7 +60,7 @@ namespace de4dot.code.deobfuscators.ILProtector {
 			get { return methodsResource; }
 		}
 
-		public IEnumerable<TypeDefinition> DelegateTypes {
+		public IEnumerable<TypeDef> DelegateTypes {
 			get { return delegateTypes; }
 		}
 
@@ -72,7 +72,7 @@ namespace de4dot.code.deobfuscators.ILProtector {
 			get { return methodsResource != null; }
 		}
 
-		public MethodsDecrypter(ModuleDefinition module, MainType mainType) {
+		public MethodsDecrypter(ModuleDefMD module, MainType mainType) {
 			this.module = module;
 			this.mainType = mainType;
 		}
@@ -82,7 +82,7 @@ namespace de4dot.code.deobfuscators.ILProtector {
 				var resource = tmp as EmbeddedResource;
 				if (resource == null)
 					continue;
-				var reader = new BinaryReader(resource.GetResourceStream());
+				var reader = resource.Data;
 				if (!checkResourceV100(reader) &&
 					!checkResourceV105(reader))
 					continue;
@@ -93,9 +93,9 @@ namespace de4dot.code.deobfuscators.ILProtector {
 		}
 
 		// 1.0.0 - 1.0.4
-		bool checkResourceV100(BinaryReader reader) {
-			reader.BaseStream.Position = 0;
-			if (reader.BaseStream.Length < 12)
+		bool checkResourceV100(IBinaryReader reader) {
+			reader.Position = 0;
+			if (reader.Length < 12)
 				return false;
 			if (reader.ReadUInt32() != RESOURCE_MAGIC)
 				return false;
@@ -107,9 +107,9 @@ namespace de4dot.code.deobfuscators.ILProtector {
 		}
 
 		// 1.0.5+
-		bool checkResourceV105(BinaryReader reader) {
-			reader.BaseStream.Position = 0;
-			if (reader.BaseStream.Length < 0xA4)
+		bool checkResourceV105(IBinaryReader reader) {
+			reader.Position = 0;
+			if (reader.Length < 0xA4)
 				return false;
 			var key = reader.ReadBytes(0x94);
 			if (!Utils.compare(reader.ReadBytes(8), ilpPublicKeyToken))
@@ -132,15 +132,15 @@ namespace de4dot.code.deobfuscators.ILProtector {
 		}
 
 		byte[] getMethodsData(EmbeddedResource resource) {
-			var reader = new BinaryReader(resource.GetResourceStream());
-			reader.BaseStream.Position = startOffset;
+			var reader = resource.Data;
+			reader.Position = startOffset;
 			if ((reader.ReadInt32() & 1) != 0)
 				return decompress(reader);
 			else
-				return reader.ReadBytes((int)(reader.BaseStream.Length - reader.BaseStream.Position));
+				return reader.ReadRemainingBytes();
 		}
 
-		byte[] decompress(BinaryReader reader) {
+		byte[] decompress(IBinaryReader reader) {
 			return decompress(reader, decryptionKey, decryptionKeyMod);
 		}
 
@@ -149,18 +149,18 @@ namespace de4dot.code.deobfuscators.ILProtector {
 				dst[dstIndex++] = src[srcIndex++];
 		}
 
-		static byte[] decompress(BinaryReader reader, byte[] key, int keyMod) {
-			var decrypted = new byte[Utils.readEncodedInt32(reader)];
+		static byte[] decompress(IBinaryReader reader, byte[] key, int keyMod) {
+			var decrypted = new byte[reader.Read7BitEncodedUInt32()];
 
 			int destIndex = 0;
-			while (reader.BaseStream.Position < reader.BaseStream.Length) {
+			while (reader.Position < reader.Length) {
 				byte flags = reader.ReadByte();
 				for (int mask = 1; mask != 0x100; mask <<= 1) {
-					if (reader.BaseStream.Position >= reader.BaseStream.Length)
+					if (reader.Position >= reader.Length)
 						break;
 					if ((flags & mask) != 0) {
-						int displ = Utils.readEncodedInt32(reader);
-						int size = Utils.readEncodedInt32(reader);
+						int displ = (int)reader.Read7BitEncodedUInt32();
+						int size = (int)reader.Read7BitEncodedUInt32();
 						copy(decrypted, destIndex - displ, decrypted, destIndex, size);
 						destIndex += size;
 					}
@@ -177,21 +177,21 @@ namespace de4dot.code.deobfuscators.ILProtector {
 		}
 
 		static MethodInfo2[] readMethodInfos(byte[] data) {
-			var reader = new BinaryReader(new MemoryStream(data));
-			int numMethods = Utils.readEncodedInt32(reader);
-			int totalCodeSize = Utils.readEncodedInt32(reader);
+			var reader = MemoryImageStream.Create(data);
+			int numMethods = (int)reader.Read7BitEncodedUInt32();
+			int totalCodeSize = (int)reader.Read7BitEncodedUInt32();
 			var methodInfos = new MethodInfo2[numMethods];
 			int offset = 0;
 			for (int i = 0; i < numMethods; i++) {
-				int id = Utils.readEncodedInt32(reader);
-				int size = Utils.readEncodedInt32(reader);
+				int id = (int)reader.Read7BitEncodedUInt32();
+				int size = (int)reader.Read7BitEncodedUInt32();
 				methodInfos[i] = new MethodInfo2(id, offset, size);
 				offset += size;
 			}
-			long dataOffset = reader.BaseStream.Position;
+			long dataOffset = reader.Position;
 			foreach (var info in methodInfos) {
-				reader.BaseStream.Position = dataOffset + info.offset;
-				reader.BaseStream.Read(info.data, 0, info.data.Length);
+				reader.Position = dataOffset + info.offset;
+				reader.Read(info.data, 0, info.data.Length);
 			}
 			return methodInfos;
 		}
@@ -200,35 +200,35 @@ namespace de4dot.code.deobfuscators.ILProtector {
 			if (methodInfos.Count == 0)
 				return;
 
-			Log.v("Restoring {0} methods", methodInfos.Count);
-			Log.indent();
+			Logger.v("Restoring {0} methods", methodInfos.Count);
+			Logger.Instance.indent();
 			foreach (var type in module.GetTypes()) {
 				foreach (var method in type.Methods) {
 					if (method.Body == null)
 						continue;
 
 					if (restoreMethod(method)) {
-						Log.v("Restored method {0} ({1:X8}). Instrs:{2}, Locals:{3}, Exceptions:{4}",
+						Logger.v("Restored method {0} ({1:X8}). Instrs:{2}, Locals:{3}, Exceptions:{4}",
 							Utils.removeNewlines(method.FullName),
-							method.MetadataToken.ToInt32(),
+							method.MDToken.ToInt32(),
 							method.Body.Instructions.Count,
-							method.Body.Variables.Count,
+							method.Body.LocalList.Count,
 							method.Body.ExceptionHandlers.Count);
 					}
 				}
 			}
-			Log.deIndent();
+			Logger.Instance.deIndent();
 			if (methodInfos.Count != 0)
-				Log.w("{0} methods weren't restored", methodInfos.Count);
+				Logger.w("{0} methods weren't restored", methodInfos.Count);
 		}
 
 		const int INVALID_METHOD_ID = -1;
-		bool restoreMethod(MethodDefinition method) {
+		bool restoreMethod(MethodDef method) {
 			int methodId = getMethodId(method);
 			if (methodId == INVALID_METHOD_ID)
 				return false;
 
-			var parameters = DotNetUtils.getParameters(method);
+			var parameters = method.Parameters;
 			var methodInfo = methodInfos[methodId];
 			methodInfos.Remove(methodId);
 			var methodReader = new MethodReader(module, methodInfo.data, parameters);
@@ -240,13 +240,13 @@ namespace de4dot.code.deobfuscators.ILProtector {
 			return true;
 		}
 
-		static void restoreMethod(MethodDefinition method, MethodReader methodReader) {
+		static void restoreMethod(MethodDef method, MethodReader methodReader) {
 			// body.MaxStackSize = <let Mono.Cecil calculate this>
 			method.Body.InitLocals = methodReader.InitLocals;
-			methodReader.restoreMethod(method);
+			methodReader.RestoreMethod(method);
 		}
 
-		int getMethodId(MethodDefinition method) {
+		int getMethodId(MethodDef method) {
 			if (method == null || method.Body == null)
 				return INVALID_METHOD_ID;
 
@@ -257,14 +257,14 @@ namespace de4dot.code.deobfuscators.ILProtector {
 					continue;
 
 				var ldci4 = instrs[i + 1];
-				if (!DotNetUtils.isLdcI4(ldci4))
+				if (!ldci4.IsLdcI4())
 					continue;
 
-				var field = ldsfld.Operand as FieldDefinition;
+				var field = ldsfld.Operand as FieldDef;
 				if (field == null || field != mainType.InvokerInstanceField)
 					continue;
 
-				return DotNetUtils.getLdcI4Value(ldci4);
+				return ldci4.GetLdcI4Value();
 			}
 
 			return INVALID_METHOD_ID;
diff --git a/de4dot.code/deobfuscators/ISimpleDeobfuscator.cs b/de4dot.code/deobfuscators/ISimpleDeobfuscator.cs
index 6b028100..a1749e38 100644
--- a/de4dot.code/deobfuscators/ISimpleDeobfuscator.cs
+++ b/de4dot.code/deobfuscators/ISimpleDeobfuscator.cs
@@ -17,12 +17,12 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace de4dot.code.deobfuscators {
 	public interface ISimpleDeobfuscator {
-		void deobfuscate(MethodDefinition method);
-		void deobfuscate(MethodDefinition method, bool force);
-		void decryptStrings(MethodDefinition method, IDeobfuscator deob);
+		void deobfuscate(MethodDef method);
+		void deobfuscate(MethodDef method, bool force);
+		void decryptStrings(MethodDef method, IDeobfuscator deob);
 	}
 }
diff --git a/de4dot.code/deobfuscators/InitializedDataCreator.cs b/de4dot.code/deobfuscators/InitializedDataCreator.cs
index 3628ca42..72598d1f 100644
--- a/de4dot.code/deobfuscators/InitializedDataCreator.cs
+++ b/de4dot.code/deobfuscators/InitializedDataCreator.cs
@@ -21,56 +21,55 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Security.Cryptography;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators {
 	class InitializedDataCreator {
-		ModuleDefinition module;
-		Dictionary<long, TypeDefinition> sizeToArrayType = new Dictionary<long, TypeDefinition>();
-		TypeDefinition ourType;
-		TypeReference valueType;
+		ModuleDef module;
+		Dictionary<long, TypeDef> sizeToArrayType = new Dictionary<long, TypeDef>();
+		TypeDef ourType;
+		TypeDefOrRefSig valueType;
 		int unique = 0;
-		MethodReference initializeArrayMethod;
+		MemberRef initializeArrayMethod;
 
-		public MethodReference InitializeArrayMethod {
+		public MemberRef InitializeArrayMethod {
 			get { return createInitializeArrayMethod(); }
 		}
 
-		public InitializedDataCreator(ModuleDefinition module) {
+		public InitializedDataCreator(ModuleDef module) {
 			this.module = module;
 		}
 
-		MethodReference createInitializeArrayMethod() {
+		MemberRef createInitializeArrayMethod() {
 			if (initializeArrayMethod == null) {
-				var runtimeHelpersType = DotNetUtils.findOrCreateTypeReference(module, module.TypeSystem.Corlib as AssemblyNameReference, "System.Runtime.CompilerServices", "RuntimeHelpers", false);
-				initializeArrayMethod = new MethodReference("InitializeArray", module.TypeSystem.Void, runtimeHelpersType);
-				var systemArrayType = DotNetUtils.findOrCreateTypeReference(module, module.TypeSystem.Corlib as AssemblyNameReference, "System", "Array", false);
-				var runtimeFieldHandleType = DotNetUtils.findOrCreateTypeReference(module, module.TypeSystem.Corlib as AssemblyNameReference, "System", "RuntimeFieldHandle", true);
-				initializeArrayMethod.Parameters.Add(new ParameterDefinition(systemArrayType));
-				initializeArrayMethod.Parameters.Add(new ParameterDefinition(runtimeFieldHandleType));
+				var runtimeHelpersType = DotNetUtils.findOrCreateTypeReference(module, module.CorLibTypes.AssemblyRef, "System.Runtime.CompilerServices", "RuntimeHelpers", false);
+				var systemArrayType = DotNetUtils.findOrCreateTypeReference(module, module.CorLibTypes.AssemblyRef, "System", "Array", false);
+				var runtimeFieldHandleType = DotNetUtils.findOrCreateTypeReference(module, module.CorLibTypes.AssemblyRef, "System", "RuntimeFieldHandle", true);
+				var methodSig = MethodSig.CreateStatic(module.CorLibTypes.Void, systemArrayType, runtimeFieldHandleType);
+				initializeArrayMethod = module.UpdateRowId(new MemberRefUser(module, "InitializeArray", methodSig, runtimeHelpersType.TypeDefOrRef));
 			}
 			return initializeArrayMethod;
 		}
 
-		public void addInitializeArrayCode(Block block, int start, int numToRemove, TypeReference elementType, byte[] data) {
+		public void addInitializeArrayCode(Block block, int start, int numToRemove, ITypeDefOrRef elementType, byte[] data) {
 			int index = start;
-			block.replace(index++, numToRemove, DotNetUtils.createLdci4(data.Length / elementType.PrimitiveSize));
+			block.replace(index++, numToRemove, Instruction.CreateLdcI4(data.Length / elementType.ToTypeSig().ElementType.GetPrimitiveSize()));
 			block.insert(index++, Instruction.Create(OpCodes.Newarr, elementType));
 			block.insert(index++, Instruction.Create(OpCodes.Dup));
-			block.insert(index++, Instruction.Create(OpCodes.Ldtoken, create(data)));
-			block.insert(index++, Instruction.Create(OpCodes.Call, InitializeArrayMethod));
+			block.insert(index++, Instruction.Create(OpCodes.Ldtoken, (IField)create(data)));
+			block.insert(index++, Instruction.Create(OpCodes.Call, (IMethod)InitializeArrayMethod));
 		}
 
 		void createOurType() {
 			if (ourType != null)
 				return;
 
-			var attrs = TypeAttributes.NotPublic | TypeAttributes.AutoLayout |
-						TypeAttributes.Class | TypeAttributes.AnsiClass;
-			ourType = new TypeDefinition("", string.Format("<PrivateImplementationDetails>{0}", getModuleId()), attrs, module.TypeSystem.Object);
-			ourType.MetadataToken = DotNetUtils.nextTypeDefToken();
+			ourType = new TypeDefUser("", string.Format("<PrivateImplementationDetails>{0}", getModuleId()), module.CorLibTypes.Object.TypeDefOrRef);
+			ourType.Attributes = TypeAttributes.NotPublic | TypeAttributes.AutoLayout |
+							TypeAttributes.Class | TypeAttributes.AnsiClass;
+			module.UpdateRowId(ourType);
 			module.Types.Add(ourType);
 		}
 
@@ -78,8 +77,8 @@ namespace de4dot.code.deobfuscators {
 			var memoryStream = new MemoryStream();
 			var writer = new BinaryWriter(memoryStream);
 			if (module.Assembly != null)
-				writer.Write(module.Assembly.Name.FullName);
-			writer.Write(module.Mvid.ToByteArray());
+				writer.Write(module.Assembly.FullName);
+			writer.Write((module.Mvid ?? Guid.Empty).ToByteArray());
 			var hash = new SHA1Managed().ComputeHash(memoryStream.GetBuffer());
 			var guid = new Guid(BitConverter.ToInt32(hash, 0),
 								BitConverter.ToInt16(hash, 4),
@@ -89,33 +88,32 @@ namespace de4dot.code.deobfuscators {
 			return guid.ToString("B");
 		}
 
-		TypeDefinition getArrayType(long size) {
+		TypeDef getArrayType(long size) {
 			createOurType();
 
-			TypeDefinition arrayType;
+			TypeDef arrayType;
 			if (sizeToArrayType.TryGetValue(size, out arrayType))
 				return arrayType;
 
 			if (valueType == null)
-				valueType = DotNetUtils.findOrCreateTypeReference(module, module.TypeSystem.Corlib as AssemblyNameReference, "System", "ValueType", false);
-			var attrs = TypeAttributes.NestedPrivate | TypeAttributes.ExplicitLayout |
-						TypeAttributes.Class | TypeAttributes.Sealed | TypeAttributes.AnsiClass;
-			arrayType = new TypeDefinition("", string.Format("__StaticArrayInitTypeSize={0}", size), attrs, valueType);
-			arrayType.MetadataToken = DotNetUtils.nextTypeDefToken();
+				valueType = DotNetUtils.findOrCreateTypeReference(module, module.CorLibTypes.AssemblyRef, "System", "ValueType", false);
+			arrayType = new TypeDefUser("", string.Format("__StaticArrayInitTypeSize={0}", size), valueType.TypeDefOrRef);
+			module.UpdateRowId(arrayType);
+			arrayType.Attributes = TypeAttributes.NestedPrivate | TypeAttributes.ExplicitLayout |
+							TypeAttributes.Class | TypeAttributes.Sealed | TypeAttributes.AnsiClass;
 			ourType.NestedTypes.Add(arrayType);
 			sizeToArrayType[size] = arrayType;
-			arrayType.ClassSize = (int)size;
-			arrayType.PackingSize = 1;
-			arrayType.IsValueType = true;
+			arrayType.ClassLayout = new ClassLayoutUser(1, (uint)size);
 			return arrayType;
 		}
 
-		public FieldDefinition create(byte[] data) {
+		public FieldDef create(byte[] data) {
 			var arrayType = getArrayType(data.LongLength);
+			var fieldSig = new FieldSig(new ValueTypeSig(arrayType));
 			var attrs = FieldAttributes.Assembly | FieldAttributes.Static;
-			var field = new FieldDefinition(string.Format("field_{0}", unique++), attrs, arrayType);
-			field.Attributes |= FieldAttributes.HasFieldRVA;
-			field.MetadataToken = DotNetUtils.nextFieldToken();
+			var field = new FieldDefUser(string.Format("field_{0}", unique++), fieldSig, attrs);
+			module.UpdateRowId(field);
+			field.HasFieldRVA = true;
 			ourType.Fields.Add(field);
 			var iv = new byte[data.Length];
 			Array.Copy(data, iv, data.Length);
diff --git a/de4dot.code/deobfuscators/InlinedMethodsFinder.cs b/de4dot.code/deobfuscators/InlinedMethodsFinder.cs
index c8f6fb49..2bcc386c 100644
--- a/de4dot.code/deobfuscators/InlinedMethodsFinder.cs
+++ b/de4dot.code/deobfuscators/InlinedMethodsFinder.cs
@@ -18,23 +18,23 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators {
 	static class InlinedMethodsFinder {
-		public static List<MethodDefinition> find(ModuleDefinition module) {
+		public static List<MethodDef> find(ModuleDef module) {
 			// Not all garbage methods are inlined, possibly because we remove some code that calls
 			// the garbage method before the methods inliner has a chance to inline it. Try to find
 			// all garbage methods and other code will figure out if there are any calls left.
 
-			var inlinedMethods = new List<MethodDefinition>();
+			var inlinedMethods = new List<MethodDef>();
 			foreach (var type in module.GetTypes()) {
 				foreach (var method in type.Methods) {
 					if (!method.IsStatic)
 						continue;
-					if (!method.IsAssembly && !method.IsCompilerControlled && !method.IsPrivate)
+					if (!method.IsAssembly && !method.IsPrivateScope && !method.IsPrivate)
 						continue;
 					if (method.GenericParameters.Count > 0)
 						continue;
@@ -97,7 +97,7 @@ namespace de4dot.code.deobfuscators {
 			return inlinedMethods;
 		}
 
-		static bool isCallMethod(MethodDefinition method) {
+		static bool isCallMethod(MethodDef method) {
 			int loadIndex = 0;
 			int methodArgsCount = DotNetUtils.getArgsCount(method);
 			var instrs = method.Body.Instructions;
@@ -113,7 +113,7 @@ namespace de4dot.code.deobfuscators {
 				case Code.Ldarg_3:
 				case Code.Ldarga:
 				case Code.Ldarga_S:
-					if (DotNetUtils.getArgIndex(instr) != loadIndex)
+					if (instr.GetParameterIndex() != loadIndex)
 						return false;
 					loadIndex++;
 					continue;
diff --git a/de4dot.code/deobfuscators/MPRESS/Deobfuscator.cs b/de4dot.code/deobfuscators/MPRESS/Deobfuscator.cs
index 3dd063b5..d349b0b8 100644
--- a/de4dot.code/deobfuscators/MPRESS/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/MPRESS/Deobfuscator.cs
@@ -21,8 +21,7 @@ using System;
 using System.Collections.Generic;
 using System.Security.Cryptography;
 using System.Text;
-using Mono.Cecil;
-using Mono.MyStuff;
+using dot10.DotNet;
 using de4dot.PE;
 using de4dot.blocks;
 
@@ -168,8 +167,8 @@ namespace de4dot.code.deobfuscators.MPRESS {
 			return Version.Unknown;
 		}
 
-		static bool checkMethods(TypeDefinition type, MethodInfo[] requiredMethods) {
-			var methods = new List<MethodDefinition>(type.Methods);
+		static bool checkMethods(TypeDef type, MethodInfo[] requiredMethods) {
+			var methods = new List<MethodDef>(type.Methods);
 			foreach (var info in requiredMethods) {
 				if (!checkMethod(methods, info))
 					return false;
@@ -177,7 +176,7 @@ namespace de4dot.code.deobfuscators.MPRESS {
 			return methods.Count == 0;
 		}
 
-		static bool checkMethod(List<MethodDefinition> methods, MethodInfo info) {
+		static bool checkMethod(List<MethodDef> methods, MethodInfo info) {
 			foreach (var method in methods) {
 				if (info.name != null && info.name != method.Name)
 					continue;
@@ -232,7 +231,7 @@ namespace de4dot.code.deobfuscators.MPRESS {
 			return true;
 		}
 
-		public override IDeobfuscator moduleReloaded(ModuleDefinition module) {
+		public override IDeobfuscator moduleReloaded(ModuleDefMD module) {
 			var newOne = new Deobfuscator(options);
 			newOne.setModule(module);
 			return newOne;
@@ -252,7 +251,7 @@ namespace de4dot.code.deobfuscators.MPRESS {
 									BitConverter.ToInt16(hash, 6),
 									hash[8], hash[9], hash[10], hash[11],
 									hash[12], hash[13], hash[14], hash[15]);
-				Log.v("Updating MVID: {0}", guid.ToString("B"));
+				Logger.v("Updating MVID: {0}", guid.ToString("B"));
 				module.Mvid = guid;
 			}
 		}
diff --git a/de4dot.code/deobfuscators/MaxtoCode/CryptDecrypter.cs b/de4dot.code/deobfuscators/MaxtoCode/CryptDecrypter.cs
index 7cdfa911..6f5ab2b2 100644
--- a/de4dot.code/deobfuscators/MaxtoCode/CryptDecrypter.cs
+++ b/de4dot.code/deobfuscators/MaxtoCode/CryptDecrypter.cs
@@ -93,7 +93,7 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			16,  7, 20, 21, 29, 12, 28, 17,
 			 1, 15, 23, 26,  5, 18, 31, 10,
 			 2,  8, 24, 14, 32, 27,  3,  9,
-			 19, 13, 30, 6, 22, 11, 4, 25,
+			19, 13, 30,  6, 22, 11,  4, 25,
 		};
 		static readonly byte[] esel = new byte[48] {
 			32,  1,  2,  3,  4,  5,  4,  5,
diff --git a/de4dot.code/deobfuscators/MaxtoCode/DecrypterInfo.cs b/de4dot.code/deobfuscators/MaxtoCode/DecrypterInfo.cs
index d15c2509..a92bb67a 100644
--- a/de4dot.code/deobfuscators/MaxtoCode/DecrypterInfo.cs
+++ b/de4dot.code/deobfuscators/MaxtoCode/DecrypterInfo.cs
@@ -21,7 +21,7 @@ using de4dot.PE;
 
 namespace de4dot.code.deobfuscators.MaxtoCode {
 	class DecrypterInfo {
-		public readonly MainType mainType;
+		public MainType mainType;
 		public readonly PeImage peImage;
 		public readonly PeHeader peHeader;
 		public readonly McKey mcKey;
diff --git a/de4dot.code/deobfuscators/MaxtoCode/Deobfuscator.cs b/de4dot.code/deobfuscators/MaxtoCode/Deobfuscator.cs
index b805bd6a..08358493 100644
--- a/de4dot.code/deobfuscators/MaxtoCode/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/MaxtoCode/Deobfuscator.cs
@@ -20,8 +20,8 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
-using Mono.Cecil;
-using Mono.MyStuff;
+using dot10.DotNet;
+using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.MaxtoCode {
 	public class DeobfuscatorInfo : DeobfuscatorInfoBase {
@@ -115,11 +115,12 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			return true;
 		}
 
-		public override IDeobfuscator moduleReloaded(ModuleDefinition module) {
+		public override IDeobfuscator moduleReloaded(ModuleDefMD module) {
 			var newOne = new Deobfuscator(options);
 			newOne.setModule(module);
 			newOne.mainType = new MainType(module, mainType);
 			newOne.decrypterInfo = decrypterInfo;
+			newOne.decrypterInfo.mainType = newOne.mainType;
 			return newOne;
 		}
 
@@ -137,7 +138,6 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			foreach (var method in mainType.InitMethods)
 				addCctorInitCallToBeRemoved(method);
 			addTypeToBeRemoved(mainType.Type, "Obfuscator type");
-			addModuleReferencesToBeRemoved(mainType.ModuleReferences, "MC runtime module reference");
 			removeDuplicateEmbeddedResources();
 		}
 
@@ -146,7 +146,7 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 				return Encoding.GetEncoding(cp);
 			}
 			catch {
-				Log.w("Invalid code page {0}!", cp);
+				Logger.w("Invalid code page {0}!", cp);
 				return Encoding.Default;
 			}
 		}
@@ -159,18 +159,22 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			}
 
 			public override int GetHashCode() {
-				return resource._GetHashCode();
+				int hash = 0;
+				hash ^= (int)resource.Data.Position;
+				hash ^= (int)resource.Data.Length;
+				return hash;
 			}
 
 			public override bool Equals(object obj) {
 				var other = obj as ResourceKey;
 				if (other == null)
 					return false;
-				return resource._Equals(other.resource);
+				return resource.Data.FileOffset == other.resource.Data.FileOffset &&
+					resource.Data.Length == other.resource.Data.Length;
 			}
 
 			public override string ToString() {
-				return resource.Name;
+				return resource.Name.String;
 			}
 		}
 
@@ -180,7 +184,7 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 				var rsrc = tmp as EmbeddedResource;
 				if (rsrc == null)
 					continue;
-				if (rsrc.Offset == null)
+				if (rsrc.Data.FileOffset == 0)
 					continue;
 				List<EmbeddedResource> list;
 				var key = new ResourceKey(rsrc);
@@ -195,7 +199,7 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 
 				EmbeddedResource resourceToKeep = null;
 				foreach (var rsrc in list) {
-					if (string.IsNullOrEmpty(rsrc.Name))
+					if (UTF8String.IsNullOrEmpty(rsrc.Name))
 						continue;
 
 					resourceToKeep = rsrc;
@@ -215,7 +219,7 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 		public override IEnumerable<int> getStringDecrypterMethods() {
 			var list = new List<int>();
 			if (stringDecrypter != null && stringDecrypter.Detected)
-				list.Add(stringDecrypter.Method.MetadataToken.ToInt32());
+				list.Add(stringDecrypter.Method.MDToken.ToInt32());
 			return list;
 		}
 	}
diff --git a/de4dot.code/deobfuscators/MaxtoCode/MainType.cs b/de4dot.code/deobfuscators/MaxtoCode/MainType.cs
index 8326503f..a39f62a2 100644
--- a/de4dot.code/deobfuscators/MaxtoCode/MainType.cs
+++ b/de4dot.code/deobfuscators/MaxtoCode/MainType.cs
@@ -19,38 +19,26 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.MaxtoCode {
 	class MainType {
-		ModuleDefinition module;
-		TypeDefinition mcType;
-		ModuleReference mcModule1, mcModule2;
+		ModuleDefMD module;
+		TypeDef mcType;
 		bool isOld;
 
 		public bool IsOld {
 			get { return isOld; }
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return mcType; }
 		}
 
-		public IEnumerable<ModuleReference> ModuleReferences {
+		public IEnumerable<MethodDef> InitMethods {
 			get {
-				var list = new List<ModuleReference>();
-				if (mcModule1 != null)
-					list.Add(mcModule1);
-				if (mcModule2 != null)
-					list.Add(mcModule2);
-				return list;
-			}
-		}
-
-		public IEnumerable<MethodDefinition> InitMethods {
-			get {
-				var list = new List<MethodDefinition>();
+				var list = new List<MethodDef>();
 				if (mcType == null)
 					return list;
 				foreach (var method in mcType.Methods) {
@@ -65,18 +53,16 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			get { return mcType != null; }
 		}
 
-		public MainType(ModuleDefinition module) {
+		public MainType(ModuleDefMD module) {
 			this.module = module;
 		}
 
-		public MainType(ModuleDefinition module, MainType oldOne) {
+		public MainType(ModuleDefMD module, MainType oldOne) {
 			this.module = module;
 			this.mcType = lookup(oldOne.mcType, "Could not find main type");
-			this.mcModule1 = DeobUtils.lookup(module, oldOne.mcModule1, "Could not find MC runtime module ref #1");
-			this.mcModule2 = DeobUtils.lookup(module, oldOne.mcModule2, "Could not find MC runtime module ref #2");
 		}
 
-		T lookup<T>(T def, string errorMessage) where T : MemberReference {
+		T lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
 			return DeobUtils.lookup(module, def, errorMessage);
 		}
 
@@ -87,21 +73,19 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			}
 		}
 
-		bool checkCctor(MethodDefinition cctor) {
+		bool checkCctor(MethodDef cctor) {
 			foreach (var method in DotNetUtils.getCalledMethods(module, cctor)) {
 				if (method.Name != "Startup")
 					continue;
 				if (!DotNetUtils.isMethod(method, "System.Void", "()"))
 					continue;
 
-				ModuleReference module1, module2;
+				ModuleRef module1, module2;
 				bool isOldTmp;
 				if (!checkType(method.DeclaringType, out module1, out module2, out isOldTmp))
 					continue;
 
 				mcType = method.DeclaringType;
-				mcModule1 = module1;
-				mcModule2 = module2;
 				isOld = isOldTmp;
 				return true;
 			}
@@ -109,11 +93,11 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			return false;
 		}
 
-		static bool checkType(TypeDefinition type, out ModuleReference module1, out ModuleReference module2, out bool isOld) {
+		static bool checkType(TypeDef type, out ModuleRef module1, out ModuleRef module2, out bool isOld) {
 			module1 = module2 = null;
 			isOld = false;
 
-			if (DotNetUtils.getMethod(type, "Startup") == null)
+			if (type.FindMethod("Startup") == null)
 				return false;
 
 			var pinvokes = getPinvokes(type);
@@ -126,27 +110,27 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			// Newer versions (3.4+ ???) also have GetModuleBase()
 			isOld = getPinvokeList(pinvokes, "GetModuleBase") == null;
 
-			module1 = pinvokeList[0].PInvokeInfo.Module;
-			module2 = pinvokeList[1].PInvokeInfo.Module;
+			module1 = pinvokeList[0].ImplMap.Module;
+			module2 = pinvokeList[1].ImplMap.Module;
 			return true;
 		}
 
-		static Dictionary<string, List<MethodDefinition>> getPinvokes(TypeDefinition type) {
-			var pinvokes = new Dictionary<string, List<MethodDefinition>>(StringComparer.Ordinal);
+		static Dictionary<string, List<MethodDef>> getPinvokes(TypeDef type) {
+			var pinvokes = new Dictionary<string, List<MethodDef>>(StringComparer.Ordinal);
 			foreach (var method in type.Methods) {
-				var info = method.PInvokeInfo;
-				if (info == null || info.EntryPoint == null)
+				var info = method.ImplMap;
+				if (info == null || UTF8String.IsNullOrEmpty(info.Name))
 					continue;
-				List<MethodDefinition> list;
-				if (!pinvokes.TryGetValue(info.EntryPoint, out list))
-					pinvokes[info.EntryPoint] = list = new List<MethodDefinition>();
+				List<MethodDef> list;
+				if (!pinvokes.TryGetValue(info.Name.String, out list))
+					pinvokes[info.Name.String] = list = new List<MethodDef>();
 				list.Add(method);
 			}
 			return pinvokes;
 		}
 
-		static List<MethodDefinition> getPinvokeList(Dictionary<string, List<MethodDefinition>> pinvokes, string methodName) {
-			List<MethodDefinition> list;
+		static List<MethodDef> getPinvokeList(Dictionary<string, List<MethodDef>> pinvokes, string methodName) {
+			List<MethodDef> list;
 			if (!pinvokes.TryGetValue(methodName, out list))
 				return null;
 			if (list.Count != 2)
diff --git a/de4dot.code/deobfuscators/MaxtoCode/MethodsDecrypter.cs b/de4dot.code/deobfuscators/MaxtoCode/MethodsDecrypter.cs
index e7d67b35..39f07e34 100644
--- a/de4dot.code/deobfuscators/MaxtoCode/MethodsDecrypter.cs
+++ b/de4dot.code/deobfuscators/MaxtoCode/MethodsDecrypter.cs
@@ -21,8 +21,8 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
-using Mono.MyStuff;
 using de4dot.PE;
+using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.MaxtoCode {
 	// Decrypts methods, resources and strings (#US heap)
@@ -106,7 +106,7 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 						return info.Version;
 				}
 
-				Log.w("Could not detect MC version. Magic2: {0:X8} {1:X8}", m2lo, m2hi);
+				Logger.w("Could not detect MC version. Magic2: {0:X8} {1:X8}", m2lo, m2hi);
 				return EncryptionVersion.Unknown;
 			}
 
@@ -482,6 +482,7 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 
 				var dm = new DumpedMethod();
 				dm.token = (uint)(0x06000001 + i);
+				dm.mdRVA = peImage.offsetRead(methodDefOffset + (uint)methodDef.fields[0].offset, methodDef.fields[0].size);
 				dm.mdImplFlags = peImage.offsetReadUInt16(methodDefOffset + (uint)methodDef.fields[1].offset);
 				dm.mdFlags = peImage.offsetReadUInt16(methodDefOffset + (uint)methodDef.fields[2].offset);
 				dm.mdName = peImage.offsetRead(methodDefOffset + (uint)methodDef.fields[3].offset, methodDef.fields[3].size);
@@ -530,10 +531,10 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 				return;
 			if (resourceRva != peImage.Cor20Header.resources.virtualAddress ||
 				resourceSize != peImage.Cor20Header.resources.size) {
-				Log.w("Invalid resource RVA and size found");
+				Logger.w("Invalid resource RVA and size found");
 			}
 
-			Log.v("Decrypting resources @ RVA {0:X8}, {1} bytes", resourceRva, resourceSize);
+			Logger.v("Decrypting resources @ RVA {0:X8}, {1} bytes", resourceRva, resourceSize);
 
 			int resourceOffset = (int)peImage.rvaToOffset(resourceRva);
 			for (int i = 0; i < resourceSize; i++)
@@ -554,11 +555,11 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			if (usHeap == null ||
 				peImage.rvaToOffset(usHeapRva) != usHeap.fileOffset ||
 				usHeapSize != usHeap.Length) {
-				Log.w("Invalid #US heap RVA and size found");
+				Logger.w("Invalid #US heap RVA and size found");
 			}
 
-			Log.v("Decrypting strings @ RVA {0:X8}, {1} bytes", usHeapRva, usHeapSize);
-			Log.indent();
+			Logger.v("Decrypting strings @ RVA {0:X8}, {1} bytes", usHeapRva, usHeapSize);
+			Logger.Instance.indent();
 
 			int mcKeyOffset = 0;
 			int usHeapOffset = (int)peImage.rvaToOffset(usHeapRva);
@@ -581,16 +582,16 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 				}
 
 				try {
-					Log.v("Decrypted string: {0}", Utils.toCsharpString(Encoding.Unicode.GetString(fileData, usHeapOffsetString, stringDataLength - 1)));
+					Logger.v("Decrypted string: {0}", Utils.toCsharpString(Encoding.Unicode.GetString(fileData, usHeapOffsetString, stringDataLength - 1)));
 				}
 				catch {
-					Log.v("Could not decrypt string at offset {0:X8}", usHeapOffsetOrig);
+					Logger.v("Could not decrypt string at offset {0:X8}", usHeapOffsetOrig);
 				}
 
 				usHeapOffset++;
 			}
 
-			Log.deIndent();
+			Logger.Instance.deIndent();
 		}
 
 		byte rolb(byte b, int n) {
diff --git a/de4dot.code/deobfuscators/MaxtoCode/StringDecrypter.cs b/de4dot.code/deobfuscators/MaxtoCode/StringDecrypter.cs
index 939d4cc6..512232ad 100644
--- a/de4dot.code/deobfuscators/MaxtoCode/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/MaxtoCode/StringDecrypter.cs
@@ -20,17 +20,17 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.MaxtoCode {
 	class StringDecrypter {
 		DecrypterInfo decrypterInfo;
-		MethodDefinition decryptMethod;
+		MethodDef decryptMethod;
 		string[] decryptedStrings;
 		Encoding encoding;
 
-		public MethodDefinition Method {
+		public MethodDef Method {
 			get { return decryptMethod; }
 		}
 
@@ -50,7 +50,7 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 				return;
 		}
 
-		static MethodDefinition findDecryptMethod(TypeDefinition type) {
+		static MethodDef findDecryptMethod(TypeDef type) {
 			if (type == null)
 				return null;
 			foreach (var method in type.Methods) {
diff --git a/de4dot.code/deobfuscators/MemberReferenceBuilder.cs b/de4dot.code/deobfuscators/MemberReferenceBuilder.cs
index 623945e0..6bcc8045 100644
--- a/de4dot.code/deobfuscators/MemberReferenceBuilder.cs
+++ b/de4dot.code/deobfuscators/MemberReferenceBuilder.cs
@@ -19,174 +19,165 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators {
 	class MemberReferenceBuilder {
-		ModuleDefinition module;
-		Dictionary<TypeReferenceKey, TypeReference> createdTypes = new Dictionary<TypeReferenceKey, TypeReference>();
+		ModuleDefMD module;
+		Dictionary<TypeSig, TypeSig> createdTypes = new Dictionary<TypeSig, TypeSig>(TypeEqualityComparer.Instance);
 
-		public MemberReferenceBuilder(ModuleDefinition module) {
+		public MemberReferenceBuilder(ModuleDefMD module) {
 			this.module = module;
 		}
 
-		public IMetadataScope CorLib {
-			get { return module.TypeSystem.Corlib; }
+		public AssemblyRef CorLib {
+			get { return module.CorLibTypes.AssemblyRef; }
 		}
 
-		public TypeReference Object {
-			get { return module.TypeSystem.Object; }
+		public CorLibTypeSig Object {
+			get { return module.CorLibTypes.Object; }
 		}
 
-		public TypeReference Void {
-			get { return module.TypeSystem.Void; }
+		public CorLibTypeSig Void {
+			get { return module.CorLibTypes.Void; }
 		}
 
-		public TypeReference Boolean {
-			get { return module.TypeSystem.Boolean; }
+		public CorLibTypeSig Boolean {
+			get { return module.CorLibTypes.Boolean; }
 		}
 
-		public TypeReference Char {
-			get { return module.TypeSystem.Char; }
+		public CorLibTypeSig Char {
+			get { return module.CorLibTypes.Char; }
 		}
 
-		public TypeReference SByte {
-			get { return module.TypeSystem.SByte; }
+		public CorLibTypeSig SByte {
+			get { return module.CorLibTypes.SByte; }
 		}
 
-		public TypeReference Byte {
-			get { return module.TypeSystem.Byte; }
+		public CorLibTypeSig Byte {
+			get { return module.CorLibTypes.Byte; }
 		}
 
-		public TypeReference Int16 {
-			get { return module.TypeSystem.Int16; }
+		public CorLibTypeSig Int16 {
+			get { return module.CorLibTypes.Int16; }
 		}
 
-		public TypeReference UInt16 {
-			get { return module.TypeSystem.UInt16; }
+		public CorLibTypeSig UInt16 {
+			get { return module.CorLibTypes.UInt16; }
 		}
 
-		public TypeReference Int32 {
-			get { return module.TypeSystem.Int32; }
+		public CorLibTypeSig Int32 {
+			get { return module.CorLibTypes.Int32; }
 		}
 
-		public TypeReference UInt32 {
-			get { return module.TypeSystem.UInt32; }
+		public CorLibTypeSig UInt32 {
+			get { return module.CorLibTypes.UInt32; }
 		}
 
-		public TypeReference Int64 {
-			get { return module.TypeSystem.Int64; }
+		public CorLibTypeSig Int64 {
+			get { return module.CorLibTypes.Int64; }
 		}
 
-		public TypeReference UInt64 {
-			get { return module.TypeSystem.UInt64; }
+		public CorLibTypeSig UInt64 {
+			get { return module.CorLibTypes.UInt64; }
 		}
 
-		public TypeReference Single {
-			get { return module.TypeSystem.Single; }
+		public CorLibTypeSig Single {
+			get { return module.CorLibTypes.Single; }
 		}
 
-		public TypeReference Double {
-			get { return module.TypeSystem.Double; }
+		public CorLibTypeSig Double {
+			get { return module.CorLibTypes.Double; }
 		}
 
-		public TypeReference IntPtr {
-			get { return module.TypeSystem.IntPtr; }
+		public CorLibTypeSig IntPtr {
+			get { return module.CorLibTypes.IntPtr; }
 		}
 
-		public TypeReference UIntPtr {
-			get { return module.TypeSystem.UIntPtr; }
+		public CorLibTypeSig UIntPtr {
+			get { return module.CorLibTypes.UIntPtr; }
 		}
 
-		public TypeReference String {
-			get { return module.TypeSystem.String; }
+		public CorLibTypeSig String {
+			get { return module.CorLibTypes.String; }
 		}
 
-		public TypeReference TypedReference {
-			get { return module.TypeSystem.TypedReference; }
+		public CorLibTypeSig TypedReference {
+			get { return module.CorLibTypes.TypedReference; }
 		}
 
-		public TypeReference type(string ns, string name, string asmSimpleName) {
+		public ClassSig type(string ns, string name, string asmSimpleName) {
 			return type(ns, name, findAssemblyReference(asmSimpleName));
 		}
 
-		public TypeReference type(string ns, string name) {
+		public ClassSig type(string ns, string name) {
 			return type(ns, name, CorLib);
 		}
 
-		public TypeReference type(string ns, string name, IMetadataScope asmRef) {
-			return type(false, ns, name, asmRef);
+		public ClassSig type(string ns, string name, AssemblyRef asmRef) {
+			return (ClassSig)type(false, ns, name, asmRef);
 		}
 
-		public TypeReference valueType(string ns, string name, string asmSimpleName) {
+		public ValueTypeSig valueType(string ns, string name, string asmSimpleName) {
 			return valueType(ns, name, findAssemblyReference(asmSimpleName));
 		}
 
-		public TypeReference valueType(string ns, string name) {
+		public ValueTypeSig valueType(string ns, string name) {
 			return valueType(ns, name, CorLib);
 		}
 
-		public TypeReference valueType(string ns, string name, IMetadataScope asmRef) {
-			return type(true, ns, name, asmRef);
+		public ValueTypeSig valueType(string ns, string name, AssemblyRef asmRef) {
+			return (ValueTypeSig)type(true, ns, name, asmRef);
 		}
 
-		public TypeReference type(bool isValueType, string ns, string name, IMetadataScope asmRef) {
-			var typeRef = new TypeReference(ns, name, module, asmRef);
-			typeRef.IsValueType = isValueType;
-			return add(isValueType, typeRef);
+		public ClassOrValueTypeSig type(bool isValueType, string ns, string name, IResolutionScope resolutionScope) {
+			var typeRef = module.UpdateRowId(new TypeRefUser(module, ns, name, resolutionScope));
+			ClassOrValueTypeSig type;
+			if (isValueType)
+				type = new ValueTypeSig(typeRef);
+			else
+				type = new ClassSig(typeRef);
+			return (ClassOrValueTypeSig)add(type);
 		}
 
-		public TypeReference array(TypeReference typeRef) {
-			return add(false, new ArrayType(typeRef));
+		public ArraySig array(TypeSig typeRef) {
+			return (ArraySig)add(new ArraySig(typeRef));
 		}
 
-		TypeReference add(bool isValueType, TypeReference typeRef) {
-			var key = new TypeReferenceKey(typeRef);
-			TypeReference createdTypeRef;
-			if (createdTypes.TryGetValue(key, out createdTypeRef)) {
-				if (createdTypeRef.IsValueType != isValueType)
+		TypeSig add(TypeSig typeRef) {
+			TypeSig createdTypeRef;
+			if (createdTypes.TryGetValue(typeRef, out createdTypeRef)) {
+				if (createdTypeRef.ElementType != typeRef.ElementType)
 					throw new ApplicationException(string.Format("Type {0}'s IsValueType is not correct", createdTypeRef));
 				return createdTypeRef;
 			}
-			createdTypes[key] = typeRef;
+			createdTypes[typeRef] = typeRef;
 			return typeRef;
 		}
 
-		public MethodReference instanceMethod(string name, TypeReference declaringType, TypeReference returnType, params TypeReference[] args) {
+		public MemberRef instanceMethod(string name, IMemberRefParent declaringType, TypeSig returnType, params TypeSig[] args) {
 			return method(true, name, declaringType, returnType, args);
 		}
 
-		public MethodReference staticMethod(string name, TypeReference declaringType, TypeReference returnType, params TypeReference[] args) {
+		public MemberRef staticMethod(string name, IMemberRefParent declaringType, TypeSig returnType, params TypeSig[] args) {
 			return method(false, name, declaringType, returnType, args);
 		}
 
-		public MethodReference method(bool isInstance, string name, TypeReference declaringType, TypeReference returnType, params TypeReference[] args) {
-			var method = new MethodReference(name, returnType, declaringType);
-			method.HasThis = isInstance;
-			foreach (var arg in args)
-				method.Parameters.Add(new ParameterDefinition(arg));
-			return method;
+		public MemberRef method(bool isInstance, string name, IMemberRefParent declaringType, TypeSig returnType, params TypeSig[] args) {
+			MethodSig sig;
+			if (isInstance)
+				sig = MethodSig.CreateInstance(returnType, args);
+			else
+				sig = MethodSig.CreateStatic(returnType, args);
+			return module.UpdateRowId(new MemberRefUser(module, name, sig, declaringType));
 		}
 
-		AssemblyNameReference findAssemblyReference(string asmSimpleName) {
-			AssemblyNameReference asmRef = null;
-			foreach (var asmRef2 in findAssemblyReferences(asmSimpleName)) {
-				if (asmRef == null || asmRef.Version == null || (asmRef2.Version != null && asmRef2.Version > asmRef.Version))
-					asmRef = asmRef2;
-			}
+		AssemblyRef findAssemblyReference(string asmSimpleName) {
+			var asmRef = module.GetAssemblyRef(asmSimpleName);
 			if (asmRef == null)
 				throw new ApplicationException(string.Format("Could not find assembly {0} in assembly references", asmSimpleName));
 			return asmRef;
 		}
-
-		List<AssemblyNameReference> findAssemblyReferences(string asmSimpleName) {
-			var asmRefs = new List<AssemblyNameReference>();
-			foreach (var asmRef in module.AssemblyReferences) {
-				if (asmRef.Name == asmSimpleName)
-					asmRefs.Add(asmRef);
-			}
-			return asmRefs;
-		}
 	}
 }
diff --git a/de4dot.code/deobfuscators/MethodBodyReaderBase.cs b/de4dot.code/deobfuscators/MethodBodyReaderBase.cs
deleted file mode 100644
index 7c3fe0ea..00000000
--- a/de4dot.code/deobfuscators/MethodBodyReaderBase.cs
+++ /dev/null
@@ -1,279 +0,0 @@
-/*
-    Copyright (C) 2011-2012 de4dot@gmail.com
-
-    This file is part of de4dot.
-
-    de4dot is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    de4dot is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-using System;
-using System.Collections.Generic;
-using System.IO;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using de4dot.blocks;
-
-namespace de4dot.code.deobfuscators {
-	abstract class MethodBodyReaderBase {
-		protected BinaryReader reader;
-		public IList<VariableDefinition> Locals { get; set; }
-		public IList<Instruction> Instructions { get; set; }
-		public IList<ExceptionHandler> ExceptionHandlers { get; set; }
-		protected IList<ParameterDefinition> parameters;
-		int currentOffset;
-
-		public MethodBodyReaderBase(BinaryReader reader) {
-			this.reader = reader;
-		}
-
-		protected void setLocals(IList<TypeReference> types) {
-			Locals = new List<VariableDefinition>(types.Count);
-			foreach (var type in types)
-				Locals.Add(new VariableDefinition(type));
-		}
-
-		protected void readInstructions(int numInstrs) {
-			Instructions = new Instruction[numInstrs];
-			currentOffset = 0;
-			for (int i = 0; i < Instructions.Count; i++)
-				Instructions[i] = readOneInstruction();
-			fixBranches();
-		}
-
-		protected void readInstructionsNumBytes(uint codeSize) {
-			var instrs = new List<Instruction>();
-			long endOffs = reader.BaseStream.Position + codeSize;
-			while (reader.BaseStream.Position < endOffs)
-				instrs.Add(readOneInstruction());
-			if (reader.BaseStream.Position != endOffs)
-				throw new ApplicationException("Could not read all instructions");
-			Instructions = instrs;
-			fixBranches();
-		}
-
-		Instruction readOneInstruction() {
-			var instr = readInstruction();
-			if (instr.OpCode.Code == Code.Switch) {
-				int[] targets = (int[])instr.Operand;
-				currentOffset += instr.OpCode.Size + 4 + 4 * targets.Length;
-			}
-			else
-				currentOffset += instr.GetSize();
-			return instr;
-		}
-
-		void fixBranches() {
-			foreach (var instr in Instructions) {
-				switch (instr.OpCode.OperandType) {
-				case OperandType.InlineBrTarget:
-				case OperandType.ShortInlineBrTarget:
-					instr.Operand = getInstruction((int)instr.Operand);
-					break;
-
-				case OperandType.InlineSwitch:
-					var intTargets = (int[])instr.Operand;
-					var targets = new Instruction[intTargets.Length];
-					for (int i = 0; i < intTargets.Length; i++)
-						targets[i] = getInstruction(intTargets[i]);
-					instr.Operand = targets;
-					break;
-				}
-			}
-		}
-
-		protected Instruction getInstructionOrNull(int offset) {
-			foreach (var instr in Instructions) {
-				if (instr.Offset == offset)
-					return instr;
-			}
-			return null;
-		}
-
-		protected Instruction getInstruction(int offset) {
-			var instr = getInstructionOrNull(offset);
-			if (instr != null)
-				return instr;
-			throw new ApplicationException(string.Format("No instruction found at offset {0:X4}", offset));
-		}
-
-		Instruction readInstruction() {
-			int offset = currentOffset;
-			var opcode = readOpCode();
-			var instr = new Instruction {
-				OpCode = opcode,
-				Offset = offset,
-			};
-			instr.Operand = readOperand(instr);
-			return instr;
-		}
-
-		object readOperand(Instruction instr) {
-			switch (instr.OpCode.OperandType) {
-			case OperandType.InlineBrTarget:
-				return readInlineBrTarget(instr);
-			case OperandType.InlineField:
-				return readInlineField(instr);
-			case OperandType.InlineI:
-				return readInlineI(instr);
-			case OperandType.InlineI8:
-				return readInlineI8(instr);
-			case OperandType.InlineMethod:
-				return readInlineMethod(instr);
-			case OperandType.InlineNone:
-				return readInlineNone(instr);
-			case OperandType.InlinePhi:
-				return readInlinePhi(instr);
-			case OperandType.InlineR:
-				return readInlineR(instr);
-			case OperandType.InlineSig:
-				return readInlineSig(instr);
-			case OperandType.InlineString:
-				return readInlineString(instr);
-			case OperandType.InlineSwitch:
-				return readInlineSwitch(instr);
-			case OperandType.InlineTok:
-				return readInlineTok(instr);
-			case OperandType.InlineType:
-				return readInlineType(instr);
-			case OperandType.InlineVar:
-				return readInlineVar(instr);
-			case OperandType.InlineArg:
-				return readInlineArg(instr);
-			case OperandType.ShortInlineBrTarget:
-				return readShortInlineBrTarget(instr);
-			case OperandType.ShortInlineI:
-				return readShortInlineI(instr);
-			case OperandType.ShortInlineR:
-				return readShortInlineR(instr);
-			case OperandType.ShortInlineVar:
-				return readShortInlineVar(instr);
-			case OperandType.ShortInlineArg:
-				return readShortInlineArg(instr);
-			default:
-				throw new ApplicationException(string.Format("Unknown operand type {0}", instr.OpCode.OperandType));
-			}
-		}
-
-		protected virtual int readInlineBrTarget(Instruction instr) {
-			return currentOffset + instr.GetSize() + reader.ReadInt32();
-		}
-
-		protected abstract FieldReference readInlineField(Instruction instr);
-
-		protected virtual int readInlineI(Instruction instr) {
-			return reader.ReadInt32();
-		}
-
-		protected virtual long readInlineI8(Instruction instr) {
-			return reader.ReadInt64();
-		}
-
-		protected abstract MethodReference readInlineMethod(Instruction instr);
-
-		protected virtual object readInlineNone(Instruction instr) {
-			return null;
-		}
-
-		protected virtual object readInlinePhi(Instruction instr) {
-			return null;
-		}
-
-		protected virtual double readInlineR(Instruction instr) {
-			return reader.ReadDouble();
-		}
-
-		protected abstract CallSite readInlineSig(Instruction instr);
-
-		protected abstract string readInlineString(Instruction instr);
-
-		protected virtual int[] readInlineSwitch(Instruction instr) {
-			var targets = new int[reader.ReadInt32()];
-			int offset = currentOffset + instr.OpCode.Size + 4 + 4 * targets.Length;
-			for (int i = 0; i < targets.Length; i++)
-				targets[i] = offset + reader.ReadInt32();
-			return targets;
-		}
-
-		protected abstract MemberReference readInlineTok(Instruction instr);
-
-		protected abstract TypeReference readInlineType(Instruction instr);
-
-		protected virtual VariableDefinition readInlineVar(Instruction instr) {
-			return Locals[reader.ReadUInt16()];
-		}
-
-		protected virtual ParameterDefinition readInlineArg(Instruction instr) {
-			return parameters[reader.ReadUInt16()];
-		}
-
-		protected virtual int readShortInlineBrTarget(Instruction instr) {
-			return currentOffset + instr.GetSize() + reader.ReadSByte();
-		}
-
-		protected virtual object readShortInlineI(Instruction instr) {
-			if (instr.OpCode.Code == Code.Ldc_I4_S)
-				return reader.ReadSByte();
-			return reader.ReadByte();
-		}
-
-		protected virtual float readShortInlineR(Instruction instr) {
-			return reader.ReadSingle();
-		}
-
-		protected virtual VariableDefinition readShortInlineVar(Instruction instr) {
-			return Locals[reader.ReadByte()];
-		}
-
-		protected virtual ParameterDefinition readShortInlineArg(Instruction instr) {
-			return parameters[reader.ReadByte()];
-		}
-
-		OpCode readOpCode() {
-			var op = reader.ReadByte();
-			if (op != 0xFE)
-				return OpCodes.OneByteOpCode[op];
-			return OpCodes.TwoBytesOpCode[reader.ReadByte()];
-		}
-
-		protected void readExceptionHandlers(int numExceptionHandlers) {
-			ExceptionHandlers = new ExceptionHandler[numExceptionHandlers];
-			for (int i = 0; i < ExceptionHandlers.Count; i++)
-				ExceptionHandlers[i] = readExceptionHandler();
-		}
-
-		protected abstract ExceptionHandler readExceptionHandler();
-
-		public virtual void restoreMethod(MethodDefinition method) {
-			var body = method.Body;
-
-			body.Variables.Clear();
-			if (Locals != null) {
-				foreach (var local in Locals)
-					body.Variables.Add(local);
-			}
-
-			body.Instructions.Clear();
-			if (Instructions != null) {
-				foreach (var instr in Instructions)
-					body.Instructions.Add(instr);
-			}
-
-			body.ExceptionHandlers.Clear();
-			if (ExceptionHandlers != null) {
-				foreach (var eh in ExceptionHandlers)
-					body.ExceptionHandlers.Add(eh);
-			}
-		}
-	}
-}
diff --git a/de4dot.code/deobfuscators/MethodCallRestorerBase.cs b/de4dot.code/deobfuscators/MethodCallRestorerBase.cs
index 6fd39010..011f80e4 100644
--- a/de4dot.code/deobfuscators/MethodCallRestorerBase.cs
+++ b/de4dot.code/deobfuscators/MethodCallRestorerBase.cs
@@ -18,82 +18,82 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators {
 	class MethodCallRestorerBase {
 		protected MemberReferenceBuilder builder;
-		protected ModuleDefinition module;
+		protected ModuleDefMD module;
 		MethodDefinitionAndDeclaringTypeDict<NewMethodInfo> oldToNewMethod = new MethodDefinitionAndDeclaringTypeDict<NewMethodInfo>();
 
 		class NewMethodInfo {
 			public OpCode opCode;
-			public MethodReference method;
+			public IMethod method;
 
-			public NewMethodInfo(OpCode opCode, MethodReference method) {
+			public NewMethodInfo(OpCode opCode, IMethod method) {
 				this.opCode = opCode;
 				this.method = method;
 			}
 		}
 
-		public MethodCallRestorerBase(ModuleDefinition module) {
+		public MethodCallRestorerBase(ModuleDefMD module) {
 			this.module = module;
 			this.builder = new MemberReferenceBuilder(module);
 		}
 
-		public void createGetManifestResourceStream1(MethodDefinition oldMethod) {
+		public void createGetManifestResourceStream1(MethodDef oldMethod) {
 			if (oldMethod == null)
 				return;
 			var assemblyType = builder.type("System.Reflection", "Assembly", builder.CorLib);
 			var streamType = builder.type("System.IO", "Stream", builder.CorLib);
-			var newMethod = builder.instanceMethod("GetManifestResourceStream", assemblyType, streamType, builder.String);
+			var newMethod = builder.instanceMethod("GetManifestResourceStream", assemblyType.TypeDefOrRef, streamType, builder.String);
 			add(oldMethod, newMethod, OpCodes.Callvirt);
 		}
 
-		public void createGetManifestResourceStream2(MethodDefinition oldMethod) {
+		public void createGetManifestResourceStream2(MethodDef oldMethod) {
 			if (oldMethod == null)
 				return;
 			var assemblyType = builder.type("System.Reflection", "Assembly", builder.CorLib);
 			var typeType = builder.type("System", "Type", builder.CorLib);
 			var streamType = builder.type("System.IO", "Stream", builder.CorLib);
-			var newMethod = builder.instanceMethod("GetManifestResourceStream", assemblyType, streamType, typeType, builder.String);
+			var newMethod = builder.instanceMethod("GetManifestResourceStream", assemblyType.TypeDefOrRef, streamType, typeType, builder.String);
 			add(oldMethod, newMethod, OpCodes.Callvirt);
 		}
 
-		public void createGetManifestResourceNames(MethodDefinition oldMethod) {
+		public void createGetManifestResourceNames(MethodDef oldMethod) {
 			if (oldMethod == null)
 				return;
 			var assemblyType = builder.type("System.Reflection", "Assembly", builder.CorLib);
 			var stringArrayType = builder.array(builder.String);
-			var newMethod = builder.instanceMethod("GetManifestResourceNames", assemblyType, stringArrayType);
+			var newMethod = builder.instanceMethod("GetManifestResourceNames", assemblyType.TypeDefOrRef, stringArrayType);
 			add(oldMethod, newMethod, OpCodes.Callvirt);
 		}
 
-		public void createBitmapCtor(MethodDefinition oldMethod) {
+		public void createBitmapCtor(MethodDef oldMethod) {
 			if (oldMethod == null)
 				return;
 			var bitmapType = builder.type("System.Drawing", "Bitmap", "System.Drawing");
 			var typeType = builder.type("System", "Type", builder.CorLib);
-			var newMethod = builder.instanceMethod(".ctor", bitmapType, builder.Void, typeType, builder.String);
+			var newMethod = builder.instanceMethod(".ctor", bitmapType.TypeDefOrRef, builder.Void, typeType, builder.String);
 			add(oldMethod, newMethod, OpCodes.Newobj);
 		}
 
-		public void createIconCtor(MethodDefinition oldMethod) {
+		public void createIconCtor(MethodDef oldMethod) {
 			if (oldMethod == null)
 				return;
 			var iconType = builder.type("System.Drawing", "Icon", "System.Drawing");
 			var typeType = builder.type("System", "Type", builder.CorLib);
-			var newMethod = builder.instanceMethod(".ctor", iconType, builder.Void, typeType, builder.String);
+			var newMethod = builder.instanceMethod(".ctor", iconType.TypeDefOrRef, builder.Void, typeType, builder.String);
 			add(oldMethod, newMethod, OpCodes.Newobj);
 		}
 
-		protected void add(MethodDefinition oldMethod, MethodReference newMethod) {
+		protected void add(MethodDef oldMethod, IMethod newMethod) {
 			add(oldMethod, newMethod, OpCodes.Callvirt);
 		}
 
-		protected void add(MethodDefinition oldMethod, MethodReference newMethod, OpCode opCode) {
+		protected void add(MethodDef oldMethod, IMethod newMethod, OpCode opCode) {
 			if (oldMethod == null)
 				return;
 			oldToNewMethod.add(oldMethod, new NewMethodInfo(opCode, newMethod));
@@ -106,7 +106,7 @@ namespace de4dot.code.deobfuscators {
 					var call = instrs[i];
 					if (call.OpCode.Code != Code.Call)
 						continue;
-					var calledMethod = call.Operand as MethodDefinition;
+					var calledMethod = call.Operand as MethodDef;
 					if (calledMethod == null)
 						continue;
 
diff --git a/de4dot.code/deobfuscators/MethodCollection.cs b/de4dot.code/deobfuscators/MethodCollection.cs
index 99b558cc..2b2e2b26 100644
--- a/de4dot.code/deobfuscators/MethodCollection.cs
+++ b/de4dot.code/deobfuscators/MethodCollection.cs
@@ -18,7 +18,7 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators {
@@ -26,7 +26,7 @@ namespace de4dot.code.deobfuscators {
 		TypeDefinitionDict<bool> types = new TypeDefinitionDict<bool>();
 		MethodDefinitionAndDeclaringTypeDict<bool> methods = new MethodDefinitionAndDeclaringTypeDict<bool>();
 
-		public bool exists(MethodReference method) {
+		public bool exists(IMethod method) {
 			if (method == null)
 				return false;
 			if (method.DeclaringType != null && types.find(method.DeclaringType))
@@ -34,26 +34,27 @@ namespace de4dot.code.deobfuscators {
 			return methods.find(method);
 		}
 
-		public void add(MethodDefinition method) {
+		public void add(MethodDef method) {
 			methods.add(method, true);
 		}
 
-		public void add(IEnumerable<MethodDefinition> methods) {
+		public void add(IEnumerable<MethodDef> methods) {
 			foreach (var method in methods)
 				add(method);
 		}
 
-		public void add(TypeDefinition type) {
+		public void add(TypeDef type) {
 			types.add(type, true);
 		}
 
-		public void addAndNested(TypeDefinition type) {
-			foreach (var t in TypeDefinition.GetTypes(new List<TypeDefinition> { type }))
-				add(type);
+		public void addAndNested(TypeDef type) {
+			add(type);
+			foreach (var t in type.GetTypes())
+				add(t);
 		}
 
-		public void addAndNested(IList<TypeDefinition> types) {
-			foreach (var type in TypeDefinition.GetTypes(types))
+		public void addAndNested(IList<TypeDef> types) {
+			foreach (var type in AllTypesHelper.Types(types))
 				add(type);
 		}
 	}
diff --git a/de4dot.code/deobfuscators/MethodStack.cs b/de4dot.code/deobfuscators/MethodStack.cs
index e4280bbb..8b853e32 100644
--- a/de4dot.code/deobfuscators/MethodStack.cs
+++ b/de4dot.code/deobfuscators/MethodStack.cs
@@ -18,8 +18,8 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators {
@@ -79,7 +79,7 @@ namespace de4dot.code.deobfuscators {
 		public static PushedArgs getPushedArgInstructions(IList<Instruction> instructions, int index) {
 			try {
 				int pushes, pops;
-				DotNetUtils.calculateStackUsage(instructions[index], false, out pushes, out pops);
+				instructions[index].CalculateStackUsage(false, out pushes, out pops);
 				if (pops != -1)
 					return getPushedArgInstructions(instructions, index, pops);
 			}
@@ -101,7 +101,7 @@ namespace de4dot.code.deobfuscators {
 					break;
 
 				int pushes, pops;
-				DotNetUtils.calculateStackUsage(instr, false, out pushes, out pops);
+				instr.CalculateStackUsage(false, out pushes, out pops);
 				if (pops == -1)
 					break;
 				if (instr.OpCode.Code == Code.Dup) {
@@ -128,7 +128,7 @@ namespace de4dot.code.deobfuscators {
 				instr = getPreviousInstruction(instructions, ref index);
 				if (instr != null) {
 					int pushes, pops;
-					DotNetUtils.calculateStackUsage(instr, false, out pushes, out pops);
+					instr.CalculateStackUsage(false, out pushes, out pops);
 					if (pushes == 1 && pops == 0)
 						pushedArgs.set(0, instr);
 				}
@@ -138,96 +138,97 @@ namespace de4dot.code.deobfuscators {
 			return pushedArgs;
 		}
 
-		public static TypeReference getLoadedType(MethodDefinition method, IList<Instruction> instructions, int instrIndex) {
+		public static TypeSig getLoadedType(MethodDef method, IList<Instruction> instructions, int instrIndex) {
 			bool wasNewobj;
 			return getLoadedType(method, instructions, instrIndex, 0, out wasNewobj);
 		}
 
-		public static TypeReference getLoadedType(MethodDefinition method, IList<Instruction> instructions, int instrIndex, int argIndexFromEnd) {
+		public static TypeSig getLoadedType(MethodDef method, IList<Instruction> instructions, int instrIndex, int argIndexFromEnd) {
 			bool wasNewobj;
 			return getLoadedType(method, instructions, instrIndex, argIndexFromEnd, out wasNewobj);
 		}
 
-		public static TypeReference getLoadedType(MethodDefinition method, IList<Instruction> instructions, int instrIndex, out bool wasNewobj) {
+		public static TypeSig getLoadedType(MethodDef method, IList<Instruction> instructions, int instrIndex, out bool wasNewobj) {
 			return getLoadedType(method, instructions, instrIndex, 0, out wasNewobj);
 		}
 
-		public static TypeReference getLoadedType(MethodDefinition method, IList<Instruction> instructions, int instrIndex, int argIndexFromEnd, out bool wasNewobj) {
+		public static TypeSig getLoadedType(MethodDef method, IList<Instruction> instructions, int instrIndex, int argIndexFromEnd, out bool wasNewobj) {
 			wasNewobj = false;
 			var pushedArgs = MethodStack.getPushedArgInstructions(instructions, instrIndex);
 			var pushInstr = pushedArgs.getEnd(argIndexFromEnd);
 			if (pushInstr == null)
 				return null;
 
-			TypeReference type;
-			VariableDefinition local;
+			TypeSig type;
+			Local local;
+			var corLibTypes = method.DeclaringType.Module.CorLibTypes;
 			switch (pushInstr.OpCode.Code) {
 			case Code.Ldstr:
-				type = method.Module.TypeSystem.String;
+				type = corLibTypes.String;
 				break;
 
 			case Code.Conv_I:
 			case Code.Conv_Ovf_I:
 			case Code.Conv_Ovf_I_Un:
-				type = method.Module.TypeSystem.IntPtr;
+				type = corLibTypes.IntPtr;
 				break;
 
 			case Code.Conv_U:
 			case Code.Conv_Ovf_U:
 			case Code.Conv_Ovf_U_Un:
-				type = method.Module.TypeSystem.UIntPtr;
+				type = corLibTypes.UIntPtr;
 				break;
 
 			case Code.Conv_I8:
 			case Code.Conv_Ovf_I8:
 			case Code.Conv_Ovf_I8_Un:
-				type = method.Module.TypeSystem.Int64;
+				type = corLibTypes.Int64;
 				break;
 
 			case Code.Conv_U8:
 			case Code.Conv_Ovf_U8:
 			case Code.Conv_Ovf_U8_Un:
-				type = method.Module.TypeSystem.UInt64;
+				type = corLibTypes.UInt64;
 				break;
 
 			case Code.Conv_R8:
 			case Code.Ldc_R8:
 			case Code.Ldelem_R8:
 			case Code.Ldind_R8:
-				type = method.Module.TypeSystem.Double;
+				type = corLibTypes.Double;
 				break;
 
 			case Code.Call:
 			case Code.Calli:
 			case Code.Callvirt:
-				var calledMethod = pushInstr.Operand as MethodReference;
+				var calledMethod = pushInstr.Operand as IMethod;
 				if (calledMethod == null)
 					return null;
-				type = calledMethod.MethodReturnType.ReturnType;
+				type = calledMethod.MethodSig.GetRetType();
 				break;
 
 			case Code.Newarr:
-				type = pushInstr.Operand as TypeReference;
-				if (type == null)
+				var type2 = pushInstr.Operand as ITypeDefOrRef;
+				if (type2 == null)
 					return null;
-				type = new ArrayType(type);
+				type = new SZArraySig(type2.ToTypeSig());
 				wasNewobj = true;
 				break;
 
 			case Code.Newobj:
-				var ctor = pushInstr.Operand as MethodReference;
+				var ctor = pushInstr.Operand as IMethod;
 				if (ctor == null)
 					return null;
-				type = ctor.DeclaringType;
+				type = ctor.DeclaringType.ToTypeSig();
 				wasNewobj = true;
 				break;
 
 			case Code.Castclass:
 			case Code.Isinst:
 			case Code.Unbox_Any:
-			case Code.Ldelem_Any:
+			case Code.Ldelem:
 			case Code.Ldobj:
-				type = pushInstr.Operand as TypeReference;
+				type = (pushInstr.Operand as ITypeDefOrRef).ToTypeSig();
 				break;
 
 			case Code.Ldarg:
@@ -236,7 +237,7 @@ namespace de4dot.code.deobfuscators {
 			case Code.Ldarg_1:
 			case Code.Ldarg_2:
 			case Code.Ldarg_3:
-				type = DotNetUtils.getArgType(method, pushInstr);
+				type = pushInstr.GetArgumentType(method.MethodSig, method.DeclaringType);
 				break;
 
 			case Code.Ldloc:
@@ -245,44 +246,44 @@ namespace de4dot.code.deobfuscators {
 			case Code.Ldloc_1:
 			case Code.Ldloc_2:
 			case Code.Ldloc_3:
-				local = DotNetUtils.getLocalVar(method.Body.Variables, pushInstr);
+				local = pushInstr.GetLocal(method.Body.LocalList);
 				if (local == null)
 					return null;
-				type = local.VariableType;
+				type = local.Type.RemovePinned();
 				break;
 
 			case Code.Ldloca:
 			case Code.Ldloca_S:
-				local = pushInstr.Operand as VariableDefinition;
+				local = pushInstr.Operand as Local;
 				if (local == null)
 					return null;
-				type = createByReferenceType(local.VariableType);
+				type = createByReferenceType(local.Type.RemovePinned());
 				break;
 
 			case Code.Ldarga:
 			case Code.Ldarga_S:
-				type = createByReferenceType(DotNetUtils.getArgType(method, pushInstr));
+				type = createByReferenceType(pushInstr.GetArgumentType(method.MethodSig, method.DeclaringType));
 				break;
 
 			case Code.Ldfld:
 			case Code.Ldsfld:
-				var field = pushInstr.Operand as FieldReference;
-				if (field == null)
+				var field = pushInstr.Operand as IField;
+				if (field == null || field.FieldSig == null)
 					return null;
-				type = field.FieldType;
+				type = field.FieldSig.GetFieldType();
 				break;
 
 			case Code.Ldflda:
 			case Code.Ldsflda:
-				var field2 = pushInstr.Operand as FieldReference;
-				if (field2 == null)
+				var field2 = pushInstr.Operand as IField;
+				if (field2 == null || field2.FieldSig == null)
 					return null;
-				type = createByReferenceType(field2.FieldType);
+				type = createByReferenceType(field2.FieldSig.GetFieldType());
 				break;
 
 			case Code.Ldelema:
 			case Code.Unbox:
-				type = createByReferenceType(pushInstr.Operand as TypeReference);
+				type = createByReferenceType(pushInstr.Operand as ITypeDefOrRef);
 				break;
 
 			default:
@@ -292,10 +293,16 @@ namespace de4dot.code.deobfuscators {
 			return type;
 		}
 
-		static ByReferenceType createByReferenceType(TypeReference elementType) {
+		static ByRefSig createByReferenceType(ITypeDefOrRef elementType) {
 			if (elementType == null)
 				return null;
-			return new ByReferenceType(elementType);
+			return new ByRefSig(elementType.ToTypeSig());
+		}
+
+		static ByRefSig createByReferenceType(TypeSig elementType) {
+			if (elementType == null)
+				return null;
+			return new ByRefSig(elementType);
 		}
 
 		static Instruction getPreviousInstruction(IList<Instruction> instructions, ref int instrIndex) {
diff --git a/de4dot.code/deobfuscators/MethodsDecrypter.cs b/de4dot.code/deobfuscators/MethodsDecrypter.cs
index 82441ff7..8c520f54 100644
--- a/de4dot.code/deobfuscators/MethodsDecrypter.cs
+++ b/de4dot.code/deobfuscators/MethodsDecrypter.cs
@@ -17,8 +17,9 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.MyStuff;
+using dot10.DotNet;
 using de4dot.code.AssemblyClient;
+using de4dot.blocks;
 using de4dot.mdecrypt;
 
 namespace de4dot.code.deobfuscators {
diff --git a/de4dot.code/deobfuscators/ProxyCallFixerBase.cs b/de4dot.code/deobfuscators/ProxyCallFixerBase.cs
index aaa25258..e960b490 100644
--- a/de4dot.code/deobfuscators/ProxyCallFixerBase.cs
+++ b/de4dot.code/deobfuscators/ProxyCallFixerBase.cs
@@ -19,15 +19,15 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators {
 	abstract class ProxyCallFixerBase {
-		protected ModuleDefinition module;
-		protected List<MethodDefinition> delegateCreatorMethods = new List<MethodDefinition>();
-		protected Dictionary<TypeDefinition, bool> delegateTypesDict = new Dictionary<TypeDefinition, bool>();
+		protected ModuleDefMD module;
+		protected List<MethodDef> delegateCreatorMethods = new List<MethodDef>();
+		protected Dictionary<TypeDef, bool> delegateTypesDict = new Dictionary<TypeDef, bool>();
 		protected int errors = 0;
 
 		public int Errors {
@@ -35,10 +35,10 @@ namespace de4dot.code.deobfuscators {
 		}
 
 		protected class DelegateInfo {
-			public MethodReference methodRef;	// Method we should call
-			public FieldDefinition field;		// Field holding the Delegate instance
+			public IMethod methodRef;	// Method we should call
+			public FieldDef field;		// Field holding the Delegate instance
 			public OpCode callOpcode;
-			public DelegateInfo(FieldDefinition field, MethodReference methodRef, OpCode callOpcode) {
+			public DelegateInfo(FieldDef field, IMethod methodRef, OpCode callOpcode) {
 				this.field = field;
 				this.methodRef = methodRef;
 				this.callOpcode = callOpcode;
@@ -47,30 +47,30 @@ namespace de4dot.code.deobfuscators {
 
 		public int RemovedDelegateCreatorCalls { get; set; }
 
-		public IEnumerable<TypeDefinition> DelegateTypes {
+		public IEnumerable<TypeDef> DelegateTypes {
 			get { return delegateTypesDict.Keys; }
 		}
 
-		public IEnumerable<TypeDefinition> DelegateCreatorTypes {
+		public IEnumerable<TypeDef> DelegateCreatorTypes {
 			get {
 				foreach (var method in delegateCreatorMethods)
 					yield return method.DeclaringType;
 			}
 		}
 
-		public virtual IEnumerable<Tuple<MethodDefinition, string>> OtherMethods {
-			get { return new List<Tuple<MethodDefinition, string>>(); }
+		public virtual IEnumerable<Tuple<MethodDef, string>> OtherMethods {
+			get { return new List<Tuple<MethodDef, string>>(); }
 		}
 
 		public bool Detected {
 			get { return delegateCreatorMethods.Count != 0; }
 		}
 
-		protected ProxyCallFixerBase(ModuleDefinition module) {
+		protected ProxyCallFixerBase(ModuleDefMD module) {
 			this.module = module;
 		}
 
-		protected ProxyCallFixerBase(ModuleDefinition module, ProxyCallFixerBase oldOne) {
+		protected ProxyCallFixerBase(ModuleDefMD module, ProxyCallFixerBase oldOne) {
 			this.module = module;
 			foreach (var method in oldOne.delegateCreatorMethods)
 				delegateCreatorMethods.Add(lookup(method, "Could not find delegate creator method"));
@@ -84,17 +84,17 @@ namespace de4dot.code.deobfuscators {
 			return new DelegateInfo(field, method, di.callOpcode);
 		}
 
-		protected T lookup<T>(T def, string errorMessage) where T : MemberReference {
+		protected T lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
 			return DeobUtils.lookup(module, def, errorMessage);
 		}
 
-		protected void setDelegateCreatorMethod(MethodDefinition delegateCreatorMethod) {
+		protected void setDelegateCreatorMethod(MethodDef delegateCreatorMethod) {
 			if (delegateCreatorMethod == null)
 				return;
 			delegateCreatorMethods.Add(delegateCreatorMethod);
 		}
 
-		protected bool isDelegateCreatorMethod(MethodDefinition method) {
+		protected bool isDelegateCreatorMethod(MethodDef method) {
 			foreach (var m in delegateCreatorMethods) {
 				if (m == method)
 					return true;
@@ -102,7 +102,7 @@ namespace de4dot.code.deobfuscators {
 			return false;
 		}
 
-		protected virtual IEnumerable<TypeDefinition> getDelegateTypes() {
+		protected virtual IEnumerable<TypeDef> getDelegateTypes() {
 			foreach (var type in module.Types) {
 				if (type.BaseType == null || type.BaseType.FullName != "System.MulticastDelegate")
 					continue;
@@ -168,7 +168,8 @@ namespace de4dot.code.deobfuscators {
 					else
 						removeIndexes.Add(info.Index);
 				}
-				block.remove(removeIndexes);
+				if (removeIndexes.Count > 0)
+					block.remove(removeIndexes);
 			}
 
 			return removeInfos.Count > 0;
@@ -182,11 +183,11 @@ namespace de4dot.code.deobfuscators {
 	abstract class ProxyCallFixer1 : ProxyCallFixerBase {
 		FieldDefinitionAndDeclaringTypeDict<DelegateInfo> fieldToDelegateInfo = new FieldDefinitionAndDeclaringTypeDict<DelegateInfo>();
 
-		protected ProxyCallFixer1(ModuleDefinition module)
+		protected ProxyCallFixer1(ModuleDefMD module)
 			: base(module) {
 		}
 
-		protected ProxyCallFixer1(ModuleDefinition module, ProxyCallFixer1 oldOne)
+		protected ProxyCallFixer1(ModuleDefMD module, ProxyCallFixer1 oldOne)
 			: base(module, oldOne) {
 			foreach (var key in oldOne.fieldToDelegateInfo.getKeys())
 				fieldToDelegateInfo.add(lookup(key, "Could not find field"), copy(oldOne.fieldToDelegateInfo.find(key)));
@@ -196,7 +197,7 @@ namespace de4dot.code.deobfuscators {
 			fieldToDelegateInfo.add(di.field, di);
 		}
 
-		protected DelegateInfo getDelegateInfo(FieldReference field) {
+		protected DelegateInfo getDelegateInfo(IField field) {
 			if (field == null)
 				return null;
 			return fieldToDelegateInfo.find(field);
@@ -206,10 +207,10 @@ namespace de4dot.code.deobfuscators {
 			if (delegateCreatorMethods.Count == 0)
 				return;
 
-			Log.v("Finding all proxy delegates");
+			Logger.v("Finding all proxy delegates");
 			foreach (var tmp in getDelegateTypes()) {
 				var type = tmp;
-				var cctor = DotNetUtils.getMethod(type, ".cctor");
+				var cctor = type.FindStaticConstructor();
 				if (cctor == null || !cctor.HasBody)
 					continue;
 				if (!type.HasFields)
@@ -219,34 +220,34 @@ namespace de4dot.code.deobfuscators {
 				if (context == null)
 					continue;
 
-				Log.v("Found proxy delegate: {0} ({1:X8})", Utils.removeNewlines(type), type.MetadataToken.ToUInt32());
+				Logger.v("Found proxy delegate: {0} ({1:X8})", Utils.removeNewlines(type), type.MDToken.ToUInt32());
 				RemovedDelegateCreatorCalls++;
 
-				Log.indent();
+				Logger.Instance.indent();
 				foreach (var field in type.Fields) {
 					if (!field.IsStatic)
 						continue;
 
-					MethodReference calledMethod;
+					IMethod calledMethod;
 					OpCode callOpcode;
 					getCallInfo(context, field, out calledMethod, out callOpcode);
 
 					if (calledMethod == null)
 						continue;
 					addDelegateInfo(new DelegateInfo(field, calledMethod, callOpcode));
-					Log.v("Field: {0}, Opcode: {1}, Method: {2} ({3:X8})",
+					Logger.v("Field: {0}, Opcode: {1}, Method: {2} ({3:X8})",
 								Utils.removeNewlines(field.Name),
 								callOpcode,
 								Utils.removeNewlines(calledMethod),
-								calledMethod.MetadataToken.ToUInt32());
+								calledMethod.MDToken.Raw);
 				}
-				Log.deIndent();
+				Logger.Instance.deIndent();
 				delegateTypesDict[type] = true;
 			}
 		}
 
-		protected abstract object checkCctor(ref TypeDefinition type, MethodDefinition cctor);
-		protected abstract void getCallInfo(object context, FieldDefinition field, out MethodReference calledMethod, out OpCode callOpcode);
+		protected abstract object checkCctor(ref TypeDef type, MethodDef cctor);
+		protected abstract void getCallInfo(object context, FieldDef field, out IMethod calledMethod, out OpCode callOpcode);
 
 		protected override bool deobfuscate(Blocks blocks, IList<Block> allBlocks) {
 			var removeInfos = new Dictionary<Block, List<RemoveInfo>>();
@@ -258,7 +259,7 @@ namespace de4dot.code.deobfuscators {
 					if (instr.OpCode != OpCodes.Ldsfld)
 						continue;
 
-					var di = getDelegateInfo(instr.Operand as FieldReference);
+					var di = getDelegateInfo(instr.Operand as IField);
 					if (di == null)
 						continue;
 
@@ -269,11 +270,11 @@ namespace de4dot.code.deobfuscators {
 					}
 					else {
 						errors++;
-						Log.w("Could not fix proxy call. Method: {0} ({1:X8}), Proxy type: {2} ({3:X8})",
+						Logger.w("Could not fix proxy call. Method: {0} ({1:X8}), Proxy type: {2} ({3:X8})",
 							Utils.removeNewlines(blocks.Method),
-							blocks.Method.MetadataToken.ToInt32(),
+							blocks.Method.MDToken.ToInt32(),
 							Utils.removeNewlines(di.field.DeclaringType),
-							di.field.DeclaringType.MetadataToken.ToInt32());
+							di.field.DeclaringType.MDToken.ToInt32());
 					}
 				}
 			}
@@ -296,7 +297,7 @@ namespace de4dot.code.deobfuscators {
 				if (stack <= 0)
 					return null;
 				var instr = instrs[i];
-				DotNetUtils.updateStack(instr.Instruction, ref stack, false);
+				instr.Instruction.UpdateStack(ref stack, false);
 				if (stack < 0)
 					return null;
 
@@ -305,7 +306,7 @@ namespace de4dot.code.deobfuscators {
 						return null;
 					continue;
 				}
-				var calledMethod = instr.Operand as MethodReference;
+				var calledMethod = instr.Operand as IMethod;
 				if (calledMethod == null)
 					return null;
 				if (stack != (DotNetUtils.hasReturnValue(calledMethod) ? 1 : 0))
@@ -336,28 +337,25 @@ namespace de4dot.code.deobfuscators {
 
 		// The obfuscator could be buggy and call a proxy delegate without pushing the
 		// instance field. SA has done it, so let's fix it.
-		void fixBrokenCalls(MethodDefinition obfuscatedMethod, IList<Block> allBlocks) {
+		void fixBrokenCalls(MethodDef obfuscatedMethod, IList<Block> allBlocks) {
 			foreach (var block in allBlocks) {
 				var instrs = block.Instructions;
 				for (int i = 0; i < instrs.Count; i++) {
 					var call = instrs[i];
 					if (call.OpCode != OpCodes.Call && call.OpCode != OpCodes.Callvirt)
 						continue;
-					var methodRef = call.Operand as MethodReference;
+					var methodRef = call.Operand as IMethod;
 					if (methodRef == null || methodRef.Name != "Invoke")
 						continue;
-					var method = DotNetUtils.getMethod(module, methodRef);
-					if (method == null)
+					MethodDef method = DotNetUtils.getMethod2(module, methodRef);
+					if (method == null || method.DeclaringType == null)
 						continue;
-					var declaringType = DotNetUtils.getType(module, method.DeclaringType);
-					if (declaringType == null)
-						continue;
-					if (!delegateTypesDict.ContainsKey(declaringType))
+					if (!delegateTypesDict.ContainsKey(method.DeclaringType))
 						continue;
 
 					// Oooops!!! The obfuscator is buggy. Well, let's hope it is, or it's my code. ;)
 
-					Log.w("Holy obfuscator bugs, Batman! Found a proxy delegate call with no instance push in {0:X8}. Replacing it with a throw...", obfuscatedMethod.MetadataToken.ToInt32());
+					Logger.w("Holy obfuscator bugs, Batman! Found a proxy delegate call with no instance push in {0:X8}. Replacing it with a throw...", obfuscatedMethod.MDToken.ToInt32());
 					block.insert(i, Instruction.Create(OpCodes.Ldnull));
 					block.replace(i + 1, 1, Instruction.Create(OpCodes.Throw));
 					i++;
@@ -373,11 +371,11 @@ namespace de4dot.code.deobfuscators {
 	abstract class ProxyCallFixer2 : ProxyCallFixerBase {
 		MethodDefinitionAndDeclaringTypeDict<DelegateInfo> proxyMethodToDelegateInfo = new MethodDefinitionAndDeclaringTypeDict<DelegateInfo>();
 
-		protected ProxyCallFixer2(ModuleDefinition module)
+		protected ProxyCallFixer2(ModuleDefMD module)
 			: base(module) {
 		}
 
-		protected ProxyCallFixer2(ModuleDefinition module, ProxyCallFixer2 oldOne)
+		protected ProxyCallFixer2(ModuleDefMD module, ProxyCallFixer2 oldOne)
 			: base(module, oldOne) {
 			foreach (var oldMethod in oldOne.proxyMethodToDelegateInfo.getKeys()) {
 				var oldDi = oldOne.proxyMethodToDelegateInfo.find(oldMethod);
@@ -390,13 +388,13 @@ namespace de4dot.code.deobfuscators {
 			if (delegateCreatorMethods.Count == 0)
 				return;
 
-			Log.v("Finding all proxy delegates");
+			Logger.v("Finding all proxy delegates");
 			find2();
 		}
 
 		protected void find2() {
 			foreach (var type in getDelegateTypes()) {
-				var cctor = DotNetUtils.getMethod(type, ".cctor");
+				var cctor = type.FindStaticConstructor();
 				if (cctor == null || !cctor.HasBody)
 					continue;
 				if (!type.HasFields)
@@ -406,43 +404,43 @@ namespace de4dot.code.deobfuscators {
 				if (context == null)
 					continue;
 
-				Log.v("Found proxy delegate: {0} ({1:X8})", Utils.removeNewlines(type), type.MetadataToken.ToUInt32());
+				Logger.v("Found proxy delegate: {0} ({1:X8})", Utils.removeNewlines(type), type.MDToken.ToUInt32());
 				RemovedDelegateCreatorCalls++;
 				var fieldToMethod = getFieldToMethodDictionary(type);
 
-				Log.indent();
+				Logger.Instance.indent();
 				foreach (var field in type.Fields) {
-					MethodDefinition proxyMethod;
+					MethodDef proxyMethod;
 					if (!fieldToMethod.TryGetValue(field, out proxyMethod))
 						continue;
 
-					MethodReference calledMethod;
+					IMethod calledMethod;
 					OpCode callOpcode;
 					getCallInfo(context, field, out calledMethod, out callOpcode);
 
 					if (calledMethod == null)
 						continue;
 					add(proxyMethod, new DelegateInfo(field, calledMethod, callOpcode));
-					Log.v("Field: {0}, Opcode: {1}, Method: {2} ({3:X8})",
+					Logger.v("Field: {0}, Opcode: {1}, Method: {2} ({3:X8})",
 								Utils.removeNewlines(field.Name),
 								callOpcode,
 								Utils.removeNewlines(calledMethod),
-								calledMethod.MetadataToken.ToUInt32());
+								calledMethod.MDToken.ToUInt32());
 				}
-				Log.deIndent();
+				Logger.Instance.deIndent();
 				delegateTypesDict[type] = true;
 			}
 		}
 
-		protected void add(MethodDefinition method, DelegateInfo di) {
+		protected void add(MethodDef method, DelegateInfo di) {
 			proxyMethodToDelegateInfo.add(method, di);
 		}
 
-		protected abstract object checkCctor(TypeDefinition type, MethodDefinition cctor);
-		protected abstract void getCallInfo(object context, FieldDefinition field, out MethodReference calledMethod, out OpCode callOpcode);
+		protected abstract object checkCctor(TypeDef type, MethodDef cctor);
+		protected abstract void getCallInfo(object context, FieldDef field, out IMethod calledMethod, out OpCode callOpcode);
 
-		Dictionary<FieldDefinition, MethodDefinition> getFieldToMethodDictionary(TypeDefinition type) {
-			var dict = new Dictionary<FieldDefinition, MethodDefinition>();
+		Dictionary<FieldDef, MethodDef> getFieldToMethodDictionary(TypeDef type) {
+			var dict = new Dictionary<FieldDef, MethodDef>();
 			foreach (var method in type.Methods) {
 				if (!method.IsStatic || !method.HasBody || method.Name == ".cctor")
 					continue;
@@ -452,7 +450,7 @@ namespace de4dot.code.deobfuscators {
 					var instr = instructions[i];
 					if (instr.OpCode.Code != Code.Ldsfld)
 						continue;
-					var field = instr.Operand as FieldDefinition;
+					var field = instr.Operand as FieldDef;
 					if (field == null)
 						continue;
 
@@ -473,7 +471,7 @@ namespace de4dot.code.deobfuscators {
 					if (instr.OpCode != OpCodes.Call)
 						continue;
 
-					var method = instr.Operand as MethodReference;
+					var method = instr.Operand as IMethod;
 					if (method == null)
 						continue;
 					var di = proxyMethodToDelegateInfo.find(method);
@@ -493,11 +491,11 @@ namespace de4dot.code.deobfuscators {
 	//		ldsfld delegate instance
 	//		call static method
 	abstract class ProxyCallFixer3 : ProxyCallFixer1 {
-		protected ProxyCallFixer3(ModuleDefinition module)
+		protected ProxyCallFixer3(ModuleDefMD module)
 			: base(module) {
 		}
 
-		protected ProxyCallFixer3(ModuleDefinition module, ProxyCallFixer3 oldOne)
+		protected ProxyCallFixer3(ModuleDefMD module, ProxyCallFixer3 oldOne)
 			: base(module, oldOne) {
 		}
 
@@ -514,10 +512,10 @@ namespace de4dot.code.deobfuscators {
 			};
 		}
 
-		static MethodReference getCalledMethod(Instr instr) {
+		static IMethod getCalledMethod(Instr instr) {
 			if (instr.OpCode.Code != Code.Call)
 				return null;
-			return instr.Operand as MethodReference;
+			return instr.Operand as IMethod;
 		}
 	}
 }
diff --git a/de4dot.code/deobfuscators/Rummage/Deobfuscator.cs b/de4dot.code/deobfuscators/Rummage/Deobfuscator.cs
index f99473bb..19dfe1fe 100644
--- a/de4dot.code/deobfuscators/Rummage/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/Rummage/Deobfuscator.cs
@@ -18,7 +18,7 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Rummage {
diff --git a/de4dot.code/deobfuscators/Rummage/StringDecrypter.cs b/de4dot.code/deobfuscators/Rummage/StringDecrypter.cs
index fc390be8..c390b03e 100644
--- a/de4dot.code/deobfuscators/Rummage/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/Rummage/StringDecrypter.cs
@@ -21,25 +21,25 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Rummage {
 	class StringDecrypter {
-		ModuleDefinition module;
-		MethodDefinition stringDecrypterMethod;
+		ModuleDefMD module;
+		MethodDef stringDecrypterMethod;
 		FieldDefinitionAndDeclaringTypeDict<StringInfo> stringInfos = new FieldDefinitionAndDeclaringTypeDict<StringInfo>();
 		int fileDispl;
 		uint[] key;
 		BinaryReader reader;
 
 		class StringInfo {
-			public readonly FieldDefinition field;
+			public readonly FieldDef field;
 			public readonly int stringId;
 			public string decrypted;
 
-			public StringInfo(FieldDefinition field, int stringId) {
+			public StringInfo(FieldDef field, int stringId) {
 				this.field = field;
 				this.stringId = stringId;
 			}
@@ -51,13 +51,13 @@ namespace de4dot.code.deobfuscators.Rummage {
 			}
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return stringDecrypterMethod != null ? stringDecrypterMethod.DeclaringType : null; }
 		}
 
-		public IEnumerable<TypeDefinition> OtherTypes {
+		public IEnumerable<TypeDef> OtherTypes {
 			get {
-				var list = new List<TypeDefinition>(stringInfos.Count);
+				var list = new List<TypeDef>(stringInfos.Count);
 				foreach (var info in stringInfos.getValues())
 					list.Add(info.field.DeclaringType);
 				return list;
@@ -68,7 +68,7 @@ namespace de4dot.code.deobfuscators.Rummage {
 			get { return stringDecrypterMethod != null; }
 		}
 
-		public StringDecrypter(ModuleDefinition module) {
+		public StringDecrypter(ModuleDefMD module) {
 			this.module = module;
 		}
 
@@ -93,10 +93,10 @@ namespace de4dot.code.deobfuscators.Rummage {
 			"System.Int32",
 			"System.IO.FileStream",
 		};
-		static MethodDefinition checkType(TypeDefinition type) {
+		static MethodDef checkType(TypeDef type) {
 			if (!new FieldTypes(type).exactly(requiredFields))
 				return null;
-			var cctor = DotNetUtils.getMethod(type, ".cctor");
+			var cctor = type.FindStaticConstructor();
 			if (cctor == null)
 				return null;
 			if (!new LocalTypes(cctor).all(requiredLocals))
@@ -105,8 +105,8 @@ namespace de4dot.code.deobfuscators.Rummage {
 			return checkMethods(type);
 		}
 
-		static MethodDefinition checkMethods(TypeDefinition type) {
-			MethodDefinition cctor = null, decrypterMethod = null;
+		static MethodDef checkMethods(TypeDef type) {
+			MethodDef cctor = null, decrypterMethod = null;
 			foreach (var method in type.Methods) {
 				if (!method.IsStatic || method.Body == null)
 					return null;
@@ -123,7 +123,7 @@ namespace de4dot.code.deobfuscators.Rummage {
 			return decrypterMethod;
 		}
 
-		static bool getDispl(MethodDefinition method, ref int displ) {
+		static bool getDispl(MethodDef method, ref int displ) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 2; i++) {
 				var mul = instrs[i];
@@ -131,14 +131,14 @@ namespace de4dot.code.deobfuscators.Rummage {
 					continue;
 
 				var ldci4 = instrs[i + 1];
-				if (!DotNetUtils.isLdcI4(ldci4))
+				if (!ldci4.IsLdcI4())
 					continue;
 
 				var sub = instrs[i + 2];
 				if (sub.OpCode.Code != Code.Sub)
 					continue;
 
-				displ = DotNetUtils.getLdcI4Value(ldci4);
+				displ = ldci4.GetLdcI4Value();
 				return true;
 			}
 
@@ -146,7 +146,7 @@ namespace de4dot.code.deobfuscators.Rummage {
 		}
 
 		public void initialize() {
-			reader = new BinaryReader(new FileStream(module.FullyQualifiedName, FileMode.Open, FileAccess.Read, FileShare.Read));
+			reader = new BinaryReader(new FileStream(module.Location, FileMode.Open, FileAccess.Read, FileShare.Read));
 			initKey();
 
 			foreach (var type in module.Types)
@@ -160,8 +160,8 @@ namespace de4dot.code.deobfuscators.Rummage {
 				key[i] = reader.ReadUInt32();
 		}
 
-		void initType(TypeDefinition type) {
-			var cctor = DotNetUtils.getMethod(type, ".cctor");
+		void initType(TypeDef type) {
+			var cctor = type.FindStaticConstructor();
 			if (cctor == null)
 				return;
 			var info = getStringInfo(cctor);
@@ -171,27 +171,27 @@ namespace de4dot.code.deobfuscators.Rummage {
 			stringInfos.add(info.field, info);
 		}
 
-		StringInfo getStringInfo(MethodDefinition method) {
+		StringInfo getStringInfo(MethodDef method) {
 			if (method == null || method.Body == null)
 				return null;
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 2; i++) {
 				var ldci4 = instrs[i];
-				if (!DotNetUtils.isLdcI4(ldci4))
+				if (!ldci4.IsLdcI4())
 					continue;
-				int stringId = DotNetUtils.getLdcI4Value(ldci4);
+				int stringId = ldci4.GetLdcI4Value();
 
 				var call = instrs[i + 1];
 				if (call.OpCode.Code != Code.Call)
 					continue;
-				var calledMethod = call.Operand as MethodReference;
-				if (!MemberReferenceHelper.compareMethodReferenceAndDeclaringType(stringDecrypterMethod, calledMethod))
+				var calledMethod = call.Operand as IMethod;
+				if (!MethodEqualityComparer.CompareDeclaringTypes.Equals(stringDecrypterMethod, calledMethod))
 					continue;
 
 				var stsfld = instrs[i + 2];
 				if (stsfld.OpCode.Code != Code.Stsfld)
 					continue;
-				var field = stsfld.Operand as FieldDefinition;
+				var field = stsfld.Operand as FieldDef;
 				if (field == null)
 					continue;
 
@@ -210,7 +210,7 @@ namespace de4dot.code.deobfuscators.Rummage {
 					if (instr.OpCode.Code != Code.Ldsfld)
 						continue;
 
-					var field = instr.Operand as FieldReference;
+					var field = instr.Operand as IField;
 					if (field == null)
 						continue;
 					var info = stringInfos.find(field);
@@ -219,7 +219,7 @@ namespace de4dot.code.deobfuscators.Rummage {
 					var decrypted = decrypt(info);
 
 					instrs[i] = new Instr(Instruction.Create(OpCodes.Ldstr, decrypted));
-					Log.v("Decrypted string: {0}", Utils.toCsharpString(decrypted));
+					Logger.v("Decrypted string: {0}", Utils.toCsharpString(decrypted));
 				}
 			}
 		}
diff --git a/de4dot.code/deobfuscators/Skater_NET/Deobfuscator.cs b/de4dot.code/deobfuscators/Skater_NET/Deobfuscator.cs
index 78aceea6..16aa8d30 100644
--- a/de4dot.code/deobfuscators/Skater_NET/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/Skater_NET/Deobfuscator.cs
@@ -18,7 +18,7 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Skater_NET {
@@ -90,7 +90,7 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 		}
 
 		bool hasAssemblyReference(string name) {
-			foreach (var asmRef in module.AssemblyReferences) {
+			foreach (var asmRef in module.GetAssemblyRefs()) {
 				if (asmRef.Name == name)
 					return true;
 			}
diff --git a/de4dot.code/deobfuscators/Skater_NET/EnumClassFinder.cs b/de4dot.code/deobfuscators/Skater_NET/EnumClassFinder.cs
index cc4795e9..0f03a043 100644
--- a/de4dot.code/deobfuscators/Skater_NET/EnumClassFinder.cs
+++ b/de4dot.code/deobfuscators/Skater_NET/EnumClassFinder.cs
@@ -17,16 +17,16 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Skater_NET {
 	class EnumClassFinder {
-		ModuleDefinition module;
-		FieldDefinition enumField;
+		ModuleDefMD module;
+		FieldDef enumField;
 
-		public EnumClassFinder(ModuleDefinition module) {
+		public EnumClassFinder(ModuleDefMD module) {
 			this.module = module;
 			find();
 		}
@@ -43,7 +43,7 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 				if (method.Name != ".ctor")
 					continue;
 				var field = type.Fields[0];
-				var fieldType = DotNetUtils.getType(module, field.FieldType);
+				var fieldType = DotNetUtils.getType(module, field.FieldSig.GetFieldType());
 				if (fieldType == null)
 					continue;
 				if (!fieldType.IsEnum)
@@ -69,8 +69,8 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 					if (stfld.OpCode.Code != Code.Stfld)
 						continue;
 
-					var field = stfld.Operand as FieldReference;
-					if (!MemberReferenceHelper.compareFieldReferenceAndDeclaringType(enumField, field))
+					var field = stfld.Operand as IField;
+					if (!FieldEqualityComparer.CompareDeclaringTypes.Equals(enumField, field))
 						continue;
 					block.remove(i, 3);
 					i--;
diff --git a/de4dot.code/deobfuscators/Skater_NET/StringDecrypter.cs b/de4dot.code/deobfuscators/Skater_NET/StringDecrypter.cs
index 21a392b7..46dd681d 100644
--- a/de4dot.code/deobfuscators/Skater_NET/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/Skater_NET/StringDecrypter.cs
@@ -23,15 +23,15 @@ using System.Globalization;
 using System.Security.Cryptography;
 using System.Text;
 using System.Text.RegularExpressions;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Skater_NET {
 	class StringDecrypter {
-		ModuleDefinition module;
-		TypeDefinition decrypterType;
-		MethodDefinition decrypterCctor;
+		ModuleDefMD module;
+		TypeDef decrypterType;
+		MethodDef decrypterCctor;
 		FieldDefinitionAndDeclaringTypeDict<string> fieldToDecryptedString = new FieldDefinitionAndDeclaringTypeDict<string>();
 		bool canRemoveType;
 		IDecrypter decrypter;
@@ -84,11 +84,11 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 			get { return canRemoveType; }
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return decrypterType; }
 		}
 
-		public StringDecrypter(ModuleDefinition module) {
+		public StringDecrypter(ModuleDefMD module) {
 			this.module = module;
 		}
 
@@ -97,7 +97,7 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 				if (type.HasProperties || type.HasEvents)
 					continue;
 
-				var cctor = DotNetUtils.getMethod(type, ".cctor");
+				var cctor = type.FindStaticConstructor();
 				if (cctor == null)
 					continue;
 
@@ -131,17 +131,17 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 					continue;
 				if (instrs[i + 4].OpCode.Code != Code.Stsfld)
 					continue;
-				var field = instrs[i + 4].Operand as FieldDefinition;
+				var field = instrs[i + 4].Operand as FieldDef;
 				if (field == null)
 					continue;
-				if (!MemberReferenceHelper.compareTypes(field.DeclaringType, decrypterType))
+				if (!new SigComparer().Equals(field.DeclaringType, decrypterType))
 					continue;
 
 				fieldToDecryptedString.add(field, decrypter.decrypt(encryptedString));
 			}
 		}
 
-		bool checkType(TypeDefinition type) {
+		bool checkType(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
@@ -157,7 +157,7 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 			return false;
 		}
 
-		bool checkMethodV1(MethodDefinition method) {
+		bool checkMethodV1(MethodDef method) {
 			var salt = getSalt(method);
 			if (salt == null)
 				return false;
@@ -181,7 +181,7 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 			"System.String System.String::Concat(System.String,System.String)",
 			"System.Char Microsoft.VisualBasic.Strings::Chr(System.Int32)",
 		};
-		bool checkMethodV2(MethodDefinition method) {
+		bool checkMethodV2(MethodDef method) {
 			if (!DeobUtils.hasInteger(method, ' '))
 				return false;
 			foreach (var calledMethodName in callsMethodsV2) {
@@ -193,7 +193,7 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 			return true;
 		}
 
-		static byte[] getSalt(MethodDefinition method) {
+		static byte[] getSalt(MethodDef method) {
 			foreach (var s in DotNetUtils.getCodeStrings(method)) {
 				var saltAry = fixSalt(s);
 				if (saltAry != null)
@@ -224,11 +224,11 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 			return saltAry;
 		}
 
-		string getPassword(MethodDefinition decryptMethod) {
+		string getPassword(MethodDef decryptMethod) {
 			foreach (var method in DotNetUtils.getCalledMethods(module, decryptMethod)) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
-				if (!MemberReferenceHelper.compareTypes(method.DeclaringType, decryptMethod.DeclaringType))
+				if (!new SigComparer().Equals(method.DeclaringType, decryptMethod.DeclaringType))
 					continue;
 				if (!DotNetUtils.isMethod(method, "System.String", "()"))
 					continue;
@@ -258,7 +258,7 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 			return password;
 		}
 
-		string getPassword2(MethodDefinition method) {
+		string getPassword2(MethodDef method) {
 			string password = "";
 			foreach (var calledMethod in DotNetUtils.getCalledMethods(module, method)) {
 				var s = getPassword3(calledMethod);
@@ -270,7 +270,7 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 			return password;
 		}
 
-		string getPassword3(MethodDefinition method) {
+		string getPassword3(MethodDef method) {
 			var strings = new List<string>(DotNetUtils.getCodeStrings(method));
 			if (strings.Count != 1)
 				return null;
@@ -291,14 +291,14 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 					if (instr.OpCode.Code == Code.Call || instr.OpCode.Code == Code.Callvirt) {
 						if (blocks.Method.DeclaringType == decrypterType)
 							continue;
-						var calledMethod = instr.Operand as MethodReference;
+						var calledMethod = instr.Operand as IMethod;
 						if (calledMethod != null && calledMethod.DeclaringType == decrypterType)
 							canRemoveType = false;
 					}
 					else if (instr.OpCode.Code == Code.Ldsfld) {
 						if (instr.OpCode.Code != Code.Ldsfld)
 							continue;
-						var field = instr.Operand as FieldReference;
+						var field = instr.Operand as IField;
 						if (field == null)
 							continue;
 						var decrypted = fieldToDecryptedString.find(field);
@@ -306,7 +306,7 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 							continue;
 
 						instrs[i] = new Instr(Instruction.Create(OpCodes.Ldstr, decrypted));
-						Log.v("Decrypted string: {0}", Utils.toCsharpString(decrypted));
+						Logger.v("Decrypted string: {0}", Utils.toCsharpString(decrypted));
 					}
 				}
 			}
diff --git a/de4dot.code/deobfuscators/SmartAssembly/AssemblyResolver.cs b/de4dot.code/deobfuscators/SmartAssembly/AssemblyResolver.cs
index a586d829..c6ca4f55 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/AssemblyResolver.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/AssemblyResolver.cs
@@ -19,7 +19,7 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace de4dot.code.deobfuscators.SmartAssembly {
 	class AssemblyResolver {
@@ -45,7 +45,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			var returned = new Dictionary<Resource, bool>();
 			foreach (var info in assemblyResolverInfo.EmbeddedAssemblyInfos) {
 				if (info.resource == null) {
-					Log.w("Could not find embedded resource {0}", Utils.toCsharpString(info.resourceName));
+					Logger.w("Could not find embedded resource {0}", Utils.toCsharpString(info.resourceName));
 					continue;
 				}
 				if (returned.ContainsKey(info.resource))
diff --git a/de4dot.code/deobfuscators/SmartAssembly/AssemblyResolverInfo.cs b/de4dot.code/deobfuscators/SmartAssembly/AssemblyResolverInfo.cs
index f3bb93a1..21a849b1 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/AssemblyResolverInfo.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/AssemblyResolverInfo.cs
@@ -20,8 +20,8 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.SmartAssembly {
@@ -38,7 +38,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return assemblyName ?? base.ToString();
 		}
 
-		public static EmbeddedAssemblyInfo create(ModuleDefinition module, string encName, string rsrcName) {
+		public static EmbeddedAssemblyInfo create(ModuleDefMD module, string encName, string rsrcName) {
 			var info = new EmbeddedAssemblyInfo();
 
 			try {
@@ -71,10 +71,10 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 	}
 
 	class AssemblyResolverInfo : ResolverInfoBase {
-		MethodDefinition simpleZipTypeMethod;
+		MethodDef simpleZipTypeMethod;
 		List<EmbeddedAssemblyInfo> embeddedAssemblyInfos = new List<EmbeddedAssemblyInfo>();
 
-		public MethodDefinition SimpleZipTypeMethod {
+		public MethodDef SimpleZipTypeMethod {
 			get { return simpleZipTypeMethod; }
 		}
 
@@ -82,7 +82,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			get { return embeddedAssemblyInfos; }
 		}
 
-		public AssemblyResolverInfo(ModuleDefinition module, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob)
+		public AssemblyResolverInfo(ModuleDefMD module, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob)
 			: base(module, simpleDeobfuscator, deob) {
 		}
 
@@ -100,7 +100,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return ok;
 		}
 
-		protected override bool checkResolverType(TypeDefinition type) {
+		protected override bool checkResolverType(TypeDef type) {
 			if (DotNetUtils.findFieldType(type, "System.Collections.Hashtable", true) != null)
 				return true;
 
@@ -114,7 +114,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return true;
 		}
 
-		protected override bool checkHandlerMethod(MethodDefinition method) {
+		protected override bool checkHandlerMethod(MethodDef method) {
 			if (!method.IsStatic || !method.HasBody)
 				return false;
 
@@ -145,22 +145,22 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				list.Add(info);
 			}
 
-			Log.v("Found embedded assemblies:");
-			Log.indent();
+			Logger.v("Found embedded assemblies:");
+			Logger.Instance.indent();
 			foreach (var info in list)
-				Log.v("{0}", info.assemblyName);
-			Log.deIndent();
+				Logger.v("{0}", info.assemblyName);
+			Logger.Instance.deIndent();
 
 			return true;
 		}
 
-		void findSimpleZipType(MethodDefinition method) {
+		void findSimpleZipType(MethodDef method) {
 			if (method == null || !method.HasBody)
 				return;
 			foreach (var call in method.Body.Instructions) {
 				if (call.OpCode.Code != Code.Call)
 					continue;
-				var calledMethod = call.Operand as MethodReference;
+				var calledMethod = call.Operand as IMethod;
 				if (calledMethod == null)
 					continue;
 				if (!SimpleZipInfo.isSimpleZipDecryptMethod_QuickCheck(module, calledMethod, out simpleZipTypeMethod))
diff --git a/de4dot.code/deobfuscators/SmartAssembly/AutomatedErrorReportingFinder.cs b/de4dot.code/deobfuscators/SmartAssembly/AutomatedErrorReportingFinder.cs
index 3f01b5b4..05939b6c 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/AutomatedErrorReportingFinder.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/AutomatedErrorReportingFinder.cs
@@ -19,24 +19,24 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.SmartAssembly {
 	class AutomatedErrorReportingFinder : ExceptionLoggerRemover {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		bool enabled;
 
 		protected override bool HasExceptionLoggers {
 			get { return enabled; }
 		}
 
-		public AutomatedErrorReportingFinder(ModuleDefinition module) {
+		public AutomatedErrorReportingFinder(ModuleDefMD module) {
 			this.module = module;
 		}
 
-		protected override bool isExceptionLogger(MethodReference method) {
+		protected override bool isExceptionLogger(IMethod method) {
 			return isExceptionLoggerMethod(method);
 		}
 
@@ -45,12 +45,12 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			if (entryPoint == null)
 				enabled = true;
 			else {
-				MethodDefinition exceptionMethod;
+				MethodDef exceptionMethod;
 				enabled = checkMethod(entryPoint, out exceptionMethod);
 			}
 		}
 
-		bool checkMethod(MethodDefinition method, out MethodDefinition exceptionMethod) {
+		bool checkMethod(MethodDef method, out MethodDef exceptionMethod) {
 			exceptionMethod = null;
 
 			var body = method.Body;
@@ -80,14 +80,14 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return isExceptionLoggerMethod(exceptionMethod);
 		}
 
-		MethodReference checkHandler(IList<Instruction> instrs, int start, int end) {
-			MethodReference calledMethod = null;
+		IMethod checkHandler(IList<Instruction> instrs, int start, int end) {
+			IMethod calledMethod = null;
 			for (int i = start; i < end; i++) {
 				var instr = instrs[i];
 				if (instr.OpCode.Code == Code.Call || instr.OpCode.Code == Code.Callvirt) {
 					if (calledMethod != null)
 						return null;
-					var method = instr.Operand as MethodReference;
+					var method = instr.Operand as IMethod;
 					if (method == null)
 						return null;
 					calledMethod = method;
@@ -97,24 +97,24 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return calledMethod;
 		}
 
-		static bool isExceptionLoggerMethod(MethodReference method) {
+		static bool isExceptionLoggerMethod(IMethod method) {
 			if (method.Name == ".ctor" || method.Name == ".cctor")
 				return false;
 
-			var parameters = method.Parameters;
-			if (parameters.Count < 1)
+			var sig = method.MethodSig;
+			if (sig == null || sig.Params.Count < 1)
 				return false;
 
-			var rtype = method.MethodReturnType.ReturnType.FullName;
-			var type0 = parameters[0].ParameterType.FullName;
-			var type1 = parameters.Count < 2 ? "" : parameters[1].ParameterType.FullName;
+			var rtype = sig.RetType.GetFullName();
+			var type0 = sig.Params[0].GetFullName();
+			var type1 = sig.Params.Count < 2 ? "" : sig.Params[1].GetFullName();
 			int index;
 			if (rtype == "System.Void") {
 				if (type0 == "System.Exception" && type1 == "System.Int32")
 					index = 2;
 				else if (type0 == "System.Object[]" && type1 == "System.Exception")
 					return true;
-				else if (parameters.Count == 2 && type0 == "System.Int32" && type1 == "System.Object[]")
+				else if (sig.Params.Count == 2 && type0 == "System.Int32" && type1 == "System.Object[]")
 					return true;
 				else if (type0 == "System.Exception")
 					index = 1;
@@ -126,7 +126,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 					index = 2;
 				else if (type0 == "System.Int32" && type1 == "System.Exception")
 					index = 2;
-				else if (parameters.Count == 2 && type0 == "System.Int32" && type1 == "System.Object[]")
+				else if (sig.Params.Count == 2 && type0 == "System.Int32" && type1 == "System.Object[]")
 					return true;
 				else if (type0 == "System.Exception")
 					index = 1;
@@ -136,11 +136,11 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			else
 				return false;
 
-			if (index + 1 == parameters.Count && parameters[index].ParameterType.FullName == "System.Object[]")
+			if (index + 1 == sig.Params.Count && sig.Params[index].GetFullName() == "System.Object[]")
 				return true;
 
-			for (int i = index; i < parameters.Count; i++) {
-				if (parameters[i].ParameterType.FullName != "System.Object")
+			for (int i = index; i < sig.Params.Count; i++) {
+				if (sig.Params[i].GetElementType() != ElementType.Object)
 					return false;
 			}
 
diff --git a/de4dot.code/deobfuscators/SmartAssembly/Deobfuscator.cs b/de4dot.code/deobfuscators/SmartAssembly/Deobfuscator.cs
index db13f8a1..8090fe83 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/Deobfuscator.cs
@@ -21,13 +21,10 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
-// SmartAssembly can add so much junk that it's very difficult to find and remove all of it.
-// I remove some safe types that are almost guaranteed not to have any references in the code.
-
 namespace de4dot.code.deobfuscators.SmartAssembly {
 	public class DeobfuscatorInfo : DeobfuscatorInfoBase {
 		public const string THE_NAME = "SmartAssembly";
@@ -123,7 +120,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			StringFeatures = StringFeatures.AllowStaticDecryption;
 		}
 
-		public override void init(ModuleDefinition module) {
+		public override void init(ModuleDefMD module) {
 			base.init(module);
 		}
 
@@ -159,7 +156,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			}
 		}
 
-		void initializeVersion(TypeDefinition attr) {
+		void initializeVersion(TypeDef attr) {
 			var s = DotNetUtils.getCustomArgAsString(getAssemblyAttribute(attr), 0);
 			if (s == null)
 				return;
@@ -230,8 +227,8 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return -1;
 		}
 
-		TypeDefinition getTypeIdAttribute() {
-			Dictionary<TypeDefinition, bool> attrs = null;
+		TypeDef getTypeIdAttribute() {
+			Dictionary<TypeDef, bool> attrs = null;
 			int counter = 0;
 			foreach (var type in module.GetTypes()) {
 				counter++;
@@ -239,11 +236,11 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				if (cattrs.Count == 0)
 					return null;
 
-				var attrs2 = new Dictionary<TypeDefinition, bool>();
+				var attrs2 = new Dictionary<TypeDef, bool>();
 				foreach (var cattr in cattrs) {
-					if (!DotNetUtils.isMethod(cattr.Constructor, "System.Void", "(System.Int32)"))
+					if (!DotNetUtils.isMethod(cattr.Constructor as IMethod, "System.Void", "(System.Int32)"))
 						continue;
-					var attrType = cattr.AttributeType as TypeDefinition;
+					var attrType = cattr.AttributeType as TypeDef;
 					if (attrType == null)
 						continue;
 					if (attrs != null && !attrs.ContainsKey(attrType))
@@ -275,7 +272,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			foreach (var type in module.Types) {
 				if (type == moduleType)
 					continue;
-				var ns = type.Namespace;
+				var ns = type.Namespace.String;
 				if (!namespaces.ContainsKey(ns))
 					namespaces[ns] = 0;
 				if (type.Name != "" || type.IsPublic || type.HasFields || type.HasMethods || type.HasProperties || type.HasEvents)
@@ -352,7 +349,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return true;
 		}
 
-		MethodDefinition getGlobalSimpleZipTypeMethod() {
+		MethodDef getGlobalSimpleZipTypeMethod() {
 			if (assemblyResolverInfo.SimpleZipTypeMethod != null)
 				return assemblyResolverInfo.SimpleZipTypeMethod;
 			foreach (var info in stringDecrypterInfos) {
@@ -409,17 +406,18 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			foreach (var info in stringDecrypterInfos) {
 				if (initd.ContainsKey(info))
 					continue;
-				Log.v("String decrypter not initialized. Token {0:X8}", info.StringsEncodingClass.MetadataToken.ToInt32());
+				Logger.v("String decrypter not initialized. Token {0:X8}", info.StringsEncodingClass.MDToken.ToInt32());
 			}
 		}
 
 		void initStringDecrypter(StringDecrypterInfo info) {
-			Log.v("Adding string decrypter. Resource: {0}", Utils.toCsharpString(info.StringsResource.Name));
+			Logger.v("Adding string decrypter. Resource: {0}", Utils.toCsharpString(info.StringsResource.Name));
 			var decrypter = new StringDecrypter(info);
 			if (decrypter.CanDecrypt) {
-				staticStringInliner.add(DotNetUtils.getMethod(info.GetStringDelegate, "Invoke"), (method, gim, args) => {
-					var fieldDefinition = DotNetUtils.getField(module, (FieldReference)args[0]);
-					return decrypter.decrypt(fieldDefinition.MetadataToken.ToInt32(), (int)args[1]);
+				var invokeMethod = info.GetStringDelegate == null ? null : info.GetStringDelegate.FindMethod("Invoke");
+				staticStringInliner.add(invokeMethod, (method, gim, args) => {
+					var fieldDefinition = DotNetUtils.getField(module, (IField)args[0]);
+					return decrypter.decrypt(fieldDefinition.MDToken.ToInt32(), (int)args[1]);
 				});
 				staticStringInliner.add(info.StringDecrypterMethod, (method, gim, args) => {
 					return decrypter.decrypt(0, (int)args[0]);
@@ -448,11 +446,11 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			base.deobfuscateEnd();
 		}
 
-		TypeDefinition findBigType() {
+		TypeDef findBigType() {
 			if (approxVersion <= new Version(6, 5, 3, 53))
 				return null;
 
-			TypeDefinition bigType = null;
+			TypeDef bigType = null;
 			foreach (var type in module.Types) {
 				if (isBigType(type)) {
 					if (bigType == null || type.Methods.Count > bigType.Methods.Count)
@@ -462,7 +460,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return bigType;
 		}
 
-		bool isBigType(TypeDefinition type) {
+		bool isBigType(TypeDef type) {
 			if (type.Methods.Count < 50)
 				return false;
 			if (type.HasProperties || type.HasEvents)
@@ -489,14 +487,14 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			if (!options.RemoveAutomatedErrorReporting)
 				return;
 			if (automatedErrorReportingFinder.remove(blocks))
-				Log.v("Removed Automated Error Reporting code");
+				Logger.v("Removed Automated Error Reporting code");
 		}
 
 		void removeTamperProtection(Blocks blocks) {
 			if (!options.RemoveTamperProtection)
 				return;
 			if (tamperProtectionRemover.remove(blocks))
-				Log.v("Removed Tamper Protection code");
+				Logger.v("Removed Tamper Protection code");
 		}
 
 		void removeMemoryManagerStuff() {
@@ -541,7 +539,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 		public override IEnumerable<int> getStringDecrypterMethods() {
 			var list = new List<int>();
 			foreach (var method in staticStringInliner.Methods)
-				list.Add(method.MetadataToken.ToInt32());
+				list.Add(method.MDToken.ToInt32());
 			return list;
 		}
 	}
diff --git a/de4dot.code/deobfuscators/SmartAssembly/MemoryManagerInfo.cs b/de4dot.code/deobfuscators/SmartAssembly/MemoryManagerInfo.cs
index b6844134..a053362c 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/MemoryManagerInfo.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/MemoryManagerInfo.cs
@@ -17,28 +17,28 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.SmartAssembly {
 	class MemoryManagerInfo {
-		ModuleDefinition module;
-		TypeDefinition memoryManagerType;
-		MethodDefinition attachAppMethod;
+		ModuleDefMD module;
+		TypeDef memoryManagerType;
+		MethodDef attachAppMethod;
 
 		public bool Detected {
 			get { return memoryManagerType != null; }
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return memoryManagerType; }
 		}
 
-		public MethodDefinition CctorInitMethod {
+		public MethodDef CctorInitMethod {
 			get { return attachAppMethod; }
 		}
 
-		public MemoryManagerInfo(ModuleDefinition module) {
+		public MemoryManagerInfo(ModuleDefMD module) {
 			this.module = module;
 		}
 
@@ -50,7 +50,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return false;
 		}
 
-		bool checkCalledMethods(MethodDefinition checkMethod) {
+		bool checkCalledMethods(MethodDef checkMethod) {
 			if (checkMethod == null)
 				return false;
 			foreach (var method in DotNetUtils.getCalledMethods(module, checkMethod)) {
@@ -68,11 +68,11 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return false;
 		}
 
-		bool checkMemoryManagerType(TypeDefinition type, MethodDefinition method) {
+		bool checkMemoryManagerType(TypeDef type, MethodDef method) {
 			// Only two fields: itself and a long
 			int fields = 0;
 			foreach (var field in type.Fields) {
-				if (MemberReferenceHelper.compareTypes(field.FieldType, type) ||
+				if (new SigComparer().Equals(field.FieldType, type) ||
 					field.FieldType.FullName == "System.Int64") {
 					fields++;
 					continue;
diff --git a/de4dot.code/deobfuscators/SmartAssembly/ProxyCallFixer.cs b/de4dot.code/deobfuscators/SmartAssembly/ProxyCallFixer.cs
index 83bb63c4..fc1dafa9 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/ProxyCallFixer.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/ProxyCallFixer.cs
@@ -19,8 +19,8 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.SmartAssembly {
@@ -37,7 +37,6 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			'\x9E', '\x9F',
 		};
 
-		IList<MemberReference> memberReferences;
 		ISimpleDeobfuscator simpleDeobfuscator;
 
 		static ProxyCallFixer() {
@@ -45,13 +44,12 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				specialCharsDict[specialChars[i]] = i;
 		}
 
-		public ProxyCallFixer(ModuleDefinition module, ISimpleDeobfuscator simpleDeobfuscator)
+		public ProxyCallFixer(ModuleDefMD module, ISimpleDeobfuscator simpleDeobfuscator)
 			: base(module) {
-			this.memberReferences = new List<MemberReference>(module.GetMemberReferences());
 			this.simpleDeobfuscator = simpleDeobfuscator;
 		}
 
-		protected override object checkCctor(ref TypeDefinition type, MethodDefinition cctor) {
+		protected override object checkCctor(ref TypeDef type, MethodDef cctor) {
 			var instrs = cctor.Body.Instructions;
 			if (instrs.Count > 10)
 				return null;
@@ -59,27 +57,27 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				simpleDeobfuscator.deobfuscate(cctor);
 			if (instrs.Count != 3)
 				return null;
-			if (!DotNetUtils.isLdcI4(instrs[0].OpCode.Code))
+			if (!instrs[0].IsLdcI4())
 				return null;
-			if (instrs[1].OpCode != OpCodes.Call || !isDelegateCreatorMethod(instrs[1].Operand as MethodDefinition))
+			if (instrs[1].OpCode != OpCodes.Call || !isDelegateCreatorMethod(instrs[1].Operand as MethodDef))
 				return null;
 			if (instrs[2].OpCode != OpCodes.Ret)
 				return null;
 
-			int delegateToken = 0x02000001 + DotNetUtils.getLdcI4Value(instrs[0]);
-			if (type.MetadataToken.ToInt32() != delegateToken) {
-				Log.w("Delegate token is not current type");
+			int delegateToken = 0x02000001 + instrs[0].GetLdcI4Value();
+			if (type.MDToken.ToInt32() != delegateToken) {
+				Logger.w("Delegate token is not current type");
 				return null;
 			}
 
 			return new object();
 		}
 
-		protected override void getCallInfo(object context, FieldDefinition field, out MethodReference calledMethod, out OpCode callOpcode) {
+		protected override void getCallInfo(object context, FieldDef field, out IMethod calledMethod, out OpCode callOpcode) {
 			callOpcode = OpCodes.Call;
-			string name = field.Name;
+			string name = field.Name.String;
 
-			int methodIndex = 0;
+			uint memberRefRid = 0;
 			for (int i = name.Length - 1; i >= 0; i--) {
 				char c = name[i];
 				if (c == '~') {
@@ -89,24 +87,21 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 
 				int val;
 				if (specialCharsDict.TryGetValue(c, out val))
-					methodIndex = methodIndex * specialChars.Length + val;
+					memberRefRid = memberRefRid * (uint)specialChars.Length + (uint)val;
 			}
+			memberRefRid++;
 
-			if (methodIndex >= memberReferences.Count) {
-				Log.w("Ignoring invalid methodIndex: {0:X8}, field: {1:X8}", methodIndex, field.MetadataToken.ToInt32());
-				calledMethod = null;
-				return;
-			}
-
-			calledMethod = memberReferences[methodIndex] as MethodReference;
+			calledMethod = module.ResolveMemberRef(memberRefRid);
+			if (calledMethod == null)
+				Logger.w("Ignoring invalid method RID: {0:X8}, field: {1:X8}", memberRefRid, field.MDToken.ToInt32());
 		}
 
-		public void findDelegateCreator(ModuleDefinition module) {
+		public void findDelegateCreator(ModuleDefMD module) {
 			var callCounter = new CallCounter();
 			foreach (var type in module.Types) {
 				if (type.Namespace != "" || !DotNetUtils.derivesFromDelegate(type))
 					continue;
-				var cctor = DotNetUtils.getMethod(type, ".cctor");
+				var cctor = type.FindStaticConstructor();
 				if (cctor == null)
 					continue;
 				foreach (var method in DotNetUtils.getMethodCalls(cctor))
diff --git a/de4dot.code/deobfuscators/SmartAssembly/ResolverInfoBase.cs b/de4dot.code/deobfuscators/SmartAssembly/ResolverInfoBase.cs
index 9e693da5..5abdcfb9 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/ResolverInfoBase.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/ResolverInfoBase.cs
@@ -18,23 +18,23 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.SmartAssembly {
 	abstract class ResolverInfoBase {
-		protected ModuleDefinition module;
+		protected ModuleDefMD module;
 		ISimpleDeobfuscator simpleDeobfuscator;
 		IDeobfuscator deob;
-		TypeDefinition resolverType;
-		MethodDefinition callResolverMethod;
+		TypeDef resolverType;
+		MethodDef callResolverMethod;
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return resolverType; }
 		}
 
-		public TypeDefinition CallResolverType {
+		public TypeDef CallResolverType {
 			get {
 				if (callResolverMethod == null)
 					return null;
@@ -44,11 +44,11 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			}
 		}
 
-		public MethodDefinition CallResolverMethod {
+		public MethodDef CallResolverMethod {
 			get { return callResolverMethod; }
 		}
 
-		public ResolverInfoBase(ModuleDefinition module, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
+		public ResolverInfoBase(ModuleDefMD module, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
 			this.module = module;
 			this.simpleDeobfuscator = simpleDeobfuscator;
 			this.deob = deob;
@@ -66,7 +66,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return false;
 		}
 
-		bool findTypes(MethodDefinition initMethod) {
+		bool findTypes(MethodDef initMethod) {
 			if (initMethod == null)
 				return false;
 			foreach (var method in DotNetUtils.getCalledMethods(module, initMethod)) {
@@ -81,7 +81,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return false;
 		}
 
-		bool checkAttachAppMethod(MethodDefinition attachAppMethod) {
+		bool checkAttachAppMethod(MethodDef attachAppMethod) {
 			callResolverMethod = null;
 			if (!attachAppMethod.HasBody)
 				return false;
@@ -120,7 +120,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return false;
 		}
 
-		static bool hasLdftn(MethodDefinition method) {
+		static bool hasLdftn(MethodDef method) {
 			if (method == null || method.Body == null)
 				return false;
 			foreach (var instr in method.Body.Instructions) {
@@ -130,7 +130,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return false;
 		}
 
-		bool checkResolverInitMethod(MethodDefinition initMethod) {
+		bool checkResolverInitMethod(MethodDef initMethod) {
 			resolverType = null;
 			if (!initMethod.HasBody)
 				return false;
@@ -152,18 +152,18 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return false;
 		}
 
-		void deobfuscate(MethodDefinition method) {
+		void deobfuscate(MethodDef method) {
 			simpleDeobfuscator.deobfuscate(method);
 			simpleDeobfuscator.decryptStrings(method, deob);
 		}
 
-		TypeDefinition getResolverType(MethodDefinition resolveHandler) {
+		TypeDef getResolverType(MethodDef resolveHandler) {
 			if (resolveHandler.Body == null)
 				return null;
 			foreach (var instr in resolveHandler.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Ldsfld && instr.OpCode.Code != Code.Stsfld)
 					continue;
-				var field = DotNetUtils.getField(module, instr.Operand as FieldReference);
+				var field = DotNetUtils.getField(module, instr.Operand as IField);
 				if (field == null)
 					continue;
 				if (!checkResolverType(field.DeclaringType))
@@ -178,10 +178,10 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return null;
 		}
 
-		protected abstract bool checkResolverType(TypeDefinition type);
-		protected abstract bool checkHandlerMethod(MethodDefinition handler);
+		protected abstract bool checkResolverType(TypeDef type);
+		protected abstract bool checkHandlerMethod(MethodDef handler);
 
-		IEnumerable<MethodDefinition> getResolverHandlers(MethodDefinition method) {
+		IEnumerable<MethodDef> getResolverHandlers(MethodDef method) {
 			int numHandlers = 0;
 			var instructions = method.Body.Instructions;
 			for (int i = 0; i < instructions.Count; i++) {
@@ -190,20 +190,20 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 					continue;
 
 				var call = instrs[0];
-				if (!DotNetUtils.isMethod(call.Operand as MethodReference, "System.AppDomain", "()"))
+				if (!DotNetUtils.isMethod(call.Operand as IMethod, "System.AppDomain", "()"))
 					continue;
 
 				var ldftn = instrs[2];
-				var handlerDef = DotNetUtils.getMethod(module, ldftn.Operand as MethodReference);
+				var handlerDef = DotNetUtils.getMethod(module, ldftn.Operand as IMethod);
 				if (handlerDef == null)
 					continue;
 
 				var newobj = instrs[3];
-				if (!DotNetUtils.isMethod(newobj.Operand as MethodReference, "System.Void", "(System.Object,System.IntPtr)"))
+				if (!DotNetUtils.isMethod(newobj.Operand as IMethod, "System.Void", "(System.Object,System.IntPtr)"))
 					continue;
 
 				var callvirt = instrs[4];
-				if (!DotNetUtils.isMethod(callvirt.Operand as MethodReference, "System.Void", "(System.ResolveEventHandler)"))
+				if (!DotNetUtils.isMethod(callvirt.Operand as IMethod, "System.Void", "(System.ResolveEventHandler)"))
 					continue;
 
 				numHandlers++;
@@ -215,7 +215,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				yield return method;
 		}
 
-		static bool hasOnlyThisMethod(TypeDefinition type, MethodDefinition method) {
+		static bool hasOnlyThisMethod(TypeDef type, MethodDef method) {
 			if (type == null || method == null)
 				return false;
 			foreach (var m in type.Methods) {
diff --git a/de4dot.code/deobfuscators/SmartAssembly/ResourceDecrypter.cs b/de4dot.code/deobfuscators/SmartAssembly/ResourceDecrypter.cs
index 4f1ed6f0..138e550a 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/ResourceDecrypter.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/ResourceDecrypter.cs
@@ -20,7 +20,7 @@
 using System;
 using System.IO;
 using System.Security.Cryptography;
-using Mono.Cecil;
+using dot10.DotNet;
 using ICSharpCode.SharpZipLib.Zip.Compression;
 
 namespace de4dot.code.deobfuscators.SmartAssembly {
diff --git a/de4dot.code/deobfuscators/SmartAssembly/ResourceDecrypterInfo.cs b/de4dot.code/deobfuscators/SmartAssembly/ResourceDecrypterInfo.cs
index 07d66909..43afb93a 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/ResourceDecrypterInfo.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/ResourceDecrypterInfo.cs
@@ -18,14 +18,14 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.SmartAssembly {
 	class ResourceDecrypterInfo {
-		ModuleDefinition module;
-		MethodDefinition simpleZipTypeDecryptMethod;
+		ModuleDefMD module;
+		MethodDef simpleZipTypeDecryptMethod;
 
 		public byte[] DES_Key { get; private set; }
 		public byte[] DES_IV  { get; private set; }
@@ -36,23 +36,23 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			get { return simpleZipTypeDecryptMethod != null; }
 		}
 
-		public ResourceDecrypterInfo(ModuleDefinition module) {
+		public ResourceDecrypterInfo(ModuleDefMD module) {
 			this.module = module;
 		}
 
-		public ResourceDecrypterInfo(ModuleDefinition module, MethodDefinition simpleZipTypeDecryptMethod, ISimpleDeobfuscator simpleDeobfuscator)
+		public ResourceDecrypterInfo(ModuleDefMD module, MethodDef simpleZipTypeDecryptMethod, ISimpleDeobfuscator simpleDeobfuscator)
 			: this(module) {
 			setSimpleZipType(simpleZipTypeDecryptMethod, simpleDeobfuscator);
 		}
 
-		public void setSimpleZipType(MethodDefinition method, ISimpleDeobfuscator simpleDeobfuscator) {
+		public void setSimpleZipType(MethodDef method, ISimpleDeobfuscator simpleDeobfuscator) {
 			if (simpleZipTypeDecryptMethod != null || method == null)
 				return;
 			simpleZipTypeDecryptMethod = method;
 			init(simpleDeobfuscator, method);
 		}
 
-		void init(ISimpleDeobfuscator simpleDeobfuscator, MethodDefinition method) {
+		void init(ISimpleDeobfuscator simpleDeobfuscator, MethodDef method) {
 			var desList = new List<byte[]>(2);
 			var aesList = new List<byte[]>(2);
 
@@ -62,7 +62,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				var ldtoken = instructions[i];
 				if (ldtoken.OpCode.Code != Code.Ldtoken)
 					continue;
-				var field = DotNetUtils.getField(module, ldtoken.Operand as FieldReference);
+				var field = DotNetUtils.getField(module, ldtoken.Operand as IField);
 				if (field == null)
 					continue;
 				if (field.InitialValue == null)
@@ -71,7 +71,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				var call = instructions[i + 1];
 				if (call.OpCode.Code != Code.Call)
 					continue;
-				var calledMethod = call.Operand as MethodReference;
+				var calledMethod = call.Operand as IMethod;
 				if (!DotNetUtils.isMethod(calledMethod, "System.Void", "(System.Array,System.RuntimeFieldHandle)"))
 					continue;
 
diff --git a/de4dot.code/deobfuscators/SmartAssembly/ResourceResolver.cs b/de4dot.code/deobfuscators/SmartAssembly/ResourceResolver.cs
index 8266f24d..5943e59d 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/ResourceResolver.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/ResourceResolver.cs
@@ -19,17 +19,17 @@
 
 using System;
 using System.IO;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.SmartAssembly {
 	class ResourceResolver {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		AssemblyResolver assemblyResolver;
 		ResourceResolverInfo resourceResolverInfo;
 		bool mergedIt = false;
 
-		public ResourceResolver(ModuleDefinition module, AssemblyResolver assemblyResolver, ResourceResolverInfo resourceResolverInfo) {
+		public ResourceResolver(ModuleDefMD module, AssemblyResolver assemblyResolver, ResourceResolverInfo resourceResolverInfo) {
 			this.module = module;
 			this.assemblyResolver = assemblyResolver;
 			this.resourceResolverInfo = resourceResolverInfo;
diff --git a/de4dot.code/deobfuscators/SmartAssembly/ResourceResolverInfo.cs b/de4dot.code/deobfuscators/SmartAssembly/ResourceResolverInfo.cs
index 1a4c8ad0..808c1af6 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/ResourceResolverInfo.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/ResourceResolverInfo.cs
@@ -17,8 +17,8 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.SmartAssembly {
@@ -30,16 +30,16 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			get { return resourceInfo; }
 		}
 
-		public ResourceResolverInfo(ModuleDefinition module, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob, AssemblyResolverInfo assemblyResolverInfo)
+		public ResourceResolverInfo(ModuleDefMD module, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob, AssemblyResolverInfo assemblyResolverInfo)
 			: base(module, simpleDeobfuscator, deob) {
 			this.assemblyResolverInfo = assemblyResolverInfo;
 		}
 
-		protected override bool checkResolverType(TypeDefinition type) {
+		protected override bool checkResolverType(TypeDef type) {
 			return DotNetUtils.findFieldType(type, "System.Reflection.Assembly", true) != null;
 		}
 
-		protected override bool checkHandlerMethod(MethodDefinition method) {
+		protected override bool checkHandlerMethod(MethodDef method) {
 			if (!method.IsStatic || !method.HasBody)
 				return false;
 
@@ -51,7 +51,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 					continue;
 
 				var s = instrs[0].Operand as string;
-				var calledMethod = instrs[1].Operand as MethodReference;
+				var calledMethod = instrs[1].Operand as IMethod;
 				if (s == null || calledMethod == null)
 					continue;
 
@@ -63,7 +63,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				return false;
 
 			resourceInfo = info;
-			Log.v("Found embedded assemblies resource {0}", Utils.toCsharpString(info.resourceName));
+			Logger.v("Found embedded assemblies resource {0}", Utils.toCsharpString(info.resourceName));
 			return true;
 		}
 	}
diff --git a/de4dot.code/deobfuscators/SmartAssembly/SimpleZipInfo.cs b/de4dot.code/deobfuscators/SmartAssembly/SimpleZipInfo.cs
index 1a6cf445..cac9d6b6 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/SimpleZipInfo.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/SimpleZipInfo.cs
@@ -17,13 +17,13 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.SmartAssembly {
 	class SimpleZipInfo {
 
-		public static bool isSimpleZipDecryptMethod_QuickCheck(ModuleDefinition module, MethodReference method, out MethodDefinition simpleZipTypeMethod) {
+		public static bool isSimpleZipDecryptMethod_QuickCheck(ModuleDefMD module, IMethod method, out MethodDef simpleZipTypeMethod) {
 			simpleZipTypeMethod = null;
 
 			if (!DotNetUtils.isMethod(method, "System.Byte[]", "(System.Byte[])"))
diff --git a/de4dot.code/deobfuscators/SmartAssembly/StringDecrypterInfo.cs b/de4dot.code/deobfuscators/SmartAssembly/StringDecrypterInfo.cs
index fba9ebad..6ce71988 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/StringDecrypterInfo.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/StringDecrypterInfo.cs
@@ -19,8 +19,8 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.SmartAssembly {
@@ -33,24 +33,24 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 	}
 
 	class StringDecrypterInfo {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		ResourceDecrypter resourceDecrypter;
-		TypeDefinition stringsEncodingClass;
+		TypeDef stringsEncodingClass;
 		EmbeddedResource stringsResource;
 		int stringOffset;
-		MethodDefinition simpleZipTypeMethod;
-		MethodDefinition stringDecrypterMethod;
+		MethodDef simpleZipTypeMethod;
+		MethodDef stringDecrypterMethod;
 		StringDecrypterVersion decrypterVersion;
 
 		public StringDecrypterVersion DecrypterVersion {
 			get { return decrypterVersion; }
 		}
 
-		public TypeDefinition GetStringDelegate { get; set; }
-		public TypeDefinition StringsType { get; set; }
-		public MethodDefinition CreateStringDelegateMethod { get; set; }
+		public TypeDef GetStringDelegate { get; set; }
+		public TypeDef StringsType { get; set; }
+		public MethodDef CreateStringDelegateMethod { get; set; }
 
-		public TypeDefinition StringsEncodingClass {
+		public TypeDef StringsEncodingClass {
 			get { return stringsEncodingClass; }
 		}
 
@@ -58,7 +58,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			get { return resourceDecrypter == null || resourceDecrypter.CanDecrypt; }
 		}
 
-		public MethodDefinition SimpleZipTypeMethod {
+		public MethodDef SimpleZipTypeMethod {
 			get { return simpleZipTypeMethod; }
 		}
 
@@ -74,11 +74,11 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			get { return simpleZipTypeMethod != null; }
 		}
 
-		public MethodDefinition StringDecrypterMethod {
+		public MethodDef StringDecrypterMethod {
 			get { return stringDecrypterMethod; }
 		}
 
-		public StringDecrypterInfo(ModuleDefinition module, TypeDefinition stringsEncodingClass) {
+		public StringDecrypterInfo(ModuleDefMD module, TypeDef stringsEncodingClass) {
 			this.module = module;
 			this.stringsEncodingClass = stringsEncodingClass;
 		}
@@ -91,7 +91,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			"System.Byte[]",
 			"System.Int32",
 		};
-		StringDecrypterVersion guessVersion(MethodDefinition cctor) {
+		StringDecrypterVersion guessVersion(MethodDef cctor) {
 			var fieldTypes = new FieldTypes(stringsEncodingClass);
 			if (fieldTypes.exactly(fields2x))
 				return StringDecrypterVersion.V2;
@@ -103,7 +103,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 		}
 
 		public bool init(IDeobfuscator deob, ISimpleDeobfuscator simpleDeobfuscator) {
-			var cctor = DotNetUtils.getMethod(stringsEncodingClass, ".cctor");
+			var cctor = stringsEncodingClass.FindStaticConstructor();
 			if (cctor != null)
 				simpleDeobfuscator.deobfuscate(cctor);
 
@@ -116,7 +116,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				return false;
 
 			if (decrypterVersion <= StringDecrypterVersion.V3) {
-				MethodDefinition initMethod;
+				MethodDef initMethod;
 				if (decrypterVersion == StringDecrypterVersion.V3)
 					initMethod = cctor;
 				else if (decrypterVersion == StringDecrypterVersion.V2)
@@ -127,16 +127,16 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				stringOffset = 0;
 				if (decrypterVersion != StringDecrypterVersion.V1) {
 					if (callsGetPublicKeyToken(initMethod)) {
-						var pkt = module.Assembly.Name.PublicKeyToken;
-						if (pkt != null) {
-							for (int i = 0; i < pkt.Length - 1; i += 2)
-								stringOffset ^= ((int)pkt[i] << 8) + pkt[i + 1];
+						var pkt = PublicKeyBase.ToPublicKeyToken(module.Assembly.PublicKeyToken);
+						if (!PublicKeyBase.IsNullOrEmpty2(pkt)) {
+							for (int i = 0; i < pkt.Data.Length - 1; i += 2)
+								stringOffset ^= ((int)pkt.Data[i] << 8) + pkt.Data[i + 1];
 						}
 					}
 
 					if (DeobUtils.hasInteger(initMethod, 0xFFFFFF) &&
 						DeobUtils.hasInteger(initMethod, 0xFFFF)) {
-						stringOffset ^= ((stringDecrypterMethod.MetadataToken.ToInt32() & 0xFFFFFF) - 1) % 0xFFFF;
+						stringOffset ^= ((stringDecrypterMethod.MDToken.ToInt32() & 0xFFFFFF) - 1) % 0xFFFF;
 					}
 				}
 			}
@@ -155,7 +155,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return true;
 		}
 
-		bool callsGetPublicKeyToken(MethodDefinition method) {
+		bool callsGetPublicKeyToken(MethodDef method) {
 			foreach (var calledMethod in DotNetUtils.getMethodCalls(method)) {
 				if (calledMethod.ToString() == "System.Byte[] System.Reflection.AssemblyName::GetPublicKeyToken()")
 					return true;
@@ -163,12 +163,12 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return false;
 		}
 
-		bool findStringsResource(IDeobfuscator deob, ISimpleDeobfuscator simpleDeobfuscator, MethodDefinition cctor) {
+		bool findStringsResource(IDeobfuscator deob, ISimpleDeobfuscator simpleDeobfuscator, MethodDef cctor) {
 			if (stringsResource != null)
 				return true;
 
 			if (decrypterVersion <= StringDecrypterVersion.V3) {
-				stringsResource = DotNetUtils.getResource(module, module.Mvid.ToString("B")) as EmbeddedResource;
+				stringsResource = DotNetUtils.getResource(module, (module.Mvid ?? Guid.NewGuid()).ToString("B")) as EmbeddedResource;
 				if (stringsResource != null)
 					return true;
 			}
@@ -181,7 +181,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return false;
 		}
 
-		bool findStringsResource2(IDeobfuscator deob, ISimpleDeobfuscator simpleDeobfuscator, MethodDefinition initMethod) {
+		bool findStringsResource2(IDeobfuscator deob, ISimpleDeobfuscator simpleDeobfuscator, MethodDef initMethod) {
 			if (initMethod == null)
 				return false;
 
@@ -204,7 +204,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 		}
 
 		// Find the embedded resource where all the strings are encrypted
-		EmbeddedResource findStringResource(MethodDefinition method) {
+		EmbeddedResource findStringResource(MethodDef method) {
 			foreach (var s in DotNetUtils.getCodeStrings(method)) {
 				if (s == null)
 					continue;
@@ -216,8 +216,8 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 		}
 
 		// Find the string decrypter string offset value or null if none found
-		int? findOffsetValue(MethodDefinition method) {
-			var fieldDict = new FieldDefinitionAndDeclaringTypeDict<FieldReference>();
+		int? findOffsetValue(MethodDef method) {
+			var fieldDict = new FieldDefinitionAndDeclaringTypeDict<IField>();
 			foreach (var field in method.DeclaringType.Fields)
 				fieldDict.add(field, field);
 
@@ -225,25 +225,25 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			if (offsetField == null)
 				return null;
 
-			return findOffsetValue(method, (FieldDefinition)fieldDict.find(offsetField), fieldDict);
+			return findOffsetValue(method, (FieldDef)fieldDict.find(offsetField), fieldDict);
 		}
 
-		FieldReference findOffsetField(MethodDefinition method) {
+		IField findOffsetField(MethodDef method) {
 			var instructions = method.Body.Instructions;
 			for (int i = 0; i <= instructions.Count - 2; i++) {
 				var ldsfld = instructions[i];
 				if (ldsfld.OpCode.Code != Code.Ldsfld)
 					continue;
-				var field = ldsfld.Operand as FieldReference;
-				if (field == null || field.FieldType.FullName != "System.String")
+				var field = ldsfld.Operand as IField;
+				if (field == null || field.FieldSig.GetFieldType().GetElementType() != ElementType.String)
 					continue;
-				if (!MemberReferenceHelper.compareTypes(stringsEncodingClass, field.DeclaringType))
+				if (!new SigComparer().Equals(stringsEncodingClass, field.DeclaringType))
 					continue;
 
 				var call = instructions[i + 1];
 				if (call.OpCode.Code != Code.Call)
 					continue;
-				var calledMethod = call.Operand as MethodReference;
+				var calledMethod = call.Operand as IMethod;
 				if (!DotNetUtils.isMethod(calledMethod, "System.Int32", "(System.String)"))
 					continue;
 
@@ -253,7 +253,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return null;
 		}
 
-		int? findOffsetValue(MethodDefinition method, FieldDefinition offsetField, FieldDefinitionAndDeclaringTypeDict<FieldReference> fields) {
+		int? findOffsetValue(MethodDef method, FieldDef offsetField, FieldDefinitionAndDeclaringTypeDict<IField> fields) {
 			var instructions = method.Body.Instructions;
 			for (int i = 0; i <= instructions.Count - 2; i++) {
 				var ldstr = instructions[i];
@@ -266,7 +266,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				var stsfld = instructions[i + 1];
 				if (stsfld.OpCode.Code != Code.Stsfld)
 					continue;
-				var field = stsfld.Operand as FieldReference;
+				var field = stsfld.Operand as IField;
 				if (field == null || fields.find(field) != offsetField)
 					continue;
 
@@ -284,7 +284,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			if (stringDecrypterMethod != null)
 				return true;
 
-			var methods = new List<MethodDefinition>(DotNetUtils.findMethods(stringsEncodingClass.Methods, "System.String", new string[] { "System.Int32" }));
+			var methods = new List<MethodDef>(DotNetUtils.findMethods(stringsEncodingClass.Methods, "System.String", new string[] { "System.Int32" }));
 			if (methods.Count != 1)
 				return false;
 
@@ -292,7 +292,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return true;
 		}
 
-		MethodDefinition findSimpleZipTypeMethod(MethodDefinition method) {
+		MethodDef findSimpleZipTypeMethod(MethodDef method) {
 			if (method == null || method.Body == null)
 				return null;
 			var instructions = method.Body.Instructions;
@@ -300,7 +300,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				var call = instructions[i];
 				if (call.OpCode.Code != Code.Call)
 					continue;
-				var calledMethod = call.Operand as MethodDefinition;
+				var calledMethod = call.Operand as MethodDef;
 				if (calledMethod == null)
 					continue;
 				if (!DotNetUtils.isMethod(calledMethod, "System.Byte[]", "(System.Byte[])"))
@@ -309,10 +309,10 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				var stsfld = instructions[i + 1];
 				if (stsfld.OpCode.Code != Code.Stsfld)
 					continue;
-				var field = stsfld.Operand as FieldReference;
-				if (field == null || field.FieldType.FullName != "System.Byte[]")
+				var field = stsfld.Operand as IField;
+				if (field == null || field.FieldSig.GetFieldType().GetFullName() != "System.Byte[]")
 					continue;
-				if (!MemberReferenceHelper.compareTypes(stringsEncodingClass, field.DeclaringType))
+				if (!new SigComparer().Equals(stringsEncodingClass, field.DeclaringType))
 					continue;
 
 				return calledMethod;
@@ -321,10 +321,12 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return null;
 		}
 
-		public IEnumerable<FieldDefinition> getAllStringDelegateFields() {
+		public IEnumerable<FieldDef> getAllStringDelegateFields() {
+			if (GetStringDelegate == null)
+				yield break;
 			foreach (var type in module.GetTypes()) {
 				foreach (var field in type.Fields) {
-					if (field.FieldType == GetStringDelegate)
+					if (field.FieldType.TryGetTypeDef() == GetStringDelegate)
 						yield return field;
 				}
 			}
@@ -347,8 +349,8 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 					var call = instructions[i];
 					if (call.OpCode != OpCodes.Call)
 						continue;
-					var method = call.Operand as MethodReference;
-					if (!MemberReferenceHelper.compareMethodReferenceAndDeclaringType(method, CreateStringDelegateMethod))
+					var method = call.Operand as IMethod;
+					if (!MethodEqualityComparer.CompareDeclaringTypes.Equals(method, CreateStringDelegateMethod))
 						continue;
 
 					block.remove(i, 1);
@@ -364,21 +366,21 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 					var ldtoken = instructions[i];
 					if (ldtoken.OpCode != OpCodes.Ldtoken)
 						continue;
-					if (!MemberReferenceHelper.compareTypes(blocks.Method.DeclaringType, ldtoken.Operand as TypeReference))
+					if (!new SigComparer().Equals(blocks.Method.DeclaringType, ldtoken.Operand as ITypeDefOrRef))
 						continue;
 
 					var call1 = instructions[i + 1];
 					if (call1.OpCode != OpCodes.Call)
 						continue;
-					var method1 = call1.Operand as MethodReference;
+					var method1 = call1.Operand as IMethod;
 					if (method1 == null || method1.ToString() != "System.Type System.Type::GetTypeFromHandle(System.RuntimeTypeHandle)")
 						continue;
 
 					var call2 = instructions[i + 2];
 					if (call2.OpCode != OpCodes.Call)
 						continue;
-					var method2 = call2.Operand as MethodReference;
-					if (!MemberReferenceHelper.compareMethodReferenceAndDeclaringType(method2, CreateStringDelegateMethod))
+					var method2 = call2.Operand as IMethod;
+					if (!MethodEqualityComparer.CompareDeclaringTypes.Equals(method2, CreateStringDelegateMethod))
 						continue;
 
 					block.remove(i, 3);
diff --git a/de4dot.code/deobfuscators/SmartAssembly/StringEncoderClassFinder.cs b/de4dot.code/deobfuscators/SmartAssembly/StringEncoderClassFinder.cs
index 1a50bcdb..6df6a376 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/StringEncoderClassFinder.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/StringEncoderClassFinder.cs
@@ -18,24 +18,24 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.SmartAssembly {
 	class StringsEncoderInfo {
 		// SmartAssembly.HouseOfCards.Strings, the class that creates the string decrypter
 		// delegates
-		public TypeDefinition StringsType { get; set; }
-		public TypeDefinition GetStringDelegate { get; set; }
-		public MethodDefinition CreateStringDelegateMethod { get; set; }
+		public TypeDef StringsType { get; set; }
+		public TypeDef GetStringDelegate { get; set; }
+		public MethodDef CreateStringDelegateMethod { get; set; }
 
 		// The class that decodes the strings. Called by the strings delegate or normal code.
-		public TypeDefinition StringDecrypterClass { get; set; }
+		public TypeDef StringDecrypterClass { get; set; }
 	}
 
 	class StringEncoderClassFinder {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		ISimpleDeobfuscator simpleDeobfuscator;
 		IList<StringsEncoderInfo> stringsEncoderInfos = new List<StringsEncoderInfo>();
 
@@ -43,12 +43,12 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			get { return stringsEncoderInfos; }
 		}
 
-		public StringEncoderClassFinder(ModuleDefinition module, ISimpleDeobfuscator simpleDeobfuscator) {
+		public StringEncoderClassFinder(ModuleDefMD module, ISimpleDeobfuscator simpleDeobfuscator) {
 			this.module = module;
 			this.simpleDeobfuscator = simpleDeobfuscator;
 		}
 
-		TypeDefinition getType(TypeReference typeReference) {
+		TypeDef getType(ITypeDefOrRef typeReference) {
 			return DotNetUtils.getType(module, typeReference);
 		}
 
@@ -84,7 +84,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			}
 		}
 
-		bool checkDelegateCreatorMethod(TypeDefinition type, MethodDefinition method) {
+		bool checkDelegateCreatorMethod(TypeDef type, MethodDef method) {
 			simpleDeobfuscator.deobfuscate(method);
 
 			var getStringDelegate = findGetStringDelegate(method);
@@ -106,20 +106,20 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 		}
 
 		// Finds the SmartAssembly.Delegates.GetString delegate
-		TypeDefinition findGetStringDelegate(MethodDefinition stringsCreateDelegateMethod) {
+		TypeDef findGetStringDelegate(MethodDef stringsCreateDelegateMethod) {
 			if (!stringsCreateDelegateMethod.HasBody)
 				return null;
 
 			foreach (var ldtoken in stringsCreateDelegateMethod.Body.Instructions) {
 				if (ldtoken.OpCode.Code != Code.Ldtoken)
 					continue;
-				var typeToken = ldtoken.Operand as TypeReference;
+				var typeToken = ldtoken.Operand as ITypeDefOrRef;
 				if (typeToken == null)
 					continue;
 				var delegateType = getType(typeToken);
 				if (!DotNetUtils.derivesFromDelegate(delegateType))
 					continue;
-				var invoke = DotNetUtils.getMethod(delegateType, "Invoke");
+				var invoke = delegateType.FindMethod("Invoke");
 				if (invoke == null || !DotNetUtils.isMethod(invoke, "System.String", "(System.Int32)"))
 					continue;
 
@@ -132,14 +132,14 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 		// Finds the SmartAssembly.StringsEncoding.Strings class. This class decrypts the
 		// strings in the resources. It gets called by the SmartAssembly.Delegates.GetString
 		// delegate instances which were created by SmartAssembly.HouseOfCards.Strings.
-		TypeDefinition findStringDecrypterClass(MethodDefinition stringsCreateDelegateMethod) {
+		TypeDef findStringDecrypterClass(MethodDef stringsCreateDelegateMethod) {
 			if (!stringsCreateDelegateMethod.HasBody)
 				return null;
 
 			foreach (var ldtoken in stringsCreateDelegateMethod.Body.Instructions) {
 				if (ldtoken.OpCode.Code != Code.Ldtoken)
 					continue;
-				var typeToken = ldtoken.Operand as TypeReference;
+				var typeToken = ldtoken.Operand as ITypeDefOrRef;
 				if (typeToken == null)
 					continue;
 				var type = getType(typeToken);
@@ -155,7 +155,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 		}
 
 		void findStringDecrypterClasses() {
-			var foundClasses = new Dictionary<TypeDefinition, bool>();
+			var foundClasses = new Dictionary<TypeDef, bool>();
 			foreach (var info in stringsEncoderInfos)
 				foundClasses[info.StringDecrypterClass] = true;
 
@@ -181,12 +181,12 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			"System.Byte[]",
 			"System.Int32",
 		};
-		bool couldBeStringDecrypterClass(TypeDefinition type) {
+		bool couldBeStringDecrypterClass(TypeDef type) {
 			var fields = new FieldTypes(type);
 			if (fields.exists("System.Collections.Hashtable") ||
 				fields.exists("System.Collections.Generic.Dictionary`2<System.Int32,System.String>") ||
 				fields.exactly(fields3x)) {
-				if (DotNetUtils.getMethod(type, ".cctor") == null)
+				if (type.FindStaticConstructor() == null)
 					return false;
 			}
 			else if (fields.exactly(fields1x) || fields.exactly(fields2x)) {
@@ -194,7 +194,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			else
 				return false;
 
-			var methods = new List<MethodDefinition>(DotNetUtils.getNormalMethods(type));
+			var methods = new List<MethodDef>(DotNetUtils.getNormalMethods(type));
 			if (methods.Count != 1)
 				return false;
 			var method = methods[0];
diff --git a/de4dot.code/deobfuscators/SmartAssembly/TamperProtectionRemover.cs b/de4dot.code/deobfuscators/SmartAssembly/TamperProtectionRemover.cs
index b8e0ee11..51a2d82e 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/TamperProtectionRemover.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/TamperProtectionRemover.cs
@@ -19,25 +19,25 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.SmartAssembly {
 	class TamperProtectionRemover {
-		ModuleDefinition module;
-		List<MethodDefinition> pinvokeMethods = new List<MethodDefinition>();
+		ModuleDefMD module;
+		List<MethodDef> pinvokeMethods = new List<MethodDef>();
 
 		enum Type {
 			V1,
 			V2,
 		}
 
-		public IList<MethodDefinition> PinvokeMethods {
+		public IList<MethodDef> PinvokeMethods {
 			get { return pinvokeMethods; }
 		}
 
-		public TamperProtectionRemover(ModuleDefinition module) {
+		public TamperProtectionRemover(ModuleDefMD module) {
 			this.module = module;
 		}
 
@@ -68,7 +68,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 
 		class TamperBlocks {
 			public Type type;
-			public MethodDefinition pinvokeMethod;
+			public MethodDef pinvokeMethod;
 			public BlockInfo first;
 			public BlockInfo second;
 			public BlockInfo bad;
@@ -89,7 +89,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return tamperBlocks;
 		}
 
-		bool findFirstBlocks(TamperBlocks tamperBlocks, IList<Block> allBlocks, IList<VariableDefinition> locals) {
+		bool findFirstBlocks(TamperBlocks tamperBlocks, IList<Block> allBlocks, IList<Local> locals) {
 			foreach (var b in allBlocks) {
 				try {
 					if (findFirstBlocks(b, tamperBlocks, allBlocks, locals))
@@ -103,14 +103,14 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return false;
 		}
 
-		static int findCallMethod(Block block, int index, bool keepLooking, Func<MethodReference, bool> func) {
+		static int findCallMethod(Block block, int index, bool keepLooking, Func<IMethod, bool> func) {
 			var instrs = block.Instructions;
 			for (int i = index; i < instrs.Count; i++) {
 				var instr = instrs[i];
 				if (instr.OpCode.Code != Code.Call && instr.OpCode.Code != Code.Callvirt)
 					continue;
 
-				var calledMethod = instr.Operand as MethodReference;
+				var calledMethod = instr.Operand as IMethod;
 				if (calledMethod != null && func(calledMethod))
 					return i;
 				if (!keepLooking)
@@ -119,7 +119,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return -1;
 		}
 
-		bool findFirstBlocks(Block block, TamperBlocks tamperBlocks, IList<Block> allBlocks, IList<VariableDefinition> locals) {
+		bool findFirstBlocks(Block block, TamperBlocks tamperBlocks, IList<Block> allBlocks, IList<Local> locals) {
 			if (!block.LastInstr.isBrfalse())
 				return false;
 
@@ -146,7 +146,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			var instrs = block.Instructions;
 			int end = instrs.Count - 1;
 			Instr instr;
-			MethodReference method;
+			IMethod method;
 			tamperBlocks.type = Type.V1;
 
 			int index = 0;
@@ -223,8 +223,8 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			instr = instrs[end++];
 			if (instr.OpCode != OpCodes.Callvirt)
 				return false;
-			method = (MethodReference)instr.Operand;
-			if (method.ToString() != "System.String System.Reflection.Assembly::get_FullName()")
+			method = instr.Operand as IMethod;
+			if (method == null || method.ToString() != "System.String System.Reflection.Assembly::get_FullName()")
 				return false;
 
 			instr = instrs[end++];
@@ -234,8 +234,8 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			instr = instrs[end++];
 			if (instr.OpCode != OpCodes.Callvirt)
 				return false;
-			method = (MethodReference)instr.Operand;
-			if (method.ToString() != "System.Boolean System.String::EndsWith(System.String)")
+			method = instr.Operand as IMethod;
+			if (method == null || method.ToString() != "System.Boolean System.String::EndsWith(System.String)")
 				return false;
 
 			instr = instrs[end++];
@@ -274,8 +274,8 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			instr = instrs[end++];
 			if (instr.OpCode != OpCodes.Newobj)
 				return null;
-			var method = (MethodReference)instr.Operand;
-			if (method.ToString() != "System.Void System.Security.SecurityException::.ctor(System.String)")
+			var method = instr.Operand as IMethod;
+			if (method == null || method.ToString() != "System.Void System.Security.SecurityException::.ctor(System.String)")
 				return null;
 
 			instr = instrs[end++];
@@ -296,7 +296,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 
 			if (tamperBlocks == null) {
 				if (isTamperProtected(allBlocks))
-					Log.w("Could not remove tamper protection code: {0} ({1:X8})", Utils.removeNewlines(blocks.Method), blocks.Method.MetadataToken.ToUInt32());
+					Logger.w("Could not remove tamper protection code: {0} ({1:X8})", Utils.removeNewlines(blocks.Method), blocks.Method.MDToken.ToUInt32());
 				return false;
 			}
 
diff --git a/de4dot.code/deobfuscators/Spices_Net/Deobfuscator.cs b/de4dot.code/deobfuscators/Spices_Net/Deobfuscator.cs
index 54cbd957..e7f18086 100644
--- a/de4dot.code/deobfuscators/Spices_Net/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/Spices_Net/Deobfuscator.cs
@@ -18,7 +18,7 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 using de4dot.blocks.cflow;
 
@@ -143,6 +143,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 				switch (type.FullName) {
 				case "NineRays.Decompiler.NotDecompile":
 				case "NineRays.Obfuscator.Evaluation":
+				case "NineRays.Obfuscator.SoftwareWatermarkAttribute":
 					addAttributeToBeRemoved(type, "Obfuscator attribute");
 					foundSpicesAttribute = true;
 					break;
@@ -213,7 +214,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 		public override IEnumerable<int> getStringDecrypterMethods() {
 			var list = new List<int>();
 			foreach (var info in stringDecrypter.DecrypterInfos)
-				list.Add(info.method.MetadataToken.ToInt32());
+				list.Add(info.method.MDToken.ToInt32());
 			return list;
 		}
 	}
diff --git a/de4dot.code/deobfuscators/Spices_Net/ResourceNamesRestorer.cs b/de4dot.code/deobfuscators/Spices_Net/ResourceNamesRestorer.cs
index 68a7b8ec..bc53fdaa 100644
--- a/de4dot.code/deobfuscators/Spices_Net/ResourceNamesRestorer.cs
+++ b/de4dot.code/deobfuscators/Spices_Net/ResourceNamesRestorer.cs
@@ -18,27 +18,27 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Spices_Net {
 	class ResourceNamesRestorer {
-		ModuleDefinition module;
-		TypeDefinition resourceManagerType;
-		TypeDefinition componentResourceManagerType;
-		MethodDefinitionAndDeclaringTypeDict<MethodReference> resourceManagerCtors = new MethodDefinitionAndDeclaringTypeDict<MethodReference>();
-		MethodDefinitionAndDeclaringTypeDict<MethodReference> componentManagerCtors = new MethodDefinitionAndDeclaringTypeDict<MethodReference>();
+		ModuleDefMD module;
+		TypeDef resourceManagerType;
+		TypeDef componentResourceManagerType;
+		MethodDefinitionAndDeclaringTypeDict<IMethod> resourceManagerCtors = new MethodDefinitionAndDeclaringTypeDict<IMethod>();
+		MethodDefinitionAndDeclaringTypeDict<IMethod> componentManagerCtors = new MethodDefinitionAndDeclaringTypeDict<IMethod>();
 
-		public TypeDefinition ResourceManagerType {
+		public TypeDef ResourceManagerType {
 			get { return resourceManagerType; }
 		}
 
-		public TypeDefinition ComponentResourceManagerType {
+		public TypeDef ComponentResourceManagerType {
 			get { return componentResourceManagerType; }
 		}
 
-		public ResourceNamesRestorer(ModuleDefinition module) {
+		public ResourceNamesRestorer(ModuleDefMD module) {
 			this.module = module;
 		}
 
@@ -54,7 +54,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			initializeCtors(componentResourceManagerType, componentManagerCtors);
 		}
 
-		static void initializeCtors(TypeDefinition manager, MethodDefinitionAndDeclaringTypeDict<MethodReference> ctors) {
+		void initializeCtors(TypeDef manager, MethodDefinitionAndDeclaringTypeDict<IMethod> ctors) {
 			if (manager == null)
 				return;
 
@@ -62,22 +62,20 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 				if (ctor.Name != ".ctor")
 					continue;
 
-				var newCtor = new MethodReference(ctor.Name, ctor.MethodReturnType.ReturnType, manager.BaseType);
-				newCtor.HasThis = true;
-				foreach (var param in ctor.Parameters)
-					newCtor.Parameters.Add(new ParameterDefinition(param.ParameterType));
+				var newCtor = new MemberRefUser(module, ctor.Name, ctor.MethodSig.Clone(), manager.BaseType);
+				module.UpdateRowId(newCtor);
 				ctors.add(ctor, newCtor);
 			}
 		}
 
-		static bool isResourceType(TypeDefinition type, string baseTypeName) {
+		static bool isResourceType(TypeDef type, string baseTypeName) {
 			if (type.BaseType == null || type.BaseType.FullName != baseTypeName)
 				return false;
 			if (type.HasProperties || type.HasEvents || type.HasFields)
 				return false;
 			if (type.Interfaces.Count > 0)
 				return false;
-			var method = DotNetUtils.getMethod(type, "GetResourceFileName");
+			var method = type.FindMethod("GetResourceFileName");
 			if (!DotNetUtils.isMethod(method, "System.String", "(System.Globalization.CultureInfo)"))
 				return false;
 
@@ -90,7 +88,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 
 			var numToResource = new Dictionary<uint, Resource>(module.Resources.Count);
 			foreach (var resource in module.Resources) {
-				var name = resource.Name;
+				var name = resource.Name.String;
 				int index = name.LastIndexOf('.');
 				string ext;
 				if (index < 0)
@@ -106,12 +104,12 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			foreach (var type in module.GetTypes()) {
 				rename(numToResource, "", type.FullName);
 				rename(numToResource, "", type.FullName + ".g");
-				rename(numToResource, type.Namespace, type.Name);
-				rename(numToResource, type.Namespace, type.Name + ".g");
+				rename(numToResource, type.Namespace.String, type.Name.String);
+				rename(numToResource, type.Namespace.String, type.Name.String + ".g");
 			}
 
 			if (module.Assembly != null)
-				rename(numToResource, "", module.Assembly.Name.Name + ".g");
+				rename(numToResource, "", module.Assembly.Name.String + ".g");
 		}
 
 		static void rename(Dictionary<uint, Resource> numToResource, string ns, string name) {
@@ -121,23 +119,23 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			if (!numToResource.TryGetValue(hash, out resource))
 				return;
 
-			int index = resource.Name.LastIndexOf('.');
+			int index = resource.Name.String.LastIndexOf('.');
 			string resourceNamespace, newName;
 			if (index < 0) {
 				resourceNamespace = "";
 				newName = resourceName;
 			}
 			else {
-				resourceNamespace = resource.Name.Substring(0, index);
+				resourceNamespace = resource.Name.String.Substring(0, index);
 				newName = resourceNamespace + "." + resourceName;
 			}
 			if (resourceNamespace != ns)
 				return;
 
-			Log.v("Restoring resource name: '{0}' => '{1}'",
+			Logger.v("Restoring resource name: '{0}' => '{1}'",
 								Utils.removeNewlines(resource.Name),
 								Utils.removeNewlines(newName));
-			resource.Name = newName;
+			resource.Name = new UTF8String(newName);
 			numToResource.Remove(hash);
 		}
 
@@ -153,13 +151,16 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 		}
 
 		public void deobfuscate(Blocks blocks) {
+			if (resourceManagerType == null && componentResourceManagerType == null)
+				return;
+
 			foreach (var block in blocks.MethodBlocks.getAllBlocks()) {
 				var instrs = block.Instructions;
 				for (int i = 0; i < instrs.Count; i++) {
 					var instr = instrs[i];
 					if (instr.OpCode.Code != Code.Newobj)
 						continue;
-					var ctor = instr.Operand as MethodReference;
+					var ctor = instr.Operand as IMethod;
 					if (ctor == null)
 						continue;
 					var newCtor = resourceManagerCtors.find(ctor);
diff --git a/de4dot.code/deobfuscators/Spices_Net/SpicesMethodCallInliner.cs b/de4dot.code/deobfuscators/Spices_Net/SpicesMethodCallInliner.cs
index 739cae6a..2822ac55 100644
--- a/de4dot.code/deobfuscators/Spices_Net/SpicesMethodCallInliner.cs
+++ b/de4dot.code/deobfuscators/Spices_Net/SpicesMethodCallInliner.cs
@@ -18,38 +18,37 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.Cecil.Metadata;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 using de4dot.blocks.cflow;
 
 namespace de4dot.code.deobfuscators.Spices_Net {
 	class SpicesMethodCallInliner : MethodCallInliner {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		TypeDefinitionDict<bool> methodsTypes = new TypeDefinitionDict<bool>();
-		MethodDefinitionAndDeclaringTypeDict<MethodDefinition> classMethods = new MethodDefinitionAndDeclaringTypeDict<MethodDefinition>();
+		MethodDefinitionAndDeclaringTypeDict<MethodDef> classMethods = new MethodDefinitionAndDeclaringTypeDict<MethodDef>();
 
-		public SpicesMethodCallInliner(ModuleDefinition module)
+		public SpicesMethodCallInliner(ModuleDefMD module)
 			: base(false) {
 			this.module = module;
 		}
 
-		protected override bool isCompatibleType(int paramIndex, TypeReference origType, TypeReference newType) {
-			if (MemberReferenceHelper.compareTypes(origType, newType))
+		protected override bool isCompatibleType(int paramIndex, IType origType, IType newType) {
+			if (new SigComparer(SigComparerOptions.IgnoreModifiers).Equals(origType, newType))
 				return true;
 			if (paramIndex == -1) {
-				if (newType.IsValueType || origType.IsValueType)
+				if (isValueType(newType) || isValueType(origType))
 					return false;
 			}
-			return newType.EType == ElementType.Object;
+			return newType.FullName == "System.Object";
 		}
 
-		public bool checkCanInline(MethodDefinition method) {
+		public bool checkCanInline(MethodDef method) {
 			return methodsTypes.find(method.DeclaringType);
 		}
 
-		protected override bool canInline(MethodDefinition method) {
+		protected override bool canInline(MethodDef method) {
 			return checkCanInline(method);
 		}
 
@@ -59,9 +58,9 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 		}
 
 		void restoreMethodBodies() {
-			var methodToOrigMethods = new MethodDefinitionAndDeclaringTypeDict<List<MethodDefinition>>();
+			var methodToOrigMethods = new MethodDefinitionAndDeclaringTypeDict<List<MethodDef>>();
 			foreach (var t in module.Types) {
-				var types = new List<TypeDefinition>(TypeDefinition.GetTypes(new List<TypeDefinition> { t }));
+				var types = new List<TypeDef>(AllTypesHelper.Types(new List<TypeDef> { t }));
 				foreach (var type in types) {
 					if (methodsTypes.find(type))
 						continue;
@@ -69,7 +68,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 						if (method.Name == ".ctor" || method.Name == ".cctor")
 							continue;
 
-						MethodDefinition calledMethod;
+						MethodDef calledMethod;
 						if (!checkRestoreBody(method, out calledMethod))
 							continue;
 						if (!checkSameMethods(method, calledMethod))
@@ -81,7 +80,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 
 						var list = methodToOrigMethods.find(calledMethod);
 						if (list == null)
-							methodToOrigMethods.add(calledMethod, list = new List<MethodDefinition>());
+							methodToOrigMethods.add(calledMethod, list = new List<MethodDef>());
 						list.Add(method);
 					}
 				}
@@ -91,19 +90,19 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 				var list = methodToOrigMethods.find(calledMethod);
 				var method = list[0];
 
-				Log.v("Restored method body {0:X8} from method {1:X8}",
-							method.MetadataToken.ToInt32(),
-							calledMethod.MetadataToken.ToInt32());
+				Logger.v("Restored method body {0:X8} from method {1:X8}",
+							method.MDToken.ToInt32(),
+							calledMethod.MDToken.ToInt32());
 				DotNetUtils.copyBodyFromTo(calledMethod, method);
 				classMethods.add(calledMethod, method);
 			}
 		}
 
-		bool checkRestoreBody(MethodDefinition method, out MethodDefinition calledMethod) {
+		bool checkRestoreBody(MethodDef method, out MethodDef calledMethod) {
 			calledMethod = null;
 			if (method.Body == null)
 				return false;
-			if (method.Body.Variables.Count > 0)
+			if (method.Body.LocalList.Count > 0)
 				return false;
 			if (method.Body.ExceptionHandlers.Count > 0)
 				return false;
@@ -122,20 +121,20 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			return true;
 		}
 
-		bool checkRestoreBody2(MethodDefinition instanceMethod, out MethodDefinition calledMethod) {
+		bool checkRestoreBody2(MethodDef instanceMethod, out MethodDef calledMethod) {
 			calledMethod = null;
 
 			var instrs = instanceMethod.Body.Instructions;
 			int index;
 			for (index = 0; index < instrs.Count; index++) {
-				if (DotNetUtils.getArgIndex(instrs[index]) != index)
+				if (instrs[index].GetParameterIndex() != index)
 					break;
 			}
 			var call = instrs[index++];
 			if (call.OpCode.Code != Code.Call)
 				return false;
 
-			calledMethod = call.Operand as MethodDefinition;
+			calledMethod = call.Operand as MethodDef;
 			if (calledMethod == null)
 				return false;
 
@@ -152,7 +151,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			}
 		}
 
-		static bool checkMethodsType(TypeDefinition type) {
+		static bool checkMethodsType(TypeDef type) {
 			if (!type.IsNested)
 				return false;
 			if ((type.Attributes & ~TypeAttributes.BeforeFieldInit) != TypeAttributes.NestedAssembly)
@@ -163,7 +162,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 				return false;
 			if (type.IsValueType || type.IsInterface)
 				return false;
-			if (type.BaseType == null || type.BaseType.EType != ElementType.Object)
+			if (type.BaseType == null || type.BaseType.FullName != "System.Object")
 				return false;
 			if (type.Interfaces.Count > 0)
 				return false;
@@ -173,7 +172,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			return true;
 		}
 
-		static bool checkMethods(TypeDefinition type) {
+		static bool checkMethods(TypeDef type) {
 			bool foundCtor = false;
 			int numMethods = 0;
 
@@ -181,14 +180,14 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 				if (method.Name == ".cctor")
 					return false;
 				if (method.Name == ".ctor") {
-					if (method.Parameters.Count != 0)
+					if (method.MethodSig.GetParamCount() != 0)
 						return false;
 					foundCtor = true;
 					continue;
 				}
 				if (method.Attributes != (MethodAttributes.Assembly | MethodAttributes.Static | MethodAttributes.HideBySig))
 					return false;
-				if (method.HasPInvokeInfo || method.PInvokeInfo != null)
+				if (method.ImplMap != null)
 					return false;
 				if (method.GenericParameters.Count > 0)
 					return false;
@@ -199,8 +198,8 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			return numMethods > 0 && foundCtor;
 		}
 
-		public List<MethodDefinition> getInlinedMethods() {
-			var list = new List<MethodDefinition>();
+		public List<MethodDef> getInlinedMethods() {
+			var list = new List<MethodDef>();
 
 			foreach (var type in methodsTypes.getKeys())
 				list.AddRange(type.Methods);
@@ -208,7 +207,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			return list;
 		}
 
-		public TypeDefinitionDict<bool> getInlinedTypes(IEnumerable<MethodDefinition> unusedMethods) {
+		public TypeDefinitionDict<bool> getInlinedTypes(IEnumerable<MethodDef> unusedMethods) {
 			var unused = new MethodDefinitionAndDeclaringTypeDict<bool>();
 			foreach (var method in unusedMethods)
 				unused.add(method, true);
@@ -221,7 +220,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			return types;
 		}
 
-		static bool checkAllMethodsUnused(MethodDefinitionAndDeclaringTypeDict<bool> unused, TypeDefinition type) {
+		static bool checkAllMethodsUnused(MethodDefinitionAndDeclaringTypeDict<bool> unused, TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (!unused.find(method))
 					return false;
@@ -236,7 +235,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 					var call = instrs[i];
 					if (call.OpCode.Code != Code.Call)
 						continue;
-					var realInstanceMethod = classMethods.find(call.Operand as MethodReference);
+					var realInstanceMethod = classMethods.find(call.Operand as IMethod);
 					if (realInstanceMethod == null)
 						continue;
 					call.Operand = realInstanceMethod;
diff --git a/de4dot.code/deobfuscators/Spices_Net/StringDecrypter.cs b/de4dot.code/deobfuscators/Spices_Net/StringDecrypter.cs
index 499c2d56..60256419 100644
--- a/de4dot.code/deobfuscators/Spices_Net/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/Spices_Net/StringDecrypter.cs
@@ -20,16 +20,15 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.Cecil.Metadata;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Spices_Net {
 	class StringDecrypter {
-		ModuleDefinition module;
-		TypeDefinition decrypterType;
-		FieldDefinition encryptedDataField;
+		ModuleDefMD module;
+		TypeDef decrypterType;
+		FieldDef encryptedDataField;
 		StringDataFlags stringDataFlags;
 		MethodDefinitionAndDeclaringTypeDict<DecrypterInfo> methodToInfo = new MethodDefinitionAndDeclaringTypeDict<DecrypterInfo>();
 		byte[] decryptedData;
@@ -45,22 +44,22 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 		}
 
 		public class DecrypterInfo {
-			public MethodDefinition method;
+			public MethodDef method;
 			public int offset;
 			public int length;
 
-			public DecrypterInfo(MethodDefinition method, int offset, int length) {
+			public DecrypterInfo(MethodDef method, int offset, int length) {
 				this.method = method;
 				this.offset = offset;
 				this.length = length;
 			}
 		}
 
-		public TypeDefinition EncryptedStringsType {
+		public TypeDef EncryptedStringsType {
 			get {
 				if (encryptedDataField == null)
 					return null;
-				var type = encryptedDataField.FieldType as TypeDefinition;
+				var type = encryptedDataField.FieldSig.GetFieldType().TryGetTypeDef();
 				if (type == null || type.Fields.Count != 1 || type.Fields[0] != encryptedDataField)
 					return null;
 				if (type.HasMethods || type.HasEvents || type.HasProperties || type.HasNestedTypes)
@@ -72,7 +71,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			}
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return decrypterType; }
 		}
 
@@ -84,7 +83,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			get { return methodToInfo.getValues(); }
 		}
 
-		public StringDecrypter(ModuleDefinition module) {
+		public StringDecrypter(ModuleDefMD module) {
 			this.module = module;
 		}
 
@@ -102,11 +101,11 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 					continue;
 				if (hasInstanceMethods(type))
 					continue;
-				var cctor = DotNetUtils.getMethod(type, ".cctor");
+				var cctor = type.FindStaticConstructor();
 				if (cctor == null)
 					continue;
 
-				FieldDefinition encryptedDataFieldTmp;
+				FieldDef encryptedDataFieldTmp;
 				StringDataFlags stringDataFlagsTmp;
 				if (!checkCctor(cctor, out encryptedDataFieldTmp, out stringDataFlagsTmp))
 					continue;
@@ -121,22 +120,22 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			}
 		}
 
-		static bool hasInstanceMethods(TypeDefinition type) {
+		static bool hasInstanceMethods(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (!method.IsStatic)
 					return true;
-				if (method.PInvokeInfo != null)
+				if (method.ImplMap != null)
 					return true;
 			}
 			return false;
 		}
 
-		bool checkCctor(MethodDefinition cctor, out FieldDefinition compressedDataField, out StringDataFlags flags) {
+		bool checkCctor(MethodDef cctor, out FieldDef compressedDataField, out StringDataFlags flags) {
 			flags = 0;
 			var instructions = cctor.Body.Instructions;
 			for (int i = 0; i < instructions.Count; i++) {
 				var ldci4 = instructions[i];
-				if (!DotNetUtils.isLdcI4(ldci4))
+				if (!ldci4.IsLdcI4())
 					continue;
 
 				var instrs = DotNetUtils.getInstructions(instructions, i + 1, OpCodes.Newarr, OpCodes.Dup, OpCodes.Ldtoken, OpCodes.Call);
@@ -147,13 +146,13 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 				if (newarr.Operand.ToString() != "System.Byte")
 					continue;
 
-				var field = instrs[2].Operand as FieldDefinition;
+				var field = instrs[2].Operand as FieldDef;
 				if (field == null || field.InitialValue == null || field.InitialValue.Length == 0)
 					continue;
 
 				int index = i + 1 + instrs.Count;
 				if (index < instructions.Count && instructions[index].OpCode.Code == Code.Call)
-					flags = getStringDataFlags(instructions[index].Operand as MethodDefinition);
+					flags = getStringDataFlags(instructions[index].Operand as MethodDef);
 
 				compressedDataField = field;
 				return true;
@@ -163,14 +162,15 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			return false;
 		}
 
-		StringDataFlags getStringDataFlags(MethodDefinition method) {
+		StringDataFlags getStringDataFlags(MethodDef method) {
 			if (method == null || method.Body == null)
 				return 0;
-			if (method.Parameters.Count != 1)
+			var sig = method.MethodSig;
+			if (sig == null || sig.Params.Count != 1)
 				return 0;
-			if (!checkClass(method.Parameters[0].ParameterType, "System.Byte[]"))
+			if (!checkClass(sig.Params[0], "System.Byte[]"))
 				return 0;
-			if (!checkClass(method.MethodReturnType.ReturnType, "System.Byte[]"))
+			if (!checkClass(sig.RetType, "System.Byte[]"))
 				return 0;
 
 			StringDataFlags flags = 0;
@@ -187,16 +187,17 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			return flags;
 		}
 
-		bool check3DesCreator(MethodDefinition method) {
+		bool check3DesCreator(MethodDef method) {
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Call)
 					continue;
-				var calledMethod = instr.Operand as MethodDefinition;
+				var calledMethod = instr.Operand as MethodDef;
 				if (calledMethod == null)
 					continue;
-				if (calledMethod.MethodReturnType.ReturnType.EType == ElementType.Void)
+				var sig = calledMethod.MethodSig;
+				if (sig == null || sig.RetType.GetElementType() == ElementType.Void)
 					continue;
-				if (calledMethod.Parameters.Count != 0)
+				if (sig.Params.Count != 0)
 					continue;
 				if (!get3DesKeyIv(calledMethod, ref key, ref iv))
 					continue;
@@ -206,42 +207,47 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			return false;
 		}
 
-		bool get3DesKeyIv(MethodDefinition method, ref byte[] key, ref byte[] iv) {
+		bool get3DesKeyIv(MethodDef method, ref byte[] key, ref byte[] iv) {
 			if (!new LocalTypes(method).exists("System.Security.Cryptography.TripleDESCryptoServiceProvider"))
 				return false;
 
 			var instrs = method.Body.Instructions;
-			var arrays = ArrayFinder.getArrays(method, module.TypeSystem.Byte);
+			var arrays = ArrayFinder.getArrays(method, module.CorLibTypes.Byte);
 			if (arrays.Count != 1 && arrays.Count != 2)
 				return false;
 
 			key = arrays[0];
-			if (arrays.Count == 1)
-				iv = module.Assembly.Name.PublicKeyToken;
+			if (arrays.Count == 1) {
+				var pkt = PublicKeyBase.ToPublicKeyToken(module.Assembly.PublicKey);
+				iv = pkt == null ? null : pkt.Data;
+			}
 			else
 				iv = arrays[1];
 			return true;
 		}
 
-		static bool callsDecompressor(MethodDefinition method) {
+		static bool callsDecompressor(MethodDef method) {
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Call)
 					continue;
-				var called = instr.Operand as MethodDefinition;
+				var called = instr.Operand as MethodDef;
 				if (called == null)
 					continue;
-				if (called.MethodReturnType.ReturnType.EType != ElementType.I4)
+				var sig = called.MethodSig;
+				if (sig == null)
 					continue;
-				var parameters = called.Parameters;
+				if (sig.RetType.GetElementType() != ElementType.I4)
+					continue;
+				var parameters = sig.Params;
 				if (parameters.Count != 4)
 					continue;
-				if (!checkClass(parameters[0].ParameterType, "System.Byte[]"))
+				if (!checkClass(parameters[0], "System.Byte[]"))
 					continue;
-				if (parameters[1].ParameterType.EType != ElementType.I4)
+				if (parameters[1].GetElementType() != ElementType.I4)
 					continue;
-				if (!checkClass(parameters[2].ParameterType, "System.Byte[]"))
+				if (!checkClass(parameters[2], "System.Byte[]"))
 					continue;
-				if (parameters[3].ParameterType.EType != ElementType.I4)
+				if (parameters[3].GetElementType() != ElementType.I4)
 					continue;
 
 				return true;
@@ -249,7 +255,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			return false;
 		}
 
-		static bool hasInstruction(MethodDefinition method, Code code) {
+		static bool hasInstruction(MethodDef method, Code code) {
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code == code)
 					return true;
@@ -257,21 +263,24 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			return false;
 		}
 
-		static bool checkClass(TypeReference type, string fullName) {
-			return type != null && (type.EType == ElementType.Object || type.FullName == fullName);
+		static bool checkClass(TypeSig type, string fullName) {
+			return type != null && (type.ElementType == ElementType.Object || type.FullName == fullName);
 		}
 
-		static bool isStringType(TypeReference type) {
-			return type != null && (type.EType == ElementType.Object || type.EType == ElementType.String);
+		static bool isStringType(TypeSig type) {
+			return type != null && (type.ElementType == ElementType.Object || type.ElementType == ElementType.String);
 		}
 
-		bool initializeDecrypterInfos(TypeDefinition type) {
+		bool initializeDecrypterInfos(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
-				if (method.Parameters.Count != 0)
+				var sig = method.MethodSig;
+				if (sig == null)
 					continue;
-				if (!isStringType(method.MethodReturnType.ReturnType))
+				if (sig.Params.Count != 0)
+					continue;
+				if (!isStringType(sig.RetType))
 					continue;
 
 				var info = createInfo(method);
@@ -284,16 +293,16 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			return methodToInfo.Count != 0;
 		}
 
-		DecrypterInfo createInfo(MethodDefinition method) {
+		DecrypterInfo createInfo(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 1; i++) {
 				var ldci4_1 = instrs[i];
 				var ldci4_2 = instrs[i + 1];
-				if (!DotNetUtils.isLdcI4(ldci4_1) || !DotNetUtils.isLdcI4(ldci4_2))
+				if (!ldci4_1.IsLdcI4() || !ldci4_2.IsLdcI4())
 					continue;
 
-				int offset = DotNetUtils.getLdcI4Value(ldci4_1);
-				int length = DotNetUtils.getLdcI4Value(ldci4_2);
+				int offset = ldci4_1.GetLdcI4Value();
+				int length = ldci4_2.GetLdcI4Value();
 				return new DecrypterInfo(method, offset, length);
 			}
 
@@ -313,7 +322,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			}
 
 			if ((stringDataFlags & StringDataFlags.Encrypted2) != 0) {
-				var k = module.Assembly.Name.PublicKey;
+				var k = module.Assembly.PublicKey.Data;
 				int mask = (byte)(~k.Length);
 				for (int i = 0; i < decryptedData.Length; i++)
 					decryptedData[i] ^= k[i & mask];
@@ -331,10 +340,11 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 				return;
 
 			encryptedDataField.InitialValue = new byte[1];
-			encryptedDataField.FieldType = module.TypeSystem.Byte;
+			encryptedDataField.FieldSig.Type = module.CorLibTypes.Byte;
+			encryptedDataField.RVA = 0;
 		}
 
-		public string decrypt(MethodDefinition method) {
+		public string decrypt(MethodDef method) {
 			var info = methodToInfo.find(method);
 			return Encoding.Unicode.GetString(decryptedData, info.offset, info.length);
 		}
diff --git a/de4dot.code/deobfuscators/StringCounts.cs b/de4dot.code/deobfuscators/StringCounts.cs
index 130c439f..d22b0121 100644
--- a/de4dot.code/deobfuscators/StringCounts.cs
+++ b/de4dot.code/deobfuscators/StringCounts.cs
@@ -19,8 +19,8 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 
 namespace de4dot.code.deobfuscators {
 	class StringCounts {
@@ -66,37 +66,40 @@ namespace de4dot.code.deobfuscators {
 	}
 
 	class FieldTypes : StringCounts {
-		public FieldTypes(TypeDefinition type) {
+		public FieldTypes(TypeDef type) {
 			init(type.Fields);
 		}
 
-		public FieldTypes(IEnumerable<FieldDefinition> fields) {
+		public FieldTypes(IEnumerable<FieldDef> fields) {
 			init(fields);
 		}
 
-		void init(IEnumerable<FieldDefinition> fields) {
+		void init(IEnumerable<FieldDef> fields) {
 			if (fields == null)
 				return;
-			foreach (var field in fields)
-				add(field.FieldType.FullName);
+			foreach (var field in fields) {
+				var type = field.FieldSig.GetFieldType();
+				if (type != null)
+					add(type.FullName);
+			}
 		}
 	}
 
 	class LocalTypes : StringCounts {
-		public LocalTypes(MethodDefinition method) {
+		public LocalTypes(MethodDef method) {
 			if (method != null && method.Body != null)
-				init(method.Body.Variables);
+				init(method.Body.LocalList);
 		}
 
-		public LocalTypes(IEnumerable<VariableDefinition> locals) {
+		public LocalTypes(IEnumerable<Local> locals) {
 			init(locals);
 		}
 
-		void init(IEnumerable<VariableDefinition> locals) {
+		void init(IEnumerable<Local> locals) {
 			if (locals == null)
 				return;
 			foreach (var local in locals)
-				add(local.VariableType.FullName);
+				add(local.Type.FullName);
 		}
 	}
 }
diff --git a/de4dot.code/deobfuscators/TypesRestorer.cs b/de4dot.code/deobfuscators/TypesRestorer.cs
index 2b3c003c..d8794d20 100644
--- a/de4dot.code/deobfuscators/TypesRestorer.cs
+++ b/de4dot.code/deobfuscators/TypesRestorer.cs
@@ -19,9 +19,8 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.Cecil.Metadata;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators {
@@ -29,41 +28,41 @@ namespace de4dot.code.deobfuscators {
 	// This thing requires a lot more code than I have time to do now (similar to symbol renaming)
 	// so it will be a basic implementation only.
 	abstract class TypesRestorerBase {
-		ModuleDefinition module;
-		List<MethodDefinition> allMethods;
-		Dictionary<ParameterDefinition, TypeInfo<ParameterDefinition>> argInfos = new Dictionary<ParameterDefinition, TypeInfo<ParameterDefinition>>();
-		TypeInfo<ParameterDefinition> methodReturnInfo;
-		Dictionary<FieldReferenceAndDeclaringTypeKey, TypeInfo<FieldDefinition>> fieldWrites = new Dictionary<FieldReferenceAndDeclaringTypeKey, TypeInfo<FieldDefinition>>();
+		ModuleDef module;
+		List<MethodDef> allMethods;
+		Dictionary<Parameter, TypeInfo<Parameter>> argInfos = new Dictionary<Parameter, TypeInfo<Parameter>>();
+		TypeInfo<Parameter> methodReturnInfo;
+		Dictionary<IField, TypeInfo<FieldDef>> fieldWrites = new Dictionary<IField, TypeInfo<FieldDef>>(FieldEqualityComparer.CompareDeclaringTypes);
 		Dictionary<int, UpdatedMethod> updatedMethods = new Dictionary<int, UpdatedMethod>();
 		Dictionary<int, UpdatedField> updatedFields = new Dictionary<int, UpdatedField>();
 
 		class UpdatedMethod {
 			public int token;
-			public TypeReference[] newArgTypes;
-			public TypeReference newReturnType;
+			public TypeSig[] newArgTypes;
+			public TypeSig newReturnType;
 
-			public UpdatedMethod(MethodDefinition method) {
-				token = method.MetadataToken.ToInt32();
-				newArgTypes = new TypeReference[DotNetUtils.getArgsCount(method)];
+			public UpdatedMethod(MethodDef method) {
+				token = method.MDToken.ToInt32();
+				newArgTypes = new TypeSig[DotNetUtils.getArgsCount(method)];
 			}
 		}
 
 		class UpdatedField {
 			public int token;
-			public TypeReference newFieldType;
+			public TypeSig newFieldType;
 
-			public UpdatedField(FieldDefinition field) {
-				token = field.MetadataToken.ToInt32();
+			public UpdatedField(FieldDef field) {
+				token = field.MDToken.ToInt32();
 			}
 		}
 
 		class TypeInfo<T> {
-			Dictionary<TypeReferenceKey, bool> types = new Dictionary<TypeReferenceKey, bool>();
-			public TypeReference newType = null;
+			Dictionary<TypeSig, bool> types = new Dictionary<TypeSig, bool>(TypeEqualityComparer.Instance);
+			public TypeSig newType = null;
 			public T arg;
 			bool newobjTypes;
 
-			public Dictionary<TypeReferenceKey, bool> Types {
+			public Dictionary<TypeSig, bool> Types {
 				get { return types; }
 			}
 
@@ -71,11 +70,11 @@ namespace de4dot.code.deobfuscators {
 				this.arg = arg;
 			}
 
-			public void add(TypeReference type) {
+			public void add(TypeSig type) {
 				add(type, false);
 			}
 
-			public void add(TypeReference type, bool wasNewobj) {
+			public void add(TypeSig type, bool wasNewobj) {
 				if (wasNewobj) {
 					if (!newobjTypes)
 						clear();
@@ -83,30 +82,30 @@ namespace de4dot.code.deobfuscators {
 				}
 				else if (newobjTypes)
 					return;
-				types[new TypeReferenceKey(type)] = true;
+				types[type] = true;
 			}
 
 			public void clear() {
 				types.Clear();
 			}
 
-			public bool updateNewType(ModuleDefinition module) {
+			public bool updateNewType(ModuleDef module) {
 				if (types.Count == 0)
 					return false;
 
-				TypeReference theNewType = null;
+				TypeSig theNewType = null;
 				foreach (var key in types.Keys) {
 					if (theNewType == null) {
-						theNewType = key.TypeReference;
+						theNewType = key;
 						continue;
 					}
-					theNewType = getCommonBaseClass(module, theNewType, key.TypeReference);
+					theNewType = getCommonBaseClass(module, theNewType, key);
 					if (theNewType == null)
 						break;
 				}
 				if (theNewType == null)
 					return false;
-				if (MemberReferenceHelper.compareTypes(theNewType, newType))
+				if (new SigComparer().Equals(theNewType, newType))
 					return false;
 
 				newType = theNewType;
@@ -114,20 +113,20 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		public TypesRestorerBase(ModuleDefinition module) {
+		public TypesRestorerBase(ModuleDef module) {
 			this.module = module;
 		}
 
-		UpdatedMethod getUpdatedMethod(MethodDefinition method) {
-			int token = method.MetadataToken.ToInt32();
+		UpdatedMethod getUpdatedMethod(MethodDef method) {
+			int token = method.MDToken.ToInt32();
 			UpdatedMethod updatedMethod;
 			if (updatedMethods.TryGetValue(token, out updatedMethod))
 				return updatedMethod;
 			return updatedMethods[token] = new UpdatedMethod(method);
 		}
 
-		UpdatedField getUpdatedField(FieldDefinition field) {
-			int token = field.MetadataToken.ToInt32();
+		UpdatedField getUpdatedField(FieldDef field) {
+			int token = field.MDToken.ToInt32();
 			UpdatedField updatedField;
 			if (updatedFields.TryGetValue(token, out updatedField))
 				return updatedField;
@@ -135,7 +134,7 @@ namespace de4dot.code.deobfuscators {
 		}
 
 		public void deobfuscate() {
-			allMethods = new List<MethodDefinition>();
+			allMethods = new List<MethodDef>();
 
 			addAllMethods();
 			addAllFields();
@@ -151,11 +150,11 @@ namespace de4dot.code.deobfuscators {
 				addMethods(type.Methods);
 		}
 
-		void addMethods(IEnumerable<MethodDefinition> methods) {
+		void addMethods(IEnumerable<MethodDef> methods) {
 			allMethods.AddRange(methods);
 		}
 
-		void addMethod(MethodDefinition method) {
+		void addMethod(MethodDef method) {
 			allMethods.Add(method);
 		}
 
@@ -165,8 +164,7 @@ namespace de4dot.code.deobfuscators {
 					if (!isUnknownType(field))
 						continue;
 
-					var key = new FieldReferenceAndDeclaringTypeKey(field);
-					fieldWrites[key] = new TypeInfo<FieldDefinition>(field);
+					fieldWrites[field] = new TypeInfo<FieldDef>(field);
 				}
 			}
 		}
@@ -186,12 +184,12 @@ namespace de4dot.code.deobfuscators {
 			if (fields.Count == 0)
 				return;
 
-			Log.v("Changing field types to real type");
-			fields.Sort((a, b) => Utils.compareInt32(a.token, b.token));
-			Log.indent();
+			Logger.v("Changing field types to real type");
+			fields.Sort((a, b) => a.token.CompareTo(b.token));
+			Logger.Instance.indent();
 			foreach (var updatedField in fields)
-				Log.v("Field {0:X8}: type {1} ({2:X8})", updatedField.token, Utils.removeNewlines(updatedField.newFieldType.FullName), updatedField.newFieldType.MetadataToken.ToInt32());
-			Log.deIndent();
+				Logger.v("Field {0:X8}: type {1} ({2:X8})", updatedField.token, Utils.removeNewlines(updatedField.newFieldType.FullName), updatedField.newFieldType.MDToken.ToInt32());
+			Logger.Instance.deIndent();
 		}
 
 		void restoreMethodTypes() {
@@ -199,47 +197,47 @@ namespace de4dot.code.deobfuscators {
 			if (methods.Count == 0)
 				return;
 
-			Log.v("Changing method args and return types to real type");
-			methods.Sort((a, b) => Utils.compareInt32(a.token, b.token));
-			Log.indent();
+			Logger.v("Changing method args and return types to real type");
+			methods.Sort((a, b) => a.token.CompareTo(b.token));
+			Logger.Instance.indent();
 			foreach (var updatedMethod in methods) {
-				Log.v("Method {0:X8}", updatedMethod.token);
-				Log.indent();
+				Logger.v("Method {0:X8}", updatedMethod.token);
+				Logger.Instance.indent();
 				if (updatedMethod.newReturnType != null) {
-					Log.v("ret: {0} ({1:X8})",
+					Logger.v("ret: {0} ({1:X8})",
 							Utils.removeNewlines(updatedMethod.newReturnType.FullName),
-							updatedMethod.newReturnType.MetadataToken.ToInt32());
+							updatedMethod.newReturnType.MDToken.ToInt32());
 				}
 				for (int i = 0; i < updatedMethod.newArgTypes.Length; i++) {
 					var updatedArg = updatedMethod.newArgTypes[i];
 					if (updatedArg == null)
 						continue;
-					Log.v("arg {0}: {1} ({2:X8})",
+					Logger.v("arg {0}: {1} ({2:X8})",
 							i,
 							Utils.removeNewlines(updatedArg.FullName),
-							updatedArg.MetadataToken.ToInt32());
+							updatedArg.MDToken.ToInt32());
 				}
-				Log.deIndent();
+				Logger.Instance.deIndent();
 			}
-			Log.deIndent();
+			Logger.Instance.deIndent();
 		}
 
 		bool deobfuscateMethods() {
 			bool changed = false;
 			foreach (var method in allMethods) {
-				methodReturnInfo = new TypeInfo<ParameterDefinition>(method.MethodReturnType.Parameter2);
+				methodReturnInfo = new TypeInfo<Parameter>(method.Parameters.ReturnParameter);
 				deobfuscateMethod(method);
 
 				if (methodReturnInfo.updateNewType(module)) {
 					getUpdatedMethod(method).newReturnType = methodReturnInfo.newType;
-					method.MethodReturnType.ReturnType = methodReturnInfo.newType;
+					method.MethodSig.RetType = methodReturnInfo.newType;
 					changed = true;
 				}
 
 				foreach (var info in argInfos.Values) {
 					if (info.updateNewType(module)) {
-						getUpdatedMethod(method).newArgTypes[DotNetUtils.getArgIndex(info.arg)] = info.newType;
-						info.arg.ParameterType = info.newType;
+						getUpdatedMethod(method).newArgTypes[info.arg.Index] = info.newType;
+						info.arg.Type = info.newType;
 						changed = true;
 					}
 				}
@@ -247,29 +245,31 @@ namespace de4dot.code.deobfuscators {
 			return changed;
 		}
 
-		static int sortTypeInfos(TypeInfo<ParameterDefinition> a, TypeInfo<ParameterDefinition> b) {
-			if (a.arg.Method.MetadataToken.ToInt32() < b.arg.Method.MetadataToken.ToInt32()) return -1;
-			if (a.arg.Method.MetadataToken.ToInt32() > b.arg.Method.MetadataToken.ToInt32()) return 1;
+		static int sortTypeInfos(TypeInfo<Parameter> a, TypeInfo<Parameter> b) {
+			if (a.arg.Method.MDToken.ToInt32() < b.arg.Method.MDToken.ToInt32()) return -1;
+			if (a.arg.Method.MDToken.ToInt32() > b.arg.Method.MDToken.ToInt32()) return 1;
 
-			return Utils.compareInt32(a.arg.Sequence, b.arg.Sequence);
+			return a.arg.Index.CompareTo(b.arg.Index);
 		}
 
-		void deobfuscateMethod(MethodDefinition method) {
+		void deobfuscateMethod(MethodDef method) {
 			if (!method.IsStatic || method.Body == null)
 				return;
 
-			bool fixReturnType = isUnknownType(method.MethodReturnType);
+			bool fixReturnType = isUnknownType(method.MethodSig.GetRetType());
 
 			argInfos.Clear();
 			foreach (var arg in method.Parameters) {
+				if (arg.IsHiddenThisParameter)
+					continue;
 				if (!isUnknownType(arg))
 					continue;
-				argInfos[arg] = new TypeInfo<ParameterDefinition>(arg);
+				argInfos[arg] = new TypeInfo<Parameter>(arg);
 			}
 			if (argInfos.Count == 0 && !fixReturnType)
 				return;
 
-			var methodParams = DotNetUtils.getParameters(method);
+			var methodParams = method.Parameters;
 			PushedArgs pushedArgs;
 			var instructions = method.Body.Instructions;
 			for (int i = 0; i < instructions.Count; i++) {
@@ -290,10 +290,10 @@ namespace de4dot.code.deobfuscators {
 				case Code.Callvirt:
 				case Code.Newobj:
 					pushedArgs = MethodStack.getPushedArgInstructions(instructions, i);
-					var calledMethod = instr.Operand as MethodReference;
+					var calledMethod = instr.Operand as IMethod;
 					if (calledMethod == null)
 						break;
-					var calledMethodParams = DotNetUtils.getParameters(calledMethod);
+					var calledMethodParams = DotNetUtils.getArgs(calledMethod);
 					for (int j = 0; j < pushedArgs.NumValidArgs; j++) {
 						int calledMethodParamIndex = calledMethodParams.Count - j - 1;
 						var ldInstr = pushedArgs.getEnd(j);
@@ -304,7 +304,7 @@ namespace de4dot.code.deobfuscators {
 						case Code.Ldarg_1:
 						case Code.Ldarg_2:
 						case Code.Ldarg_3:
-							addMethodArgType(method, getParameter(methodParams, ldInstr), DotNetUtils.getParameter(calledMethodParams, calledMethodParamIndex));
+							addMethodArgType(method, getParameter(methodParams, ldInstr), DotNetUtils.getArg(calledMethodParams, calledMethodParamIndex));
 							break;
 
 						default:
@@ -317,7 +317,7 @@ namespace de4dot.code.deobfuscators {
 					pushedArgs = MethodStack.getPushedArgInstructions(instructions, i);
 					if (pushedArgs.NumValidArgs < 1)
 						break;
-					addMethodArgType(method, getParameter(methodParams, pushedArgs.getEnd(0)), instr.Operand as TypeReference);
+					addMethodArgType(method, getParameter(methodParams, pushedArgs.getEnd(0)), instr.Operand as ITypeDefOrRef);
 					break;
 
 				case Code.Stloc:
@@ -329,20 +329,20 @@ namespace de4dot.code.deobfuscators {
 					pushedArgs = MethodStack.getPushedArgInstructions(instructions, i);
 					if (pushedArgs.NumValidArgs < 1)
 						break;
-					addMethodArgType(method, getParameter(methodParams, pushedArgs.getEnd(0)), DotNetUtils.getLocalVar(method.Body.Variables, instr));
+					addMethodArgType(method, getParameter(methodParams, pushedArgs.getEnd(0)), instr.GetLocal(method.Body.LocalList));
 					break;
 
 				case Code.Stsfld:
 					pushedArgs = MethodStack.getPushedArgInstructions(instructions, i);
 					if (pushedArgs.NumValidArgs < 1)
 						break;
-					addMethodArgType(method, getParameter(methodParams, pushedArgs.getEnd(0)), instr.Operand as FieldReference);
+					addMethodArgType(method, getParameter(methodParams, pushedArgs.getEnd(0)), instr.Operand as IField);
 					break;
 
 				case Code.Stfld:
 					pushedArgs = MethodStack.getPushedArgInstructions(instructions, i);
 					if (pushedArgs.NumValidArgs >= 1) {
-						var field = instr.Operand as FieldReference;
+						var field = instr.Operand as IField;
 						addMethodArgType(method, getParameter(methodParams, pushedArgs.getEnd(0)), field);
 						if (pushedArgs.NumValidArgs >= 2 && field != null)
 							addMethodArgType(method, getParameter(methodParams, pushedArgs.getEnd(1)), field.DeclaringType);
@@ -354,7 +354,7 @@ namespace de4dot.code.deobfuscators {
 					pushedArgs = MethodStack.getPushedArgInstructions(instructions, i);
 					if (pushedArgs.NumValidArgs < 1)
 						break;
-					addMethodArgType(method, getParameter(methodParams, pushedArgs.getEnd(0)), instr.Operand as FieldReference);
+					addMethodArgType(method, getParameter(methodParams, pushedArgs.getEnd(0)), instr.Operand as IField);
 					break;
 
 				//TODO: For better results, these should be checked:
@@ -362,7 +362,7 @@ namespace de4dot.code.deobfuscators {
 				case Code.Starg_S:
 
 				case Code.Ldelema:
-				case Code.Ldelem_Any:
+				case Code.Ldelem:
 				case Code.Ldelem_I:
 				case Code.Ldelem_I1:
 				case Code.Ldelem_I2:
@@ -389,7 +389,7 @@ namespace de4dot.code.deobfuscators {
 
 				case Code.Ldobj:
 
-				case Code.Stelem_Any:
+				case Code.Stelem:
 				case Code.Stelem_I:
 				case Code.Stelem_I1:
 				case Code.Stelem_I2:
@@ -415,7 +415,7 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		static ParameterDefinition getParameter(IList<ParameterDefinition> parameters, Instruction instr) {
+		static Parameter getParameter(IList<Parameter> parameters, Instruction instr) {
 			switch (instr.OpCode.Code) {
 			case Code.Ldarg:
 			case Code.Ldarg_S:
@@ -423,42 +423,46 @@ namespace de4dot.code.deobfuscators {
 			case Code.Ldarg_1:
 			case Code.Ldarg_2:
 			case Code.Ldarg_3:
-				return DotNetUtils.getParameter(parameters, instr);
+				return instr.GetParameter(parameters);
 
 			default:
 				return null;
 			}
 		}
 
-		bool addMethodArgType(IGenericParameterProvider gpp, ParameterDefinition methodParam, FieldReference field) {
+		bool addMethodArgType(IGenericParameterProvider gpp, Parameter methodParam, IField field) {
 			if (field == null)
 				return false;
-			return addMethodArgType(gpp, methodParam, field.FieldType);
+			return addMethodArgType(gpp, methodParam, field.FieldSig.GetFieldType());
 		}
 
-		bool addMethodArgType(IGenericParameterProvider gpp, ParameterDefinition methodParam, VariableDefinition otherLocal) {
+		bool addMethodArgType(IGenericParameterProvider gpp, Parameter methodParam, Local otherLocal) {
 			if (otherLocal == null)
 				return false;
-			return addMethodArgType(gpp, methodParam, otherLocal.VariableType);
+			return addMethodArgType(gpp, methodParam, otherLocal.Type);
 		}
 
-		bool addMethodArgType(IGenericParameterProvider gpp, ParameterDefinition methodParam, ParameterDefinition otherParam) {
+		bool addMethodArgType(IGenericParameterProvider gpp, Parameter methodParam, Parameter otherParam) {
 			if (otherParam == null)
 				return false;
-			return addMethodArgType(gpp, methodParam, otherParam.ParameterType);
+			return addMethodArgType(gpp, methodParam, otherParam.Type);
 		}
 
-		bool addMethodArgType(IGenericParameterProvider gpp, ParameterDefinition methodParam, TypeReference type) {
+		bool addMethodArgType(IGenericParameterProvider gpp, Parameter methodParam, ITypeDefOrRef type) {
+			return addMethodArgType(gpp, methodParam, type.ToTypeSig());
+		}
+
+		bool addMethodArgType(IGenericParameterProvider gpp, Parameter methodParam, TypeSig type) {
 			if (methodParam == null || type == null)
 				return false;
 
 			if (!isValidType(gpp, type))
 				return false;
 
-			TypeInfo<ParameterDefinition> info;
+			TypeInfo<Parameter> info;
 			if (!argInfos.TryGetValue(methodParam, out info))
 				return false;
-			if (info.Types.ContainsKey(new TypeReferenceKey(type)))
+			if (info.Types.ContainsKey(type))
 				return false;
 
 			info.add(type);
@@ -475,16 +479,16 @@ namespace de4dot.code.deobfuscators {
 				var instructions = method.Body.Instructions;
 				for (int i = 0; i < instructions.Count; i++) {
 					var instr = instructions[i];
-					TypeReference fieldType = null;
-					TypeInfo<FieldDefinition> info = null;
-					FieldReference field;
+					TypeSig fieldType = null;
+					TypeInfo<FieldDef> info = null;
+					IField field;
 					switch (instr.OpCode.Code) {
 					case Code.Stfld:
 					case Code.Stsfld:
-						field = instr.Operand as FieldReference;
+						field = instr.Operand as IField;
 						if (field == null)
 							continue;
-						if (!fieldWrites.TryGetValue(new FieldReferenceAndDeclaringTypeKey(field), out info))
+						if (!fieldWrites.TryGetValue(field, out info))
 							continue;
 						bool wasNewobj;
 						fieldType = getLoadedType(info.arg.DeclaringType, method, instructions, i, out wasNewobj);
@@ -498,20 +502,27 @@ namespace de4dot.code.deobfuscators {
 					case Code.Callvirt:
 					case Code.Newobj:
 						var pushedArgs = MethodStack.getPushedArgInstructions(instructions, i);
-						var calledMethod = instr.Operand as MethodReference;
+						var calledMethod = instr.Operand as IMethod;
 						if (calledMethod == null)
 							continue;
-						IList<TypeReference> calledMethodArgs = DotNetUtils.getArgs(calledMethod);
-						calledMethodArgs = DotNetUtils.replaceGenericParameters(calledMethod.DeclaringType as GenericInstanceType, calledMethod as GenericInstanceMethod, calledMethodArgs);
+						var calledMethodDefOrRef = calledMethod as IMethodDefOrRef;
+						var calledMethodSpec = calledMethod as MethodSpec;
+						if (calledMethodSpec != null)
+							calledMethodDefOrRef = calledMethodSpec.Method;
+						if (calledMethodDefOrRef == null)
+							continue;
+
+						IList<TypeSig> calledMethodArgs = DotNetUtils.getArgs(calledMethodDefOrRef);
+						calledMethodArgs = DotNetUtils.replaceGenericParameters(calledMethodDefOrRef.DeclaringType.ToGenericInstSig(), calledMethodSpec, calledMethodArgs);
 						for (int j = 0; j < pushedArgs.NumValidArgs; j++) {
 							var pushInstr = pushedArgs.getEnd(j);
 							if (pushInstr.OpCode.Code != Code.Ldfld && pushInstr.OpCode.Code != Code.Ldsfld)
 								continue;
 
-							field = pushInstr.Operand as FieldReference;
+							field = pushInstr.Operand as IField;
 							if (field == null)
 								continue;
-							if (!fieldWrites.TryGetValue(new FieldReferenceAndDeclaringTypeKey(field), out info))
+							if (!fieldWrites.TryGetValue(field, out info))
 								continue;
 							fieldType = calledMethodArgs[calledMethodArgs.Count - 1 - j];
 							if (!isValidType(info.arg.DeclaringType, fieldType))
@@ -527,77 +538,91 @@ namespace de4dot.code.deobfuscators {
 			}
 
 			bool changed = false;
-			var removeThese = new List<FieldDefinition>();
+			var removeThese = new List<FieldDef>();
 			foreach (var info in fieldWrites.Values) {
 				if (info.updateNewType(module)) {
 					removeThese.Add(info.arg);
 					getUpdatedField(info.arg).newFieldType = info.newType;
-					info.arg.FieldType = info.newType;
+					info.arg.FieldSig.Type = info.newType;
 					changed = true;
 				}
 			}
 			foreach (var field in removeThese)
-				fieldWrites.Remove(new FieldReferenceAndDeclaringTypeKey(field));
+				fieldWrites.Remove(field);
 			return changed;
 		}
 
-		TypeReference getLoadedType(IGenericParameterProvider gpp, MethodDefinition method, IList<Instruction> instructions, int instrIndex, out bool wasNewobj) {
+		TypeSig getLoadedType(IGenericParameterProvider gpp, MethodDef method, IList<Instruction> instructions, int instrIndex, out bool wasNewobj) {
 			var fieldType = MethodStack.getLoadedType(method, instructions, instrIndex, out wasNewobj);
 			if (fieldType == null || !isValidType(gpp, fieldType))
 				return null;
 			return fieldType;
 		}
 
-		protected virtual bool isValidType(IGenericParameterProvider gpp, TypeReference type) {
+		protected virtual bool isValidType(IGenericParameterProvider gpp, TypeSig type) {
 			if (type == null)
 				return false;
-			if (type.EType == ElementType.Void)
+			if (type.ElementType == ElementType.Void)
 				return false;
 
 			while (type != null) {
-				switch (MemberReferenceHelper.getMemberReferenceType(type)) {
-				case CecilType.GenericInstanceType:
-					foreach (var ga in ((GenericInstanceType)type).GenericArguments) {
+				switch (type.ElementType) {
+				case ElementType.GenericInst:
+					foreach (var ga in ((GenericInstSig)type).GenericArguments) {
 						if (!isValidType(gpp, ga))
 							return false;
 					}
 					break;
 
-				case CecilType.ArrayType:
-				case CecilType.PointerType:
-				case CecilType.TypeDefinition:
-				case CecilType.TypeReference:
+				case ElementType.SZArray:
+				case ElementType.Array:
+				case ElementType.Ptr:
+				case ElementType.Class:
+				case ElementType.ValueType:
+				case ElementType.Void:
+				case ElementType.Boolean:
+				case ElementType.Char:
+				case ElementType.I1:
+				case ElementType.U1:
+				case ElementType.I2:
+				case ElementType.U2:
+				case ElementType.I4:
+				case ElementType.U4:
+				case ElementType.I8:
+				case ElementType.U8:
+				case ElementType.R4:
+				case ElementType.R8:
+				case ElementType.TypedByRef:
+				case ElementType.I:
+				case ElementType.U:
+				case ElementType.String:
+				case ElementType.Object:
 					break;
 
-				case CecilType.GenericParameter:
-					var gp = (GenericParameter)type;
-					var methodRef = gpp as MethodReference;
-					var typeRef = gpp as TypeReference;
-					if (methodRef != null) {
-						if (methodRef.DeclaringType != gp.Owner && methodRef != gp.Owner)
-							return false;
-					}
-					else if (typeRef != null) {
-						if (typeRef != gp.Owner)
-							return false;
-					}
-					else
-						return false;
-					break;
+				case ElementType.Var:
+				case ElementType.MVar:
+					// TODO: Return false for now. We don't know whether the Var is a Var in
+					// this type or from some other type.
+					return false;
 
-				case CecilType.ByReferenceType:
-				case CecilType.FunctionPointerType:
-				case CecilType.OptionalModifierType:
-				case CecilType.PinnedType:
-				case CecilType.RequiredModifierType:
-				case CecilType.SentinelType:
+				case ElementType.ByRef:
+				case ElementType.FnPtr:
+				case ElementType.CModOpt:
+				case ElementType.CModReqd:
+				case ElementType.Pinned:
+				case ElementType.Sentinel:
+				case ElementType.ValueArray:
+				case ElementType.R:
+				case ElementType.End:
+				case ElementType.Internal:
+				case ElementType.Module:
 				default:
 					return false;
 				}
 
-				if (!(type is TypeSpecification))
+				if (type.Next == null)
 					break;
-				type = ((TypeSpecification)type).ElementType;
+				type = type.Next;
 			}
 
 			return type != null;
@@ -605,42 +630,42 @@ namespace de4dot.code.deobfuscators {
 
 		protected abstract bool isUnknownType(object o);
 
-		static TypeReference getCommonBaseClass(ModuleDefinition module, TypeReference a, TypeReference b) {
-			if (DotNetUtils.isDelegate(a) && DotNetUtils.derivesFromDelegate(DotNetUtils.getType(module, b)))
+		static TypeSig getCommonBaseClass(ModuleDef module, TypeSig a, TypeSig b) {
+			if (DotNetUtils.isDelegate(a) && DotNetUtils.derivesFromDelegate(module.Find(b.ToTypeDefOrRef())))
 				return b;
-			if (DotNetUtils.isDelegate(b) && DotNetUtils.derivesFromDelegate(DotNetUtils.getType(module, a)))
+			if (DotNetUtils.isDelegate(b) && DotNetUtils.derivesFromDelegate(module.Find(a.ToTypeDefOrRef())))
 				return a;
 			return null;	//TODO:
 		}
 	}
 
 	class TypesRestorer : TypesRestorerBase {
-		public TypesRestorer(ModuleDefinition module)
+		public TypesRestorer(ModuleDef module)
 			: base(module) {
 		}
 
-		protected override bool isValidType(IGenericParameterProvider gpp, TypeReference type) {
+		protected override bool isValidType(IGenericParameterProvider gpp, TypeSig type) {
 			if (type == null)
 				return false;
 			if (type.IsValueType)
 				return false;
-			if (MemberReferenceHelper.isSystemObject(type))
+			if (type.ElementType == ElementType.Object)
 				return false;
 			return base.isValidType(gpp, type);
 		}
 
 		protected override bool isUnknownType(object o) {
-			var arg = o as ParameterDefinition;
+			var arg = o as Parameter;
 			if (arg != null)
-				return MemberReferenceHelper.isSystemObject(arg.ParameterType);
+				return arg.Type.GetElementType() == ElementType.Object;
 
-			var field = o as FieldDefinition;
+			var field = o as FieldDef;
 			if (field != null)
-				return MemberReferenceHelper.isSystemObject(field.FieldType);
+				return field.FieldSig.GetFieldType().GetElementType() == ElementType.Object;
 
-			var retType = o as MethodReturnType;
-			if (retType != null)
-				return MemberReferenceHelper.isSystemObject(retType.ReturnType);
+			var sig = o as TypeSig;
+			if (sig != null)
+				return sig.ElementType == ElementType.Object;
 
 			throw new ApplicationException(string.Format("Unknown type: {0}", o.GetType()));
 		}
diff --git a/de4dot.code/deobfuscators/Unknown/Deobfuscator.cs b/de4dot.code/deobfuscators/Unknown/Deobfuscator.cs
index 4a3308cd..8cf49820 100644
--- a/de4dot.code/deobfuscators/Unknown/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/Unknown/Deobfuscator.cs
@@ -86,15 +86,16 @@ namespace de4dot.code.deobfuscators.Unknown {
 
 		string scanTypes() {
 			foreach (var type in module.Types) {
-				if (type.FullName == "ConfusedByAttribute")
+				var fn = type.FullName;
+				if (fn == "ConfusedByAttribute")
 					return "Confuser";
-				if (type.FullName == "ZYXDNGuarder")
+				if (fn == "ZYXDNGuarder")
 					return "DNGuard HVM";
-				if (type.Name.Contains("();\t"))
+				if (type.Name.String.Contains("();\t"))
 					return "Manco .NET Obfuscator";
-				if (Regex.IsMatch(type.FullName, @"^EMyPID_\d+_$"))
+				if (Regex.IsMatch(fn, @"^EMyPID_\d+_$"))
 					return "BitHelmet Obfuscator";
-				if (type.FullName == "YanoAttribute")
+				if (fn == "YanoAttribute")
 					return "Yano Obfuscator";
 			}
 			return null;
diff --git a/de4dot.code/deobfuscators/UnusedMethodsFinder.cs b/de4dot.code/deobfuscators/UnusedMethodsFinder.cs
index 8fbc37f6..70332630 100644
--- a/de4dot.code/deobfuscators/UnusedMethodsFinder.cs
+++ b/de4dot.code/deobfuscators/UnusedMethodsFinder.cs
@@ -18,27 +18,27 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators {
 	class UnusedMethodsFinder {
-		ModuleDefinition module;
+		ModuleDef module;
 		MethodCollection removedMethods;
-		Dictionary<MethodDefinition, bool> possiblyUnusedMethods = new Dictionary<MethodDefinition, bool>();
-		Stack<MethodDefinition> notUnusedStack = new Stack<MethodDefinition>();
+		Dictionary<MethodDef, bool> possiblyUnusedMethods = new Dictionary<MethodDef, bool>();
+		Stack<MethodDef> notUnusedStack = new Stack<MethodDef>();
 
-		public UnusedMethodsFinder(ModuleDefinition module, IEnumerable<MethodDefinition> possiblyUnusedMethods, MethodCollection removedMethods) {
+		public UnusedMethodsFinder(ModuleDef module, IEnumerable<MethodDef> possiblyUnusedMethods, MethodCollection removedMethods) {
 			this.module = module;
 			this.removedMethods = removedMethods;
 			foreach (var method in possiblyUnusedMethods) {
-				if (method != module.EntryPoint && !removedMethods.exists(method))
+				if (method != module.ManagedEntryPoint && !removedMethods.exists(method))
 					this.possiblyUnusedMethods[method] = true;
 			}
 		}
 
-		public IEnumerable<MethodDefinition> find() {
+		public IEnumerable<MethodDef> find() {
 			if (possiblyUnusedMethods.Count == 0)
 				return possiblyUnusedMethods.Keys;
 
@@ -57,7 +57,7 @@ namespace de4dot.code.deobfuscators {
 			return possiblyUnusedMethods.Keys;
 		}
 
-		void check(MethodDefinition method) {
+		void check(MethodDef method) {
 			if (method.Body == null)
 				return;
 			if (possiblyUnusedMethods.ContainsKey(method))
@@ -79,7 +79,7 @@ namespace de4dot.code.deobfuscators {
 					continue;
 				}
 
-				var calledMethod = DotNetUtils.getMethod2(module, instr.Operand as MethodReference);
+				var calledMethod = DotNetUtils.getMethod2(module, instr.Operand as IMethod);
 				if (calledMethod == null)
 					continue;
 				if (possiblyUnusedMethods.ContainsKey(calledMethod))
diff --git a/de4dot.code/deobfuscators/ValueInlinerBase.cs b/de4dot.code/deobfuscators/ValueInlinerBase.cs
index 1ad85168..824019df 100644
--- a/de4dot.code/deobfuscators/ValueInlinerBase.cs
+++ b/de4dot.code/deobfuscators/ValueInlinerBase.cs
@@ -19,19 +19,19 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators {
 	abstract class ValueInlinerBase<TValue> : MethodReturnValueInliner {
-		MethodDefinitionAndDeclaringTypeDict<Func<MethodDefinition, GenericInstanceMethod, object[], object>> decrypterMethods = new MethodDefinitionAndDeclaringTypeDict<Func<MethodDefinition, GenericInstanceMethod, object[], object>>();
+		MethodDefinitionAndDeclaringTypeDict<Func<MethodDef, MethodSpec, object[], object>> decrypterMethods = new MethodDefinitionAndDeclaringTypeDict<Func<MethodDef, MethodSpec, object[], object>>();
 		bool removeUnbox = false;
 
 		class MyCallResult : CallResult {
-			public MethodReference methodReference;
-			public GenericInstanceMethod gim;
-			public MyCallResult(Block block, int callEndIndex, MethodReference method, GenericInstanceMethod gim)
+			public IMethod methodReference;
+			public MethodSpec gim;
+			public MyCallResult(Block block, int callEndIndex, IMethod method, MethodSpec gim)
 				: base(block, callEndIndex) {
 				this.methodReference = method;
 				this.gim = gim;
@@ -47,15 +47,15 @@ namespace de4dot.code.deobfuscators {
 			get { return decrypterMethods.Count != 0; }
 		}
 
-		public IEnumerable<MethodDefinition> Methods {
+		public IEnumerable<MethodDef> Methods {
 			get { return decrypterMethods.getKeys(); }
 		}
 
-		public void add(MethodDefinition method, Func<MethodDefinition, GenericInstanceMethod, object[], object> handler) {
+		public void add(MethodDef method, Func<MethodDef, MethodSpec, object[], object> handler) {
 			if (method == null)
 				return;
 			if (decrypterMethods.find(method) != null)
-				throw new ApplicationException(string.Format("Handler for method {0:X8} has already been added", method.MetadataToken.ToInt32()));
+				throw new ApplicationException(string.Format("Handler for method {0:X8} has already been added", method.MDToken.ToInt32()));
 			if (method != null)
 				decrypterMethods.add(method, handler);
 		}
@@ -64,11 +64,11 @@ namespace de4dot.code.deobfuscators {
 			foreach (var tmp in callResults) {
 				var callResult = (MyCallResult)tmp;
 				var handler = decrypterMethods.find(callResult.methodReference);
-				callResult.returnValue = handler((MethodDefinition)callResult.methodReference, callResult.gim, callResult.args);
+				callResult.returnValue = handler((MethodDef)callResult.methodReference, callResult.gim, callResult.args);
 			}
 		}
 
-		protected override CallResult createCallResult(MethodReference method, GenericInstanceMethod gim, Block block, int callInstrIndex) {
+		protected override CallResult createCallResult(IMethod method, MethodSpec gim, Block block, int callInstrIndex) {
 			if (decrypterMethods.find(method) == null)
 				return null;
 			return new MyCallResult(block, callInstrIndex, method, gim);
@@ -83,7 +83,7 @@ namespace de4dot.code.deobfuscators {
 			var unbox = instrs[index];
 			if (unbox.OpCode.Code != Code.Unbox_Any)
 				return false;
-			var type = unbox.Operand as TypeReference;
+			var type = unbox.Operand as ITypeDefOrRef;
 			if (type == null || type.FullName != unboxType)
 				return false;
 			block.remove(index, 1);
@@ -97,9 +97,9 @@ namespace de4dot.code.deobfuscators {
 				var block = callResult.block;
 				int num = callResult.callEndIndex - callResult.callStartIndex + 1;
 
-				block.replace(callResult.callStartIndex, num, DotNetUtils.createLdci4((bool)callResult.returnValue ? 1 : 0));
+				block.replace(callResult.callStartIndex, num, Instruction.CreateLdcI4((bool)callResult.returnValue ? 1 : 0));
 				removeUnboxInstruction(block, callResult.callStartIndex + 1, "System.Boolean");
-				Log.v("Decrypted boolean: {0}", callResult.returnValue);
+				Logger.v("Decrypted boolean: {0}", callResult.returnValue);
 			}
 		}
 	}
@@ -110,9 +110,9 @@ namespace de4dot.code.deobfuscators {
 				var block = callResult.block;
 				int num = callResult.callEndIndex - callResult.callStartIndex + 1;
 
-				block.replace(callResult.callStartIndex, num, DotNetUtils.createLdci4((int)callResult.returnValue));
+				block.replace(callResult.callStartIndex, num, Instruction.CreateLdcI4((int)callResult.returnValue));
 				removeUnboxInstruction(block, callResult.callStartIndex + 1, "System.Int32");
-				Log.v("Decrypted int32: {0}", callResult.returnValue);
+				Logger.v("Decrypted int32: {0}", callResult.returnValue);
 			}
 		}
 	}
@@ -125,7 +125,7 @@ namespace de4dot.code.deobfuscators {
 
 				block.replace(callResult.callStartIndex, num, Instruction.Create(OpCodes.Ldc_I8, (long)callResult.returnValue));
 				removeUnboxInstruction(block, callResult.callStartIndex + 1, "System.Int64");
-				Log.v("Decrypted int64: {0}", callResult.returnValue);
+				Logger.v("Decrypted int64: {0}", callResult.returnValue);
 			}
 		}
 	}
@@ -138,7 +138,7 @@ namespace de4dot.code.deobfuscators {
 
 				block.replace(callResult.callStartIndex, num, Instruction.Create(OpCodes.Ldc_R4, (float)callResult.returnValue));
 				removeUnboxInstruction(block, callResult.callStartIndex + 1, "System.Single");
-				Log.v("Decrypted single: {0}", callResult.returnValue);
+				Logger.v("Decrypted single: {0}", callResult.returnValue);
 			}
 		}
 	}
@@ -151,7 +151,7 @@ namespace de4dot.code.deobfuscators {
 
 				block.replace(callResult.callStartIndex, num, Instruction.Create(OpCodes.Ldc_R8, (double)callResult.returnValue));
 				removeUnboxInstruction(block, callResult.callStartIndex + 1, "System.Double");
-				Log.v("Decrypted double: {0}", callResult.returnValue);
+				Logger.v("Decrypted double: {0}", callResult.returnValue);
 			}
 		}
 	}
diff --git a/de4dot.code/deobfuscators/Xenocode/Deobfuscator.cs b/de4dot.code/deobfuscators/Xenocode/Deobfuscator.cs
index ec357b57..13042236 100644
--- a/de4dot.code/deobfuscators/Xenocode/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/Xenocode/Deobfuscator.cs
@@ -18,7 +18,7 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace de4dot.code.deobfuscators.Xenocode {
 	public class DeobfuscatorInfo : DeobfuscatorInfoBase {
@@ -114,7 +114,7 @@ namespace de4dot.code.deobfuscators.Xenocode {
 		public override IEnumerable<int> getStringDecrypterMethods() {
 			var list = new List<int>();
 			if (stringDecrypter.Method != null)
-				list.Add(stringDecrypter.Method.MetadataToken.ToInt32());
+				list.Add(stringDecrypter.Method.MDToken.ToInt32());
 			return list;
 		}
 	}
diff --git a/de4dot.code/deobfuscators/Xenocode/StringDecrypter.cs b/de4dot.code/deobfuscators/Xenocode/StringDecrypter.cs
index 55e119ba..4c7e4437 100644
--- a/de4dot.code/deobfuscators/Xenocode/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/Xenocode/StringDecrypter.cs
@@ -18,29 +18,29 @@
 */
 
 using System.Text;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Xenocode {
 	class StringDecrypter {
 		const int STRING_DECRYPTER_KEY_CONST = 1789;
-		ModuleDefinition module;
-		TypeDefinition stringDecrypterType;
-		MethodDefinition stringDecrypterMethod;
+		ModuleDefMD module;
+		TypeDef stringDecrypterType;
+		MethodDef stringDecrypterMethod;
 
 		public bool Detected {
 			get { return stringDecrypterMethod != null; }
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return stringDecrypterType; }
 		}
 
-		public MethodDefinition Method {
+		public MethodDef Method {
 			get { return stringDecrypterMethod; }
 		}
 
-		public StringDecrypter(ModuleDefinition module) {
+		public StringDecrypter(ModuleDefMD module) {
 			this.module = module;
 		}
 
@@ -53,7 +53,7 @@ namespace de4dot.code.deobfuscators.Xenocode {
 				if (type.HasProperties || type.HasEvents)
 					continue;
 
-				MethodDefinition method = null;
+				MethodDef method = null;
 				foreach (var m in type.Methods) {
 					if (m.Name == ".ctor" || m.Name == ".cctor")
 						continue;
@@ -69,7 +69,7 @@ namespace de4dot.code.deobfuscators.Xenocode {
 
 				bool foundConstant = false;
 				foreach (var instr in method.Body.Instructions) {
-					if (DotNetUtils.isLdcI4(instr) && DotNetUtils.getLdcI4Value(instr) == STRING_DECRYPTER_KEY_CONST) {
+					if (instr.IsLdcI4() && instr.GetLdcI4Value() == STRING_DECRYPTER_KEY_CONST) {
 						foundConstant = true;
 						break;
 					}
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/MyPEImage.cs b/de4dot.code/deobfuscators/dotNET_Reactor/MyPEImage.cs
new file mode 100644
index 00000000..fe06d857
--- /dev/null
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/MyPEImage.cs
@@ -0,0 +1,136 @@
+using System;
+using dot10.IO;
+using dot10.PE;
+using dot10.DotNet.MD;
+
+namespace de4dot.code.deobfuscators.dotNET_Reactor {
+	sealed class MyPEImage : IDisposable {
+		IPEImage peImage;
+		byte[] peImageData;
+		IImageStream peStream;
+		DotNetFile dnFile;
+		ImageSectionHeader dotNetSection;
+		bool ownPeImage;
+
+		public IPEImage PEImage {
+			get { return peImage; }
+		}
+
+		public uint Length {
+			get { return (uint)peStream.Length; }
+		}
+
+		public MyPEImage(IPEImage peImage) {
+			initialize(peImage);
+		}
+
+		public MyPEImage(byte[] peImageData) {
+			this.ownPeImage = true;
+			this.peImageData = peImageData;
+			initialize(new PEImage(peImageData));
+		}
+
+		void initialize(IPEImage peImage) {
+			this.peImage = peImage;
+			this.peStream = peImage.CreateFullStream();
+
+			//TODO: Only init this if they use the .NET MD
+			var dotNetDir = peImage.ImageNTHeaders.OptionalHeader.DataDirectories[14];
+			if (dotNetDir.VirtualAddress != 0 && dotNetDir.Size >= 0x48) {
+				dnFile = DotNetFile.Load(peImage, false);
+				dotNetSection = findSection(dotNetDir.VirtualAddress);
+			}
+		}
+
+		ImageSectionHeader findSection(RVA rva) {
+			foreach (var section in peImage.ImageSectionHeaders) {
+				if (section.VirtualAddress <= rva && rva < section.VirtualAddress + Math.Max(section.VirtualSize, section.SizeOfRawData))
+					return section;
+			}
+			return null;
+		}
+
+		static bool isInside(ImageSectionHeader section, uint offset, uint length) {
+			return offset >= section.PointerToRawData && offset + length <= section.PointerToRawData + section.SizeOfRawData;
+		}
+
+		public void offsetWriteUInt32(uint offset, uint val) {
+			peImageData[offset + 0] = (byte)val;
+			peImageData[offset + 1] = (byte)(val >> 8);
+			peImageData[offset + 2] = (byte)(val >> 16);
+			peImageData[offset + 3] = (byte)(val >> 24);
+		}
+
+		public void offsetWriteUInt16(uint offset, ushort val) {
+			peImageData[offset + 0] = (byte)val;
+			peImageData[offset + 1] = (byte)(val >> 8);
+		}
+
+		public uint offsetReadUInt32(uint offset) {
+			peStream.Position = offset;
+			return peStream.ReadUInt32();
+		}
+
+		public ushort offsetReadUInt16(uint offset) {
+			peStream.Position = offset;
+			return peStream.ReadUInt16();
+		}
+
+		public byte offsetReadByte(uint offset) {
+			peStream.Position = offset;
+			return peStream.ReadByte();
+		}
+
+		public byte[] offsetReadBytes(uint offset, int size) {
+			peStream.Position = offset;
+			return peStream.ReadBytes(size);
+		}
+
+		public void offsetWrite(uint offset, byte[] data) {
+			Array.Copy(data, 0, peImageData, offset, data.Length);
+		}
+
+		bool intersect(uint offset1, uint length1, uint offset2, uint length2) {
+			return !(offset1 + length1 <= offset2 || offset2 + length2 <= offset1);
+		}
+
+		bool intersect(uint offset, uint length, IFileSection location) {
+			return intersect(offset, length, (uint)location.StartOffset, (uint)(location.EndOffset - location.StartOffset));
+		}
+
+		public bool dotNetSafeWriteOffset(uint offset, byte[] data) {
+			if (dnFile != null) {
+				uint length = (uint)data.Length;
+
+				if (!isInside(dotNetSection, offset, length))
+					return false;
+				if (intersect(offset, length, dnFile.MetaData.ImageCor20Header))
+					return false;
+				if (intersect(offset, length, (uint)dnFile.MetaData.TablesStream.FileOffset, dnFile.MetaData.TablesStream.HeaderLength))
+					return false;
+			}
+
+			offsetWrite(offset, data);
+			return true;
+		}
+
+		public bool dotNetSafeWrite(uint rva, byte[] data) {
+			return dotNetSafeWriteOffset((uint)peImage.ToFileOffset((RVA)rva), data);
+		}
+
+		public void Dispose() {
+			if (ownPeImage) {
+				if (dnFile != null)
+					dnFile.Dispose();
+				if (peImage != null)
+					peImage.Dispose();
+			}
+			if (peStream != null)
+				peStream.Dispose();
+
+			dnFile = null;
+			peImage = null;
+			peStream = null;
+		}
+	}
+}
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v3/AntiStrongName.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v3/AntiStrongName.cs
index 00da2b21..2f9408a1 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v3/AntiStrongName.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v3/AntiStrongName.cs
@@ -18,8 +18,8 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
@@ -120,7 +120,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 		static bool checkCall(Instr instr, string methodFullname) {
 			if (instr.OpCode.Code != Code.Call && instr.OpCode.Code != Code.Callvirt)
 				return false;
-			var calledMethod = instr.Operand as MethodReference;
+			var calledMethod = instr.Operand as IMethod;
 			if (calledMethod == null)
 				return false;
 			return calledMethod.ToString() == methodFullname;
@@ -129,13 +129,13 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 		static bool checkCall(Instr instr, string returnType, string parameters) {
 			if (instr.OpCode.Code != Code.Call && instr.OpCode.Code != Code.Callvirt)
 				return false;
-			var calledMethod = instr.Operand as MethodReference;
+			var calledMethod = instr.Operand as IMethod;
 			if (calledMethod == null)
 				return false;
 			return DotNetUtils.isMethod(calledMethod, returnType, parameters);
 		}
 
-		static bool checkLdloc(IList<VariableDefinition> locals, Instr instr, VariableDefinition local) {
+		static bool checkLdloc(IList<Local> locals, Instr instr, Local local) {
 			if (!instr.isLdloc())
 				return false;
 			if (Instr.getLocalVar(locals, instr) != local)
@@ -143,7 +143,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			return true;
 		}
 
-		static bool checkStloc(IList<VariableDefinition> locals, Instr instr, VariableDefinition local) {
+		static bool checkStloc(IList<Local> locals, Instr instr, Local local) {
 			if (!instr.isStloc())
 				return false;
 			if (Instr.getLocalVar(locals, instr) != local)
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v3/ApplicationModeDecrypter.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v3/ApplicationModeDecrypter.cs
index 692574d9..b8faf232 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v3/ApplicationModeDecrypter.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v3/ApplicationModeDecrypter.cs
@@ -17,13 +17,13 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 using de4dot.blocks.cflow;
 
 namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 	class ApplicationModeDecrypter {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		AssemblyResolver assemblyResolver;
 		MemoryPatcher memoryPatcher;
 
@@ -43,7 +43,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			get { return assemblyResolver != null; }
 		}
 
-		public ApplicationModeDecrypter(ModuleDefinition module) {
+		public ApplicationModeDecrypter(ModuleDefMD module) {
 			this.module = module;
 			find();
 		}
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v3/ApplicationModeUnpacker.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v3/ApplicationModeUnpacker.cs
index 3bf94291..da5a8ffc 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v3/ApplicationModeUnpacker.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v3/ApplicationModeUnpacker.cs
@@ -22,8 +22,10 @@ using System.Collections.Generic;
 using System.IO;
 using System.Text;
 using System.Text.RegularExpressions;
-using Mono.Cecil;
-using de4dot.PE;
+using dot10.IO;
+using dot10.PE;
+using dot10.DotNet;
+using dot10.DotNet.MD;
 
 namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 	class IniFile {
@@ -77,7 +79,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			0x73, 0x33, 0x6E, 0x6D, 0x34, 0x32, 0x64, 0x35,
 		};
 
-		PeImage peImage;
+		IPEImage peImage;
 		List<UnpackedFile> satelliteAssemblies = new List<UnpackedFile>();
 		uint[] sizes;
 		string[] filenames;
@@ -87,29 +89,35 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			get { return satelliteAssemblies; }
 		}
 
-		public ApplicationModeUnpacker(PeImage peImage) {
+		public ApplicationModeUnpacker(IPEImage peImage) {
 			this.peImage = peImage;
 		}
 
 		public byte[] unpack() {
 			byte[] data = null;
+			MyPEImage myPeImage = null;
 			try {
-				data = unpack2();
+				myPeImage = new MyPEImage(peImage);
+				data = unpack2(myPeImage);
 			}
 			catch {
 			}
+			finally {
+				if (myPeImage != null)
+					myPeImage.Dispose();
+			}
 			if (data != null)
 				return data;
 
 			if (shouldUnpack)
-				Log.w("Could not unpack the file");
+				Logger.w("Could not unpack file: {0}", peImage.FileName ?? "(unknown filename)");
 			return null;
 		}
 
-		byte[] unpack2() {
+		byte[] unpack2(MyPEImage peImage) {
 			shouldUnpack = false;
-			uint headerOffset = peImage.ImageLength - 12;
-			uint offsetEncryptedAssembly = checkOffset(peImage.offsetReadUInt32(headerOffset));
+			uint headerOffset = (uint)peImage.Length - 12;
+			uint offsetEncryptedAssembly = checkOffset(peImage, peImage.offsetReadUInt32(headerOffset));
 			uint ezencryptionLibLength = peImage.offsetReadUInt32(headerOffset + 4);
 			uint iniFileLength = peImage.offsetReadUInt32(headerOffset + 8);
 
@@ -135,30 +143,31 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 				return null;
 
 			byte[] ezencryptionLibData = decompress1(peImage.offsetReadBytes(ezencryptionLibOffset, (int)ezencryptionLibLength));
-			var ezencryptionLibModule = ModuleDefinition.ReadModule(new MemoryStream(ezencryptionLibData));
+			var ezencryptionLibModule = ModuleDefMD.Load(ezencryptionLibData);
 			var decrypter = new ApplicationModeDecrypter(ezencryptionLibModule);
 			if (!decrypter.Detected)
 				return null;
 
-			var mainAssembly = unpackEmbeddedFile(0, decrypter);
+			var mainAssembly = unpackEmbeddedFile(peImage, 0, decrypter);
 			decrypter.MemoryPatcher.patch(mainAssembly.data);
 			for (int i = 1; i < filenames.Length; i++)
-				satelliteAssemblies.Add(unpackEmbeddedFile(i, decrypter));
+				satelliteAssemblies.Add(unpackEmbeddedFile(peImage, i, decrypter));
 
 			clearDllBit(mainAssembly.data);
 			return mainAssembly.data;
 		}
 
 		static void clearDllBit(byte[] peImageData) {
-			var mainPeImage = new PeImage(peImageData);
-			uint characteristicsOffset = mainPeImage.FileHeaderOffset + 18;
-			ushort characteristics = mainPeImage.offsetReadUInt16(characteristicsOffset);
-			characteristics &= 0xDFFF;
-			characteristics |= 2;
-			mainPeImage.offsetWriteUInt16(characteristicsOffset, characteristics);
+			using (var mainPeImage = new MyPEImage(peImageData)) {
+				uint characteristicsOffset = (uint)mainPeImage.PEImage.ImageNTHeaders.FileHeader.StartOffset + 18;
+				ushort characteristics = mainPeImage.offsetReadUInt16(characteristicsOffset);
+				characteristics &= 0xDFFF;
+				characteristics |= 2;
+				mainPeImage.offsetWriteUInt16(characteristicsOffset, characteristics);
+			}
 		}
 
-		UnpackedFile unpackEmbeddedFile(int index, ApplicationModeDecrypter decrypter) {
+		UnpackedFile unpackEmbeddedFile(MyPEImage peImage, int index, ApplicationModeDecrypter decrypter) {
 			uint offset = 0;
 			for (int i = 0; i < index + 1; i++)
 				offset += sizes[i];
@@ -178,8 +187,8 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			return list.ToArray();
 		}
 
-		uint checkOffset(uint offset) {
-			if (offset >= peImage.ImageLength)
+		uint checkOffset(MyPEImage peImage, uint offset) {
+			if (offset >= peImage.Length)
 				throw new Exception();
 			return offset;
 		}
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v3/AssemblyResolver.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v3/AssemblyResolver.cs
index bb362aca..e6536bc5 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v3/AssemblyResolver.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v3/AssemblyResolver.cs
@@ -18,7 +18,7 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 using de4dot.blocks.cflow;
 
@@ -38,11 +38,11 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			get { return decryptMethod.Detected; }
 		}
 
-		public AssemblyResolver(TypeDefinition type, ICflowDeobfuscator cflowDeobfuscator) {
+		public AssemblyResolver(TypeDef type, ICflowDeobfuscator cflowDeobfuscator) {
 			find(type, cflowDeobfuscator);
 		}
 
-		void find(TypeDefinition type, ICflowDeobfuscator cflowDeobfuscator) {
+		void find(TypeDef type, ICflowDeobfuscator cflowDeobfuscator) {
 			var additionalTypes = new List<string> {
 				"System.IO.BinaryReader",
 				"System.IO.FileStream",
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v3/DecryptMethod.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v3/DecryptMethod.cs
index aa833355..3f2d16fa 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v3/DecryptMethod.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v3/DecryptMethod.cs
@@ -19,11 +19,11 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 	class DecryptMethod {
-		MethodDefinition decryptionMethod;
+		MethodDef decryptionMethod;
 		byte[] key;
 		byte[] iv;
 
@@ -39,7 +39,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			get { return decryptionMethod != null; }
 		}
 
-		public static bool couldBeDecryptMethod(MethodDefinition method, IEnumerable<string> additionalTypes) {
+		public static bool couldBeDecryptMethod(MethodDef method, IEnumerable<string> additionalTypes) {
 			if (method.Body == null)
 				return false;
 
@@ -60,7 +60,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			return true;
 		}
 
-		public bool getKey(MethodDefinition method) {
+		public bool getKey(MethodDef method) {
 			var tmpKey = ArrayFinder.getInitializedByteArray(method, 32);
 			if (tmpKey == null)
 				return false;
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v3/DecrypterType.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v3/DecrypterType.cs
index 0e49d91b..c0732649 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v3/DecrypterType.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v3/DecrypterType.cs
@@ -20,26 +20,26 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 using de4dot.PE;
 
 namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 	// Find the type that decrypts strings and calls the native lib
 	class DecrypterType {
-		ModuleDefinition module;
-		TypeDefinition decrypterType;
-		MethodDefinition stringDecrypter1;
-		MethodDefinition stringDecrypter2;
-		List<MethodDefinition> initMethods = new List<MethodDefinition>();
-		List<ModuleReference> moduleReferences = new List<ModuleReference>();
+		ModuleDefMD module;
+		TypeDef decrypterType;
+		MethodDef stringDecrypter1;
+		MethodDef stringDecrypter2;
+		List<MethodDef> initMethods = new List<MethodDef>();
+		List<ModuleRef> moduleReferences = new List<ModuleRef>();
 		Resource linkedResource;
 
 		public bool Detected {
 			get { return decrypterType != null; }
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return decrypterType; }
 		}
 
@@ -47,36 +47,32 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			get { return linkedResource; }
 		}
 
-		public MethodDefinition StringDecrypter1 {
+		public MethodDef StringDecrypter1 {
 			get { return stringDecrypter1; }
 		}
 
-		public MethodDefinition StringDecrypter2 {
+		public MethodDef StringDecrypter2 {
 			get { return stringDecrypter2; }
 		}
 
-		public IEnumerable<MethodDefinition> InitMethods {
+		public IEnumerable<MethodDef> InitMethods {
 			get { return initMethods; }
 		}
 
-		public List<ModuleReference> ModuleReferences {
-			get { return moduleReferences; }
-		}
-
-		public IEnumerable<MethodDefinition> StringDecrypters {
+		public IEnumerable<MethodDef> StringDecrypters {
 			get {
-				return new List<MethodDefinition> {
+				return new List<MethodDef> {
 					stringDecrypter1,
 					stringDecrypter2,
 				};
 			}
 		}
 
-		public DecrypterType(ModuleDefinition module) {
+		public DecrypterType(ModuleDefMD module) {
 			this.module = module;
 		}
 
-		public DecrypterType(ModuleDefinition module, DecrypterType oldOne) {
+		public DecrypterType(ModuleDefMD module, DecrypterType oldOne) {
 			this.module = module;
 			this.decrypterType = lookup(oldOne.decrypterType, "Could not find decrypterType");
 			this.stringDecrypter1 = lookup(oldOne.stringDecrypter1, "Could not find stringDecrypter1");
@@ -86,7 +82,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			updateModuleReferences();
 		}
 
-		T lookup<T>(T def, string errorMessage) where T : MemberReference {
+		T lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
 			return DeobUtils.lookup(module, def, errorMessage);
 		}
 
@@ -109,11 +105,11 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 
 		void updateModuleReferences() {
 			foreach (var method in decrypterType.Methods) {
-				if (method.PInvokeInfo != null) {
-					switch (method.PInvokeInfo.EntryPoint) {
+				if (method.ImplMap != null) {
+					switch (method.ImplMap.Name.String) {
 					case "nr_nli":
 					case "nr_startup":
-						moduleReferences.Add(method.PInvokeInfo.Module);
+						moduleReferences.Add(method.ImplMap.Module);
 						break;
 					}
 				}
@@ -123,7 +119,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 
 		void updateLinkedResource() {
 			foreach (var modref in moduleReferences) {
-				var resource = DotNetUtils.getResource(module, modref.Name) as LinkedResource;
+				var resource = DotNetUtils.getResource(module, modref.Name.String) as LinkedResource;
 				if (resource == null)
 					continue;
 
@@ -132,8 +128,8 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			}
 		}
 
-		MethodDefinition getStringDecrypter(TypeDefinition type, string name) {
-			var method = DotNetUtils.getMethod(type, name);
+		MethodDef getStringDecrypter(TypeDef type, string name) {
+			var method = type.FindMethod(name);
 			if (method == null)
 				return null;
 			if (!DotNetUtils.isMethod(method, "System.String", "(System.String)"))
@@ -152,19 +148,20 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			return Encoding.Unicode.GetString(Convert.FromBase64String(s));
 		}
 
-		public bool patch(PeImage peImage) {
+		public bool patch(byte[] peData) {
 			try {
-				return patch2(peImage);
+				using (var peImage = new MyPEImage(peData))
+					return patch2(peImage);
 			}
 			catch {
-				Log.w("Could not patch the file");
+				Logger.w("Could not patch the file");
 				return false;
 			}
 		}
 
-		bool patch2(PeImage peImage) {
-			uint numPatches = peImage.offsetReadUInt32(peImage.ImageLength - 4);
-			uint offset = checked(peImage.ImageLength - 4 - numPatches * 8);
+		bool patch2(MyPEImage peImage) {
+			uint numPatches = peImage.offsetReadUInt32(peImage.Length - 4);
+			uint offset = checked(peImage.Length - 4 - numPatches * 8);
 
 			bool startedPatchingBadData = false;
 			for (uint i = 0; i < numPatches; i++, offset += 8) {
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v3/Deobfuscator.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v3/Deobfuscator.cs
index f543fc3c..a31010e8 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v3/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v3/Deobfuscator.cs
@@ -21,11 +21,11 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Text.RegularExpressions;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.MyStuff;
+using dot10.IO;
+using dot10.PE;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
-using de4dot.PE;
 
 namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 	public class DeobfuscatorInfo : DeobfuscatorInfoBase {
@@ -125,7 +125,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 				this.RenamingOptions &= ~RenamingOptions.RemoveNamespaceIfOneType;
 		}
 
-		public override byte[] unpackNativeFile(PeImage peImage) {
+		public override byte[] unpackNativeFile(IPEImage peImage) {
 			var unpacker = new ApplicationModeUnpacker(peImage);
 			var data = unpacker.unpack();
 			if (data == null)
@@ -146,15 +146,14 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 				return false;
 
 			var fileData = ModuleBytes ?? DeobUtils.readModule(module);
-			var peImage = new PeImage(fileData);
-			if (!decrypterType.patch(peImage))
+			if (!decrypterType.patch(fileData))
 				return false;
 
 			newFileData = fileData;
 			return true;
 		}
 
-		public override IDeobfuscator moduleReloaded(ModuleDefinition module) {
+		public override IDeobfuscator moduleReloaded(ModuleDefMD module) {
 			var newOne = new Deobfuscator(options);
 			newOne.setModule(module);
 			newOne.decrypterType = new DecrypterType(module, decrypterType);
@@ -162,7 +161,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			return newOne;
 		}
 
-		public override void init(ModuleDefinition module) {
+		public override void init(ModuleDefMD module) {
 			base.init(module);
 		}
 
@@ -218,6 +217,10 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			return name != null && checkValidName(name, isRandomNameMembers);
 		}
 
+		public override bool isValidMethodReturnArgName(string name) {
+			return string.IsNullOrEmpty(name) || checkValidName(name, isRandomNameMembers);
+		}
+
 		public override bool isValidResourceKeyName(string name) {
 			return name != null && checkValidName(name, isRandomNameMembers);
 		}
@@ -280,7 +283,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			startedDeobfuscating = true;
 		}
 
-		void removeInitCall(MethodDefinition initMethod) {
+		void removeInitCall(MethodDef initMethod) {
 			addCctorInitCallToBeRemoved(initMethod);
 			addCtorInitCallToBeRemoved(initMethod);
 		}
@@ -294,7 +297,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 
 		void dumpResourceFiles() {
 			foreach (var resource in libAssemblyResolver.Resources) {
-				var mod = ModuleDefinition.ReadModule(resource.GetResourceStream());
+				var mod = ModuleDefMD.Load(resource.Data.ReadAllBytes());
 				addResourceToBeRemoved(resource, string.Format("Embedded assembly: {0}", mod.Assembly.FullName));
 				DeobfuscatedFile.createAssemblyFile(resource.GetResourceData(),
 							Utils.getAssemblySimpleName(mod.Assembly.FullName),
@@ -308,7 +311,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 		public override void deobfuscateMethodEnd(Blocks blocks) {
 			if (options.RemoveAntiStrongName) {
 				if (antiStrongName.remove(blocks))
-					Log.v("Removed Anti Strong Name code");
+					Logger.v("Removed Anti Strong Name code");
 			}
 			base.deobfuscateMethodEnd(blocks);
 		}
@@ -320,7 +323,6 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 
 			if (canRemoveDecrypterType && !isTypeCalled(decrypterType.Type)) {
 				addTypeToBeRemoved(decrypterType.Type, "Decrypter type");
-				addModuleReferencesToBeRemoved(decrypterType.ModuleReferences, "Native lib module reference");
 				addResourceToBeRemoved(decrypterType.LinkedResource, "Native lib linked resource");
 			}
 
@@ -336,7 +338,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 		public override IEnumerable<int> getStringDecrypterMethods() {
 			var list = new List<int>();
 			foreach (var method in decrypterType.StringDecrypters)
-				list.Add(method.MetadataToken.ToInt32());
+				list.Add(method.MDToken.ToInt32());
 			return list;
 		}
 	}
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v3/LibAssemblyResolver.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v3/LibAssemblyResolver.cs
index 11a33892..72b9c4c0 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v3/LibAssemblyResolver.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v3/LibAssemblyResolver.cs
@@ -18,22 +18,22 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 	// Find the assembly resolver that's used in lib mode (3.8+)
 	class LibAssemblyResolver {
-		ModuleDefinition module;
-		MethodDefinition initMethod;
+		ModuleDefMD module;
+		MethodDef initMethod;
 		List<EmbeddedResource> resources = new List<EmbeddedResource>();
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return initMethod == null ? null : initMethod.DeclaringType; }
 		}
 
-		public MethodDefinition InitMethod {
+		public MethodDef InitMethod {
 			get { return initMethod; }
 		}
 
@@ -41,7 +41,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			get { return resources; }
 		}
 
-		public LibAssemblyResolver(ModuleDefinition module) {
+		public LibAssemblyResolver(ModuleDefMD module) {
 			this.module = module;
 		}
 
@@ -52,7 +52,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 				return;
 		}
 
-		bool checkInitMethod(MethodDefinition checkMethod, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
+		bool checkInitMethod(MethodDef checkMethod, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
 			var requiredFields = new string[] {
 				"System.Collections.Hashtable",
 				"System.Boolean",
@@ -69,7 +69,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 				var type = method.DeclaringType;
 				if (!new FieldTypes(type).exactly(requiredFields))
 					continue;
-				var ctor = DotNetUtils.getMethod(type, ".ctor");
+				var ctor = type.FindMethod(".ctor");
 				if (ctor == null)
 					continue;
 				var handler = DeobUtils.getResolveMethod(ctor);
@@ -94,7 +94,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			return false;
 		}
 
-		string getResourcePrefix(MethodDefinition handler) {
+		string getResourcePrefix(MethodDef handler) {
 			foreach (var s in DotNetUtils.getCodeStrings(handler)) {
 				var resource = DotNetUtils.getResource(module, s + "00000") as EmbeddedResource;
 				if (resource != null)
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v3/MemoryPatcher.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v3/MemoryPatcher.cs
index ab459b16..aa21ab0a 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v3/MemoryPatcher.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v3/MemoryPatcher.cs
@@ -20,7 +20,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 using de4dot.blocks.cflow;
 using de4dot.PE;
@@ -43,11 +43,11 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			get { return decryptMethod.Detected; }
 		}
 
-		public MemoryPatcher(TypeDefinition type, ICflowDeobfuscator cflowDeobfuscator) {
+		public MemoryPatcher(TypeDef type, ICflowDeobfuscator cflowDeobfuscator) {
 			find(type, cflowDeobfuscator);
 		}
 
-		void find(TypeDefinition type, ICflowDeobfuscator cflowDeobfuscator) {
+		void find(TypeDef type, ICflowDeobfuscator cflowDeobfuscator) {
 			var additionalTypes = new List<string> {
 				"System.IO.BinaryWriter",
 			};
@@ -65,7 +65,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			}
 		}
 
-		void findPatchData(TypeDefinition type, ICflowDeobfuscator cflowDeobfuscator) {
+		void findPatchData(TypeDef type, ICflowDeobfuscator cflowDeobfuscator) {
 			var locals = new List<string> {
 				"System.Int32[]",
 				"System.UInt32[]",
@@ -86,7 +86,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			}
 		}
 
-		PatchInfo getPatchInfo(MethodDefinition method) {
+		PatchInfo getPatchInfo(MethodDef method) {
 			int index1 = 0, index2, index3, size1, size2, size3;
 			if (!ArrayFinder.findNewarr(method, ref index1, out size1))
 				return null;
@@ -135,10 +135,11 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 		}
 
 		public void patch(byte[] peImageData) {
-			var peImage = new PeImage(peImageData);
-			foreach (var info in patchInfos) {
-				for (int i = 0; i < info.offsets.Length; i++)
-					peImage.dotNetSafeWriteOffset((uint)info.offsets[i], BitConverter.GetBytes(info.values[i]));
+			using (var peImage = new MyPEImage(peImageData)) {
+				foreach (var info in patchInfos) {
+					for (int i = 0; i < info.offsets.Length; i++)
+						peImage.dotNetSafeWriteOffset((uint)info.offsets[i], BitConverter.GetBytes(info.values[i]));
+				}
 			}
 		}
 	}
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v3/NativeLibSaver.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v3/NativeLibSaver.cs
index bc2eb849..45faf868 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v3/NativeLibSaver.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v3/NativeLibSaver.cs
@@ -18,22 +18,22 @@
 */
 
 using System;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 	// Finds the type that saves the native lib (if in resources) to disk
 	class NativeLibSaver {
-		ModuleDefinition module;
-		TypeDefinition nativeLibCallerType;
-		MethodDefinition initMethod;
+		ModuleDefMD module;
+		TypeDef nativeLibCallerType;
+		MethodDef initMethod;
 		Resource nativeFileResource;
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return nativeLibCallerType; }
 		}
 
-		public MethodDefinition InitMethod {
+		public MethodDef InitMethod {
 			get { return initMethod; }
 		}
 
@@ -45,22 +45,22 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			get { return nativeLibCallerType != null; }
 		}
 
-		public NativeLibSaver(ModuleDefinition module) {
+		public NativeLibSaver(ModuleDefMD module) {
 			this.module = module;
 		}
 
-		public NativeLibSaver(ModuleDefinition module, NativeLibSaver oldOne) {
+		public NativeLibSaver(ModuleDefMD module, NativeLibSaver oldOne) {
 			this.module = module;
 			this.nativeLibCallerType = lookup(oldOne.nativeLibCallerType, "Could not find nativeLibCallerType");
 			this.initMethod = lookup(oldOne.initMethod, "Could not find initMethod");
 			if (oldOne.nativeFileResource != null) {
-				this.nativeFileResource = DotNetUtils.getResource(module, oldOne.nativeFileResource.Name);
+				this.nativeFileResource = DotNetUtils.getResource(module, oldOne.nativeFileResource.Name.String);
 				if (this.nativeFileResource == null)
 					throw new ApplicationException("Could not find nativeFileResource");
 			}
 		}
 
-		T lookup<T>(T def, string errorMessage) where T : MemberReference {
+		T lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
 			return DeobUtils.lookup(module, def, errorMessage);
 		}
 
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v4/AntiStrongname.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v4/AntiStrongname.cs
index dc050057..64425767 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v4/AntiStrongname.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v4/AntiStrongname.cs
@@ -18,16 +18,16 @@
 */
 
 using System;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 	class AntiStrongName {
-		TypeDefinition decrypterType;
-		MethodDefinition antiStrongNameMethod;
+		TypeDef decrypterType;
+		MethodDef antiStrongNameMethod;
 
-		public AntiStrongName(TypeDefinition decrypterType) {
+		public AntiStrongName(TypeDef decrypterType) {
 			this.decrypterType = decrypterType;
 			find();
 		}
@@ -45,7 +45,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			}
 		}
 
-		bool checkType(TypeDefinition type) {
+		bool checkType(TypeDef type) {
 			var requiredTypes = new string[] {
 				"System.Byte[]",
 				"System.IO.MemoryStream",
@@ -57,13 +57,14 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			foreach (var method in type.Methods) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
-				if (method.Parameters.Count != 2)
+				var sig = method.MethodSig;
+				if (sig == null || sig.Params.Count != 2)
 					continue;
-				if (!checkType(method.MethodReturnType.ReturnType.FullName, "System.String"))
+				if (!checkType(sig.RetType, ElementType.String))
 					continue;
-				if (!checkType(method.Parameters[0].ParameterType.FullName, "System.String"))
+				if (!checkType(sig.Params[0], ElementType.String))
 					continue;
-				if (!checkType(method.Parameters[1].ParameterType.FullName, "System.String"))
+				if (!checkType(sig.Params[1], ElementType.String))
 					continue;
 
 				var localTypes = new LocalTypes(method);
@@ -77,8 +78,8 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			return false;
 		}
 
-		static bool checkType(string type, string expectedType) {
-			return type == "System.Object" || type == expectedType;
+		static bool checkType(TypeSig type, ElementType expectedType) {
+			return type != null && (type.ElementType == ElementType.Object || type.ElementType == expectedType);
 		}
 
 		public bool remove(Blocks blocks) {
@@ -129,7 +130,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				int i = instructions.Count - NUM_INSTRS;
 				if (instructions[i].OpCode.Code != Code.Ldtoken)
 					continue;
-				if (!(instructions[i].Operand is TypeReference))
+				if (!(instructions[i].Operand is ITypeDefOrRef))
 					continue;
 				if (!checkCall(instructions[i + 1], "System.Type System.Type::GetTypeFromHandle(System.RuntimeTypeHandle)"))
 					continue;
@@ -163,19 +164,19 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 		static bool checkCall(Instr instr, string methodFullName) {
 			if (instr.OpCode.Code != Code.Call && instr.OpCode.Code != Code.Callvirt)
 				return false;
-			var calledMethod = instr.Operand as MethodReference;
+			var calledMethod = instr.Operand as IMethod;
 			if (calledMethod == null)
 				return false;
 			return calledMethod.FullName == methodFullName;
 		}
 
-		static bool checkCall(Instr instr, MethodReference expectedMethod) {
+		static bool checkCall(Instr instr, IMethod expectedMethod) {
 			if (instr.OpCode.Code != Code.Call && instr.OpCode.Code != Code.Callvirt)
 				return false;
-			var calledMethod = instr.Operand as MethodReference;
+			var calledMethod = instr.Operand as IMethod;
 			if (calledMethod == null)
 				return false;
-			return MemberReferenceHelper.compareMethodReferenceAndDeclaringType(calledMethod, expectedMethod);
+			return MethodEqualityComparer.CompareDeclaringTypes.Equals(calledMethod, expectedMethod);
 		}
 	}
 }
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v4/AssemblyResolver.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v4/AssemblyResolver.cs
index def1dfc3..affbfe57 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v4/AssemblyResolver.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v4/AssemblyResolver.cs
@@ -19,8 +19,8 @@
 
 using System;
 using System.Collections.Generic;
-using System.IO;
-using Mono.Cecil;
+using dot10.DotNet;
+using dot10.IO;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
@@ -39,35 +39,35 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 	}
 
 	class AssemblyResolver {
-		ModuleDefinition module;
-		TypeDefinition assemblyResolverType;
-		MethodDefinition assemblyResolverInitMethod;
-		MethodDefinition assemblyResolverMethod;
+		ModuleDefMD module;
+		TypeDef assemblyResolverType;
+		MethodDef assemblyResolverInitMethod;
+		MethodDef assemblyResolverMethod;
 
 		public bool Detected {
 			get { return assemblyResolverType != null; }
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return assemblyResolverType; }
 		}
 
-		public MethodDefinition InitMethod {
+		public MethodDef InitMethod {
 			get { return assemblyResolverInitMethod; }
 		}
 
-		public AssemblyResolver(ModuleDefinition module) {
+		public AssemblyResolver(ModuleDefMD module) {
 			this.module = module;
 		}
 
-		public AssemblyResolver(ModuleDefinition module, AssemblyResolver oldOne) {
+		public AssemblyResolver(ModuleDefMD module, AssemblyResolver oldOne) {
 			this.module = module;
 			this.assemblyResolverType = lookup(oldOne.assemblyResolverType, "Could not find assembly resolver type");
 			this.assemblyResolverMethod = lookup(oldOne.assemblyResolverMethod, "Could not find assembly resolver method");
 			this.assemblyResolverInitMethod = lookup(oldOne.assemblyResolverInitMethod, "Could not find assembly resolver init method");
 		}
 
-		T lookup<T>(T def, string errorMessage) where T : MemberReference {
+		T lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
 			return DeobUtils.lookup(module, def, errorMessage);
 		}
 
@@ -75,12 +75,12 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			if (checkMethod(simpleDeobfuscator, module.EntryPoint))
 				return;
 			if (module.EntryPoint != null) {
-				if (checkMethod(simpleDeobfuscator, DotNetUtils.getMethod(module.EntryPoint.DeclaringType, ".cctor")))
+				if (checkMethod(simpleDeobfuscator, module.EntryPoint.DeclaringType.FindStaticConstructor()))
 					return;
 			}
 		}
 
-		bool checkMethod(ISimpleDeobfuscator simpleDeobfuscator, MethodDefinition methodToCheck) {
+		bool checkMethod(ISimpleDeobfuscator simpleDeobfuscator, MethodDef methodToCheck) {
 			if (methodToCheck == null)
 				return false;
 
@@ -127,7 +127,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			return false;
 		}
 
-		static bool checkFields(IList<FieldDefinition> fields) {
+		static bool checkFields(IList<FieldDef> fields) {
 			if (fields.Count != 2)
 				return false;
 
@@ -137,7 +137,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				 fieldTypes.count("System.Object") == 1);
 		}
 
-		static MethodDefinition findAssemblyResolveMethod(TypeDefinition type) {
+		static MethodDef findAssemblyResolveMethod(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (DotNetUtils.isMethod(method, "System.Reflection.Assembly", "(System.Object,System.ResolveEventArgs)"))
 					return method;
@@ -181,7 +181,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				var resource = rsrc as EmbeddedResource;
 				if (resource == null)
 					continue;
-				if (!Utils.StartsWith(resource.Name, prefix, StringComparison.Ordinal))
+				if (!Utils.StartsWith(resource.Name.String, prefix, StringComparison.Ordinal))
 					continue;
 
 				result.Add(resource);
@@ -193,8 +193,8 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 		static int unknownNameCounter = 0;
 		static string getAssemblyName(EmbeddedResource resource) {
 			try {
-				var resourceModule = ModuleDefinition.ReadModule(new MemoryStream(resource.GetResourceData()));
-				return resourceModule.Assembly.Name.FullName;
+				var resourceModule = ModuleDefMD.Load(resource.Data.ReadAllBytes());
+				return resourceModule.Assembly.FullName;
 			}
 			catch {
 				return string.Format("unknown_name_{0}", unknownNameCounter++);
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v4/BooleanDecrypter.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v4/BooleanDecrypter.cs
index d3e62d16..93aa59ce 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v4/BooleanDecrypter.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v4/BooleanDecrypter.cs
@@ -18,12 +18,12 @@
 */
 
 using System;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 	class BooleanDecrypter {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		EncryptedResource encryptedResource;
 		byte[] fileData;
 		byte[] decryptedData;
@@ -32,11 +32,11 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			get { return encryptedResource.Method != null; }
 		}
 
-		public TypeDefinition DecrypterType {
+		public TypeDef DecrypterType {
 			get { return encryptedResource.Type; }
 		}
 
-		public MethodDefinition Method {
+		public MethodDef Method {
 			get { return encryptedResource.Method; }
 		}
 
@@ -44,12 +44,12 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			get { return encryptedResource.Resource; }
 		}
 
-		public BooleanDecrypter(ModuleDefinition module) {
+		public BooleanDecrypter(ModuleDefMD module) {
 			this.module = module;
 			this.encryptedResource = new EncryptedResource(module);
 		}
 
-		public BooleanDecrypter(ModuleDefinition module, BooleanDecrypter oldOne) {
+		public BooleanDecrypter(ModuleDefMD module, BooleanDecrypter oldOne) {
 			this.module = module;
 			this.encryptedResource = new EncryptedResource(module, oldOne.encryptedResource);
 		}
@@ -84,7 +84,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			if (!encryptedResource.FoundResource)
 				return;
 
-			Log.v("Adding boolean decrypter. Resource: {0}", Utils.toCsharpString(encryptedResource.Resource.Name));
+			Logger.v("Adding boolean decrypter. Resource: {0}", Utils.toCsharpString(encryptedResource.Resource.Name));
 			decryptedData = encryptedResource.decrypt();
 		}
 
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v4/Deobfuscator.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v4/Deobfuscator.cs
index f5ca0c69..bb044ca8 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v4/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v4/Deobfuscator.cs
@@ -21,9 +21,10 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Text.RegularExpressions;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.MyStuff;
+using dot10.PE;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
+using dot10.DotNet.Writer;
 using de4dot.blocks;
 using de4dot.PE;
 
@@ -157,7 +158,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				this.RenamingOptions &= ~RenamingOptions.RemoveNamespaceIfOneType;
 		}
 
-		public override byte[] unpackNativeFile(PeImage peImage) {
+		public override byte[] unpackNativeFile(IPEImage peImage) {
 			var data = new NativeImageUnpacker(peImage).unpack();
 			if (data == null)
 				return null;
@@ -167,7 +168,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			return data;
 		}
 
-		public override void init(ModuleDefinition module) {
+		public override void init(ModuleDefMD module) {
 			base.init(module);
 		}
 
@@ -223,6 +224,10 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			return name != null && checkValidName(name, isRandomNameMembers);
 		}
 
+		public override bool isValidMethodReturnArgName(string name) {
+			return string.IsNullOrEmpty(name) || checkValidName(name, isRandomNameMembers);
+		}
+
 		public override bool isValidResourceKeyName(string name) {
 			return name != null && checkValidName(name, isRandomNameMembers);
 		}
@@ -359,7 +364,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			return DeobfuscatorInfo.THE_NAME + " 4.3";
 		}
 
-		static bool findString(MethodDefinition method, string s) {
+		static bool findString(MethodDef method, string s) {
 			foreach (var cs in DotNetUtils.getCodeStrings(method)) {
 				if (cs == s)
 					return true;
@@ -381,7 +386,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				return false;
 
 			if (options.DumpNativeMethods) {
-				using (var fileStream = new FileStream(module.FullyQualifiedName + ".native", FileMode.Create, FileAccess.Write, FileShare.Read)) {
+				using (var fileStream = new FileStream(module.Location + ".native", FileMode.Create, FileAccess.Write, FileShare.Read)) {
 					var sortedTokens = new List<uint>(tokenToNativeCode.Keys);
 					sortedTokens.Sort();
 					var writer = new BinaryWriter(fileStream);
@@ -399,7 +404,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			return true;
 		}
 
-		public override IDeobfuscator moduleReloaded(ModuleDefinition module) {
+		public override IDeobfuscator moduleReloaded(ModuleDefMD module) {
 			var newOne = new Deobfuscator(options);
 			newOne.setModule(module);
 			newOne.fileData = fileData;
@@ -504,7 +509,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			startedDeobfuscating = true;
 		}
 
-		void addEntryPointCallToBeRemoved(MethodDefinition methodToBeRemoved) {
+		void addEntryPointCallToBeRemoved(MethodDef methodToBeRemoved) {
 			var entryPoint = module.EntryPoint;
 			addCallToBeRemoved(entryPoint, methodToBeRemoved);
 			foreach (var calledMethod in DotNetUtils.getCalledMethods(module, entryPoint))
@@ -544,10 +549,10 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			if (!options.RemoveAntiStrongName)
 				return;
 			if (antiStrongname.remove(blocks))
-				Log.v("Removed anti strong name code");
+				Logger.v("Removed anti strong name code");
 		}
 
-		TypeDefinition getDecrypterType() {
+		TypeDef getDecrypterType() {
 			return methodsDecrypter.DecrypterType ?? stringDecrypter.DecrypterType ?? booleanDecrypter.DecrypterType;
 		}
 
@@ -562,7 +567,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 					var instr = instructions[i];
 					if (instr.OpCode.Code != Code.Ldtoken)
 						continue;
-					if (!MemberReferenceHelper.compareTypes(type, instr.Operand as TypeReference))
+					if (!new SigComparer().Equals(type, instr.Operand as ITypeDefOrRef))
 						continue;
 					instructions[i] = new Instr(Instruction.Create(OpCodes.Ldtoken, blocks.Method.DeclaringType));
 				}
@@ -582,7 +587,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			if (canRemoveDecrypterType)
 				addTypeToBeRemoved(decrypterType, "Decrypter type");
 			else
-				Log.v("Could not remove decrypter type");
+				Logger.v("Could not remove decrypter type");
 
 			base.deobfuscateEnd();
 		}
@@ -596,16 +601,29 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 		public override IEnumerable<int> getStringDecrypterMethods() {
 			var list = new List<int>();
 			foreach (var info in stringDecrypter.DecrypterInfos)
-				list.Add(info.method.MetadataToken.ToInt32());
+				list.Add(info.method.MDToken.ToInt32());
 			if (stringDecrypter.OtherStringDecrypter != null)
-				list.Add(stringDecrypter.OtherStringDecrypter.MetadataToken.ToInt32());
+				list.Add(stringDecrypter.OtherStringDecrypter.MDToken.ToInt32());
 			return list;
 		}
 
-		public override void OnBeforeAddingResources(MetadataBuilder builder) {
+		public override void OnWriterEvent(ModuleWriterBase writer, ModuleWriterEvent evt) {
 			if (!options.DecryptMethods)
 				return;
-			methodsDecrypter.encryptNativeMethods(builder);
+			switch (evt) {
+			case ModuleWriterEvent.Begin:
+				// The decrypter assumes RVAs are unique so don't share any method bodies
+				writer.TheOptions.ShareMethodBodies = false;
+				break;
+
+			case ModuleWriterEvent.MDBeginAddResources:
+				methodsDecrypter.prepareEncryptNativeMethods(writer);
+				break;
+
+			case ModuleWriterEvent.BeginWriteChunks:
+				methodsDecrypter.encryptNativeMethods(writer);
+				break;
+			}
 		}
 	}
 }
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v4/EmptyClass.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v4/EmptyClass.cs
index 705901ce..415d4ccf 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v4/EmptyClass.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v4/EmptyClass.cs
@@ -17,24 +17,24 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 	// Detect some empty class that is called from most .ctor's
 	class EmptyClass {
-		ModuleDefinition module;
-		MethodDefinition emptyMethod;
+		ModuleDefMD module;
+		MethodDef emptyMethod;
 
-		public MethodDefinition Method {
+		public MethodDef Method {
 			get { return emptyMethod; }
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return emptyMethod != null ? emptyMethod.DeclaringType : null; }
 		}
 
-		public EmptyClass(ModuleDefinition module) {
+		public EmptyClass(ModuleDefMD module) {
 			this.module = module;
 			init();
 		}
@@ -62,12 +62,12 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			}
 
 			int numCalls;
-			var theMethod = (MethodDefinition)callCounter.most(out numCalls);
+			var theMethod = (MethodDef)callCounter.most(out numCalls);
 			if (numCalls >= 10)
 				emptyMethod = theMethod;
 		}
 
-		bool isEmptyClass(MethodDefinition emptyMethod) {
+		bool isEmptyClass(MethodDef emptyMethod) {
 			if (!DotNetUtils.isEmptyObfuscated(emptyMethod))
 				return false;
 
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v4/EncryptedResource.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v4/EncryptedResource.cs
index 42b155e3..60bbda7b 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v4/EncryptedResource.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v4/EncryptedResource.cs
@@ -21,22 +21,22 @@ using System;
 using System.IO;
 using System.Collections.Generic;
 using System.Security.Cryptography;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 	class EncryptedResource {
-		ModuleDefinition module;
-		MethodDefinition resourceDecrypterMethod;
+		ModuleDefMD module;
+		MethodDef resourceDecrypterMethod;
 		EmbeddedResource encryptedDataResource;
 		byte[] key, iv;
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return resourceDecrypterMethod == null ? null : resourceDecrypterMethod.DeclaringType; }
 		}
 
-		public MethodDefinition Method {
+		public MethodDef Method {
 			get { return resourceDecrypterMethod; }
 			set { resourceDecrypterMethod = value; }
 		}
@@ -49,15 +49,15 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			get { return encryptedDataResource != null; }
 		}
 
-		public EncryptedResource(ModuleDefinition module) {
+		public EncryptedResource(ModuleDefMD module) {
 			this.module = module;
 		}
 
-		public EncryptedResource(ModuleDefinition module, EncryptedResource oldOne) {
+		public EncryptedResource(ModuleDefMD module, EncryptedResource oldOne) {
 			this.module = module;
 			resourceDecrypterMethod = lookup(oldOne.resourceDecrypterMethod, "Could not find resource decrypter method");
 			if (oldOne.encryptedDataResource != null)
-				encryptedDataResource = DotNetUtils.getResource(module, oldOne.encryptedDataResource.Name) as EmbeddedResource;
+				encryptedDataResource = DotNetUtils.getResource(module, oldOne.encryptedDataResource.Name.String) as EmbeddedResource;
 			key = oldOne.key;
 			iv = oldOne.iv;
 
@@ -65,15 +65,15 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				throw new ApplicationException("Could not initialize EncryptedResource");
 		}
 
-		T lookup<T>(T def, string errorMessage) where T : MemberReference {
+		T lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
 			return DeobUtils.lookup(module, def, errorMessage);
 		}
 
-		public bool couldBeResourceDecrypter(MethodDefinition method, IEnumerable<string> additionalTypes) {
+		public bool couldBeResourceDecrypter(MethodDef method, IEnumerable<string> additionalTypes) {
 			return couldBeResourceDecrypter(method, additionalTypes, true);
 		}
 
-		public bool couldBeResourceDecrypter(MethodDefinition method, IEnumerable<string> additionalTypes, bool checkResource) {
+		public bool couldBeResourceDecrypter(MethodDef method, IEnumerable<string> additionalTypes, bool checkResource) {
 			if (!method.IsStatic)
 				return false;
 			if (method.Body == null)
@@ -117,10 +117,10 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			if (iv == null)
 				throw new ApplicationException("Could not find resource decrypter IV");
 			if (usesPublicKeyToken()) {
-				var publicKeyToken = module.Assembly.Name.PublicKeyToken;
-				if (publicKeyToken != null && publicKeyToken.Length > 0) {
+				var publicKeyToken = module.Assembly.PublicKeyToken;
+				if (publicKeyToken != null && publicKeyToken.Data.Length > 0) {
 					for (int i = 0; i < 8; i++)
-						iv[i * 2 + 1] = publicKeyToken[i];
+						iv[i * 2 + 1] = publicKeyToken.Data[i];
 				}
 			}
 		}
@@ -133,9 +133,9 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 					pktIndex = 0;
 					continue;
 				}
-				if (!DotNetUtils.isLdcI4(instr))
+				if (!instr.IsLdcI4())
 					continue;
-				int val = DotNetUtils.getLdcI4Value(instr);
+				int val = instr.GetLdcI4Value();
 				if (val != pktIndexes[pktIndex++]) {
 					pktIndex = 0;
 					continue;
@@ -146,7 +146,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			return false;
 		}
 
-		EmbeddedResource findMethodsDecrypterResource(MethodDefinition method) {
+		EmbeddedResource findMethodsDecrypterResource(MethodDef method) {
 			foreach (var s in DotNetUtils.getCodeStrings(method)) {
 				var resource = DotNetUtils.getResource(module, s) as EmbeddedResource;
 				if (resource != null)
@@ -172,16 +172,5 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				}
 			}
 		}
-
-		public void updateResource(byte[] encryptedData) {
-			for (int i = 0; i < module.Resources.Count; i++) {
-				if (module.Resources[i] == encryptedDataResource) {
-					encryptedDataResource = new EmbeddedResource(encryptedDataResource.Name, encryptedDataResource.Attributes, encryptedData);
-					module.Resources[i] = encryptedDataResource;
-					return;
-				}
-			}
-			throw new ApplicationException("Could not find encrypted resource");
-		}
 	}
 }
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v4/MetadataTokenObfuscator.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v4/MetadataTokenObfuscator.cs
index 8d4030a1..66e4aa0a 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v4/MetadataTokenObfuscator.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v4/MetadataTokenObfuscator.cs
@@ -17,24 +17,24 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 	// Find the class that returns a RuntimeTypeHandle/RuntimeFieldHandle. The value passed to
 	// its methods is the original metadata token, which will be different when we save the file.
 	class MetadataTokenObfuscator {
-		ModuleDefinition module;
-		TypeDefinition type;
-		MethodDefinition typeMethod;
-		MethodDefinition fieldMethod;
+		ModuleDefMD module;
+		TypeDef type;
+		MethodDef typeMethod;
+		MethodDef fieldMethod;
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return type; }
 		}
 
-		public MetadataTokenObfuscator(ModuleDefinition module) {
+		public MetadataTokenObfuscator(ModuleDefMD module) {
 			this.module = module;
 			find();
 		}
@@ -49,15 +49,16 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				if (type.HasProperties || type.HasEvents)
 					continue;
 
-				MethodDefinition fieldMethod = null, typeMethod = null;
+				MethodDef fieldMethod = null, typeMethod = null;
 				foreach (var method in type.Methods) {
-					if (method.Parameters.Count != 1)
+					var sig = method.MethodSig;
+					if (sig == null || sig.Params.Count != 1)
 						continue;
-					if (method.Parameters[0].ParameterType.FullName != "System.Int32")
+					if (sig.Params[0].GetElementType() != ElementType.I4)
 						continue;
-					if (method.MethodReturnType.ReturnType.FullName == "System.RuntimeTypeHandle")
+					if (sig.RetType.GetFullName() == "System.RuntimeTypeHandle")
 						typeMethod = method;
-					else if (method.MethodReturnType.ReturnType.FullName == "System.RuntimeFieldHandle")
+					else if (sig.RetType.GetFullName() == "System.RuntimeFieldHandle")
 						fieldMethod = method;
 				}
 
@@ -84,10 +85,10 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 					var call = instrs[i + 1];
 					if (call.OpCode.Code != Code.Call)
 						continue;
-					var method = call.Operand as MethodReference;
+					var method = call.Operand as IMethod;
 					if (method == null)
 						continue;
-					if (!MemberReferenceHelper.compareTypes(type, method.DeclaringType))
+					if (!new SigComparer().Equals(type, method.DeclaringType))
 						continue;
 					var methodDef = DotNetUtils.getMethod(module, method);
 					if (methodDef == null)
@@ -95,9 +96,9 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 					if (methodDef != typeMethod && methodDef != fieldMethod)
 						continue;
 
-					int token = (int)instrs[i].Operand;
+					uint token = (uint)(int)instrs[i].Operand;
 					instrs[i] = new Instr(Instruction.Create(OpCodes.Nop));
-					instrs[i + 1] = new Instr(new Instruction(OpCodes.Ldtoken, module.LookupToken(token) as MemberReference));
+					instrs[i + 1] = new Instr(new Instruction(OpCodes.Ldtoken, module.ResolveToken(token) as ITokenOperand));
 				}
 			}
 		}
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v4/MethodsDecrypter.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v4/MethodsDecrypter.cs
index de992d52..afba3332 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v4/MethodsDecrypter.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v4/MethodsDecrypter.cs
@@ -20,18 +20,21 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.MyStuff;
+using dot10.IO;
+using dot10.DotNet;
+using dot10.DotNet.MD;
+using dot10.DotNet.Emit;
+using dot10.DotNet.Writer;
 using de4dot.blocks;
 using de4dot.PE;
 
 namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 	class MethodsDecrypter {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		EncryptedResource encryptedResource;
 		Dictionary<uint, byte[]> tokenToNativeMethod = new Dictionary<uint, byte[]>();
-		Dictionary<MethodDefinition, byte[]> methodToNativeMethod = new Dictionary<MethodDefinition, byte[]>();
+		Dictionary<MethodDef, byte[]> methodToNativeMethod = new Dictionary<MethodDef, byte[]>();
+		List<MethodDef> validNativeMethods;
 		int totalEncryptedNativeMethods = 0;
 		long xorKey;
 
@@ -43,11 +46,11 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			get { return methodToNativeMethod.Count > 0; }
 		}
 
-		public TypeDefinition DecrypterType {
+		public TypeDef DecrypterType {
 			get { return encryptedResource.Type; }
 		}
 
-		public MethodDefinition Method {
+		public MethodDef Method {
 			get { return encryptedResource.Method; }
 		}
 
@@ -55,12 +58,12 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			get { return encryptedResource.Resource; }
 		}
 
-		public MethodsDecrypter(ModuleDefinition module) {
+		public MethodsDecrypter(ModuleDefMD module) {
 			this.module = module;
 			this.encryptedResource = new EncryptedResource(module);
 		}
 
-		public MethodsDecrypter(ModuleDefinition module, MethodsDecrypter oldOne) {
+		public MethodsDecrypter(ModuleDefMD module, MethodsDecrypter oldOne) {
 			this.module = module;
 			this.encryptedResource = new EncryptedResource(module, oldOne.encryptedResource);
 			this.tokenToNativeMethod = oldOne.tokenToNativeMethod;
@@ -73,35 +76,34 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				"System.IntPtr",
 //				"System.Reflection.Assembly",		//TODO: Not in unknown DNR version with jitter support
 			};
-			var checkedMethods = new Dictionary<MethodReferenceAndDeclaringTypeKey, bool>();
+			var checkedMethods = new Dictionary<IMethod, bool>(MethodEqualityComparer.CompareDeclaringTypes);
 			var callCounter = new CallCounter();
 			int typesLeft = 30;
 			foreach (var type in module.GetTypes()) {
-				var cctor = DotNetUtils.getMethod(type, ".cctor");
+				var cctor = type.FindStaticConstructor();
 				if (cctor == null || cctor.Body == null)
 					continue;
 				if (typesLeft-- <= 0)
 					break;
 
 				foreach (var method in DotNetUtils.getCalledMethods(module, cctor)) {
-					var key = new MethodReferenceAndDeclaringTypeKey(method);
-					if (!checkedMethods.ContainsKey(key)) {
-						checkedMethods[key] = false;
+					if (!checkedMethods.ContainsKey(method)) {
+						checkedMethods[method] = false;
 						if (method.DeclaringType.BaseType == null || method.DeclaringType.BaseType.FullName != "System.Object")
 							continue;
 						if (!DotNetUtils.isMethod(method, "System.Void", "()"))
 							continue;
 						if (!encryptedResource.couldBeResourceDecrypter(method, additionalTypes))
 							continue;
-						checkedMethods[key] = true;
+						checkedMethods[method] = true;
 					}
-					else if (!checkedMethods[key])
+					else if (!checkedMethods[method])
 						continue;
 					callCounter.add(method);
 				}
 			}
 
-			encryptedResource.Method = (MethodDefinition)callCounter.most();
+			encryptedResource.Method = (MethodDef)callCounter.most();
 		}
 
 		void xorEncrypt(byte[] data) {
@@ -198,7 +200,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 
 					int methodIndex;
 					if (!rvaToIndex.TryGetValue(rva, out methodIndex)) {
-						Log.w("Could not find method having code RVA {0:X8}", rva);
+						Logger.w("Could not find method having code RVA {0:X8}", rva);
 						continue;
 					}
 					uint methodToken = 0x06000001 + (uint)methodIndex;
@@ -237,24 +239,22 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 
 					offset = methodDef.fileOffset + (uint)(methodIndex * methodDef.totalSize);
 					rva = peImage.offsetReadUInt32(offset);
+					dm.mdRVA = peImage.offsetRead(offset + (uint)methodDef.fields[0].offset, methodDef.fields[0].size);
 					dm.mdImplFlags = peImage.offsetReadUInt16(offset + (uint)methodDef.fields[1].offset);
 					dm.mdFlags = peImage.offsetReadUInt16(offset + (uint)methodDef.fields[2].offset);
 					dm.mdName = peImage.offsetRead(offset + (uint)methodDef.fields[3].offset, methodDef.fields[3].size);
 					dm.mdSignature = peImage.offsetRead(offset + (uint)methodDef.fields[4].offset, methodDef.fields[4].size);
 					dm.mdParamList = peImage.offsetRead(offset + (uint)methodDef.fields[5].offset, methodDef.fields[5].size);
 
-					if ((peImage.readByte(rva) & 3) == 2) {
-						dm.mhFlags = 2;
-						dm.mhMaxStack = 8;
-						dm.mhCodeSize = (uint)dm.code.Length;
-						dm.mhLocalVarSigTok = 0;
-					}
-					else {
-						dm.mhFlags = peImage.readUInt16(rva);
-						dm.mhMaxStack = peImage.readUInt16(rva + 2);
-						dm.mhCodeSize = (uint)dm.code.Length;
-						dm.mhLocalVarSigTok = peImage.readUInt32(rva + 8);
-					}
+					var codeReader = peImage.Reader;
+					codeReader.BaseStream.Position = peImage.rvaToOffset(rva);
+					byte[] code, extraSections;
+					var mb = MethodBodyParser.parseMethodBody(codeReader, out code, out extraSections);
+					dm.mhFlags = mb.flags;
+					dm.mhMaxStack = mb.maxStack;
+					dm.mhCodeSize = (uint)dm.code.Length;
+					dm.mhLocalVarSigTok = mb.localVarSigTok;
+					dm.extraSections = extraSections;
 
 					dumpedMethods.add(dm);
 				}
@@ -277,10 +277,10 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				if (instructions[i].OpCode.Code != Code.Ldind_I8)
 					continue;
 				var ldci4 = instructions[i + 1];
-				if (!DotNetUtils.isLdcI4(ldci4))
+				if (!ldci4.IsLdcI4())
 					continue;
 
-				return DotNetUtils.getLdcI4Value(ldci4);
+				return ldci4.GetLdcI4Value();
 			}
 			return 0;
 		}
@@ -288,7 +288,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 		public void reloaded() {
 			foreach (var pair in tokenToNativeMethod) {
 				int token = (int)pair.Key;
-				var method = module.LookupToken(token) as MethodDefinition;
+				var method = module.ResolveToken(token) as MethodDef;
 				if (method == null)
 					throw new ApplicationException(string.Format("Could not find method {0:X8}", token));
 				methodToNativeMethod[method] = pair.Value;
@@ -296,35 +296,56 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			tokenToNativeMethod = null;
 		}
 
-		public void encryptNativeMethods(MetadataBuilder builder) {
+		public void prepareEncryptNativeMethods(ModuleWriterBase moduleWriter) {
 			if (methodToNativeMethod.Count == 0)
 				return;
 
-			Log.v("Encrypting native methods");
+			validNativeMethods = new List<MethodDef>(methodToNativeMethod.Count);
+			int len = 12;
+			foreach (var kv in methodToNativeMethod) {
+				if (kv.Key.DeclaringType == null)
+					continue;	// Method was removed
+				if (kv.Key.DeclaringType.Module != module)
+					continue;	// method.DeclaringType was removed
+				validNativeMethods.Add(kv.Key);
+				len += 3 * 4 + kv.Value.Length;
+			}
+			if (validNativeMethods.Count == 0)
+				return;
+
+			len = (len & ~15) + 16;
+			encryptedResource.Resource.Data = MemoryImageStream.Create(new byte[len]);
+		}
+
+		public void encryptNativeMethods(ModuleWriterBase moduleWriter) {
+			if (validNativeMethods == null || validNativeMethods.Count == 0)
+				return;
+
+			Logger.v("Encrypting native methods");
 
 			var stream = new MemoryStream();
 			var writer = new BinaryWriter(stream);
 			writer.Write((uint)0);	// patch count
 			writer.Write((uint)0);	// mode
-			writer.Write(methodToNativeMethod.Count);
+			writer.Write(validNativeMethods.Count);
 
 			int index = 0;
-			var codeWriter = builder.CodeWriter;
-			foreach (var pair in methodToNativeMethod) {
-				var method = pair.Key;
-				if (method.DeclaringType == null)
-					continue;	// Method was removed
-				if (method.DeclaringType.Module == null)
-					continue;	// method.DeclaringType was removed
-				var code = pair.Value;
+			foreach (var method in validNativeMethods) {
+				var code = methodToNativeMethod[method];
 
-				uint codeRva = builder.GetMethodBodyRva((int)method.MetadataToken.RID - 1);
-				if ((codeWriter.ReadByteAtRva(codeRva) & 3) == 2)
+				var mb = moduleWriter.MetaData.GetMethodBody(method);
+				if (mb == null) {
+					Logger.e("Could not find method body for method {0} ({1:X8})", method, method.MDToken.Raw);
+					continue;
+				}
+
+				uint codeRva = (uint)mb.RVA;
+				if (mb.IsTiny)
 					codeRva++;
 				else
-					codeRva += 4 * (uint)(codeWriter.ReadByteAtRva(codeRva + 1) >> 4);
+					codeRva += (uint)(4 * (mb.Code[1] >> 4));
 
-				Log.v("Native method {0:X8}, code RVA {1:X8}", method.MetadataToken.ToInt32(), codeRva);
+				Logger.v("Native method {0:X8}, code RVA {1:X8}", new MDToken(Table.Method, moduleWriter.MetaData.GetRid(method)).Raw, codeRva);
 
 				writer.Write(codeRva);
 				writer.Write(0x70000000 + index++);
@@ -333,18 +354,26 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			}
 
 			if (index != 0)
-				Log.n("Re-encrypted {0}/{1} native methods", index, totalEncryptedNativeMethods);
+				Logger.n("Re-encrypted {0}/{1} native methods", index, totalEncryptedNativeMethods);
 
-			var encryptedData = stream.ToArray();
-			xorEncrypt(encryptedData);
-			encryptedResource.updateResource(encryptedResource.encrypt(encryptedData));
+			var resourceChunk = moduleWriter.MetaData.GetChunk(encryptedResource.Resource);
+			var resourceData = resourceChunk.Data;
+
+			var encrypted = stream.ToArray();
+			xorEncrypt(encrypted);
+
+			encrypted = encryptedResource.encrypt(encrypted);
+			if (encrypted.Length != resourceData.Length)
+				Logger.e("Encrypted native methods array is not same size as original array");
+			Array.Copy(encrypted, resourceData, resourceData.Length);
 		}
 
-		public static MethodDefinition findDnrCompileMethod(TypeDefinition type) {
+		public static MethodDef findDnrCompileMethod(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
-				if (method.Parameters.Count != 6)
+				var sig = method.MethodSig;
+				if (sig == null || sig.Params.Count != 6)
 					continue;
 				if (!DotNetUtils.isMethod(method, "System.UInt32", "(System.UInt64&,System.IntPtr,System.IntPtr,System.UInt32,System.IntPtr&,System.UInt32&)"))
 					continue;
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v4/NativeImageUnpacker.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v4/NativeImageUnpacker.cs
index 28b90eaa..a87b8a32 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v4/NativeImageUnpacker.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v4/NativeImageUnpacker.cs
@@ -20,31 +20,26 @@
 using System;
 using System.IO;
 using ICSharpCode.SharpZipLib.Zip.Compression;
-using de4dot.PE;
+using dot10.PE;
+using dot10.IO;
 
 namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 	class NativeImageUnpacker {
-		PeImage peImage;
+		MyPEImage peImage;
 		bool isNet1x;
 
-		public NativeImageUnpacker(PeImage peImage) {
-			this.peImage = peImage;
+		public NativeImageUnpacker(IPEImage peImage) {
+			this.peImage = new MyPEImage(peImage);
 		}
 
 		public byte[] unpack() {
-			var resources = peImage.Resources;
-			var dir = resources.getRoot();
-			if ((dir = dir.getDirectory(10)) == null)
+			if (peImage.PEImage.Win32Resources == null)
 				return null;
-			if ((dir = dir.getDirectory("__")) == null)
-				return null;
-			var dataEntry = dir.getData(0);
+			var dataEntry = peImage.PEImage.Win32Resources.Find(10, "__", 0);
 			if (dataEntry == null)
 				return null;
 
-			var encryptedData = peImage.readBytes(dataEntry.RVA, (int)dataEntry.Size);
-			if (encryptedData.Length != dataEntry.Size)
-				return null;
+			var encryptedData = dataEntry.Data.ReadAllBytes();
 
 			var keyData = getKeyData();
 			if (keyData == null)
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v4/ProxyCallFixer.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v4/ProxyCallFixer.cs
index 432a0df7..4ca4e115 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v4/ProxyCallFixer.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v4/ProxyCallFixer.cs
@@ -17,15 +17,15 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 	class ProxyCallFixer : ProxyCallFixer3 {
 		ISimpleDeobfuscator simpleDeobfuscator;
 
-		public ProxyCallFixer(ModuleDefinition module, ISimpleDeobfuscator simpleDeobfuscator)
+		public ProxyCallFixer(ModuleDefMD module, ISimpleDeobfuscator simpleDeobfuscator)
 			: base(module) {
 			this.simpleDeobfuscator = simpleDeobfuscator;
 		}
@@ -44,17 +44,17 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 		static readonly string[] requiredFields = new string[] {
 			"System.Reflection.Module",
 		};
-		static MethodDefinition checkType(TypeDefinition type) {
+		static MethodDef checkType(TypeDef type) {
 			if (!new FieldTypes(type).exactly(requiredFields))
 				return null;
-			if (DotNetUtils.getMethod(type, ".cctor") == null)
+			if (type.FindStaticConstructor() == null)
 				return null;
 
 			return checkMethods(type);
 		}
 
-		static MethodDefinition checkMethods(TypeDefinition type) {
-			MethodDefinition creatorMethod = null;
+		static MethodDef checkMethods(TypeDef type) {
+			MethodDef creatorMethod = null;
 			foreach (var method in type.Methods) {
 				if (method.Body == null)
 					return null;
@@ -71,7 +71,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			return creatorMethod;
 		}
 
-		protected override object checkCctor(ref TypeDefinition type, MethodDefinition cctor) {
+		protected override object checkCctor(ref TypeDef type, MethodDef cctor) {
 			simpleDeobfuscator.deobfuscate(cctor);
 			var realType = getDelegateType(cctor);
 			if (realType == null)
@@ -81,27 +81,27 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			return this;
 		}
 
-		TypeDefinition getDelegateType(MethodDefinition method) {
+		TypeDef getDelegateType(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 1; i++) {
 				var ldci4 = instrs[i];
-				if (!DotNetUtils.isLdcI4(ldci4))
+				if (!ldci4.IsLdcI4())
 					continue;
 
 				var call = instrs[i + 1];
 				if (call.OpCode.Code != Code.Call)
 					continue;
-				var calledMethod = call.Operand as MethodDefinition;
+				var calledMethod = call.Operand as MethodDef;
 				if (calledMethod == null || !isDelegateCreatorMethod(calledMethod))
 					continue;
 
-				return module.LookupToken(0x02000000 + DotNetUtils.getLdcI4Value(ldci4)) as TypeDefinition;
+				return module.ResolveToken(0x02000000 + ldci4.GetLdcI4Value()) as TypeDef;
 			}
 			return null;
 		}
 
-		protected override void getCallInfo(object context, FieldDefinition field, out MethodReference calledMethod, out OpCode callOpcode) {
-			calledMethod = module.LookupToken(0x06000000 + field.MetadataToken.ToInt32()) as MethodReference;
+		protected override void getCallInfo(object context, FieldDef field, out IMethod calledMethod, out OpCode callOpcode) {
+			calledMethod = module.ResolveToken(0x06000000 + field.MDToken.ToInt32()) as IMethod;
 			callOpcode = OpCodes.Call;
 		}
 	}
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v4/ResourceResolver.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v4/ResourceResolver.cs
index 42d05725..bcca5397 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v4/ResourceResolver.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v4/ResourceResolver.cs
@@ -19,25 +19,25 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 	class ResourceResolver {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		EncryptedResource encryptedResource;
-		MethodDefinition initMethod;
+		MethodDef initMethod;
 
 		public bool Detected {
 			get { return encryptedResource.Method != null; }
 		}
 
-		public TypeDefinition Type {
+		public TypeDef Type {
 			get { return encryptedResource.Type; }
 		}
 
-		public MethodDefinition InitMethod {
+		public MethodDef InitMethod {
 			get { return initMethod; }
 		}
 
@@ -45,12 +45,12 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			get { return encryptedResource.FoundResource; }
 		}
 
-		public ResourceResolver(ModuleDefinition module) {
+		public ResourceResolver(ModuleDefMD module) {
 			this.module = module;
 			this.encryptedResource = new EncryptedResource(module);
 		}
 
-		public ResourceResolver(ModuleDefinition module, ResourceResolver oldOne) {
+		public ResourceResolver(ModuleDefMD module, ResourceResolver oldOne) {
 			this.module = module;
 			this.encryptedResource = new EncryptedResource(module, oldOne.encryptedResource);
 		}
@@ -79,7 +79,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			}
 		}
 
-		bool checkFields(IList<FieldDefinition> fields) {
+		bool checkFields(IList<FieldDef> fields) {
 			if (fields.Count != 3)
 				return false;
 
@@ -105,32 +105,32 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			encryptedResource.init(simpleDeobfuscator);
 		}
 
-		MethodDefinition findInitMethod(ISimpleDeobfuscator simpleDeobfuscator) {
-			var ctor = DotNetUtils.getMethod(Type, ".ctor");
+		MethodDef findInitMethod(ISimpleDeobfuscator simpleDeobfuscator) {
+			var ctor = Type.FindMethod(".ctor");
 			foreach (var method in Type.Methods) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
 				if (!DotNetUtils.isMethod(method, "System.Void", "()"))
 					continue;
-				if (method.Body.Variables.Count > 1)
+				if (method.Body.LocalList.Count > 1)
 					continue;
 
 				simpleDeobfuscator.deobfuscate(method);
 				bool stsfldUsed = false, newobjUsed = false;
 				foreach (var instr in method.Body.Instructions) {
 					if (instr.OpCode.Code == Code.Stsfld) {
-						var field = instr.Operand as FieldReference;
-						if (field == null || field.FieldType.FullName != "System.Boolean")
+						var field = instr.Operand as IField;
+						if (field == null || field.FieldSig.GetFieldType().GetElementType() != ElementType.Boolean)
 							continue;
-						if (!MemberReferenceHelper.compareTypes(Type, field.DeclaringType))
+						if (!new SigComparer().Equals(Type, field.DeclaringType))
 							continue;
 						stsfldUsed = true;
 					}
 					else if (instr.OpCode.Code == Code.Newobj) {
-						var calledCtor = instr.Operand as MethodReference;
+						var calledCtor = instr.Operand as IMethod;
 						if (calledCtor == null)
 							continue;
-						if (!MemberReferenceHelper.compareMethodReferenceAndDeclaringType(calledCtor, ctor))
+						if (!MethodEqualityComparer.CompareDeclaringTypes.Equals(calledCtor, ctor))
 							continue;
 						newobjUsed = true;
 					}
@@ -146,7 +146,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 		public EmbeddedResource mergeResources() {
 			if (encryptedResource.Resource == null)
 				return null;
-			DeobUtils.decryptAndAddResources(module, encryptedResource.Resource.Name, () => {
+			DeobUtils.decryptAndAddResources(module, encryptedResource.Resource.Name.String, () => {
 				return QuickLZ.decompress(encryptedResource.decrypt());
 			});
 			return encryptedResource.Resource;
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v4/StringDecrypter.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v4/StringDecrypter.cs
index 50a4269c..cbb54f0e 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v4/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v4/StringDecrypter.cs
@@ -20,17 +20,17 @@
 using System;
 using System.Text;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 using de4dot.PE;
 
 namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 	class StringDecrypter {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		EncryptedResource encryptedResource;
 		List<DecrypterInfo> decrypterInfos = new List<DecrypterInfo>();
-		MethodDefinition otherStringDecrypter;
+		MethodDef otherStringDecrypter;
 		byte[] decryptedData;
 		PeImage peImage;
 		byte[] fileData;
@@ -43,11 +43,11 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 		}
 
 		public class DecrypterInfo {
-			public MethodDefinition method;
+			public MethodDef method;
 			public byte[] key;
 			public byte[] iv;
 
-			public DecrypterInfo(MethodDefinition method, byte[] key, byte[] iv) {
+			public DecrypterInfo(MethodDef method, byte[] key, byte[] iv) {
 				this.method = method;
 				this.key = key;
 				this.iv = iv;
@@ -58,7 +58,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			get { return encryptedResource.Method != null; }
 		}
 
-		public TypeDefinition DecrypterType {
+		public TypeDef DecrypterType {
 			get { return encryptedResource.Type; }
 		}
 
@@ -70,16 +70,16 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			get { return decrypterInfos; }
 		}
 
-		public MethodDefinition OtherStringDecrypter {
+		public MethodDef OtherStringDecrypter {
 			get { return otherStringDecrypter; }
 		}
 
-		public StringDecrypter(ModuleDefinition module) {
+		public StringDecrypter(ModuleDefMD module) {
 			this.module = module;
 			this.encryptedResource = new EncryptedResource(module);
 		}
 
-		public StringDecrypter(ModuleDefinition module, StringDecrypter oldOne) {
+		public StringDecrypter(ModuleDefMD module, StringDecrypter oldOne) {
 			this.module = module;
 			this.stringDecrypterVersion = oldOne.stringDecrypterVersion;
 			this.encryptedResource = new EncryptedResource(module, oldOne.encryptedResource);
@@ -90,7 +90,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			otherStringDecrypter = lookup(oldOne.otherStringDecrypter, "Could not find string decrypter method");
 		}
 
-		T lookup<T>(T def, string errorMessage) where T : MemberReference {
+		T lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
 			return DeobUtils.lookup(module, def, errorMessage);
 		}
 
@@ -133,16 +133,19 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				findOtherStringDecrypter(decrypterInfos[0].method.DeclaringType);
 		}
 
-		void findOtherStringDecrypter(TypeDefinition type) {
+		void findOtherStringDecrypter(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (!method.IsStatic || !method.HasBody)
 					continue;
-				if (method.MethodReturnType.ReturnType.FullName != "System.String")
+				var sig = method.MethodSig;
+				if (sig == null)
 					continue;
-				if (method.Parameters.Count != 1)
+				if (sig.RetType.GetElementType() != ElementType.String)
 					continue;
-				if (method.Parameters[0].ParameterType.FullName != "System.Object" &&
-					method.Parameters[0].ParameterType.FullName != "System.String")
+				if (sig.Params.Count != 1)
+					continue;
+				if (sig.Params[0].GetElementType() != ElementType.Object &&
+					sig.Params[0].GetElementType() != ElementType.String)
 					continue;
 
 				otherStringDecrypter = method;
@@ -159,11 +162,11 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			encryptedResource.init(simpleDeobfuscator);
 			if (!encryptedResource.FoundResource)
 				return;
-			Log.v("Adding string decrypter. Resource: {0}", Utils.toCsharpString(encryptedResource.Resource.Name));
+			Logger.v("Adding string decrypter. Resource: {0}", Utils.toCsharpString(encryptedResource.Resource.Name));
 			decryptedData = encryptedResource.decrypt();
 		}
 
-		void findKeyIv(MethodDefinition method, out byte[] key, out byte[] iv) {
+		void findKeyIv(MethodDef method, out byte[] key, out byte[] iv) {
 			key = null;
 			iv = null;
 
@@ -176,7 +179,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			foreach (var calledMethod in DotNetUtils.getCalledMethods(module, method)) {
 				if (calledMethod.DeclaringType != method.DeclaringType)
 					continue;
-				if (calledMethod.MethodReturnType.ReturnType.FullName != "System.Byte[]")
+				if (calledMethod.MethodSig.GetRetType().GetFullName() != "System.Byte[]")
 					continue;
 				var localTypes = new LocalTypes(calledMethod);
 				if (!localTypes.all(requiredTypes))
@@ -188,7 +191,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 					var instr = instructions[i];
 					if (instr.OpCode.Code != Code.Ldtoken)
 						continue;
-					var field = instr.Operand as FieldDefinition;
+					var field = instr.Operand as FieldDef;
 					if (field == null)
 						continue;
 					if (field.InitialValue == null)
@@ -208,7 +211,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			}
 		}
 
-		void initializeStringDecrypterVersion(MethodDefinition method) {
+		void initializeStringDecrypterVersion(MethodDef method) {
 			var localTypes = new LocalTypes(method);
 			if (localTypes.exists("System.IntPtr"))
 				stringDecrypterVersion = StringDecrypterVersion.VER_38;
@@ -216,7 +219,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				stringDecrypterVersion = StringDecrypterVersion.VER_37;
 		}
 
-		DecrypterInfo getDecrypterInfo(MethodDefinition method) {
+		DecrypterInfo getDecrypterInfo(MethodDef method) {
 			foreach (var info in decrypterInfos) {
 				if (info.method == method)
 					return info;
@@ -224,7 +227,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			throw new ApplicationException("Invalid string decrypter method");
 		}
 
-		public string decrypt(MethodDefinition method, int offset) {
+		public string decrypt(MethodDef method, int offset) {
 			var info = getDecrypterInfo(method);
 
 			if (info.key == null) {
diff --git a/de4dot.code/renamer/DerivedFrom.cs b/de4dot.code/renamer/DerivedFrom.cs
index bd3889b2..ef91d8b7 100644
--- a/de4dot.code/renamer/DerivedFrom.cs
+++ b/de4dot.code/renamer/DerivedFrom.cs
@@ -24,7 +24,7 @@ using de4dot.code.renamer.asmmodules;
 namespace de4dot.code.renamer {
 	class DerivedFrom {
 		Dictionary<string, bool> classNames = new Dictionary<string, bool>(StringComparer.Ordinal);
-		Dictionary<TypeDef, bool> results = new Dictionary<TypeDef, bool>();
+		Dictionary<MTypeDef, bool> results = new Dictionary<MTypeDef, bool>();
 
 		public DerivedFrom(string className) {
 			addName(className);
@@ -39,16 +39,16 @@ namespace de4dot.code.renamer {
 			classNames[className] = true;
 		}
 
-		public bool check(TypeDef type) {
+		public bool check(MTypeDef type) {
 			if (results.ContainsKey(type))
 				return results[type];
 
 			bool val;
-			if (classNames.ContainsKey(type.TypeDefinition.FullName))
+			if (classNames.ContainsKey(type.TypeDef.FullName))
 				val = true;
 			else if (type.baseType == null) {
-				if (type.TypeDefinition.BaseType != null)
-					val = classNames.ContainsKey(type.TypeDefinition.BaseType.FullName);
+				if (type.TypeDef.BaseType != null)
+					val = classNames.ContainsKey(type.TypeDef.BaseType.FullName);
 				else
 					val = false;
 			}
diff --git a/de4dot.code/renamer/ExistingNames.cs b/de4dot.code/renamer/ExistingNames.cs
index bec8c54c..d65f70c9 100644
--- a/de4dot.code/renamer/ExistingNames.cs
+++ b/de4dot.code/renamer/ExistingNames.cs
@@ -19,6 +19,7 @@
 
 using System;
 using System.Collections.Generic;
+using dot10.DotNet;
 
 namespace de4dot.code.renamer {
 	class ExistingNames {
@@ -32,10 +33,18 @@ namespace de4dot.code.renamer {
 			return allNames.ContainsKey(name);
 		}
 
+		public string getName(UTF8String oldName, INameCreator nameCreator) {
+			return getName(UTF8String.ToSystemStringOrEmpty(oldName), nameCreator);
+		}
+
 		public string getName(string oldName, INameCreator nameCreator) {
 			return getName(oldName, () => nameCreator.create());
 		}
 
+		public string getName(UTF8String oldName, Func<string> createNewName) {
+			return getName(UTF8String.ToSystemStringOrEmpty(oldName), createNewName);
+		}
+
 		public string getName(string oldName, Func<string> createNewName) {
 			string prevName = null;
 			while (true) {
diff --git a/de4dot.code/renamer/INameChecker.cs b/de4dot.code/renamer/INameChecker.cs
index 2edd05f0..f271bb9f 100644
--- a/de4dot.code/renamer/INameChecker.cs
+++ b/de4dot.code/renamer/INameChecker.cs
@@ -27,6 +27,7 @@ namespace de4dot.code.renamer {
 		bool isValidFieldName(string name);
 		bool isValidGenericParamName(string name);
 		bool isValidMethodArgName(string name);
+		bool isValidMethodReturnArgName(string name);
 		bool isValidResourceKeyName(string name);
 	}
 }
diff --git a/de4dot.code/renamer/MemberInfos.cs b/de4dot.code/renamer/MemberInfos.cs
index 6fe69523..22918903 100644
--- a/de4dot.code/renamer/MemberInfos.cs
+++ b/de4dot.code/renamer/MemberInfos.cs
@@ -32,8 +32,8 @@ namespace de4dot.code.renamer {
 		public MemberInfo(Ref memberRef) {
 			this.memberRef = memberRef;
 			oldFullName = memberRef.memberReference.FullName;
-			oldName = memberRef.memberReference.Name;
-			newName = memberRef.memberReference.Name;
+			oldName = memberRef.memberReference.Name.String;
+			newName = memberRef.memberReference.Name.String;
 		}
 
 		public void rename(string newTypeName) {
@@ -51,45 +51,45 @@ namespace de4dot.code.renamer {
 	}
 
 	class GenericParamInfo : MemberInfo {
-		public GenericParamInfo(GenericParamDef genericParamDef)
+		public GenericParamInfo(MGenericParamDef genericParamDef)
 			: base(genericParamDef) {
 		}
 	}
 
 	class PropertyInfo : MemberInfo {
-		public PropertyInfo(PropertyDef propertyDef)
+		public PropertyInfo(MPropertyDef propertyDef)
 			: base(propertyDef) {
 		}
 	}
 
 	class EventInfo : MemberInfo {
-		public EventInfo(EventDef eventDef)
+		public EventInfo(MEventDef eventDef)
 			: base(eventDef) {
 		}
 	}
 
 	class FieldInfo : MemberInfo {
-		public FieldInfo(FieldDef fieldDef)
+		public FieldInfo(MFieldDef fieldDef)
 			: base(fieldDef) {
 		}
 	}
 
 	class MethodInfo : MemberInfo {
-		public MethodDef MethodDef {
-			get { return (MethodDef)memberRef; }
+		public MMethodDef MethodDef {
+			get { return (MMethodDef)memberRef; }
 		}
 
-		public MethodInfo(MethodDef methodDef)
+		public MethodInfo(MMethodDef methodDef)
 			: base(methodDef) {
 		}
 	}
 
 	class ParamInfo {
-		ParamDef paramDef;
+		MParamDef paramDef;
 		public string oldName;
 		public string newName;
 
-		public ParamInfo(ParamDef paramDef) {
+		public ParamInfo(MParamDef paramDef) {
 			this.paramDef = paramDef;
 			this.oldName = paramDef.ParameterDefinition.Name;
 			this.newName = paramDef.ParameterDefinition.Name;
@@ -101,13 +101,13 @@ namespace de4dot.code.renamer {
 	}
 
 	class MemberInfos {
-		Dictionary<TypeDef, TypeInfo> allTypeInfos = new Dictionary<TypeDef, TypeInfo>();
-		Dictionary<PropertyDef, PropertyInfo> allPropertyInfos = new Dictionary<PropertyDef, PropertyInfo>();
-		Dictionary<EventDef, EventInfo> allEventInfos = new Dictionary<EventDef, EventInfo>();
-		Dictionary<FieldDef, FieldInfo> allFieldInfos = new Dictionary<FieldDef, FieldInfo>();
-		Dictionary<MethodDef, MethodInfo> allMethodInfos = new Dictionary<MethodDef, MethodInfo>();
-		Dictionary<GenericParamDef, GenericParamInfo> allGenericParamInfos = new Dictionary<GenericParamDef, GenericParamInfo>();
-		Dictionary<ParamDef, ParamInfo> allParamInfos = new Dictionary<ParamDef, ParamInfo>();
+		Dictionary<MTypeDef, TypeInfo> allTypeInfos = new Dictionary<MTypeDef, TypeInfo>();
+		Dictionary<MPropertyDef, PropertyInfo> allPropertyInfos = new Dictionary<MPropertyDef, PropertyInfo>();
+		Dictionary<MEventDef, EventInfo> allEventInfos = new Dictionary<MEventDef, EventInfo>();
+		Dictionary<MFieldDef, FieldInfo> allFieldInfos = new Dictionary<MFieldDef, FieldInfo>();
+		Dictionary<MMethodDef, MethodInfo> allMethodInfos = new Dictionary<MMethodDef, MethodInfo>();
+		Dictionary<MGenericParamDef, GenericParamInfo> allGenericParamInfos = new Dictionary<MGenericParamDef, GenericParamInfo>();
+		Dictionary<MParamDef, ParamInfo> allParamInfos = new Dictionary<MParamDef, ParamInfo>();
 		DerivedFrom checkWinFormsClass;
 
 		static string[] WINFORMS_CLASSES = new string[] {
@@ -210,55 +210,55 @@ namespace de4dot.code.renamer {
 			checkWinFormsClass = new DerivedFrom(WINFORMS_CLASSES);
 		}
 
-		public bool isWinFormsClass(TypeDef type) {
+		public bool isWinFormsClass(MTypeDef type) {
 			return checkWinFormsClass.check(type);
 		}
 
-		public TypeInfo type(TypeDef t) {
+		public TypeInfo type(MTypeDef t) {
 			return allTypeInfos[t];
 		}
 
-		public bool tryGetType(TypeDef t, out TypeInfo info) {
+		public bool tryGetType(MTypeDef t, out TypeInfo info) {
 			return allTypeInfos.TryGetValue(t, out info);
 		}
 
-		public bool tryGetEvent(EventDef e, out EventInfo info) {
+		public bool tryGetEvent(MEventDef e, out EventInfo info) {
 			return allEventInfos.TryGetValue(e, out info);
 		}
 
-		public bool tryGetProperty(PropertyDef p, out PropertyInfo info) {
+		public bool tryGetProperty(MPropertyDef p, out PropertyInfo info) {
 			return allPropertyInfos.TryGetValue(p, out info);
 		}
 
-		public PropertyInfo prop(PropertyDef prop) {
+		public PropertyInfo prop(MPropertyDef prop) {
 			return allPropertyInfos[prop];
 		}
 
-		public EventInfo evt(EventDef evt) {
+		public EventInfo evt(MEventDef evt) {
 			return allEventInfos[evt];
 		}
 
-		public FieldInfo field(FieldDef field) {
+		public FieldInfo field(MFieldDef field) {
 			return allFieldInfos[field];
 		}
 
-		public MethodInfo method(MethodDef method) {
+		public MethodInfo method(MMethodDef method) {
 			return allMethodInfos[method];
 		}
 
-		public GenericParamInfo gparam(GenericParamDef gparam) {
+		public GenericParamInfo gparam(MGenericParamDef gparam) {
 			return allGenericParamInfos[gparam];
 		}
 
-		public ParamInfo param(ParamDef param) {
+		public ParamInfo param(MParamDef param) {
 			return allParamInfos[param];
 		}
 
-		public void add(PropertyDef prop) {
+		public void add(MPropertyDef prop) {
 			allPropertyInfos[prop] = new PropertyInfo(prop);
 		}
 
-		public void add(EventDef evt) {
+		public void add(MEventDef evt) {
 			allEventInfos[evt] = new EventInfo(evt);
 		}
 
@@ -282,7 +282,7 @@ namespace de4dot.code.renamer {
 					allMethodInfos[method] = new MethodInfo(method);
 					foreach (var gp in method.GenericParams)
 						allGenericParamInfos[gp] = new GenericParamInfo(gp);
-					foreach (var param in method.ParamDefs)
+					foreach (var param in method.AllParamDefs)
 						allParamInfos[param] = new ParamInfo(param);
 				}
 			}
diff --git a/de4dot.code/renamer/NameCreators.cs b/de4dot.code/renamer/NameCreators.cs
index 73e49caf..71be2abf 100644
--- a/de4dot.code/renamer/NameCreators.cs
+++ b/de4dot.code/renamer/NameCreators.cs
@@ -18,7 +18,7 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.renamer {
@@ -107,7 +107,7 @@ namespace de4dot.code.renamer {
 	}
 
 	interface ITypeNameCreator {
-		string create(TypeDefinition typeDefinition, string newBaseTypeName);
+		string create(TypeDef typeDefinition, string newBaseTypeName);
 	}
 
 	class NameInfos {
@@ -172,12 +172,12 @@ namespace de4dot.code.renamer {
 			return new NameCreator(prefix);
 		}
 
-		public string create(TypeDefinition typeDefinition, string newBaseTypeName) {
+		public string create(TypeDef typeDefinition, string newBaseTypeName) {
 			var nameCreator = getNameCreator(typeDefinition, newBaseTypeName);
-			return existingNames.getName(typeDefinition.Name, nameCreator);
+			return existingNames.getName(typeDefinition.Name.String, nameCreator);
 		}
 
-		NameCreator getNameCreator(TypeDefinition typeDefinition, string newBaseTypeName) {
+		NameCreator getNameCreator(TypeDef typeDefinition, string newBaseTypeName) {
 			var nameCreator = createUnknownTypeName;
 			if (typeDefinition.IsEnum)
 				nameCreator = createEnumName;
@@ -185,12 +185,13 @@ namespace de4dot.code.renamer {
 				nameCreator = createStructName;
 			else if (typeDefinition.IsClass) {
 				if (typeDefinition.BaseType != null) {
-					if (MemberReferenceHelper.verifyType(typeDefinition.BaseType, "mscorlib", "System.Delegate"))
+					var fn = typeDefinition.BaseType.FullName;
+					if (fn == "System.Delegate")
 						nameCreator = createDelegateName;
-					else if (MemberReferenceHelper.verifyType(typeDefinition.BaseType, "mscorlib", "System.MulticastDelegate"))
+					else if (fn == "System.MulticastDelegate")
 						nameCreator = createDelegateName;
 					else {
-						nameCreator = nameInfos.find(newBaseTypeName ?? typeDefinition.BaseType.Name);
+						nameCreator = nameInfos.find(newBaseTypeName ?? typeDefinition.BaseType.Name.String);
 						if (nameCreator == null)
 							nameCreator = createClassName;
 					}
diff --git a/de4dot.code/renamer/Renamer.cs b/de4dot.code/renamer/Renamer.cs
index 663c75f6..3e2a5bbe 100644
--- a/de4dot.code/renamer/Renamer.cs
+++ b/de4dot.code/renamer/Renamer.cs
@@ -20,8 +20,8 @@
 using System;
 using System.Collections.Generic;
 using System.Text.RegularExpressions;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.code.renamer.asmmodules;
 using de4dot.blocks;
 
@@ -44,6 +44,7 @@ namespace de4dot.code.renamer {
 		MemberInfos memberInfos = new MemberInfos();
 		DerivedFrom isDelegateClass;
 		MergeStateHelper mergeStateHelper;
+		bool isVerbose;
 
 		static string[] delegateClasses = new string[] {
 			"System.Delegate",
@@ -75,7 +76,8 @@ namespace de4dot.code.renamer {
 		public void rename() {
 			if (modules.Empty)
 				return;
-			Log.n("Renaming all obfuscated symbols");
+			isVerbose = !Logger.Instance.IgnoresEvent(LoggerEvent.Verbose);
+			Logger.n("Renaming all obfuscated symbols");
 
 			modules.initialize();
 			renameResourceKeys();
@@ -97,7 +99,7 @@ namespace de4dot.code.renamer {
 			foreach (var module in modules.TheModules) {
 				if (!module.ObfuscatedFile.RenameResourceKeys)
 					continue;
-				new ResourceKeysRenamer(module.ModuleDefinition, module.ObfuscatedFile.NameChecker).rename();
+				new ResourceKeysRenamer(module.ModuleDefMD, module.ObfuscatedFile.NameChecker).rename();
 			}
 		}
 
@@ -108,15 +110,16 @@ namespace de4dot.code.renamer {
 						continue;
 					if (!method.isPublic())
 						continue;
-					var overrides = method.MethodDefinition.Overrides;
+					var overrides = method.MethodDef.Overrides;
 					for (int i = 0; i < overrides.Count; i++) {
-						var overrideMethod = overrides[i];
-						if (method.MethodDefinition.Name != overrideMethod.Name)
+						var overrideMethod = overrides[i].MethodDeclaration;
+						if (method.MethodDef.Name != overrideMethod.Name)
 							continue;
-						Log.v("Removed useless override from method {0} ({1:X8}), override: {2:X8}",
-									Utils.removeNewlines(method.MethodDefinition),
-									method.MethodDefinition.MetadataToken.ToInt32(),
-									overrideMethod.MetadataToken.ToInt32());
+						if (isVerbose)
+							Logger.v("Removed useless override from method {0} ({1:X8}), override: {2:X8}",
+									Utils.removeNewlines(method.MethodDef),
+									method.MethodDef.MDToken.ToInt32(),
+									overrideMethod.MDToken.ToInt32());
 						overrides.RemoveAt(i);
 						i--;
 					}
@@ -125,7 +128,8 @@ namespace de4dot.code.renamer {
 		}
 
 		void renameTypeDefinitions() {
-			Log.v("Renaming obfuscated type definitions");
+			if (isVerbose)
+				Logger.v("Renaming obfuscated type definitions");
 
 			foreach (var module in modules.TheModules) {
 				if (module.ObfuscatedFile.RemoveNamespaceWithOneType)
@@ -141,104 +145,110 @@ namespace de4dot.code.renamer {
 		}
 
 		void removeOneClassNamespaces(Module module) {
-			var nsToTypes = new Dictionary<string, List<TypeDef>>(StringComparer.Ordinal);
+			var nsToTypes = new Dictionary<string, List<MTypeDef>>(StringComparer.Ordinal);
 
 			foreach (var typeDef in module.getAllTypes()) {
-				List<TypeDef> list;
-				var ns = typeDef.TypeDefinition.Namespace;
+				List<MTypeDef> list;
+				var ns = typeDef.TypeDef.Namespace.String;
 				if (string.IsNullOrEmpty(ns))
 					continue;
 				if (module.ObfuscatedFile.NameChecker.isValidNamespaceName(ns))
 					continue;
 				if (!nsToTypes.TryGetValue(ns, out list))
-					nsToTypes[ns] = list = new List<TypeDef>();
+					nsToTypes[ns] = list = new List<MTypeDef>();
 				list.Add(typeDef);
 			}
 
-			var sortedNamespaces = new List<List<TypeDef>>(nsToTypes.Values);
+			var sortedNamespaces = new List<List<MTypeDef>>(nsToTypes.Values);
 			sortedNamespaces.Sort((a, b) => {
-				return string.CompareOrdinal(a[0].TypeDefinition.Namespace, b[0].TypeDefinition.Namespace);
+				return UTF8String.CompareTo(a[0].TypeDef.Namespace, b[0].TypeDef.Namespace);
 			});
 			foreach (var list in sortedNamespaces) {
 				const int maxClasses = 1;
 				if (list.Count != maxClasses)
 					continue;
-				var ns = list[0].TypeDefinition.Namespace;
-				Log.v("Removing namespace: {0}", Utils.removeNewlines(ns));
+				if (isVerbose)
+					Logger.v("Removing namespace: {0}", Utils.removeNewlines(list[0].TypeDef.Namespace));
 				foreach (var type in list)
 					memberInfos.type(type).newNamespace = "";
 			}
 		}
 
-		void renameTypeDefinitions(IEnumerable<TypeDef> typeDefs) {
-			Log.indent();
+		void renameTypeDefinitions(IEnumerable<MTypeDef> typeDefs) {
+			Logger.Instance.indent();
 			foreach (var typeDef in typeDefs) {
 				rename(typeDef);
 				renameTypeDefinitions(typeDef.NestedTypes);
 			}
-			Log.deIndent();
+			Logger.Instance.deIndent();
 		}
 
-		void rename(TypeDef type) {
-			var typeDefinition = type.TypeDefinition;
+		void rename(MTypeDef type) {
+			var typeDefinition = type.TypeDef;
 			var info = memberInfos.type(type);
 
-			Log.v("Type: {0} ({1:X8})", Utils.removeNewlines(typeDefinition.FullName), typeDefinition.MetadataToken.ToUInt32());
-			Log.indent();
+			if (isVerbose)
+				Logger.v("Type: {0} ({1:X8})", Utils.removeNewlines(typeDefinition.FullName), typeDefinition.MDToken.ToUInt32());
+			Logger.Instance.indent();
 
 			renameGenericParams(type.GenericParams);
 
 			if (RenameTypes && info.gotNewName()) {
 				var old = typeDefinition.Name;
-				typeDefinition.Name = info.newName;
-				Log.v("Name: {0} => {1}", Utils.removeNewlines(old), Utils.removeNewlines(typeDefinition.Name));
+				typeDefinition.Name = new UTF8String(info.newName);
+				if (isVerbose)
+					Logger.v("Name: {0} => {1}", Utils.removeNewlines(old), Utils.removeNewlines(typeDefinition.Name));
 			}
 
 			if (RenameNamespaces && info.newNamespace != null) {
 				var old = typeDefinition.Namespace;
-				typeDefinition.Namespace = info.newNamespace;
-				Log.v("Namespace: {0} => {1}", Utils.removeNewlines(old), Utils.removeNewlines(typeDefinition.Namespace));
+				typeDefinition.Namespace = new UTF8String(info.newNamespace);
+				if (isVerbose)
+					Logger.v("Namespace: {0} => {1}", Utils.removeNewlines(old), Utils.removeNewlines(typeDefinition.Namespace));
 			}
 
-			Log.deIndent();
+			Logger.Instance.deIndent();
 		}
 
-		void renameGenericParams(IEnumerable<GenericParamDef> genericParams) {
+		void renameGenericParams(IEnumerable<MGenericParamDef> genericParams) {
 			if (!RenameGenericParams)
 				return;
 			foreach (var param in genericParams) {
 				var info = memberInfos.gparam(param);
 				if (!info.gotNewName())
 					continue;
-				param.GenericParameter.Name = info.newName;
-				Log.v("GenParam: {0} => {1}", Utils.removeNewlines(info.oldFullName), Utils.removeNewlines(param.GenericParameter.FullName));
+				param.GenericParam.Name = new UTF8String(info.newName);
+				if (isVerbose)
+					Logger.v("GenParam: {0} => {1}", Utils.removeNewlines(info.oldFullName), Utils.removeNewlines(param.GenericParam.FullName));
 			}
 		}
 
 		void renameMemberDefinitions() {
-			Log.v("Renaming member definitions #2");
+			if (isVerbose)
+				Logger.v("Renaming member definitions #2");
 
-			var allTypes = new List<TypeDef>(modules.AllTypes);
-			allTypes.Sort((a, b) => Utils.compareInt32(a.Index, b.Index));
+			var allTypes = new List<MTypeDef>(modules.AllTypes);
+			allTypes.Sort((a, b) => a.Index.CompareTo(b.Index));
 
-			Log.indent();
+			Logger.Instance.indent();
 			foreach (var typeDef in allTypes)
 				renameMembers(typeDef);
-			Log.deIndent();
+			Logger.Instance.deIndent();
 		}
 
-		void renameMembers(TypeDef type) {
+		void renameMembers(MTypeDef type) {
 			var info = memberInfos.type(type);
 
-			Log.v("Type: {0}", Utils.removeNewlines(info.type.TypeDefinition.FullName));
-			Log.indent();
+			if (isVerbose)
+				Logger.v("Type: {0}", Utils.removeNewlines(info.type.TypeDef.FullName));
+			Logger.Instance.indent();
 
 			renameFields(info);
 			renameProperties(info);
 			renameEvents(info);
 			renameMethods(info);
 
-			Log.deIndent();
+			Logger.Instance.deIndent();
 		}
 
 		void renameFields(TypeInfo info) {
@@ -248,11 +258,12 @@ namespace de4dot.code.renamer {
 				var fieldInfo = memberInfos.field(fieldDef);
 				if (!fieldInfo.gotNewName())
 					continue;
-				fieldDef.FieldDefinition.Name = fieldInfo.newName;
-				Log.v("Field: {0} ({1:X8}) => {2}",
+				fieldDef.FieldDef.Name = new UTF8String(fieldInfo.newName);
+				if (isVerbose)
+					Logger.v("Field: {0} ({1:X8}) => {2}",
 							Utils.removeNewlines(fieldInfo.oldFullName),
-							fieldDef.FieldDefinition.MetadataToken.ToUInt32(),
-							Utils.removeNewlines(fieldDef.FieldDefinition.FullName));
+							fieldDef.FieldDef.MDToken.ToUInt32(),
+							Utils.removeNewlines(fieldDef.FieldDef.FullName));
 			}
 		}
 
@@ -263,11 +274,12 @@ namespace de4dot.code.renamer {
 				var propInfo = memberInfos.prop(propDef);
 				if (!propInfo.gotNewName())
 					continue;
-				propDef.PropertyDefinition.Name = propInfo.newName;
-				Log.v("Property: {0} ({1:X8}) => {2}",
+				propDef.PropertyDef.Name = new UTF8String(propInfo.newName);
+				if (isVerbose)
+					Logger.v("Property: {0} ({1:X8}) => {2}",
 							Utils.removeNewlines(propInfo.oldFullName),
-							propDef.PropertyDefinition.MetadataToken.ToUInt32(),
-							Utils.removeNewlines(propDef.PropertyDefinition.FullName));
+							propDef.PropertyDef.MDToken.ToUInt32(),
+							Utils.removeNewlines(propDef.PropertyDef.FullName));
 			}
 		}
 
@@ -278,11 +290,12 @@ namespace de4dot.code.renamer {
 				var eventInfo = memberInfos.evt(eventDef);
 				if (!eventInfo.gotNewName())
 					continue;
-				eventDef.EventDefinition.Name = eventInfo.newName;
-				Log.v("Event: {0} ({1:X8}) => {2}",
+				eventDef.EventDef.Name = new UTF8String(eventInfo.newName);
+				if (isVerbose)
+					Logger.v("Event: {0} ({1:X8}) => {2}",
 							Utils.removeNewlines(eventInfo.oldFullName),
-							eventDef.EventDefinition.MetadataToken.ToUInt32(),
-							Utils.removeNewlines(eventDef.EventDefinition.FullName));
+							eventDef.EventDef.MDToken.ToUInt32(),
+							Utils.removeNewlines(eventDef.EventDef.FullName));
 			}
 		}
 
@@ -291,60 +304,66 @@ namespace de4dot.code.renamer {
 				return;
 			foreach (var methodDef in info.type.AllMethodsSorted) {
 				var methodInfo = memberInfos.method(methodDef);
-				Log.v("Method {0} ({1:X8})", Utils.removeNewlines(methodInfo.oldFullName), methodDef.MethodDefinition.MetadataToken.ToUInt32());
-				Log.indent();
+				if (isVerbose)
+					Logger.v("Method {0} ({1:X8})", Utils.removeNewlines(methodInfo.oldFullName), methodDef.MethodDef.MDToken.ToUInt32());
+				Logger.Instance.indent();
 
 				renameGenericParams(methodDef.GenericParams);
 
 				if (RenameMethods && methodInfo.gotNewName()) {
-					methodDef.MethodDefinition.Name = methodInfo.newName;
-					Log.v("Name: {0} => {1}", Utils.removeNewlines(methodInfo.oldFullName), Utils.removeNewlines(methodDef.MethodDefinition.FullName));
+					methodDef.MethodDef.Name = new UTF8String(methodInfo.newName);
+					if (isVerbose)
+						Logger.v("Name: {0} => {1}", Utils.removeNewlines(methodInfo.oldFullName), Utils.removeNewlines(methodDef.MethodDef.FullName));
 				}
 
 				if (RenameMethodArgs) {
-					foreach (var param in methodDef.ParamDefs) {
+					foreach (var param in methodDef.AllParamDefs) {
 						var paramInfo = memberInfos.param(param);
 						if (!paramInfo.gotNewName())
 							continue;
+						param.ParameterDefinition.CreateParamDef();
 						param.ParameterDefinition.Name = paramInfo.newName;
-						Log.v("Param ({0}/{1}): {2} => {3}", param.Index + 1, methodDef.ParamDefs.Count, Utils.removeNewlines(paramInfo.oldName), Utils.removeNewlines(paramInfo.newName));
+						if (isVerbose) {
+							if (param.IsReturnParameter)
+								Logger.v("RetParam: {0} => {1}", Utils.removeNewlines(paramInfo.oldName), Utils.removeNewlines(paramInfo.newName));
+							else
+								Logger.v("Param ({0}/{1}): {2} => {3}", param.ParameterDefinition.MethodSigIndex + 1, methodDef.MethodDef.MethodSig.GetParamCount(), Utils.removeNewlines(paramInfo.oldName), Utils.removeNewlines(paramInfo.newName));
+						}
 					}
 				}
 
-				Log.deIndent();
+				Logger.Instance.deIndent();
 			}
 		}
 
 		void renameMemberReferences() {
-			Log.v("Renaming references to other definitions");
+			if (isVerbose)
+				Logger.v("Renaming references to other definitions");
 			foreach (var module in modules.TheModules) {
-				if (modules.TheModules.Count > 1)
-					Log.v("Renaming references to other definitions ({0})", module.Filename);
-				Log.indent();
+				if (modules.TheModules.Count > 1 && isVerbose)
+					Logger.v("Renaming references to other definitions ({0})", module.Filename);
+				Logger.Instance.indent();
 				foreach (var refToDef in module.MethodRefsToRename)
 					refToDef.reference.Name = refToDef.definition.Name;
 				foreach (var refToDef in module.FieldRefsToRename)
 					refToDef.reference.Name = refToDef.definition.Name;
-				foreach (var info in module.CustomAttributeFieldReferences) {
-					var field = info.cattr.Fields[info.index];
-					info.cattr.Fields[info.index] = new CustomAttributeNamedArgument(info.reference.Name, field.Argument);
-				}
-				foreach (var info in module.CustomAttributePropertyReferences) {
-					var prop = info.cattr.Properties[info.index];
-					info.cattr.Properties[info.index] = new CustomAttributeNamedArgument(info.reference.Name, prop.Argument);
-				}
-				Log.deIndent();
+				foreach (var info in module.CustomAttributeFieldReferences)
+					info.cattr.NamedArguments[info.index].Name = info.reference.Name;
+				foreach (var info in module.CustomAttributePropertyReferences)
+					info.cattr.NamedArguments[info.index].Name = info.reference.Name;
+				Logger.Instance.deIndent();
 			}
 		}
 
 		void renameResources() {
-			Log.v("Renaming resources");
+			if (isVerbose)
+				Logger.v("Renaming resources");
 			foreach (var module in modules.TheModules) {
-				if (modules.TheModules.Count > 1)
-					Log.v("Renaming resources ({0})", module.Filename);
-				Log.indent();
+				if (modules.TheModules.Count > 1 && isVerbose)
+					Logger.v("Renaming resources ({0})", module.Filename);
+				Logger.Instance.indent();
 				renameResources(module);
-				Log.deIndent();
+				Logger.Instance.deIndent();
 			}
 		}
 
@@ -352,7 +371,7 @@ namespace de4dot.code.renamer {
 			var renamedTypes = new List<TypeInfo>();
 			foreach (var type in module.getAllTypes()) {
 				var info = memberInfos.type(type);
-				if (info.oldFullName != info.type.TypeDefinition.FullName)
+				if (info.oldFullName != info.type.TypeDef.FullName)
 					renamedTypes.Add(info);
 			}
 			if (renamedTypes.Count == 0)
@@ -369,7 +388,7 @@ namespace de4dot.code.renamer {
 				fixClsTypeNames(null, type);
 		}
 
-		void fixClsTypeNames(TypeDef nesting, TypeDef nested) {
+		void fixClsTypeNames(MTypeDef nesting, MTypeDef nested) {
 			int nestingCount = nesting == null ? 0 : nesting.GenericParams.Count;
 			int arity = nested.GenericParams.Count - nestingCount;
 			var nestedInfo = memberInfos.type(nested);
@@ -379,7 +398,7 @@ namespace de4dot.code.renamer {
 				fixClsTypeNames(nested, nestedType);
 		}
 
-		void prepareRenameTypes(IEnumerable<TypeDef> types, TypeRenamerState state) {
+		void prepareRenameTypes(IEnumerable<MTypeDef> types, TypeRenamerState state) {
 			foreach (var typeDef in types) {
 				memberInfos.type(typeDef).prepareRenameTypes(state);
 				prepareRenameTypes(typeDef.derivedTypes, state);
@@ -387,17 +406,18 @@ namespace de4dot.code.renamer {
 		}
 
 		void renameTypeReferences() {
-			Log.v("Renaming references to type definitions");
+			if (isVerbose)
+				Logger.v("Renaming references to type definitions");
 			var theModules = modules.TheModules;
 			foreach (var module in theModules) {
-				if (theModules.Count > 1)
-					Log.v("Renaming references to type definitions ({0})", module.Filename);
-				Log.indent();
+				if (theModules.Count > 1 && isVerbose)
+					Logger.v("Renaming references to type definitions ({0})", module.Filename);
+				Logger.Instance.indent();
 				foreach (var refToDef in module.TypeRefsToRename) {
 					refToDef.reference.Name = refToDef.definition.Name;
 					refToDef.reference.Namespace = refToDef.definition.Namespace;
 				}
-				Log.deIndent();
+				Logger.Instance.deIndent();
 			}
 		}
 
@@ -415,7 +435,7 @@ namespace de4dot.code.renamer {
 			if (!this.RenameProperties)
 				return;
 			foreach (var group in allGroups) {
-				PropertyDef prop = null;
+				MPropertyDef prop = null;
 				foreach (var method in group.Methods) {
 					if (method.Property == null)
 						continue;
@@ -431,7 +451,7 @@ namespace de4dot.code.renamer {
 						continue;
 					if (method.Property == null)
 						continue;
-					memberInfos.prop(method.Property).rename(prop.PropertyDefinition.Name);
+					memberInfos.prop(method.Property).rename(prop.PropertyDef.Name.String);
 				}
 			}
 		}
@@ -440,7 +460,7 @@ namespace de4dot.code.renamer {
 			if (!this.RenameEvents)
 				return;
 			foreach (var group in allGroups) {
-				EventDef evt = null;
+				MEventDef evt = null;
 				foreach (var method in group.Methods) {
 					if (method.Event == null)
 						continue;
@@ -456,7 +476,7 @@ namespace de4dot.code.renamer {
 						continue;
 					if (method.Event == null)
 						continue;
-					memberInfos.evt(method.Event).rename(evt.EventDefinition.Name);
+					memberInfos.evt(method.Event).rename(evt.EventDef.Name.String);
 				}
 			}
 		}
@@ -476,7 +496,7 @@ namespace de4dot.code.renamer {
 			var propMethod = group.Methods[0];
 			if (propMethod.Property != null)
 				return;
-			if (propMethod.MethodDefinition.Overrides.Count == 0)
+			if (propMethod.MethodDef.Overrides.Count == 0)
 				return;
 
 			var theProperty = getOverriddenProperty(propMethod);
@@ -490,12 +510,12 @@ namespace de4dot.code.renamer {
 			if (group.Methods.Count <= 1 || !group.hasProperty())
 				return;
 
-			PropertyDef prop = null;
-			List<MethodDef> missingProps = null;
+			MPropertyDef prop = null;
+			List<MMethodDef> missingProps = null;
 			foreach (var method in group.Methods) {
 				if (method.Property == null) {
 					if (missingProps == null)
-						missingProps = new List<MethodDef>();
+						missingProps = new List<MMethodDef>();
 					missingProps.Add(method);
 				}
 				else if (prop == null || !method.Owner.HasModule)
@@ -510,12 +530,12 @@ namespace de4dot.code.renamer {
 				createProperty(prop, method, "");
 		}
 
-		void createProperty(PropertyDef propDef, MethodDef methodDef, string overridePrefix) {
+		void createProperty(MPropertyDef propDef, MMethodDef methodDef, string overridePrefix) {
 			if (!methodDef.Owner.HasModule)
 				return;
 
-			var newPropertyName = overridePrefix + propDef.PropertyDefinition.Name;
-			if (!DotNetUtils.hasReturnValue(methodDef.MethodDefinition))
+			var newPropertyName = overridePrefix + propDef.PropertyDef.Name;
+			if (!DotNetUtils.hasReturnValue(methodDef.MethodDef))
 				createPropertySetter(newPropertyName, methodDef);
 			else
 				createPropertyGetter(newPropertyName, methodDef);
@@ -527,7 +547,7 @@ namespace de4dot.code.renamer {
 
 			foreach (var group in allGroups) {
 				var groupMethod = group.Methods[0];
-				var methodName = groupMethod.MethodDefinition.Name;
+				var methodName = groupMethod.MethodDef.Name.String;
 				bool onlyRenamableMethods = !group.hasNonRenamableMethod();
 
 				if (Utils.StartsWith(methodName, "get_", StringComparison.Ordinal)) {
@@ -554,7 +574,7 @@ namespace de4dot.code.renamer {
 						continue;	// Virtual methods are in allGroups, so already fixed above
 					if (method.Property != null)
 						continue;
-					var methodName = method.MethodDefinition.Name;
+					var methodName = method.MethodDef.Name.String;
 					if (Utils.StartsWith(methodName, "get_", StringComparison.Ordinal))
 						createPropertyGetter(methodName.Substring(4), method);
 					else if (Utils.StartsWith(methodName, "set_", StringComparison.Ordinal))
@@ -563,7 +583,7 @@ namespace de4dot.code.renamer {
 			}
 		}
 
-		PropertyDef createPropertyGetter(string name, MethodDef propMethod) {
+		MPropertyDef createPropertyGetter(string name, MMethodDef propMethod) {
 			if (string.IsNullOrEmpty(name))
 				return null;
 			var ownerType = propMethod.Owner;
@@ -572,25 +592,28 @@ namespace de4dot.code.renamer {
 			if (propMethod.Property != null)
 				return null;
 
-			var method = propMethod.MethodDefinition;
-			var propType = method.MethodReturnType.ReturnType;
-			var propDef = createProperty(ownerType, name, propType, propMethod.MethodDefinition, null);
+			var sig = propMethod.MethodDef.MethodSig;
+			if (sig == null)
+				return null;
+			var propType = sig.RetType;
+			var propDef = createProperty(ownerType, name, propType, propMethod.MethodDef, null);
 			if (propDef == null)
 				return null;
 			if (propDef.GetMethod != null)
 				return null;
-			Log.v("Restoring property getter {0} ({1:X8}), Property: {2} ({3:X8})",
+			if (isVerbose)
+				Logger.v("Restoring property getter {0} ({1:X8}), Property: {2} ({3:X8})",
 						Utils.removeNewlines(propMethod),
-						propMethod.MethodDefinition.MetadataToken.ToInt32(),
-						Utils.removeNewlines(propDef.PropertyDefinition),
-						propDef.PropertyDefinition.MetadataToken.ToInt32());
-			propDef.PropertyDefinition.GetMethod = propMethod.MethodDefinition;
+						propMethod.MethodDef.MDToken.ToInt32(),
+						Utils.removeNewlines(propDef.PropertyDef),
+						propDef.PropertyDef.MDToken.ToInt32());
+			propDef.PropertyDef.GetMethod = propMethod.MethodDef;
 			propDef.GetMethod = propMethod;
 			propMethod.Property = propDef;
 			return propDef;
 		}
 
-		PropertyDef createPropertySetter(string name, MethodDef propMethod) {
+		MPropertyDef createPropertySetter(string name, MMethodDef propMethod) {
 			if (string.IsNullOrEmpty(name))
 				return null;
 			var ownerType = propMethod.Owner;
@@ -599,40 +622,66 @@ namespace de4dot.code.renamer {
 			if (propMethod.Property != null)
 				return null;
 
-			var method = propMethod.MethodDefinition;
-			if (method.Parameters.Count == 0)
+			var sig = propMethod.MethodDef.MethodSig;
+			if (sig == null || sig.Params.Count == 0)
 				return null;
-			var propType = method.Parameters[method.Parameters.Count - 1].ParameterType;
-			var propDef = createProperty(ownerType, name, propType, null, propMethod.MethodDefinition);
+			var propType = sig.Params[sig.Params.Count - 1];
+			var propDef = createProperty(ownerType, name, propType, null, propMethod.MethodDef);
 			if (propDef == null)
 				return null;
 			if (propDef.SetMethod != null)
 				return null;
-			Log.v("Restoring property setter {0} ({1:X8}), Property: {2} ({3:X8})",
+			if (isVerbose)
+				Logger.v("Restoring property setter {0} ({1:X8}), Property: {2} ({3:X8})",
 						Utils.removeNewlines(propMethod),
-						propMethod.MethodDefinition.MetadataToken.ToInt32(),
-						Utils.removeNewlines(propDef.PropertyDefinition),
-						propDef.PropertyDefinition.MetadataToken.ToInt32());
-			propDef.PropertyDefinition.SetMethod = propMethod.MethodDefinition;
+						propMethod.MethodDef.MDToken.ToInt32(),
+						Utils.removeNewlines(propDef.PropertyDef),
+						propDef.PropertyDef.MDToken.ToInt32());
+			propDef.PropertyDef.SetMethod = propMethod.MethodDef;
 			propDef.SetMethod = propMethod;
 			propMethod.Property = propDef;
 			return propDef;
 		}
 
-		PropertyDef createProperty(TypeDef ownerType, string name, TypeReference propType, MethodDefinition getter, MethodDefinition setter) {
-			if (string.IsNullOrEmpty(name) || propType.FullName == "System.Void")
+		MPropertyDef createProperty(MTypeDef ownerType, string name, TypeSig propType, MethodDef getter, MethodDef setter) {
+			if (string.IsNullOrEmpty(name) || propType.ElementType == ElementType.Void)
 				return null;
-			var newProp = DotNetUtils.createPropertyDefinition(name, propType, getter, setter);
+			var newSig = createPropertySig(getter, propType, true) ?? createPropertySig(setter, propType, false);
+			if (newSig == null)
+				return null;
+			var newProp = ownerType.Module.ModuleDefMD.UpdateRowId(new PropertyDefUser(name, newSig, 0));
+			newProp.GetMethod = getter;
+			newProp.SetMethod = setter;
 			var propDef = ownerType.findAny(newProp);
 			if (propDef != null)
 				return propDef;
 
 			propDef = ownerType.create(newProp);
 			memberInfos.add(propDef);
-			Log.v("Restoring property: {0}", Utils.removeNewlines(newProp));
+			if (isVerbose)
+				Logger.v("Restoring property: {0}", Utils.removeNewlines(newProp));
 			return propDef;
 		}
 
+		static PropertySig createPropertySig(MethodDef method, TypeSig propType, bool isGetter) {
+			if (method == null)
+				return null;
+			var sig = method.MethodSig;
+			if (sig == null)
+				return null;
+
+			var newSig = new PropertySig(sig.HasThis, propType);
+			newSig.GenParamCount = sig.GenParamCount;
+
+			int count = sig.Params.Count;
+			if (!isGetter)
+				count--;
+			for (int i = 0; i < count; i++)
+				newSig.Params.Add(sig.Params[i]);
+
+			return newSig;
+		}
+
 		void restoreVirtualEvents(IEnumerable<MethodNameGroup> allGroups) {
 			if (!RestoreEvents)
 				return;
@@ -656,10 +705,10 @@ namespace de4dot.code.renamer {
 			var eventMethod = group.Methods[0];
 			if (eventMethod.Event != null)
 				return;
-			if (eventMethod.MethodDefinition.Overrides.Count == 0)
+			if (eventMethod.MethodDef.Overrides.Count == 0)
 				return;
 
-			MethodDef overriddenMethod;
+			MMethodDef overriddenMethod;
 			var theEvent = getOverriddenEvent(eventMethod, out overriddenMethod);
 			if (theEvent == null)
 				return;
@@ -672,12 +721,12 @@ namespace de4dot.code.renamer {
 				return;
 
 			EventMethodType methodType = EventMethodType.None;
-			EventDef evt = null;
-			List<MethodDef> missingEvents = null;
+			MEventDef evt = null;
+			List<MMethodDef> missingEvents = null;
 			foreach (var method in group.Methods) {
 				if (method.Event == null) {
 					if (missingEvents == null)
-						missingEvents = new List<MethodDef>();
+						missingEvents = new List<MMethodDef>();
 					missingEvents.Add(method);
 				}
 				else if (evt == null || !method.Owner.HasModule) {
@@ -694,11 +743,11 @@ namespace de4dot.code.renamer {
 				createEvent(evt, method, methodType, "");
 		}
 
-		void createEvent(EventDef eventDef, MethodDef methodDef, EventMethodType methodType, string overridePrefix) {
+		void createEvent(MEventDef eventDef, MMethodDef methodDef, EventMethodType methodType, string overridePrefix) {
 			if (!methodDef.Owner.HasModule)
 				return;
 
-			var newEventName = overridePrefix + eventDef.EventDefinition.Name;
+			var newEventName = overridePrefix + eventDef.EventDef.Name;
 			switch (methodType) {
 			case EventMethodType.Adder:
 				createEventAdder(newEventName, methodDef);
@@ -709,7 +758,7 @@ namespace de4dot.code.renamer {
 			}
 		}
 
-		static EventMethodType getEventMethodType(MethodDef method) {
+		static EventMethodType getEventMethodType(MMethodDef method) {
 			var evt = method.Event;
 			if (evt == null)
 				return EventMethodType.None;
@@ -728,7 +777,7 @@ namespace de4dot.code.renamer {
 
 			foreach (var group in allGroups) {
 				var groupMethod = group.Methods[0];
-				var methodName = groupMethod.MethodDefinition.Name;
+				var methodName = groupMethod.MethodDef.Name.String;
 				bool onlyRenamableMethods = !group.hasNonRenamableMethod();
 
 				if (Utils.StartsWith(methodName, "add_", StringComparison.Ordinal)) {
@@ -755,7 +804,7 @@ namespace de4dot.code.renamer {
 						continue;	// Virtual methods are in allGroups, so already fixed above
 					if (method.Event != null)
 						continue;
-					var methodName = method.MethodDefinition.Name;
+					var methodName = method.MethodDef.Name.String;
 					if (Utils.StartsWith(methodName, "add_", StringComparison.Ordinal))
 						createEventAdder(methodName.Substring(4), method);
 					else if (Utils.StartsWith(methodName, "remove_", StringComparison.Ordinal))
@@ -764,7 +813,7 @@ namespace de4dot.code.renamer {
 			}
 		}
 
-		EventDef createEventAdder(string name, MethodDef eventMethod) {
+		MEventDef createEventAdder(string name, MMethodDef eventMethod) {
 			if (string.IsNullOrEmpty(name))
 				return null;
 			var ownerType = eventMethod.Owner;
@@ -773,24 +822,25 @@ namespace de4dot.code.renamer {
 			if (eventMethod.Event != null)
 				return null;
 
-			var method = eventMethod.MethodDefinition;
+			var method = eventMethod.MethodDef;
 			var eventDef = createEvent(ownerType, name, getEventType(method));
 			if (eventDef == null)
 				return null;
 			if (eventDef.AddMethod != null)
 				return null;
-			Log.v("Restoring event adder {0} ({1:X8}), Event: {2} ({3:X8})",
+			if (isVerbose)
+				Logger.v("Restoring event adder {0} ({1:X8}), Event: {2} ({3:X8})",
 						Utils.removeNewlines(eventMethod),
-						eventMethod.MethodDefinition.MetadataToken.ToInt32(),
-						Utils.removeNewlines(eventDef.EventDefinition),
-						eventDef.EventDefinition.MetadataToken.ToInt32());
-			eventDef.EventDefinition.AddMethod = eventMethod.MethodDefinition;
+						eventMethod.MethodDef.MDToken.ToInt32(),
+						Utils.removeNewlines(eventDef.EventDef),
+						eventDef.EventDef.MDToken.ToInt32());
+			eventDef.EventDef.AddMethod = eventMethod.MethodDef;
 			eventDef.AddMethod = eventMethod;
 			eventMethod.Event = eventDef;
 			return eventDef;
 		}
 
-		EventDef createEventRemover(string name, MethodDef eventMethod) {
+		MEventDef createEventRemover(string name, MMethodDef eventMethod) {
 			if (string.IsNullOrEmpty(name))
 				return null;
 			var ownerType = eventMethod.Owner;
@@ -799,47 +849,51 @@ namespace de4dot.code.renamer {
 			if (eventMethod.Event != null)
 				return null;
 
-			var method = eventMethod.MethodDefinition;
+			var method = eventMethod.MethodDef;
 			var eventDef = createEvent(ownerType, name, getEventType(method));
 			if (eventDef == null)
 				return null;
 			if (eventDef.RemoveMethod != null)
 				return null;
-			Log.v("Restoring event remover {0} ({1:X8}), Event: {2} ({3:X8})",
+			if (isVerbose)
+				Logger.v("Restoring event remover {0} ({1:X8}), Event: {2} ({3:X8})",
 						Utils.removeNewlines(eventMethod),
-						eventMethod.MethodDefinition.MetadataToken.ToInt32(),
-						Utils.removeNewlines(eventDef.EventDefinition),
-						eventDef.EventDefinition.MetadataToken.ToInt32());
-			eventDef.EventDefinition.RemoveMethod = eventMethod.MethodDefinition;
+						eventMethod.MethodDef.MDToken.ToInt32(),
+						Utils.removeNewlines(eventDef.EventDef),
+						eventDef.EventDef.MDToken.ToInt32());
+			eventDef.EventDef.RemoveMethod = eventMethod.MethodDef;
 			eventDef.RemoveMethod = eventMethod;
 			eventMethod.Event = eventDef;
 			return eventDef;
 		}
 
-		TypeReference getEventType(MethodReference method) {
+		TypeSig getEventType(IMethod method) {
 			if (DotNetUtils.hasReturnValue(method))
 				return null;
-			if (method.Parameters.Count != 1)
+			var sig = method.MethodSig;
+			if (sig == null || sig.Params.Count != 1)
 				return null;
-			return method.Parameters[0].ParameterType;
+			return sig.Params[0];
 		}
 
-		EventDef createEvent(TypeDef ownerType, string name, TypeReference eventType) {
-			if (string.IsNullOrEmpty(name) || eventType == null || eventType.FullName == "System.Void")
+		MEventDef createEvent(MTypeDef ownerType, string name, TypeSig eventType) {
+			if (string.IsNullOrEmpty(name) || eventType == null || eventType.ElementType == ElementType.Void)
 				return null;
-			var newEvent = DotNetUtils.createEventDefinition(name, eventType);
+			var newEvent = ownerType.Module.ModuleDefMD.UpdateRowId(new EventDefUser(name, eventType.ToTypeDefOrRef(), 0));
 			var eventDef = ownerType.findAny(newEvent);
 			if (eventDef != null)
 				return eventDef;
 
 			eventDef = ownerType.create(newEvent);
 			memberInfos.add(eventDef);
-			Log.v("Restoring event: {0}", Utils.removeNewlines(newEvent));
+			if (isVerbose)
+				Logger.v("Restoring event: {0}", Utils.removeNewlines(newEvent));
 			return eventDef;
 		}
 
 		void prepareRenameMemberDefinitions(MethodNameGroups groups) {
-			Log.v("Renaming member definitions #1");
+			if (isVerbose)
+				Logger.v("Renaming member definitions #1");
 
 			prepareRenameEntryPoints();
 
@@ -886,7 +940,7 @@ namespace de4dot.code.renamer {
 
 		void restoreMethodArgs(MethodNameGroups groups) {
 			foreach (var group in groups.getAllGroups()) {
-				if (group.Methods[0].ParamDefs.Count == 0)
+				if (group.Methods[0].VisibleParameterCount == 0)
 					continue;
 
 				var argNames = getValidArgNames(group);
@@ -910,19 +964,20 @@ namespace de4dot.code.renamer {
 		}
 
 		string[] getValidArgNames(MethodNameGroup group) {
-			var methods = new List<MethodDef>(group.Methods);
+			var methods = new List<MMethodDef>(group.Methods);
 			foreach (var method in group.Methods) {
-				foreach (var overrideRef in method.MethodDefinition.Overrides) {
-					var overrideDef = modules.resolve(overrideRef);
+				foreach (var ovrd in method.MethodDef.Overrides) {
+					var overrideRef = ovrd.MethodDeclaration;
+					var overrideDef = modules.resolveMethod(overrideRef);
 					if (overrideDef == null) {
-						var typeDef = modules.resolve(overrideRef.DeclaringType) ?? modules.resolveOther(overrideRef.DeclaringType);
+						var typeDef = modules.resolveType(overrideRef.DeclaringType) ?? modules.resolveOther(overrideRef.DeclaringType);
 						if (typeDef == null)
 							continue;
-						overrideDef = typeDef.find(overrideRef);
+						overrideDef = typeDef.findMethod(overrideRef);
 						if (overrideDef == null)
 							continue;
 					}
-					if (overrideDef.ParamDefs.Count != method.ParamDefs.Count)
+					if (overrideDef.VisibleParameterCount != method.VisibleParameterCount)
 						continue;
 					methods.Add(overrideDef);
 				}
@@ -941,12 +996,12 @@ namespace de4dot.code.renamer {
 		}
 
 		class PrepareHelper {
-			Dictionary<TypeDef, bool> prepareMethodCalled = new Dictionary<TypeDef, bool>();
+			Dictionary<MTypeDef, bool> prepareMethodCalled = new Dictionary<MTypeDef, bool>();
 			MemberInfos memberInfos;
 			Action<TypeInfo> func;
-			IEnumerable<TypeDef> allTypes;
+			IEnumerable<MTypeDef> allTypes;
 
-			public PrepareHelper(MemberInfos memberInfos, IEnumerable<TypeDef> allTypes) {
+			public PrepareHelper(MemberInfos memberInfos, IEnumerable<MTypeDef> allTypes) {
 				this.memberInfos = memberInfos;
 				this.allTypes = allTypes;
 			}
@@ -958,7 +1013,7 @@ namespace de4dot.code.renamer {
 					prepare(typeDef);
 			}
 
-			void prepare(TypeDef type) {
+			void prepare(MTypeDef type) {
 				if (prepareMethodCalled.ContainsKey(type))
 					return;
 				prepareMethodCalled[type] = true;
@@ -976,19 +1031,19 @@ namespace de4dot.code.renamer {
 
 		static List<MethodNameGroup> getSorted(MethodNameGroups groups) {
 			var allGroups = new List<MethodNameGroup>(groups.getAllGroups());
-			allGroups.Sort((a, b) => Utils.compareInt32(b.Count, a.Count));
+			allGroups.Sort((a, b) => b.Count.CompareTo(a.Count));
 			return allGroups;
 		}
 
 		class GroupHelper {
 			MemberInfos memberInfos;
-			Dictionary<TypeDef, bool> visited = new Dictionary<TypeDef, bool>();
-			Dictionary<MethodDef, MethodNameGroup> methodToGroup;
+			Dictionary<MTypeDef, bool> visited = new Dictionary<MTypeDef, bool>();
+			Dictionary<MMethodDef, MethodNameGroup> methodToGroup;
 			List<MethodNameGroup> groups = new List<MethodNameGroup>();
-			IEnumerable<TypeDef> allTypes;
+			IEnumerable<MTypeDef> allTypes;
 			Action<MethodNameGroup> func;
 
-			public GroupHelper(MemberInfos memberInfos, IEnumerable<TypeDef> allTypes) {
+			public GroupHelper(MemberInfos memberInfos, IEnumerable<MTypeDef> allTypes) {
 				this.memberInfos = memberInfos;
 				this.allTypes = allTypes;
 			}
@@ -1001,7 +1056,7 @@ namespace de4dot.code.renamer {
 				this.func = func;
 				visited.Clear();
 
-				methodToGroup = new Dictionary<MethodDef, MethodNameGroup>();
+				methodToGroup = new Dictionary<MMethodDef, MethodNameGroup>();
 				foreach (var group in groups) {
 					foreach (var method in group.Methods)
 						methodToGroup[method] = group;
@@ -1011,7 +1066,7 @@ namespace de4dot.code.renamer {
 					visit(type);
 			}
 
-			void visit(TypeDef type) {
+			void visit(MTypeDef type) {
 				if (visited.ContainsKey(type))
 					return;
 				visited[type] = true;
@@ -1037,17 +1092,17 @@ namespace de4dot.code.renamer {
 		}
 
 		static readonly Regex removeGenericsArityRegex = new Regex(@"`[0-9]+");
-		static string getOverridePrefix(MethodNameGroup group, MethodDef method) {
-			if (method == null || method.MethodDefinition.Overrides.Count == 0)
+		static string getOverridePrefix(MethodNameGroup group, MMethodDef method) {
+			if (method == null || method.MethodDef.Overrides.Count == 0)
 				return "";
 			if (group.Methods.Count > 1) {
 				// Don't use an override prefix if the group has an iface method.
 				foreach (var m in group.Methods) {
-					if (m.Owner.TypeDefinition.IsInterface)
+					if (m.Owner.TypeDef.IsInterface)
 						return "";
 				}
 			}
-			var overrideMethod = method.MethodDefinition.Overrides[0];
+			var overrideMethod = method.MethodDef.Overrides[0].MethodDeclaration;
 			var name = overrideMethod.DeclaringType.FullName.Replace('/', '.');
 			name = removeGenericsArityRegex.Replace(name, "");
 			return name + ".";
@@ -1108,7 +1163,7 @@ namespace de4dot.code.renamer {
 					if (memberInfos.tryGetEvent(overriddenEventDef, out info))
 						oldEventName = getRealName(info.newName);
 					else
-						oldEventName = getRealName(overriddenEventDef.EventDefinition.Name);
+						oldEventName = getRealName(overriddenEventDef.EventDef.Name.String);
 				}
 			}
 
@@ -1134,14 +1189,14 @@ namespace de4dot.code.renamer {
 			return newEventName;
 		}
 
-		EventDef getOverriddenEvent(MethodDef overrideMethod) {
-			MethodDef overriddenMethod;
+		MEventDef getOverriddenEvent(MMethodDef overrideMethod) {
+			MMethodDef overriddenMethod;
 			return getOverriddenEvent(overrideMethod, out overriddenMethod);
 		}
 
-		EventDef getOverriddenEvent(MethodDef overrideMethod, out MethodDef overriddenMethod) {
-			var theMethod = overrideMethod.MethodDefinition.Overrides[0];
-			overriddenMethod = modules.resolve(theMethod);
+		MEventDef getOverriddenEvent(MMethodDef overrideMethod, out MMethodDef overriddenMethod) {
+			var theMethod = overrideMethod.MethodDef.Overrides[0].MethodDeclaration;
+			overriddenMethod = modules.resolveMethod(theMethod);
 			if (overriddenMethod != null)
 				return overriddenMethod.Event;
 
@@ -1151,14 +1206,14 @@ namespace de4dot.code.renamer {
 			var extTypeDef = modules.resolveOther(extType);
 			if (extTypeDef == null)
 				return null;
-			overriddenMethod = extTypeDef.find(theMethod);
+			overriddenMethod = extTypeDef.findMethod(theMethod);
 			if (overriddenMethod != null)
 				return overriddenMethod.Event;
 
 			return null;
 		}
 
-		MethodDef getEventMethod(MethodNameGroup group) {
+		MMethodDef getEventMethod(MethodNameGroup group) {
 			foreach (var method in group.Methods) {
 				if (method.Event != null)
 					return method;
@@ -1218,7 +1273,7 @@ namespace de4dot.code.renamer {
 					if (memberInfos.tryGetProperty(overriddenPropDef, out info))
 						oldPropName = getRealName(info.newName);
 					else
-						oldPropName = getRealName(overriddenPropDef.PropertyDefinition.Name);
+						oldPropName = getRealName(overriddenPropDef.PropertyDef.Name.String);
 				}
 			}
 
@@ -1260,9 +1315,9 @@ namespace de4dot.code.renamer {
 			return false;
 		}
 
-		PropertyDef getOverriddenProperty(MethodDef overrideMethod) {
-			var theMethod = overrideMethod.MethodDefinition.Overrides[0];
-			var overriddenMethod = modules.resolve(theMethod);
+		MPropertyDef getOverriddenProperty(MMethodDef overrideMethod) {
+			var theMethod = overrideMethod.MethodDef.Overrides[0].MethodDeclaration;
+			var overriddenMethod = modules.resolveMethod(theMethod);
 			if (overriddenMethod != null)
 				return overriddenMethod.Property;
 
@@ -1272,14 +1327,14 @@ namespace de4dot.code.renamer {
 			var extTypeDef = modules.resolveOther(extType);
 			if (extTypeDef == null)
 				return null;
-			var theMethodDef = extTypeDef.find(theMethod);
+			var theMethodDef = extTypeDef.findMethod(theMethod);
 			if (theMethodDef != null)
 				return theMethodDef.Property;
 
 			return null;
 		}
 
-		MethodDef getPropertyMethod(MethodNameGroup group) {
+		MMethodDef getPropertyMethod(MethodNameGroup group) {
 			foreach (var method in group.Methods) {
 				if (method.Property != null)
 					return method;
@@ -1305,13 +1360,13 @@ namespace de4dot.code.renamer {
 			if (propType == null)
 				return defaultVal;
 
-			var elementType = propType.GetElementType();
-			if (propType is GenericInstanceType || elementType is GenericParameter)
+			var elementType = propType.ScopeType.ToTypeSig(false).RemovePinnedAndModifiers();
+			if (propType is GenericInstSig || elementType is GenericSig)
 				return defaultVal;
 
 			var prefix = getPrefix(propType);
 
-			string name = elementType.Name;
+			string name = elementType.TypeName;
 			int i;
 			if ((i = name.IndexOf('`')) >= 0)
 				name = name.Substring(0, i);
@@ -1327,10 +1382,11 @@ namespace de4dot.code.renamer {
 			return s.Substring(0, 1).ToUpperInvariant() + s.Substring(1);
 		}
 
-		static string getPrefix(TypeReference typeRef) {
+		static string getPrefix(TypeSig typeRef) {
 			string prefix = "";
-			while (typeRef is PointerType) {
-				typeRef = ((PointerType)typeRef).ElementType;
+			typeRef = typeRef.RemovePinnedAndModifiers();
+			while (typeRef is PtrSig) {
+				typeRef = typeRef.Next;
 				prefix += "p";
 			}
 			return prefix;
@@ -1342,38 +1398,38 @@ namespace de4dot.code.renamer {
 			Setter,
 		}
 
-		static PropertyMethodType getPropertyMethodType(MethodDef method) {
-			if (DotNetUtils.hasReturnValue(method.MethodDefinition))
+		static PropertyMethodType getPropertyMethodType(MMethodDef method) {
+			if (DotNetUtils.hasReturnValue(method.MethodDef))
 				return PropertyMethodType.Getter;
-			if (method.ParamDefs.Count > 0)
+			if (method.VisibleParameterCount > 0)
 				return PropertyMethodType.Setter;
 			return PropertyMethodType.Other;
 		}
 
 		// Returns property type, or null if not all methods have the same type
-		TypeReference getPropertyType(MethodNameGroup group) {
+		TypeSig getPropertyType(MethodNameGroup group) {
 			var methodType = getPropertyMethodType(group.Methods[0]);
 			if (methodType == PropertyMethodType.Other)
 				return null;
 
-			TypeReference type = null;
+			TypeSig type = null;
 			foreach (var propMethod in group.Methods) {
-				TypeReference propType;
+				TypeSig propType;
 				if (methodType == PropertyMethodType.Setter)
-					propType = propMethod.ParamDefs[propMethod.ParamDefs.Count - 1].ParameterDefinition.ParameterType;
+					propType = propMethod.ParamDefs[propMethod.ParamDefs.Count - 1].ParameterDefinition.Type;
 				else
-					propType = propMethod.MethodDefinition.MethodReturnType.ReturnType;
+					propType = propMethod.MethodDef.MethodSig.GetRetType();
 				if (type == null)
 					type = propType;
-				else if (!MemberReferenceHelper.compareTypes(type, propType))
+				else if (!new SigComparer().Equals(type, propType))
 					return null;
 			}
 			return type;
 		}
 
-		MethodDef getOverrideMethod(MethodNameGroup group) {
+		MMethodDef getOverrideMethod(MethodNameGroup group) {
 			foreach (var method in group.Methods) {
-				if (method.MethodDefinition.Overrides.Count > 0)
+				if (method.MethodDef.Overrides.Count > 0)
 					return method;
 			}
 			return null;
@@ -1384,7 +1440,7 @@ namespace de4dot.code.renamer {
 				return;
 
 			if (hasDelegateOwner(group)) {
-				switch (group.Methods[0].MethodDefinition.Name) {
+				switch (group.Methods[0].MethodDef.Name.String) {
 				case "Invoke":
 				case "BeginInvoke":
 				case "EndInvoke":
@@ -1404,7 +1460,7 @@ namespace de4dot.code.renamer {
 				var overrideInfo = memberInfos.method(overrideMethod);
 				var overriddenMethod = getOverriddenMethod(overrideMethod);
 				if (overriddenMethod == null)
-					newMethodName = getRealName(overrideMethod.MethodDefinition.Overrides[0].Name);
+					newMethodName = getRealName(overrideMethod.MethodDef.Overrides[0].MethodDeclaration.Name.String);
 				else
 					newMethodName = getRealName(memberInfos.method(overriddenMethod).newName);
 			}
@@ -1432,7 +1488,7 @@ namespace de4dot.code.renamer {
 		class MergeStateHelper {
 			MemberInfos memberInfos;
 			MergeStateFlags flags;
-			Dictionary<TypeDef, bool> visited = new Dictionary<TypeDef, bool>();
+			Dictionary<MTypeDef, bool> visited = new Dictionary<MTypeDef, bool>();
 
 			public MergeStateHelper(MemberInfos memberInfos) {
 				this.memberInfos = memberInfos;
@@ -1445,7 +1501,7 @@ namespace de4dot.code.renamer {
 					merge(method.Owner);
 			}
 
-			void merge(TypeDef type) {
+			void merge(MTypeDef type) {
 				if (visited.ContainsKey(type))
 					return;
 				visited[type] = true;
@@ -1465,7 +1521,7 @@ namespace de4dot.code.renamer {
 					merge(info, ifaceInfo.typeDef);
 			}
 
-			void merge(TypeInfo info, TypeDef other) {
+			void merge(TypeInfo info, MTypeDef other) {
 				TypeInfo otherInfo;
 				if (!memberInfos.tryGetType(other, out otherInfo))
 					return;
@@ -1479,8 +1535,8 @@ namespace de4dot.code.renamer {
 			}
 		}
 
-		MethodDef getOverriddenMethod(MethodDef overrideMethod) {
-			return modules.resolve(overrideMethod.MethodDefinition.Overrides[0]);
+		MMethodDef getOverriddenMethod(MMethodDef overrideMethod) {
+			return modules.resolveMethod(overrideMethod.MethodDef.Overrides[0].MethodDeclaration);
 		}
 
 		string getSuggestedMethodName(MethodNameGroup group) {
@@ -1544,12 +1600,12 @@ namespace de4dot.code.renamer {
 
 		void prepareRenameEntryPoints() {
 			foreach (var module in modules.TheModules) {
-				var entryPoint = module.ModuleDefinition.EntryPoint;
+				var entryPoint = module.ModuleDefMD.EntryPoint;
 				if (entryPoint == null)
 					continue;
-				var methodDef = modules.resolve(entryPoint);
+				var methodDef = modules.resolveMethod(entryPoint);
 				if (methodDef == null) {
-					Log.w(string.Format("Could not find entry point. Module: {0}, Method: {1}", module.ModuleDefinition.FullyQualifiedName, Utils.removeNewlines(entryPoint)));
+					Logger.w(string.Format("Could not find entry point. Module: {0}, Method: {1}", module.ModuleDefMD.Location, Utils.removeNewlines(entryPoint)));
 					continue;
 				}
 				if (!methodDef.isStatic())
@@ -1557,7 +1613,7 @@ namespace de4dot.code.renamer {
 				memberInfos.method(methodDef).suggestedName = "Main";
 				if (methodDef.ParamDefs.Count == 1) {
 					var paramDef = methodDef.ParamDefs[0];
-					var type = paramDef.ParameterDefinition.ParameterType;
+					var type = paramDef.ParameterDefinition.Type;
 					if (type.FullName == "System.String[]")
 						memberInfos.param(paramDef).newName = "args";
 				}
diff --git a/de4dot.code/renamer/ResourceKeysRenamer.cs b/de4dot.code/renamer/ResourceKeysRenamer.cs
index 6ad77116..32bfee22 100644
--- a/de4dot.code/renamer/ResourceKeysRenamer.cs
+++ b/de4dot.code/renamer/ResourceKeysRenamer.cs
@@ -22,8 +22,9 @@ using System.Collections.Generic;
 using System.IO;
 using System.Text;
 using System.Text.RegularExpressions;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
+using dot10.IO;
 using de4dot.blocks;
 using de4dot.code.resources;
 
@@ -32,33 +33,33 @@ namespace de4dot.code.renamer {
 		const int RESOURCE_KEY_MAX_LEN = 50;
 		const string DEFAULT_KEY_NAME = "Key";
 
-		ModuleDefinition module;
+		ModuleDefMD module;
 		INameChecker nameChecker;
 		Dictionary<string, bool> newNames = new Dictionary<string, bool>();
 
-		public ResourceKeysRenamer(ModuleDefinition module, INameChecker nameChecker) {
+		public ResourceKeysRenamer(ModuleDefMD module, INameChecker nameChecker) {
 			this.module = module;
 			this.nameChecker = nameChecker;
 		}
 
 		public void rename() {
-			Log.v("Renaming resource keys ({0})", module);
-			Log.indent();
+			Logger.v("Renaming resource keys ({0})", module);
+			Logger.Instance.indent();
 			foreach (var type in module.GetTypes()) {
 				string resourceName = getResourceName(type);
 				if (resourceName == null)
 					continue;
 				var resource = getResource(resourceName);
 				if (resource == null) {
-					Log.w("Could not find resource {0}", Utils.removeNewlines(resourceName));
+					Logger.w("Could not find resource {0}", Utils.removeNewlines(resourceName));
 					continue;
 				}
-				Log.v("Resource: {0}", Utils.toCsharpString(resource.Name));
-				Log.indent();
+				Logger.v("Resource: {0}", Utils.toCsharpString(resource.Name));
+				Logger.Instance.indent();
 				rename(type, resource);
-				Log.deIndent();
+				Logger.Instance.deIndent();
 			}
-			Log.deIndent();
+			Logger.Instance.deIndent();
 		}
 
 		EmbeddedResource getResource(string resourceName) {
@@ -78,7 +79,7 @@ namespace de4dot.code.renamer {
 			return null;
 		}
 
-		static string getResourceName(TypeDefinition type) {
+		static string getResourceName(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (method.Body == null)
 					continue;
@@ -92,11 +93,11 @@ namespace de4dot.code.renamer {
 					}
 
 					if (instr.OpCode.Code == Code.Newobj) {
-						var ctor = instr.Operand as MethodReference;
+						var ctor = instr.Operand as IMethod;
 						if (ctor.FullName != "System.Void System.Resources.ResourceManager::.ctor(System.String,System.Reflection.Assembly)")
 							continue;
 						if (resourceName == null) {
-							Log.w("Could not find resource name");
+							Logger.w("Could not find resource name");
 							continue;
 						}
 
@@ -121,9 +122,9 @@ namespace de4dot.code.renamer {
 			}
 		}
 
-		void rename(TypeDefinition type, EmbeddedResource resource) {
+		void rename(TypeDef type, EmbeddedResource resource) {
 			newNames.Clear();
-			var resourceSet = ResourceReader.read(module, resource.GetResourceStream());
+			var resourceSet = ResourceReader.read(module, resource.Data);
 			var renamed = new List<RenameInfo>();
 			foreach (var elem in resourceSet.ResourceElements) {
 				if (nameChecker.isValidResourceKeyName(elem.Name)) {
@@ -141,15 +142,14 @@ namespace de4dot.code.renamer {
 
 			var outStream = new MemoryStream();
 			ResourceWriter.write(module, outStream, resourceSet);
-			outStream.Position = 0;
-			var newResource = new EmbeddedResource(resource.Name, resource.Attributes, outStream);
+			var newResource = new EmbeddedResource(resource.Name, outStream.ToArray(), resource.Attributes);
 			int resourceIndex = module.Resources.IndexOf(resource);
 			if (resourceIndex < 0)
 				throw new ApplicationException("Could not find index of resource");
 			module.Resources[resourceIndex] = newResource;
 		}
 
-		void rename(TypeDefinition type, List<RenameInfo> renamed) {
+		void rename(TypeDef type, List<RenameInfo> renamed) {
 			var nameToInfo = new Dictionary<string, RenameInfo>(StringComparer.Ordinal);
 			foreach (var info in renamed)
 				nameToInfo[info.element.Name] = info;
@@ -163,7 +163,7 @@ namespace de4dot.code.renamer {
 					var call = instrs[i];
 					if (call.OpCode.Code != Code.Call && call.OpCode.Code != Code.Callvirt)
 						continue;
-					var calledMethod = call.Operand as MethodReference;
+					var calledMethod = call.Operand as IMethod;
 					if (calledMethod == null)
 						continue;
 
@@ -190,7 +190,7 @@ namespace de4dot.code.renamer {
 					if (ldstrIndex >= 0)
 						ldstr = instrs[ldstrIndex];
 					if (ldstr == null || (name = ldstr.Operand as string) == null) {
-						Log.w("Could not find string argument to method {0}", calledMethod);
+						Logger.w("Could not find string argument to method {0}", calledMethod);
 						continue;
 					}
 
@@ -199,7 +199,7 @@ namespace de4dot.code.renamer {
 						continue;	// should not be renamed
 
 					ldstr.Operand = info.newName;
-					Log.v("Renamed resource key {0} => {1}", Utils.toCsharpString(info.element.Name), Utils.toCsharpString(info.newName));
+					Logger.v("Renamed resource key {0} => {1}", Utils.toCsharpString(info.element.Name), Utils.toCsharpString(info.newName));
 					info.element.Name = info.newName;
 					info.foundInCode = true;
 				}
@@ -207,7 +207,7 @@ namespace de4dot.code.renamer {
 
 			foreach (var info in renamed) {
 				if (!info.foundInCode)
-					Log.w("Could not find resource key {0} in code", Utils.removeNewlines(info.element.Name));
+					Logger.w("Could not find resource key {0} in code", Utils.removeNewlines(info.element.Name));
 			}
 		}
 
diff --git a/de4dot.code/renamer/ResourceRenamer.cs b/de4dot.code/renamer/ResourceRenamer.cs
index cb92a9c5..42008984 100644
--- a/de4dot.code/renamer/ResourceRenamer.cs
+++ b/de4dot.code/renamer/ResourceRenamer.cs
@@ -19,8 +19,8 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 using de4dot.code.renamer.asmmodules;
 
@@ -36,11 +36,11 @@ namespace de4dot.code.renamer {
 		public void rename(List<TypeInfo> renamedTypes) {
 			// Rename the longest names first. Otherwise eg. b.g.resources could be renamed
 			// Class0.g.resources instead of Class1.resources when b.g was renamed Class1.
-			renamedTypes.Sort((a, b) => Utils.compareInt32(b.oldFullName.Length, a.oldFullName.Length));
+			renamedTypes.Sort((a, b) => b.oldFullName.Length.CompareTo(a.oldFullName.Length));
 
-			nameToResource = new Dictionary<string, Resource>(module.ModuleDefinition.Resources.Count * 3, StringComparer.Ordinal);
-			foreach (var resource in module.ModuleDefinition.Resources) {
-				var name = resource.Name;
+			nameToResource = new Dictionary<string, Resource>(module.ModuleDefMD.Resources.Count * 3, StringComparer.Ordinal);
+			foreach (var resource in module.ModuleDefMD.Resources) {
+				var name = resource.Name.String;
 				nameToResource[name] = resource;
 				if (name.EndsWith(".g.resources"))
 					nameToResource[name.Substring(0, name.Length - 12)] = resource;
@@ -77,15 +77,15 @@ namespace de4dot.code.renamer {
 					TypeInfo typeInfo;
 					if (!oldNameToTypeInfo.TryGetValue(codeString, out typeInfo))
 						continue;
-					var newName = typeInfo.type.TypeDefinition.FullName;
+					var newName = typeInfo.type.TypeDef.FullName;
 
 					bool renameCodeString = module.ObfuscatedFile.RenameResourcesInCode ||
 											isCallingResourceManagerCtor(instrs, i, typeInfo);
 					if (!renameCodeString)
-						Log.v("Possible resource name in code: '{0}' => '{1}' in method {2}", Utils.removeNewlines(codeString), newName, Utils.removeNewlines(method));
+						Logger.v("Possible resource name in code: '{0}' => '{1}' in method {2}", Utils.removeNewlines(codeString), newName, Utils.removeNewlines(method));
 					else {
 						instr.Operand = newName;
-						Log.v("Renamed resource string in code: '{0}' => '{1}' ({2})", Utils.removeNewlines(codeString), newName, Utils.removeNewlines(method));
+						Logger.v("Renamed resource string in code: '{0}' => '{1}' ({2})", Utils.removeNewlines(codeString), newName, Utils.removeNewlines(method));
 					}
 				}
 			}
@@ -98,7 +98,7 @@ namespace de4dot.code.renamer {
 				var ldtoken = instrs[index++];
 				if (ldtoken.OpCode.Code != Code.Ldtoken)
 					return false;
-				if (!MemberReferenceHelper.compareTypes(typeInfo.type.TypeDefinition, ldtoken.Operand as TypeReference))
+				if (!new SigComparer().Equals(typeInfo.type.TypeDef, ldtoken.Operand as ITypeDefOrRef))
 					return false;
 
 				if (!checkCalledMethod(instrs[index++], "System.Type", "(System.RuntimeTypeHandle)"))
@@ -125,7 +125,7 @@ namespace de4dot.code.renamer {
 		static bool checkCalledMethod(Instruction instr, string returnType, string parameters) {
 			if (instr.OpCode.Code != Code.Call && instr.OpCode.Code != Code.Callvirt)
 				return false;
-			return DotNetUtils.isMethod(instr.Operand as MethodReference, returnType, parameters);
+			return DotNetUtils.isMethod(instr.Operand as IMethod, returnType, parameters);
 		}
 
 		class RenameInfo {
@@ -151,12 +151,12 @@ namespace de4dot.code.renamer {
 					continue;
 				if (newNames.ContainsKey(resource))
 					continue;
-				var newTypeName = info.type.TypeDefinition.FullName;
-				var newName = newTypeName + resource.Name.Substring(oldFullName.Length);
+				var newTypeName = info.type.TypeDef.FullName;
+				var newName = newTypeName + resource.Name.String.Substring(oldFullName.Length);
 				newNames[resource] = new RenameInfo(resource, info, newName);
 
-				Log.v("Renamed resource in resources: {0} => {1}", Utils.removeNewlines(resource.Name), newName);
-				resource.Name = newName;
+				Logger.v("Renamed resource in resources: {0} => {1}", Utils.removeNewlines(resource.Name), newName);
+				resource.Name = new UTF8String(newName);
 			}
 		}
 	}
diff --git a/de4dot.code/renamer/TypeInfo.cs b/de4dot.code/renamer/TypeInfo.cs
index ff0d1b19..111da10b 100644
--- a/de4dot.code/renamer/TypeInfo.cs
+++ b/de4dot.code/renamer/TypeInfo.cs
@@ -20,8 +20,8 @@
 using System;
 using System.Collections.Generic;
 using System.Text.RegularExpressions;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.code.renamer.asmmodules;
 using de4dot.blocks;
 
@@ -30,45 +30,45 @@ namespace de4dot.code.renamer {
 		public string oldNamespace;
 		public string newNamespace;
 		public VariableNameState variableNameState = VariableNameState.create();
-		public TypeDef type;
+		public MTypeDef type;
 		MemberInfos memberInfos;
 
 		public INameChecker NameChecker {
 			get { return type.Module.ObfuscatedFile.NameChecker; }
 		}
 
-		public TypeInfo(TypeDef typeDef, MemberInfos memberInfos)
+		public TypeInfo(MTypeDef typeDef, MemberInfos memberInfos)
 			: base(typeDef) {
 			this.type = typeDef;
 			this.memberInfos = memberInfos;
-			oldNamespace = typeDef.TypeDefinition.Namespace;
+			oldNamespace = typeDef.TypeDef.Namespace.String;
 		}
 
 		bool isWinFormsClass() {
 			return memberInfos.isWinFormsClass(type);
 		}
 
-		public PropertyInfo prop(PropertyDef prop) {
+		public PropertyInfo prop(MPropertyDef prop) {
 			return memberInfos.prop(prop);
 		}
 
-		public EventInfo evt(EventDef evt) {
+		public EventInfo evt(MEventDef evt) {
 			return memberInfos.evt(evt);
 		}
 
-		public FieldInfo field(FieldDef field) {
+		public FieldInfo field(MFieldDef field) {
 			return memberInfos.field(field);
 		}
 
-		public MethodInfo method(MethodDef method) {
+		public MethodInfo method(MMethodDef method) {
 			return memberInfos.method(method);
 		}
 
-		public GenericParamInfo gparam(GenericParamDef gparam) {
+		public GenericParamInfo gparam(MGenericParamDef gparam) {
 			return memberInfos.gparam(gparam);
 		}
 
-		public ParamInfo param(ParamDef param) {
+		public ParamInfo param(MParamDef param) {
 			return memberInfos.param(param);
 		}
 
@@ -82,17 +82,17 @@ namespace de4dot.code.renamer {
 		}
 
 		bool isModuleType() {
-			return type.TypeDefinition == DotNetUtils.getModuleType(type.TypeDefinition.Module);
+			return type.TypeDef.IsGlobalModuleType;
 		}
 
 		public void prepareRenameTypes(TypeRenamerState state) {
 			var checker = NameChecker;
 
 			if (newNamespace == null && oldNamespace != "") {
-				if (type.TypeDefinition.IsNested)
+				if (type.TypeDef.IsNested)
 					newNamespace = "";
 				else if (!checker.isValidNamespaceName(oldNamespace))
-					newNamespace = state.createNamespace(this.type.TypeDefinition, oldNamespace);
+					newNamespace = state.createNamespace(this.type.TypeDef, oldNamespace);
 			}
 
 			string origClassName = null;
@@ -114,7 +114,7 @@ namespace de4dot.code.renamer {
 					TypeInfo baseInfo = getBase();
 					if (baseInfo != null && baseInfo.renamed)
 						newBaseType = baseInfo.newName;
-					rename(nameCreator.create(type.TypeDefinition, newBaseType));
+					rename(nameCreator.create(type.TypeDef, newBaseType));
 				}
 			}
 
@@ -128,7 +128,7 @@ namespace de4dot.code.renamer {
 				mergeState(type.baseType.typeDef);
 		}
 
-		void mergeState(TypeDef other) {
+		void mergeState(MTypeDef other) {
 			if (other == null)
 				return;
 			TypeInfo otherInfo;
@@ -164,7 +164,7 @@ namespace de4dot.code.renamer {
 		void prepareRenameFields() {
 			var checker = NameChecker;
 
-			if (type.TypeDefinition.IsEnum) {
+			if (type.TypeDef.IsEnum) {
 				var instanceFields = getInstanceFields();
 				if (instanceFields.Count == 1)
 					field(instanceFields[0]).rename("value__");
@@ -175,7 +175,7 @@ namespace de4dot.code.renamer {
 					var fieldInfo = field(fieldDef);
 					if (fieldInfo.renamed)
 						continue;
-					if (!fieldDef.FieldDefinition.IsStatic || !fieldDef.FieldDefinition.IsLiteral)
+					if (!fieldDef.FieldDef.IsStatic || !fieldDef.FieldDef.IsLiteral)
 						continue;
 					if (!checker.isValidFieldName(fieldInfo.oldName))
 						fieldInfo.rename(string.Format(nameFormat, i));
@@ -187,21 +187,21 @@ namespace de4dot.code.renamer {
 				if (fieldInfo.renamed)
 					continue;
 				if (!checker.isValidFieldName(fieldInfo.oldName))
-					fieldInfo.rename(fieldInfo.suggestedName ?? variableNameState.getNewFieldName(fieldDef.FieldDefinition));
+					fieldInfo.rename(fieldInfo.suggestedName ?? variableNameState.getNewFieldName(fieldDef.FieldDef));
 			}
 		}
 
-		List<FieldDef> getInstanceFields() {
-			var fields = new List<FieldDef>();
+		List<MFieldDef> getInstanceFields() {
+			var fields = new List<MFieldDef>();
 			foreach (var fieldDef in type.AllFields) {
-				if (!fieldDef.FieldDefinition.IsStatic)
+				if (!fieldDef.FieldDef.IsStatic)
 					fields.Add(fieldDef);
 			}
 			return fields;
 		}
 
 		bool hasFlagsAttribute() {
-			foreach (var attr in type.TypeDefinition.CustomAttributes) {
+			foreach (var attr in type.TypeDef.CustomAttributes) {
 				if (attr.AttributeType.FullName == "System.FlagsAttribute")
 					return true;
 			}
@@ -216,7 +216,7 @@ namespace de4dot.code.renamer {
 			}
 		}
 
-		void prepareRenameProperty(PropertyDef propDef) {
+		void prepareRenameProperty(MPropertyDef propDef) {
 			if (propDef.isVirtual())
 				throw new ApplicationException("Can't rename virtual props here");
 			var propInfo = prop(propDef);
@@ -230,7 +230,7 @@ namespace de4dot.code.renamer {
 				if (propDef.isItemProperty())
 					propName = "Item";
 				else
-					propName = variableNameState.getNewPropertyName(propDef.PropertyDefinition);
+					propName = variableNameState.getNewPropertyName(propDef.PropertyDef);
 			}
 			variableNameState.addPropertyName(propName);
 			propInfo.rename(propName);
@@ -247,7 +247,7 @@ namespace de4dot.code.renamer {
 			}
 		}
 
-		void prepareRenameEvent(EventDef eventDef) {
+		void prepareRenameEvent(MEventDef eventDef) {
 			if (eventDef.isVirtual())
 				throw new ApplicationException("Can't rename virtual events here");
 			var eventInfo = evt(eventDef);
@@ -258,7 +258,7 @@ namespace de4dot.code.renamer {
 			if (!NameChecker.isValidEventName(eventName))
 				eventName = eventInfo.suggestedName;
 			if (!NameChecker.isValidEventName(eventName))
-				eventName = variableNameState.getNewEventName(eventDef.EventDefinition);
+				eventName = variableNameState.getNewEventName(eventDef.EventDef);
 			variableNameState.addEventName(eventName);
 			eventInfo.rename(eventName);
 
@@ -267,7 +267,7 @@ namespace de4dot.code.renamer {
 			renameSpecialMethod(eventDef.RaiseMethod, "raise_" + eventName);
 		}
 
-		void renameSpecialMethod(MethodDef methodDef, string newName) {
+		void renameSpecialMethod(MMethodDef methodDef, string newName) {
 			if (methodDef == null)
 				return;
 			if (methodDef.isVirtual())
@@ -292,24 +292,26 @@ namespace de4dot.code.renamer {
 			}
 		}
 
-		void prepareRenameMethodArgs(MethodDef methodDef) {
-			if (methodDef.ParamDefs.Count > 0) {
+		void prepareRenameMethodArgs(MMethodDef methodDef) {
+			VariableNameState newVariableNameState = null;
+			ParamInfo info;
+			if (methodDef.VisibleParameterCount > 0) {
 				if (isEventHandler(methodDef)) {
-					ParamInfo info;
-
-					info = param(methodDef.ParamDefs[0]);
+					info = param(methodDef.ParamDefs[methodDef.VisibleParameterBaseIndex]);
 					if (!info.gotNewName())
 						info.newName = "sender";
 
-					info = param(methodDef.ParamDefs[1]);
+					info = param(methodDef.ParamDefs[methodDef.VisibleParameterBaseIndex + 1]);
 					if (!info.gotNewName())
 						info.newName = "e";
 				}
 				else {
-					var newVariableNameState = variableNameState.cloneParamsOnly();
+					newVariableNameState = variableNameState.cloneParamsOnly();
 					var checker = NameChecker;
 					foreach (var paramDef in methodDef.ParamDefs) {
-						var info = param(paramDef);
+						if (paramDef.IsHiddenThisParameter)
+							continue;
+						info = param(paramDef);
 						if (info.gotNewName())
 							continue;
 						if (!checker.isValidMethodArgName(info.oldName))
@@ -318,23 +320,32 @@ namespace de4dot.code.renamer {
 				}
 			}
 
+			info = param(methodDef.ReturnParamDef);
+			if (!info.gotNewName()) {
+				if (!NameChecker.isValidMethodReturnArgName(info.oldName)) {
+					if (newVariableNameState == null)
+						newVariableNameState = variableNameState.cloneParamsOnly();
+					info.newName = newVariableNameState.getNewParamName(info.oldName, methodDef.ReturnParamDef.ParameterDefinition);
+				}
+			}
+
 			if ((methodDef.Property != null && methodDef == methodDef.Property.SetMethod) ||
 				(methodDef.Event != null && (methodDef == methodDef.Event.AddMethod || methodDef == methodDef.Event.RemoveMethod))) {
-				if (methodDef.ParamDefs.Count > 0) {
+				if (methodDef.VisibleParameterCount > 0) {
 					var paramDef = methodDef.ParamDefs[methodDef.ParamDefs.Count - 1];
 					param(paramDef).newName = "value";
 				}
 			}
 		}
 
-		bool canRenameMethod(MethodDef methodDef) {
+		bool canRenameMethod(MMethodDef methodDef) {
 			var methodInfo = method(methodDef);
 			if (methodDef.isStatic()) {
 				if (methodInfo.oldName == ".cctor")
 					return false;
 			}
 			else if (methodDef.isVirtual()) {
-				if (DotNetUtils.derivesFromDelegate(type.TypeDefinition)) {
+				if (DotNetUtils.derivesFromDelegate(type.TypeDef)) {
 					switch (methodInfo.oldName) {
 					case "BeginInvoke":
 					case "EndInvoke":
@@ -350,7 +361,7 @@ namespace de4dot.code.renamer {
 			return true;
 		}
 
-		public void renameMethod(MethodDef methodDef, string methodName) {
+		public void renameMethod(MMethodDef methodDef, string methodName) {
 			if (!canRenameMethod(methodDef))
 				return;
 			var methodInfo = method(methodDef);
@@ -358,7 +369,7 @@ namespace de4dot.code.renamer {
 			methodInfo.rename(methodName);
 		}
 
-		void renameMethod(MethodDef methodDef) {
+		void renameMethod(MMethodDef methodDef) {
 			if (methodDef.isVirtual())
 				throw new ApplicationException("Can't rename virtual methods here");
 			if (!canRenameMethod(methodDef))
@@ -371,45 +382,49 @@ namespace de4dot.code.renamer {
 			var checker = NameChecker;
 
 			// PInvoke methods' EntryPoint is always valid. It has to, so always rename.
-			if (!NameChecker.isValidMethodName(info.oldName) || methodDef.MethodDefinition.PInvokeInfo != null) {
+			bool isValidName = NameChecker.isValidMethodName(info.oldName);
+			bool isExternPInvoke = methodDef.MethodDef.ImplMap != null && methodDef.MethodDef.RVA == 0;
+			if (!isValidName || isExternPInvoke) {
 				INameCreator nameCreator = null;
 				string newName = info.suggestedName;
-				if (methodDef.MethodDefinition.PInvokeInfo != null)
-					newName = getPinvokeName(methodDef);
+				string newName2;
+				if (methodDef.MethodDef.ImplMap != null && !string.IsNullOrEmpty(newName2 = getPinvokeName(methodDef)))
+					newName = newName2;
 				else if (methodDef.isStatic())
 					nameCreator = variableNameState.staticMethodNameCreator;
 				else
 					nameCreator = variableNameState.instanceMethodNameCreator;
-				if (newName != null)
+				if (!string.IsNullOrEmpty(newName))
 					nameCreator = new NameCreator2(newName);
 				renameMethod(methodDef, variableNameState.getNewMethodName(info.oldName, nameCreator));
 			}
 		}
 
-		string getPinvokeName(MethodDef methodDef) {
-			var entryPoint = methodDef.MethodDefinition.PInvokeInfo.EntryPoint;
+		string getPinvokeName(MMethodDef methodDef) {
+			var entryPoint = methodDef.MethodDef.ImplMap.Name.String;
 			if (Regex.IsMatch(entryPoint, @"^#\d+$"))
-				entryPoint = DotNetUtils.getDllName(methodDef.MethodDefinition.PInvokeInfo.Module.Name) + "_" + entryPoint.Substring(1);
+				entryPoint = DotNetUtils.getDllName(methodDef.MethodDef.ImplMap.Module.Name.String) + "_" + entryPoint.Substring(1);
 			return entryPoint;
 		}
 
-		static bool isEventHandler(MethodDef methodDef) {
-			if (methodDef.MethodDefinition.Parameters.Count != 2)
+		static bool isEventHandler(MMethodDef methodDef) {
+			var sig = methodDef.MethodDef.MethodSig;
+			if (sig == null || sig.Params.Count != 2)
 				return false;
-			if (methodDef.MethodDefinition.MethodReturnType.ReturnType.FullName != "System.Void")
+			if (sig.RetType.ElementType != ElementType.Void)
 				return false;
-			if (methodDef.MethodDefinition.Parameters[0].ParameterType.FullName != "System.Object")
+			if (sig.Params[0].ElementType != ElementType.Object)
 				return false;
-			if (!methodDef.MethodDefinition.Parameters[1].ParameterType.FullName.Contains("EventArgs"))
+			if (!sig.Params[1].FullName.Contains("EventArgs"))
 				return false;
 			return true;
 		}
 
-		void prepareRenameGenericParams(IEnumerable<GenericParamDef> genericParams, INameChecker checker) {
+		void prepareRenameGenericParams(IEnumerable<MGenericParamDef> genericParams, INameChecker checker) {
 			prepareRenameGenericParams(genericParams, checker, null);
 		}
 
-		void prepareRenameGenericParams(IEnumerable<GenericParamDef> genericParams, INameChecker checker, IEnumerable<GenericParamDef> otherGenericParams) {
+		void prepareRenameGenericParams(IEnumerable<MGenericParamDef> genericParams, INameChecker checker, IEnumerable<MGenericParamDef> otherGenericParams) {
 			var usedNames = new Dictionary<string, bool>(StringComparer.Ordinal);
 			var nameCreator = new GenericParamNameCreator();
 
@@ -436,24 +451,24 @@ namespace de4dot.code.renamer {
 		void initializeWindowsFormsFieldsAndProps() {
 			var checker = NameChecker;
 
-			var ourFields = new FieldDefinitionAndDeclaringTypeDict<FieldDef>();
+			var ourFields = new FieldDefinitionAndDeclaringTypeDict<MFieldDef>();
 			foreach (var fieldDef in type.AllFields)
-				ourFields.add(fieldDef.FieldDefinition, fieldDef);
-			var ourMethods = new MethodDefinitionAndDeclaringTypeDict<MethodDef>();
+				ourFields.add(fieldDef.FieldDef, fieldDef);
+			var ourMethods = new MethodDefinitionAndDeclaringTypeDict<MMethodDef>();
 			foreach (var methodDef in type.AllMethods)
-				ourMethods.add(methodDef.MethodDefinition, methodDef);
+				ourMethods.add(methodDef.MethodDef, methodDef);
 
 			foreach (var methodDef in type.AllMethods) {
-				if (methodDef.MethodDefinition.Body == null)
+				if (methodDef.MethodDef.Body == null)
 					continue;
-				if (methodDef.MethodDefinition.IsStatic || methodDef.MethodDefinition.IsVirtual)
+				if (methodDef.MethodDef.IsStatic || methodDef.MethodDef.IsVirtual)
 					continue;
-				var instructions = methodDef.MethodDefinition.Body.Instructions;
+				var instructions = methodDef.MethodDef.Body.Instructions;
 				for (int i = 2; i < instructions.Count; i++) {
 					var call = instructions[i];
 					if (call.OpCode.Code != Code.Call && call.OpCode.Code != Code.Callvirt)
 						continue;
-					if (!isWindowsFormsSetNameMethod(call.Operand as MethodReference))
+					if (!isWindowsFormsSetNameMethod(call.Operand as IMethod))
 						continue;
 
 					var ldstr = instructions[i - 1];
@@ -464,15 +479,15 @@ namespace de4dot.code.renamer {
 						continue;
 
 					var instr = instructions[i - 2];
-					FieldReference fieldRef = null;
+					IField fieldRef = null;
 					if (instr.OpCode.Code == Code.Call || instr.OpCode.Code == Code.Callvirt) {
-						var calledMethod = instr.Operand as MethodReference;
+						var calledMethod = instr.Operand as IMethod;
 						if (calledMethod == null)
 							continue;
 						var calledMethodDef = ourMethods.find(calledMethod);
 						if (calledMethodDef == null)
 							continue;
-						fieldRef = getFieldReference(calledMethodDef.MethodDefinition);
+						fieldRef = getFieldReference(calledMethodDef.MethodDef);
 
 						var propDef = calledMethodDef.Property;
 						if (propDef == null)
@@ -482,7 +497,7 @@ namespace de4dot.code.renamer {
 						fieldName = "_" + fieldName;
 					}
 					else if (instr.OpCode.Code == Code.Ldfld) {
-						fieldRef = instr.Operand as FieldReference;
+						fieldRef = instr.Operand as IField;
 					}
 
 					if (fieldRef == null)
@@ -500,13 +515,13 @@ namespace de4dot.code.renamer {
 			}
 		}
 
-		static FieldReference getFieldReference(MethodDefinition method) {
+		static IField getFieldReference(MethodDef method) {
 			if (method == null || method.Body == null)
 				return null;
 			var instructions = method.Body.Instructions;
 			int index = 0;
 			var ldarg0 = DotNetUtils.getInstruction(instructions, ref index);
-			if (ldarg0 == null || DotNetUtils.getArgIndex(ldarg0) != 0)
+			if (ldarg0 == null || ldarg0.GetParameterIndex() != 0)
 				return null;
 			var ldfld = DotNetUtils.getInstruction(instructions, ref index);
 			if (ldfld == null || ldfld.OpCode.Code != Code.Ldfld)
@@ -514,27 +529,27 @@ namespace de4dot.code.renamer {
 			var ret = DotNetUtils.getInstruction(instructions, ref index);
 			if (ret == null)
 				return null;
-			if (DotNetUtils.isStloc(ret)) {
-				var local = DotNetUtils.getLocalVar(method.Body.Variables, ret);
+			if (ret.IsStloc()) {
+				var local = ret.GetLocal(method.Body.LocalList);
 				ret = DotNetUtils.getInstruction(instructions, ref index);
-				if (ret == null || !DotNetUtils.isLdloc(ret))
+				if (ret == null || !ret.IsLdloc())
 					return null;
-				if (DotNetUtils.getLocalVar(method.Body.Variables, ret) != local)
+				if (ret.GetLocal(method.Body.LocalList) != local)
 					return null;
 				ret = DotNetUtils.getInstruction(instructions, ref index);
 			}
 			if (ret == null || ret.OpCode.Code != Code.Ret)
 				return null;
-			return ldfld.Operand as FieldReference;
+			return ldfld.Operand as IField;
 		}
 
 		public void initializeEventHandlerNames() {
-			var ourFields = new FieldDefinitionAndDeclaringTypeDict<FieldDef>();
+			var ourFields = new FieldDefinitionAndDeclaringTypeDict<MFieldDef>();
 			foreach (var fieldDef in type.AllFields)
-				ourFields.add(fieldDef.FieldDefinition, fieldDef);
-			var ourMethods = new MethodDefinitionAndDeclaringTypeDict<MethodDef>();
+				ourFields.add(fieldDef.FieldDef, fieldDef);
+			var ourMethods = new MethodDefinitionAndDeclaringTypeDict<MMethodDef>();
 			foreach (var methodDef in type.AllMethods)
-				ourMethods.add(methodDef.MethodDefinition, methodDef);
+				ourMethods.add(methodDef.MethodDef, methodDef);
 
 			initVbEventHandlers(ourFields, ourMethods);
 			initFieldEventHandlers(ourFields, ourMethods);
@@ -543,7 +558,7 @@ namespace de4dot.code.renamer {
 
 		// VB initializes the handlers in the property setter, where it first removes the handler
 		// from the previous control, and then adds the handler to the new control.
-		void initVbEventHandlers(FieldDefinitionAndDeclaringTypeDict<FieldDef> ourFields, MethodDefinitionAndDeclaringTypeDict<MethodDef> ourMethods) {
+		void initVbEventHandlers(FieldDefinitionAndDeclaringTypeDict<MFieldDef> ourFields, MethodDefinitionAndDeclaringTypeDict<MMethodDef> ourMethods) {
 			var checker = NameChecker;
 
 			foreach (var propDef in type.AllProperties) {
@@ -552,7 +567,7 @@ namespace de4dot.code.renamer {
 					continue;
 
 				string eventName;
-				var handler = getVbHandler(setterDef.MethodDefinition, out eventName);
+				var handler = getVbHandler(setterDef.MethodDef, out eventName);
 				if (handler == null)
 					continue;
 				var handlerDef = ourMethods.find(handler);
@@ -566,17 +581,20 @@ namespace de4dot.code.renamer {
 			}
 		}
 
-		static MethodReference getVbHandler(MethodDefinition method, out string eventName) {
+		static IMethod getVbHandler(MethodDef method, out string eventName) {
 			eventName = null;
 			if (method.Body == null)
 				return null;
-			if (method.MethodReturnType.ReturnType.FullName != "System.Void")
+			var sig = method.MethodSig;
+			if (sig == null)
 				return null;
-			if (method.Parameters.Count != 1)
+			if (sig.RetType.ElementType != ElementType.Void)
 				return null;
-			if (method.Body.Variables.Count != 1)
+			if (sig.Params.Count != 1)
 				return null;
-			if (!isEventHandlerType(method.Body.Variables[0].VariableType))
+			if (method.Body.LocalList.Count != 1)
+				return null;
+			if (!isEventHandlerType(method.Body.LocalList[0].Type))
 				return null;
 
 			var instructions = method.Body.Instructions;
@@ -585,22 +603,22 @@ namespace de4dot.code.renamer {
 			int newobjIndex = findInstruction(instructions, index, Code.Newobj);
 			if (newobjIndex == -1 || findInstruction(instructions, newobjIndex + 1, Code.Newobj) != -1)
 				return null;
-			if (!isEventHandlerCtor(instructions[newobjIndex].Operand as MethodReference))
+			if (!isEventHandlerCtor(instructions[newobjIndex].Operand as IMethod))
 				return null;
 			if (newobjIndex < 1)
 				return null;
 			var ldvirtftn = instructions[newobjIndex - 1];
 			if (ldvirtftn.OpCode.Code != Code.Ldvirtftn && ldvirtftn.OpCode.Code != Code.Ldftn)
 				return null;
-			var handlerMethod = ldvirtftn.Operand as MethodReference;
+			var handlerMethod = ldvirtftn.Operand as IMethod;
 			if (handlerMethod == null)
 				return null;
-			if (!MemberReferenceHelper.compareTypes(method.DeclaringType, handlerMethod.DeclaringType))
+			if (!new SigComparer().Equals(method.DeclaringType, handlerMethod.DeclaringType))
 				return null;
 			index = newobjIndex;
 
-			FieldReference addField, removeField;
-			MethodReference addMethod, removeMethod;
+			IField addField, removeField;
+			IMethod addMethod, removeMethod;
 			if (!findEventCall(instructions, ref index, out removeField, out removeMethod))
 				return null;
 			if (!findEventCall(instructions, ref index, out addField, out addMethod))
@@ -608,18 +626,18 @@ namespace de4dot.code.renamer {
 
 			if (findInstruction(instructions, index, Code.Callvirt) != -1)
 				return null;
-			if (!MemberReferenceHelper.compareFieldReference(addField, removeField))
+			if (!new SigComparer().Equals(addField, removeField))
 				return null;
-			if (!MemberReferenceHelper.compareTypes(method.DeclaringType, addField.DeclaringType))
+			if (!new SigComparer().Equals(method.DeclaringType, addField.DeclaringType))
 				return null;
-			if (!MemberReferenceHelper.compareTypes(addMethod.DeclaringType, removeMethod.DeclaringType))
+			if (!new SigComparer().Equals(addMethod.DeclaringType, removeMethod.DeclaringType))
 				return null;
-			if (!Utils.StartsWith(addMethod.Name, "add_", StringComparison.Ordinal))
+			if (!Utils.StartsWith(addMethod.Name.String, "add_", StringComparison.Ordinal))
 				return null;
-			if (!Utils.StartsWith(removeMethod.Name, "remove_", StringComparison.Ordinal))
+			if (!Utils.StartsWith(removeMethod.Name.String, "remove_", StringComparison.Ordinal))
 				return null;
-			eventName = addMethod.Name.Substring(4);
-			if (eventName != removeMethod.Name.Substring(7))
+			eventName = addMethod.Name.String.Substring(4);
+			if (eventName != removeMethod.Name.String.Substring(7))
 				return null;
 			if (eventName == "")
 				return null;
@@ -627,7 +645,7 @@ namespace de4dot.code.renamer {
 			return handlerMethod;
 		}
 
-		static bool findEventCall(IList<Instruction> instructions, ref int index, out FieldReference field, out MethodReference calledMethod) {
+		static bool findEventCall(IList<Instruction> instructions, ref int index, out IField field, out IMethod calledMethod) {
 			field = null;
 			calledMethod = null;
 
@@ -644,8 +662,8 @@ namespace de4dot.code.renamer {
 			if (ldfld.OpCode.Code != Code.Ldfld)
 				return false;
 
-			field = ldfld.Operand as FieldReference;
-			calledMethod = instructions[callvirt].Operand as MethodReference;
+			field = ldfld.Operand as IField;
+			calledMethod = instructions[callvirt].Operand as IMethod;
 			return field != null && calledMethod != null;
 		}
 
@@ -657,15 +675,15 @@ namespace de4dot.code.renamer {
 			return -1;
 		}
 
-		void initFieldEventHandlers(FieldDefinitionAndDeclaringTypeDict<FieldDef> ourFields, MethodDefinitionAndDeclaringTypeDict<MethodDef> ourMethods) {
+		void initFieldEventHandlers(FieldDefinitionAndDeclaringTypeDict<MFieldDef> ourFields, MethodDefinitionAndDeclaringTypeDict<MMethodDef> ourMethods) {
 			var checker = NameChecker;
 
 			foreach (var methodDef in type.AllMethods) {
-				if (methodDef.MethodDefinition.Body == null)
+				if (methodDef.MethodDef.Body == null)
 					continue;
-				if (methodDef.MethodDefinition.IsStatic)
+				if (methodDef.MethodDef.IsStatic)
 					continue;
-				var instructions = methodDef.MethodDefinition.Body.Instructions;
+				var instructions = methodDef.MethodDef.Body.Instructions;
 				for (int i = 0; i < instructions.Count - 6; i++) {
 					// We're looking for this code pattern:
 					//	ldarg.0
@@ -675,36 +693,36 @@ namespace de4dot.code.renamer {
 					//	newobj event_handler_ctor
 					//	callvirt add_SomeEvent
 
-					if (DotNetUtils.getArgIndex(instructions[i]) != 0)
+					if (instructions[i].GetParameterIndex() != 0)
 						continue;
 					int index = i + 1;
 
 					var ldfld = instructions[index++];
 					if (ldfld.OpCode.Code != Code.Ldfld)
 						continue;
-					var fieldRef = ldfld.Operand as FieldReference;
+					var fieldRef = ldfld.Operand as IField;
 					if (fieldRef == null)
 						continue;
 					var fieldDef = ourFields.find(fieldRef);
 					if (fieldDef == null)
 						continue;
 
-					if (DotNetUtils.getArgIndex(instructions[index++]) != 0)
+					if (instructions[index++].GetParameterIndex() != 0)
 						continue;
 
-					MethodReference methodRef;
+					IMethod methodRef;
 					var instr = instructions[index + 1];
 					if (instr.OpCode.Code == Code.Ldvirtftn) {
 						if (!isThisOrDup(instructions[index++]))
 							continue;
 						var ldvirtftn = instructions[index++];
-						methodRef = ldvirtftn.Operand as MethodReference;
+						methodRef = ldvirtftn.Operand as IMethod;
 					}
 					else {
 						var ldftn = instructions[index++];
 						if (ldftn.OpCode.Code != Code.Ldftn)
 							continue;
-						methodRef = ldftn.Operand as MethodReference;
+						methodRef = ldftn.Operand as IMethod;
 					}
 					if (methodRef == null)
 						continue;
@@ -715,19 +733,19 @@ namespace de4dot.code.renamer {
 					var newobj = instructions[index++];
 					if (newobj.OpCode.Code != Code.Newobj)
 						continue;
-					if (!isEventHandlerCtor(newobj.Operand as MethodReference))
+					if (!isEventHandlerCtor(newobj.Operand as IMethod))
 						continue;
 
 					var call = instructions[index++];
 					if (call.OpCode.Code != Code.Call && call.OpCode.Code != Code.Callvirt)
 						continue;
-					var addHandler = call.Operand as MethodReference;
+					var addHandler = call.Operand as IMethod;
 					if (addHandler == null)
 						continue;
-					if (!Utils.StartsWith(addHandler.Name, "add_", StringComparison.Ordinal))
+					if (!Utils.StartsWith(addHandler.Name.String, "add_", StringComparison.Ordinal))
 						continue;
 
-					var eventName = addHandler.Name.Substring(4);
+					var eventName = addHandler.Name.String.Substring(4);
 					if (!checker.isValidEventName(eventName))
 						continue;
 
@@ -736,15 +754,15 @@ namespace de4dot.code.renamer {
 			}
 		}
 
-		void initTypeEventHandlers(FieldDefinitionAndDeclaringTypeDict<FieldDef> ourFields, MethodDefinitionAndDeclaringTypeDict<MethodDef> ourMethods) {
+		void initTypeEventHandlers(FieldDefinitionAndDeclaringTypeDict<MFieldDef> ourFields, MethodDefinitionAndDeclaringTypeDict<MMethodDef> ourMethods) {
 			var checker = NameChecker;
 
 			foreach (var methodDef in type.AllMethods) {
-				if (methodDef.MethodDefinition.Body == null)
+				if (methodDef.MethodDef.Body == null)
 					continue;
-				if (methodDef.MethodDefinition.IsStatic)
+				if (methodDef.MethodDef.IsStatic)
 					continue;
-				var method = methodDef.MethodDefinition;
+				var method = methodDef.MethodDef;
 				var instructions = method.Body.Instructions;
 				for (int i = 0; i < instructions.Count - 5; i++) {
 					// ldarg.0
@@ -754,15 +772,15 @@ namespace de4dot.code.renamer {
 					// newobj event handler ctor
 					// call add_Xyz
 
-					if (DotNetUtils.getArgIndex(instructions[i]) != 0)
+					if (instructions[i].GetParameterIndex() != 0)
 						continue;
 					int index = i + 1;
 
 					if (!isThisOrDup(instructions[index++]))
 						continue;
-					MethodReference handler;
+					IMethod handler;
 					if (instructions[index].OpCode.Code == Code.Ldftn) {
-						handler = instructions[index++].Operand as MethodReference;
+						handler = instructions[index++].Operand as IMethod;
 					}
 					else {
 						if (!isThisOrDup(instructions[index++]))
@@ -770,7 +788,7 @@ namespace de4dot.code.renamer {
 						var instr = instructions[index++];
 						if (instr.OpCode.Code != Code.Ldvirtftn)
 							continue;
-						handler = instr.Operand as MethodReference;
+						handler = instr.Operand as IMethod;
 					}
 					if (handler == null)
 						continue;
@@ -781,19 +799,19 @@ namespace de4dot.code.renamer {
 					var newobj = instructions[index++];
 					if (newobj.OpCode.Code != Code.Newobj)
 						continue;
-					if (!isEventHandlerCtor(newobj.Operand as MethodReference))
+					if (!isEventHandlerCtor(newobj.Operand as IMethod))
 						continue;
 
 					var call = instructions[index++];
 					if (call.OpCode.Code != Code.Call && call.OpCode.Code != Code.Callvirt)
 						continue;
-					var addMethod = call.Operand as MethodReference;
+					var addMethod = call.Operand as IMethod;
 					if (addMethod == null)
 						continue;
-					if (!Utils.StartsWith(addMethod.Name, "add_", StringComparison.Ordinal))
+					if (!Utils.StartsWith(addMethod.Name.String, "add_", StringComparison.Ordinal))
 						continue;
 
-					var eventName = addMethod.Name.Substring(4);
+					var eventName = addMethod.Name.String.Substring(4);
 					if (!checker.isValidEventName(eventName))
 						continue;
 
@@ -803,10 +821,10 @@ namespace de4dot.code.renamer {
 		}
 
 		static bool isThisOrDup(Instruction instr) {
-			return DotNetUtils.getArgIndex(instr) == 0 || instr.OpCode.Code == Code.Dup;
+			return instr.GetParameterIndex() == 0 || instr.OpCode.Code == Code.Dup;
 		}
 
-		static bool isEventHandlerCtor(MethodReference method) {
+		static bool isEventHandlerCtor(IMethod method) {
 			if (method == null)
 				return false;
 			if (method.Name != ".ctor")
@@ -818,22 +836,22 @@ namespace de4dot.code.renamer {
 			return true;
 		}
 
-		static bool isEventHandlerType(TypeReference type) {
+		static bool isEventHandlerType(IType type) {
 			return type.FullName.EndsWith("EventHandler", StringComparison.Ordinal);
 		}
 
-		string findWindowsFormsClassName(TypeDef type) {
+		string findWindowsFormsClassName(MTypeDef type) {
 			foreach (var methodDef in type.AllMethods) {
-				if (methodDef.MethodDefinition.Body == null)
+				if (methodDef.MethodDef.Body == null)
 					continue;
-				if (methodDef.MethodDefinition.IsStatic || methodDef.MethodDefinition.IsVirtual)
+				if (methodDef.MethodDef.IsStatic || methodDef.MethodDef.IsVirtual)
 					continue;
-				var instructions = methodDef.MethodDefinition.Body.Instructions;
+				var instructions = methodDef.MethodDef.Body.Instructions;
 				for (int i = 2; i < instructions.Count; i++) {
 					var call = instructions[i];
 					if (call.OpCode.Code != Code.Call && call.OpCode.Code != Code.Callvirt)
 						continue;
-					if (!isWindowsFormsSetNameMethod(call.Operand as MethodReference))
+					if (!isWindowsFormsSetNameMethod(call.Operand as IMethod))
 						continue;
 
 					var ldstr = instructions[i - 1];
@@ -843,7 +861,7 @@ namespace de4dot.code.renamer {
 					if (className == null)
 						continue;
 
-					if (DotNetUtils.getArgIndex(instructions[i - 2]) != 0)
+					if (instructions[i - 2].GetParameterIndex() != 0)
 						continue;
 
 					findInitializeComponentMethod(type, methodDef);
@@ -853,16 +871,16 @@ namespace de4dot.code.renamer {
 			return null;
 		}
 
-		void findInitializeComponentMethod(TypeDef type, MethodDef possibleInitMethod) {
+		void findInitializeComponentMethod(MTypeDef type, MMethodDef possibleInitMethod) {
 			foreach (var methodDef in type.AllMethods) {
-				if (methodDef.MethodDefinition.Name != ".ctor")
+				if (methodDef.MethodDef.Name != ".ctor")
 					continue;
-				if (methodDef.MethodDefinition.Body == null)
+				if (methodDef.MethodDef.Body == null)
 					continue;
-				foreach (var instr in methodDef.MethodDefinition.Body.Instructions) {
+				foreach (var instr in methodDef.MethodDef.Body.Instructions) {
 					if (instr.OpCode.Code != Code.Call && instr.OpCode.Code != Code.Callvirt)
 						continue;
-					if (!MemberReferenceHelper.compareMethodReferenceAndDeclaringType(possibleInitMethod.MethodDefinition, instr.Operand as MethodReference))
+					if (!MethodEqualityComparer.CompareDeclaringTypes.Equals(possibleInitMethod.MethodDef, instr.Operand as IMethod))
 						continue;
 
 					memberInfos.method(possibleInitMethod).suggestedName = "InitializeComponent";
@@ -871,16 +889,19 @@ namespace de4dot.code.renamer {
 			}
 		}
 
-		static bool isWindowsFormsSetNameMethod(MethodReference method) {
+		static bool isWindowsFormsSetNameMethod(IMethod method) {
 			if (method == null)
 				return false;
-			if (method.Name != "set_Name")
+			if (method.Name.String != "set_Name")
 				return false;
-			if (method.MethodReturnType.ReturnType.FullName != "System.Void")
+			var sig = method.MethodSig;
+			if (sig == null)
 				return false;
-			if (method.Parameters.Count != 1)
+			if (sig.RetType.ElementType != ElementType.Void)
 				return false;
-			if (method.Parameters[0].ParameterType.FullName != "System.String")
+			if (sig.Params.Count != 1)
+				return false;
+			if (sig.Params[0].ElementType != ElementType.String)
 				return false;
 			return true;
 		}
diff --git a/de4dot.code/renamer/TypeNames.cs b/de4dot.code/renamer/TypeNames.cs
index 91a4d94f..41adabc8 100644
--- a/de4dot.code/renamer/TypeNames.cs
+++ b/de4dot.code/renamer/TypeNames.cs
@@ -19,28 +19,35 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace de4dot.code.renamer {
 	abstract class TypeNames {
 		protected Dictionary<string, NameCreator> typeNames = new Dictionary<string, NameCreator>(StringComparer.Ordinal);
 		protected NameCreator genericParamNameCreator = new NameCreator("gparam_");
+		protected NameCreator fnPtrNameCreator = new NameCreator("fnptr_");
+		protected NameCreator unknownNameCreator = new NameCreator("unknown_");
 		protected Dictionary<string, string> fullNameToShortName;
 		protected Dictionary<string, string> fullNameToShortNamePrefix;
 
-		public string create(TypeReference typeRef) {
-			if (typeRef.IsGenericInstance) {
-				var git = (GenericInstanceType)typeRef;
-				if (git.ElementType.FullName == "System.Nullable`1" &&
-					git.GenericArguments.Count == 1 && git.GenericArguments[0] != null) {
-					typeRef = git.GenericArguments[0];
+		public string create(TypeSig typeRef) {
+			typeRef = typeRef.RemovePinnedAndModifiers();
+			if (typeRef == null)
+				return unknownNameCreator.create();
+			var gis = typeRef as GenericInstSig;
+			if (gis != null) {
+				if (gis.FullName == "System.Nullable`1" &&
+					gis.GenericArguments.Count == 1 && gis.GenericArguments[0] != null) {
+					typeRef = gis.GenericArguments[0];
 				}
 			}
 
 			string prefix = getPrefix(typeRef);
 
-			var elementType = typeRef.GetElementType();
-			if (elementType is GenericParameter)
+			var elementType = typeRef.ScopeType;
+			if (elementType == null && isFnPtrSig(typeRef))
+				return fnPtrNameCreator.create();
+			if (isGenericParam(elementType))
 				return genericParamNameCreator.create();
 
 			NameCreator nc;
@@ -48,7 +55,7 @@ namespace de4dot.code.renamer {
 			if (typeNames.TryGetValue(typeFullName, out nc))
 				return nc.create();
 
-			var fullName = elementType.FullName;
+			var fullName = elementType == null ? typeRef.FullName : elementType.FullName;
 			string shortName;
 			var dict = prefix == "" ? fullNameToShortName : fullNameToShortNamePrefix;
 			if (!dict.TryGetValue(fullName, out shortName)) {
@@ -64,12 +71,29 @@ namespace de4dot.code.renamer {
 			return addTypeName(typeFullName, shortName, prefix).create();
 		}
 
-		static string getPrefix(TypeReference typeRef) {
+		bool isFnPtrSig(TypeSig sig) {
+			while (sig != null) {
+				if (sig is FnPtrSig)
+					return true;
+				sig = sig.Next;
+			}
+			return false;
+		}
+
+		bool isGenericParam(ITypeDefOrRef tdr) {
+			var ts = tdr as TypeSpec;
+			if (ts == null)
+				return false;
+			var sig = ts.TypeSig.RemovePinnedAndModifiers();
+			return sig is GenericSig;
+		}
+
+		static string getPrefix(TypeSig typeRef) {
 			string prefix = "";
-			while (typeRef is TypeSpecification) {
+			while (typeRef != null) {
 				if (typeRef.IsPointer)
 					prefix += "p";
-				typeRef = ((TypeSpecification)typeRef).ElementType;
+				typeRef = typeRef.Next;
 			}
 			return prefix;
 		}
@@ -97,10 +121,14 @@ namespace de4dot.code.renamer {
 					typeNames[pair.Key] = pair.Value.clone();
 			}
 			genericParamNameCreator.merge(other.genericParamNameCreator);
+			fnPtrNameCreator.merge(other.fnPtrNameCreator);
+			unknownNameCreator.merge(other.unknownNameCreator);
 			return this;
 		}
 
 		protected static string upperFirst(string s) {
+			if (string.IsNullOrEmpty(s))
+				return string.Empty;
 			return s.Substring(0, 1).ToUpperInvariant() + s.Substring(1);
 		}
 	}
diff --git a/de4dot.code/renamer/TypeRenamerState.cs b/de4dot.code/renamer/TypeRenamerState.cs
index a248a06c..aac24201 100644
--- a/de4dot.code/renamer/TypeRenamerState.cs
+++ b/de4dot.code/renamer/TypeRenamerState.cs
@@ -19,7 +19,7 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace de4dot.code.renamer {
 	class TypeRenamerState {
@@ -45,7 +45,7 @@ namespace de4dot.code.renamer {
 			return existingNames.getName(oldName, new NameCreator2(newName));
 		}
 
-		public string createNamespace(TypeDefinition type, string ns) {
+		public string createNamespace(TypeDef type, string ns) {
 			string newName;
 
 			string asmFullName;
@@ -57,7 +57,7 @@ namespace de4dot.code.renamer {
 			// Make sure that two namespaces with the same names in different modules aren't renamed
 			// to the same name.
 			var key = string.Format(" [{0}] [{1}] [{2}] [{3}] ",
-						type.Module.FullyQualifiedName,
+						type.Module.Location,
 						asmFullName,
 						type.Module.Name,
 						ns);
diff --git a/de4dot.code/renamer/VariableNameState.cs b/de4dot.code/renamer/VariableNameState.cs
index a877a2fa..c8bd88f1 100644
--- a/de4dot.code/renamer/VariableNameState.cs
+++ b/de4dot.code/renamer/VariableNameState.cs
@@ -17,7 +17,7 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace de4dot.code.renamer {
 	class VariableNameState {
@@ -86,8 +86,8 @@ namespace de4dot.code.renamer {
 			existingEventNames.merge(other.existingEventNames);
 		}
 
-		public string getNewPropertyName(PropertyDefinition propertyDefinition) {
-			var propType = propertyDefinition.PropertyType;
+		public string getNewPropertyName(PropertyDef propertyDefinition) {
+			var propType = propertyDefinition.PropertySig.GetRetType();
 			string newName;
 			if (isGeneric(propType))
 				newName = existingPropertyNames.getName(propertyDefinition.Name, genericPropertyNameCreator);
@@ -97,18 +97,16 @@ namespace de4dot.code.renamer {
 			return newName;
 		}
 
-		static bool isGeneric(TypeReference type) {
-			while (true) {
-				if (type is GenericParameter)
+		static bool isGeneric(TypeSig type) {
+			while (type != null) {
+				if (type.IsGenericParameter)
 					return true;
-				var ts = type as TypeSpecification;
-				if (ts == null)
-					return false;
-				type = ts.ElementType;
+				type = type.Next;
 			}
+			return false;
 		}
 
-		public string getNewEventName(EventDefinition eventDefinition) {
+		public string getNewEventName(EventDef eventDefinition) {
 			string newName = eventNameCreator.create();
 			addEventName(newName);
 			return newName;
@@ -146,16 +144,16 @@ namespace de4dot.code.renamer {
 			return existingEventNames.exists(eventName);
 		}
 
-		public string getNewFieldName(FieldDefinition field) {
-			return existingVariableNames.getName(field.Name, () => variableNameCreator.create(field.FieldType));
+		public string getNewFieldName(FieldDef field) {
+			return existingVariableNames.getName(field.Name, () => variableNameCreator.create(field.FieldSig.GetFieldType()));
 		}
 
 		public string getNewFieldName(string oldName, INameCreator nameCreator) {
 			return existingVariableNames.getName(oldName, () => nameCreator.create());
 		}
 
-		public string getNewParamName(string oldName, ParameterDefinition param) {
-			return existingVariableNames.getName(oldName, () => variableNameCreator.create(param.ParameterType));
+		public string getNewParamName(string oldName, Parameter param) {
+			return existingVariableNames.getName(oldName, () => variableNameCreator.create(param.Type));
 		}
 
 		public string getNewMethodName(string oldName, INameCreator nameCreator) {
diff --git a/de4dot.code/renamer/asmmodules/EventDef.cs b/de4dot.code/renamer/asmmodules/EventDef.cs
index 2ea9047a..14ea1742 100644
--- a/de4dot.code/renamer/asmmodules/EventDef.cs
+++ b/de4dot.code/renamer/asmmodules/EventDef.cs
@@ -18,31 +18,31 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace de4dot.code.renamer.asmmodules {
-	class EventDef : Ref {
-		public MethodDef AddMethod { get; set; }
-		public MethodDef RemoveMethod { get; set; }
-		public MethodDef RaiseMethod { get; set; }
+	class MEventDef : Ref {
+		public MMethodDef AddMethod { get; set; }
+		public MMethodDef RemoveMethod { get; set; }
+		public MMethodDef RaiseMethod { get; set; }
 
-		public EventDefinition EventDefinition {
-			get { return (EventDefinition)memberReference; }
+		public EventDef EventDef {
+			get { return (EventDef)memberReference; }
 		}
 
-		public EventDef(EventDefinition eventDefinition, TypeDef owner, int index)
+		public MEventDef(EventDef eventDefinition, MTypeDef owner, int index)
 			: base(eventDefinition, owner, index) {
 		}
 
-		public IEnumerable<MethodDefinition> methodDefinitions() {
-			if (EventDefinition.AddMethod != null)
-				yield return EventDefinition.AddMethod;
-			if (EventDefinition.RemoveMethod != null)
-				yield return EventDefinition.RemoveMethod;
-			if (EventDefinition.InvokeMethod != null)
-				yield return EventDefinition.InvokeMethod;
-			if (EventDefinition.OtherMethods != null) {
-				foreach (var m in EventDefinition.OtherMethods)
+		public IEnumerable<MethodDef> methodDefinitions() {
+			if (EventDef.AddMethod != null)
+				yield return EventDef.AddMethod;
+			if (EventDef.RemoveMethod != null)
+				yield return EventDef.RemoveMethod;
+			if (EventDef.InvokeMethod != null)
+				yield return EventDef.InvokeMethod;
+			if (EventDef.OtherMethods != null) {
+				foreach (var m in EventDef.OtherMethods)
 					yield return m;
 			}
 		}
diff --git a/de4dot.code/renamer/asmmodules/FieldDef.cs b/de4dot.code/renamer/asmmodules/FieldDef.cs
index 3e16a003..13049071 100644
--- a/de4dot.code/renamer/asmmodules/FieldDef.cs
+++ b/de4dot.code/renamer/asmmodules/FieldDef.cs
@@ -17,15 +17,15 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace de4dot.code.renamer.asmmodules {
-	class FieldDef : Ref {
-		public FieldDefinition FieldDefinition {
-			get { return (FieldDefinition)memberReference; }
+	class MFieldDef : Ref {
+		public FieldDef FieldDef {
+			get { return (FieldDef)memberReference; }
 		}
 
-		public FieldDef(FieldDefinition fieldDefinition, TypeDef owner, int index)
+		public MFieldDef(FieldDef fieldDefinition, MTypeDef owner, int index)
 			: base(fieldDefinition, owner, index) {
 		}
 	}
diff --git a/de4dot.code/renamer/asmmodules/GenericParamDef.cs b/de4dot.code/renamer/asmmodules/GenericParamDef.cs
index ca2833cd..c7a7c992 100644
--- a/de4dot.code/renamer/asmmodules/GenericParamDef.cs
+++ b/de4dot.code/renamer/asmmodules/GenericParamDef.cs
@@ -18,25 +18,25 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace de4dot.code.renamer.asmmodules {
-	class GenericParamDef : Ref {
-		public GenericParameter GenericParameter {
-			get { return (GenericParameter)memberReference; }
+	class MGenericParamDef : Ref {
+		public GenericParam GenericParam {
+			get { return (GenericParam)memberReference; }
 		}
 
-		public GenericParamDef(GenericParameter genericParameter, int index)
+		public MGenericParamDef(GenericParam genericParameter, int index)
 			: base(genericParameter, null, index) {
 		}
 
-		public static List<GenericParamDef> createGenericParamDefList(IEnumerable<GenericParameter> parameters) {
-			var list = new List<GenericParamDef>();
+		public static List<MGenericParamDef> createGenericParamDefList(IEnumerable<GenericParam> parameters) {
+			var list = new List<MGenericParamDef>();
 			if (parameters == null)
 				return list;
 			int i = 0;
 			foreach (var param in parameters)
-				list.Add(new GenericParamDef(param, i++));
+				list.Add(new MGenericParamDef(param, i++));
 			return list;
 		}
 	}
diff --git a/de4dot.code/renamer/asmmodules/IResolver.cs b/de4dot.code/renamer/asmmodules/IResolver.cs
index d6401cb2..e7f4bd09 100644
--- a/de4dot.code/renamer/asmmodules/IResolver.cs
+++ b/de4dot.code/renamer/asmmodules/IResolver.cs
@@ -17,12 +17,12 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace de4dot.code.renamer.asmmodules {
 	interface IResolver {
-		TypeDef resolve(TypeReference typeReference);
-		MethodDef resolve(MethodReference methodReference);
-		FieldDef resolve(FieldReference fieldReference);
+		MTypeDef resolveType(ITypeDefOrRef typeReference);
+		MMethodDef resolveMethod(IMethodDefOrRef methodReference);
+		MFieldDef resolveField(MemberRef fieldReference);
 	}
 }
diff --git a/de4dot.code/renamer/asmmodules/MemberRefFinder.cs b/de4dot.code/renamer/asmmodules/MemberRefFinder.cs
index f986f24e..27ca0755 100644
--- a/de4dot.code/renamer/asmmodules/MemberRefFinder.cs
+++ b/de4dot.code/renamer/asmmodules/MemberRefFinder.cs
@@ -19,675 +19,674 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
+using dot10.DotNet;
+using dot10.DotNet.Emit;
 using de4dot.blocks;
 
 namespace de4dot.code.renamer.asmmodules {
+	enum ObjectType {
+		Unknown,
+		EventDef,
+		FieldDef,
+		GenericParam,
+		MemberRef,
+		MethodDef,
+		MethodSpec,
+		PropertyDef,
+		TypeDef,
+		TypeRef,
+		TypeSig,
+		TypeSpec,
+		ExportedType,
+	}
+
 	class MemberRefFinder {
-		public Dictionary<EventDefinition, bool> eventDefinitions = new Dictionary<EventDefinition, bool>();
-		public Dictionary<FieldReference, bool> fieldReferences = new Dictionary<FieldReference, bool>();
-		public Dictionary<FieldDefinition, bool> fieldDefinitions = new Dictionary<FieldDefinition, bool>();
-		public Dictionary<MethodReference, bool> methodReferences = new Dictionary<MethodReference, bool>();
-		public Dictionary<MethodDefinition, bool> methodDefinitions = new Dictionary<MethodDefinition, bool>();
-		public Dictionary<GenericInstanceMethod, bool> genericInstanceMethods = new Dictionary<GenericInstanceMethod, bool>();
-		public Dictionary<PropertyDefinition, bool> propertyDefinitions = new Dictionary<PropertyDefinition, bool>();
-		public Dictionary<TypeReference, bool> typeReferences = new Dictionary<TypeReference, bool>();
-		public Dictionary<TypeDefinition, bool> typeDefinitions = new Dictionary<TypeDefinition, bool>();
-		public Dictionary<GenericParameter, bool> genericParameters = new Dictionary<GenericParameter, bool>();
-		public Dictionary<ArrayType, bool> arrayTypes = new Dictionary<ArrayType, bool>();
-		public Dictionary<FunctionPointerType, bool> functionPointerTypes = new Dictionary<FunctionPointerType, bool>();
-		public Dictionary<GenericInstanceType, bool> genericInstanceTypes = new Dictionary<GenericInstanceType, bool>();
-		public Dictionary<OptionalModifierType, bool> optionalModifierTypes = new Dictionary<OptionalModifierType, bool>();
-		public Dictionary<RequiredModifierType, bool> requiredModifierTypes = new Dictionary<RequiredModifierType, bool>();
-		public Dictionary<PinnedType, bool> pinnedTypes = new Dictionary<PinnedType, bool>();
-		public Dictionary<PointerType, bool> pointerTypes = new Dictionary<PointerType, bool>();
-		public Dictionary<ByReferenceType, bool> byReferenceTypes = new Dictionary<ByReferenceType, bool>();
-		public Dictionary<SentinelType, bool> sentinelTypes = new Dictionary<SentinelType, bool>();
 		public Dictionary<CustomAttribute, bool> customAttributes = new Dictionary<CustomAttribute, bool>();
+		public Dictionary<EventDef, bool> eventDefs = new Dictionary<EventDef, bool>();
+		public Dictionary<FieldDef, bool> fieldDefs = new Dictionary<FieldDef, bool>();
+		public Dictionary<GenericParam, bool> genericParams = new Dictionary<GenericParam, bool>();
+		public Dictionary<MemberRef, bool> memberRefs = new Dictionary<MemberRef, bool>();
+		public Dictionary<MethodDef, bool> methodDefs = new Dictionary<MethodDef, bool>();
+		public Dictionary<MethodSpec, bool> methodSpecs = new Dictionary<MethodSpec, bool>();
+		public Dictionary<PropertyDef, bool> propertyDefs = new Dictionary<PropertyDef, bool>();
+		public Dictionary<TypeDef, bool> typeDefs = new Dictionary<TypeDef, bool>();
+		public Dictionary<TypeRef, bool> typeRefs = new Dictionary<TypeRef, bool>();
+		public Dictionary<TypeSig, bool> typeSigs = new Dictionary<TypeSig, bool>();
+		public Dictionary<TypeSpec, bool> typeSpecs = new Dictionary<TypeSpec, bool>();
+		public Dictionary<ExportedType, bool> exportedTypes = new Dictionary<ExportedType, bool>();
 
-		Stack<MemberReference> memberRefStack;
-		ModuleDefinition validModule;
+		Stack<object> objectStack;
+		ModuleDef validModule;
 
-		public void removeTypeDefinition(TypeDefinition td) {
-			if (!typeDefinitions.Remove(td))
-				throw new ApplicationException(string.Format("Could not remove TypeDefinition: {0}", td));
+		public void removeTypeDef(TypeDef td) {
+			if (!typeDefs.Remove(td))
+				throw new ApplicationException(string.Format("Could not remove TypeDef: {0}", td));
 		}
 
-		public void removeEventDefinition(EventDefinition ed) {
-			if (!eventDefinitions.Remove(ed))
-				throw new ApplicationException(string.Format("Could not remove EventDefinition: {0}", ed));
+		public void removeEventDef(EventDef ed) {
+			if (!eventDefs.Remove(ed))
+				throw new ApplicationException(string.Format("Could not remove EventDef: {0}", ed));
 		}
 
-		public void removeFieldDefinition(FieldDefinition fd) {
-			if (!fieldDefinitions.Remove(fd))
-				throw new ApplicationException(string.Format("Could not remove FieldDefinition: {0}", fd));
+		public void removeFieldDef(FieldDef fd) {
+			if (!fieldDefs.Remove(fd))
+				throw new ApplicationException(string.Format("Could not remove FieldDef: {0}", fd));
 		}
 
-		public void removeMethodDefinition(MethodDefinition md) {
-			if (!methodDefinitions.Remove(md))
-				throw new ApplicationException(string.Format("Could not remove MethodDefinition: {0}", md));
+		public void removeMethodDef(MethodDef md) {
+			if (!methodDefs.Remove(md))
+				throw new ApplicationException(string.Format("Could not remove MethodDef: {0}", md));
 		}
 
-		public void removePropertyDefinition(PropertyDefinition pd) {
-			if (!propertyDefinitions.Remove(pd))
-				throw new ApplicationException(string.Format("Could not remove PropertyDefinition: {0}", pd));
+		public void removePropertyDef(PropertyDef pd) {
+			if (!propertyDefs.Remove(pd))
+				throw new ApplicationException(string.Format("Could not remove PropertyDef: {0}", pd));
 		}
 
-		public void findAll(ModuleDefinition module, IEnumerable<TypeDefinition> types) {
+		public void findAll(ModuleDef module) {
 			validModule = module;
 
 			// This needs to be big. About 2048 entries should be enough for most though...
-			memberRefStack = new Stack<MemberReference>(0x1000);
+			objectStack = new Stack<object>(0x1000);
 
-			foreach (var type in types)
-				pushMember(type);
-
-			addModule(module);
+			add(module);
 			processAll();
 
-			memberRefStack = null;
+			objectStack = null;
 		}
 
-		Dictionary<string, bool> exceptionMessages = new Dictionary<string, bool>(StringComparer.Ordinal);
-		void access(Action action) {
-			string exMessage = null;
-			try {
-				action();
-			}
-			catch (ResolutionException ex) {
-				exMessage = ex.Message;
-			}
-			catch (AssemblyResolutionException ex) {
-				exMessage = ex.Message;
-			}
-			if (exMessage != null) {
-				if (!exceptionMessages.ContainsKey(exMessage)) {
-					exceptionMessages[exMessage] = true;
-					Log.w("Could not resolve a reference. ERROR: {0}", exMessage);
+		void push(object mr) {
+			if (mr == null)
+				return;
+			objectStack.Push(mr);
+		}
+
+		void processAll() {
+			while (objectStack.Count > 0) {
+				var o = objectStack.Pop();
+				switch (getObjectType(o)) {
+				case ObjectType.Unknown: break;
+				case ObjectType.EventDef:	add((EventDef)o); break;
+				case ObjectType.FieldDef:	add((FieldDef)o); break;
+				case ObjectType.GenericParam: add((GenericParam)o); break;
+				case ObjectType.MemberRef:	add((MemberRef)o); break;
+				case ObjectType.MethodDef:	add((MethodDef)o); break;
+				case ObjectType.MethodSpec:	add((MethodSpec)o); break;
+				case ObjectType.PropertyDef:add((PropertyDef)o); break;
+				case ObjectType.TypeDef:	add((TypeDef)o); break;
+				case ObjectType.TypeRef:	add((TypeRef)o); break;
+				case ObjectType.TypeSig:	add((TypeSig)o); break;
+				case ObjectType.TypeSpec:	add((TypeSpec)o); break;
+				case ObjectType.ExportedType: add((ExportedType)o); break;
+				default: throw new InvalidOperationException(string.Format("Unknown type: {0}", o.GetType()));
 				}
 			}
 		}
 
-		void pushMember(MemberReference memberReference) {
-			if (memberReference == null)
-				return;
-			if (memberReference.Module != validModule)
-				return;
-			memberRefStack.Push(memberReference);
+		readonly Dictionary<Type, ObjectType> toObjectType = new Dictionary<Type, ObjectType>();
+		ObjectType getObjectType(object o) {
+			if (o == null)
+				return ObjectType.Unknown;
+			var type = o.GetType();
+			ObjectType mrType;
+			if (toObjectType.TryGetValue(type, out mrType))
+				return mrType;
+			mrType = getObjectType2(o);
+			toObjectType[type] = mrType;
+			return mrType;
 		}
 
-		void addModule(ModuleDefinition module) {
-			pushMember(module.EntryPoint);
-			access(() => addCustomAttributes(module.CustomAttributes));
-			if (module.Assembly != null && module == module.Assembly.MainModule) {
-				var asm = module.Assembly;
-				access(() => addCustomAttributes(asm.CustomAttributes));
-				addSecurityDeclarations(asm.SecurityDeclarations);
+		static ObjectType getObjectType2(object o) {
+			if (o is EventDef)		return ObjectType.EventDef;
+			if (o is FieldDef)		return ObjectType.FieldDef;
+			if (o is GenericParam)	return ObjectType.GenericParam;
+			if (o is MemberRef)		return ObjectType.MemberRef;
+			if (o is MethodDef)		return ObjectType.MethodDef;
+			if (o is MethodSpec)	return ObjectType.MethodSpec;
+			if (o is PropertyDef)	return ObjectType.PropertyDef;
+			if (o is TypeDef)		return ObjectType.TypeDef;
+			if (o is TypeRef)		return ObjectType.TypeRef;
+			if (o is TypeSig)		return ObjectType.TypeSig;
+			if (o is TypeSpec)		return ObjectType.TypeSpec;
+			if (o is ExportedType)	return ObjectType.ExportedType;
+			return ObjectType.Unknown;
+		}
+
+		void add(ModuleDef mod) {
+			push(mod.ManagedEntryPoint);
+			add(mod.CustomAttributes);
+			add(mod.Types);
+			add(mod.ExportedTypes);
+			if (mod.IsManifestModule)
+				add(mod.Assembly);
+			add(mod.VTableFixups);
+		}
+
+		void add(VTableFixups fixups) {
+			if (fixups == null)
+				return;
+			foreach (var fixup in fixups) {
+				foreach (var method in fixup)
+					push(method);
 			}
 		}
 
-		void processAll() {
-			while (memberRefStack.Count > 0)
-				process(memberRefStack.Pop());
+		void add(AssemblyDef asm) {
+			if (asm == null)
+				return;
+			add(asm.DeclSecurities);
+			add(asm.CustomAttributes);
 		}
 
-		void process(MemberReference memberRef) {
-			if (memberRef == null)
+		void add(CallingConventionSig sig) {
+			if (sig == null)
 				return;
 
-			var type = MemberReferenceHelper.getMemberReferenceType(memberRef);
-			switch (type) {
-			case CecilType.ArrayType:
-				doArrayType((ArrayType)memberRef);
-				break;
-			case CecilType.ByReferenceType:
-				doByReferenceType((ByReferenceType)memberRef);
-				break;
-			case CecilType.EventDefinition:
-				doEventDefinition((EventDefinition)memberRef);
-				break;
-			case CecilType.FieldDefinition:
-				doFieldDefinition((FieldDefinition)memberRef);
-				break;
-			case CecilType.FieldReference:
-				doFieldReference((FieldReference)memberRef);
-				break;
-			case CecilType.FunctionPointerType:
-				doFunctionPointerType((FunctionPointerType)memberRef);
-				break;
-			case CecilType.GenericInstanceMethod:
-				doGenericInstanceMethod((GenericInstanceMethod)memberRef);
-				break;
-			case CecilType.GenericInstanceType:
-				doGenericInstanceType((GenericInstanceType)memberRef);
-				break;
-			case CecilType.GenericParameter:
-				doGenericParameter((GenericParameter)memberRef);
-				break;
-			case CecilType.MethodDefinition:
-				doMethodDefinition((MethodDefinition)memberRef);
-				break;
-			case CecilType.MethodReference:
-				doMethodReference((MethodReference)memberRef);
-				break;
-			case CecilType.OptionalModifierType:
-				doOptionalModifierType((OptionalModifierType)memberRef);
-				break;
-			case CecilType.PinnedType:
-				doPinnedType((PinnedType)memberRef);
-				break;
-			case CecilType.PointerType:
-				doPointerType((PointerType)memberRef);
-				break;
-			case CecilType.PropertyDefinition:
-				doPropertyDefinition((PropertyDefinition)memberRef);
-				break;
-			case CecilType.RequiredModifierType:
-				doRequiredModifierType((RequiredModifierType)memberRef);
-				break;
-			case CecilType.SentinelType:
-				doSentinelType((SentinelType)memberRef);
-				break;
-			case CecilType.TypeDefinition:
-				doTypeDefinition((TypeDefinition)memberRef);
-				break;
-			case CecilType.TypeReference:
-				doTypeReference((TypeReference)memberRef);
-				break;
-			default:
-				throw new ApplicationException(string.Format("Unknown cecil type {0}", type));
+			var fs = sig as FieldSig;
+			if (fs != null) {
+				add(fs);
+				return;
+			}
+
+			var mbs = sig as MethodBaseSig;
+			if (mbs != null) {
+				add(mbs);
+				return;
+			}
+
+			var ls = sig as LocalSig;
+			if (ls != null) {
+				add(ls);
+				return;
+			}
+
+			var gims = sig as GenericInstMethodSig;
+			if (gims != null) {
+				add(gims);
+				return;
 			}
 		}
 
-		void addCustomAttributes(IEnumerable<CustomAttribute> attributes) {
-			if (attributes == null)
+		void add(FieldSig sig) {
+			if (sig == null)
 				return;
-			foreach (var attr in attributes)
-				addCustomAttribute(attr);
+			add(sig.Type);
 		}
-		void addCustomAttributeArguments(IEnumerable<CustomAttributeArgument> args) {
+
+		void add(MethodBaseSig sig) {
+			if (sig == null)
+				return;
+			add(sig.RetType);
+			add(sig.Params);
+			add(sig.ParamsAfterSentinel);
+		}
+
+		void add(LocalSig sig) {
+			if (sig == null)
+				return;
+			add(sig.Locals);
+		}
+
+		void add(GenericInstMethodSig sig) {
+			if (sig == null)
+				return;
+			add(sig.GenericArguments);
+		}
+
+		void add(IEnumerable<CustomAttribute> cas) {
+			if (cas == null)
+				return;
+			foreach (var ca in cas)
+				add(ca);
+		}
+
+		void add(CustomAttribute ca) {
+			if (ca == null || customAttributes.ContainsKey(ca))
+				return;
+			customAttributes[ca] = true;
+			push(ca.Constructor);
+			add(ca.ConstructorArguments);
+			add(ca.NamedArguments);
+		}
+
+		void add(IEnumerable<CAArgument> args) {
 			if (args == null)
 				return;
 			foreach (var arg in args)
-				addCustomAttributeArgument(arg);
+				add(arg);
 		}
-		void addCustomAttributeNamedArguments(IEnumerable<CustomAttributeNamedArgument> args) {
+
+		void add(CAArgument arg) {
+			// It's a struct so can't be null
+			add(arg.Type);
+		}
+
+		void add(IEnumerable<CANamedArgument> args) {
 			if (args == null)
 				return;
 			foreach (var arg in args)
-				addCustomAttributeNamedArgument(arg);
+				add(arg);
 		}
-		void addParameterDefinitions(IEnumerable<ParameterDefinition> parameters) {
-			if (parameters == null)
+
+		void add(CANamedArgument arg) {
+			if (arg == null)
 				return;
-			foreach (var param in parameters)
-				addParameterDefinition(param);
+			add(arg.Type);
+			add(arg.Argument);
 		}
-		void addSecurityDeclarations(IEnumerable<SecurityDeclaration> decls) {
+
+		void add(IEnumerable<DeclSecurity> decls) {
 			if (decls == null)
 				return;
 			foreach (var decl in decls)
-				addSecurityDeclaration(decl);
+				add(decl);
 		}
-		void addSecurityAttributes(IEnumerable<SecurityAttribute> attrs) {
-			if (attrs == null)
+
+		void add(DeclSecurity decl) {
+			if (decl == null)
 				return;
-			foreach (var attr in attrs)
-				addSecurityAttribute(attr);
+			add(decl.CustomAttributes);
 		}
-		void addExceptionHandlers(IEnumerable<ExceptionHandler> handlers) {
-			if (handlers == null)
+
+		void add(IEnumerable<EventDef> eds) {
+			if (eds == null)
 				return;
-			foreach (var h in handlers)
-				addExceptionHandler(h);
+			foreach (var ed in eds)
+				add(ed);
 		}
-		void addVariableDefinitions(IEnumerable<VariableDefinition> vars) {
-			if (vars == null)
+
+		void add(EventDef ed) {
+			if (ed == null || eventDefs.ContainsKey(ed))
 				return;
-			foreach (var v in vars)
-				addVariableDefinition(v);
-		}
-		void addScopes(IEnumerable<Scope> scopes) {
-			if (scopes == null)
+			if (ed.DeclaringType != null && ed.DeclaringType.Module != validModule)
 				return;
-			foreach (var s in scopes)
-				addScope(s);
+			eventDefs[ed] = true;
+			push(ed.EventType);
+			add(ed.CustomAttributes);
+			add(ed.AddMethod);
+			add(ed.InvokeMethod);
+			add(ed.RemoveMethod);
+			add(ed.OtherMethods);
+			add(ed.DeclaringType);
 		}
-		void addInstructions(IEnumerable<Instruction> instrs) {
+
+		void add(IEnumerable<FieldDef> fds) {
+			if (fds == null)
+				return;
+			foreach (var fd in fds)
+				add(fd);
+		}
+
+		void add(FieldDef fd) {
+			if (fd == null || fieldDefs.ContainsKey(fd))
+				return;
+			if (fd.DeclaringType != null && fd.DeclaringType.Module != validModule)
+				return;
+			fieldDefs[fd] = true;
+			add(fd.CustomAttributes);
+			add(fd.Signature);
+			add(fd.DeclaringType);
+		}
+
+		void add(IEnumerable<GenericParam> gps) {
+			if (gps == null)
+				return;
+			foreach (var gp in gps)
+				add(gp);
+		}
+
+		void add(GenericParam gp) {
+			if (gp == null || genericParams.ContainsKey(gp))
+				return;
+			genericParams[gp] = true;
+			push(gp.Owner);
+			push(gp.Kind);
+			add(gp.GenericParamConstraints);
+			add(gp.CustomAttributes);
+		}
+
+		void add(IEnumerable<GenericParamConstraint> gpcs) {
+			if (gpcs == null)
+				return;
+			foreach (var gpc in gpcs)
+				add(gpc);
+		}
+
+		void add(GenericParamConstraint gpc) {
+			if (gpc == null)
+				return;
+			add(gpc.Owner);
+			push(gpc.Constraint);
+			add(gpc.CustomAttributes);
+		}
+
+		void add(MemberRef mr) {
+			if (mr == null || memberRefs.ContainsKey(mr))
+				return;
+			if (mr.Module != validModule)
+				return;
+			memberRefs[mr] = true;
+			push(mr.Class);
+			add(mr.Signature);
+			add(mr.CustomAttributes);
+		}
+
+		void add(IEnumerable<MethodDef> methods) {
+			if (methods == null)
+				return;
+			foreach (var m in methods)
+				add(m);
+		}
+
+		void add(MethodDef md) {
+			if (md == null || methodDefs.ContainsKey(md))
+				return;
+			if (md.DeclaringType != null && md.DeclaringType.Module != validModule)
+				return;
+			methodDefs[md] = true;
+			add(md.Signature);
+			add(md.ParamList);
+			add(md.GenericParameters);
+			add(md.DeclSecurities);
+			add(md.MethodBody);
+			add(md.CustomAttributes);
+			add(md.Overrides);
+			add(md.DeclaringType);
+		}
+
+		void add(MethodBody mb) {
+			var cb = mb as CilBody;
+			if (cb != null)
+				add(cb);
+		}
+
+		void add(CilBody cb) {
+			if (cb == null)
+				return;
+			add(cb.Instructions);
+			add(cb.ExceptionHandlers);
+			add(cb.LocalList);
+		}
+
+		void add(IEnumerable<Instruction> instrs) {
 			if (instrs == null)
 				return;
 			foreach (var instr in instrs) {
+				if (instr == null)
+					continue;
 				switch (instr.OpCode.OperandType) {
 				case OperandType.InlineTok:
 				case OperandType.InlineType:
 				case OperandType.InlineMethod:
 				case OperandType.InlineField:
-					pushMember(instr.Operand as MemberReference);
+					push(instr.Operand);
 					break;
+
 				case OperandType.InlineSig:
-					addCallSite(instr.Operand as CallSite);
+					add(instr.Operand as CallingConventionSig);
 					break;
+
 				case OperandType.InlineVar:
 				case OperandType.ShortInlineVar:
-					addVariableDefinition(instr.Operand as VariableDefinition);
-					break;
-				case OperandType.InlineArg:
-				case OperandType.ShortInlineArg:
-					addParameterDefinition(instr.Operand as ParameterDefinition);
+					var local = instr.Operand as Local;
+					if (local != null) {
+						add(local);
+						break;
+					}
+					var arg = instr.Operand as Parameter;
+					if (arg != null) {
+						add(arg);
+						break;
+					}
 					break;
 				}
 			}
 		}
-		void addTypeReferences(IEnumerable<TypeReference> types) {
-			if (types == null)
-				return;
-			foreach (var typeRef in types)
-				pushMember(typeRef);
-		}
-		void addTypeDefinitions(IEnumerable<TypeDefinition> types) {
-			if (types == null)
-				return;
-			foreach (var type in types)
-				pushMember(type);
-		}
-		void addMethodReferences(IEnumerable<MethodReference> methodRefs) {
-			if (methodRefs == null)
-				return;
-			foreach (var m in methodRefs)
-				pushMember(m);
-		}
-		void addMethodDefinitions(IEnumerable<MethodDefinition> methods) {
-			if (methods == null)
-				return;
-			foreach (var m in methods)
-				pushMember(m);
-		}
-		void addGenericParameters(IEnumerable<GenericParameter> parameters) {
-			if (parameters == null)
-				return;
-			foreach (var param in parameters)
-				pushMember(param);
-		}
-		void addFieldDefinitions(IEnumerable<FieldDefinition> fields) {
-			if (fields == null)
-				return;
-			foreach (var f in fields)
-				pushMember(f);
-		}
-		void addEventDefinitions(IEnumerable<EventDefinition> events) {
-			if (events == null)
-				return;
-			foreach (var e in events)
-				pushMember(e);
-		}
-		void addPropertyDefinitions(IEnumerable<PropertyDefinition> props) {
-			if (props == null)
-				return;
-			foreach (var p in props)
-				pushMember(p);
-		}
-		void addMemberReference(MemberReference memberReference) {
-			if (memberReference == null)
-				return;
-			pushMember(memberReference.DeclaringType);
-		}
-		void addEventReference(EventReference eventReference) {
-			if (eventReference == null)
-				return;
-			addMemberReference(eventReference);
-			pushMember(eventReference.EventType);
-		}
-		void addEventDefinition(EventDefinition eventDefinition) {
-			if (eventDefinition == null)
-				return;
-			addEventReference(eventDefinition);
-			pushMember(eventDefinition.AddMethod);
-			pushMember(eventDefinition.InvokeMethod);
-			pushMember(eventDefinition.RemoveMethod);
-			addMethodDefinitions(eventDefinition.OtherMethods);
-			access(() => addCustomAttributes(eventDefinition.CustomAttributes));
-		}
-		void addCustomAttribute(CustomAttribute attr) {
-			if (attr == null)
-				return;
-			customAttributes[attr] = true;
-			pushMember(attr.Constructor);
 
-			// Some obfuscators don't rename custom ctor arguments to the new name, causing
-			// Mono.Cecil to use a null reference.
-			try { access(() => addCustomAttributeArguments(attr.ConstructorArguments)); } catch (NullReferenceException) { }
-			try { access(() => addCustomAttributeNamedArguments(attr.Fields)); } catch (NullReferenceException) { }
-			try { access(() => addCustomAttributeNamedArguments(attr.Properties)); } catch (NullReferenceException) { }
-		}
-		void addCustomAttributeArgument(CustomAttributeArgument arg) {
-			pushMember(arg.Type);
-		}
-		void addCustomAttributeNamedArgument(CustomAttributeNamedArgument field) {
-			addCustomAttributeArgument(field.Argument);
-		}
-		void addFieldReference(FieldReference fieldReference) {
-			if (fieldReference == null)
+		void add(IEnumerable<ExceptionHandler> ehs) {
+			if (ehs == null)
 				return;
-			addMemberReference(fieldReference);
-			pushMember(fieldReference.FieldType);
-		}
-		void addFieldDefinition(FieldDefinition fieldDefinition) {
-			if (fieldDefinition == null)
-				return;
-			addFieldReference(fieldDefinition);
-			access(() => addCustomAttributes(fieldDefinition.CustomAttributes));
-		}
-		void addMethodReference(MethodReference methodReference) {
-			if (methodReference == null)
-				return;
-			addMemberReference(methodReference);
-			addParameterDefinitions(methodReference.Parameters);
-			addMethodReturnType(methodReference.MethodReturnType);
-			addGenericParameters(methodReference.GenericParameters);
-		}
-		void addParameterReference(ParameterReference param) {
-			if (param == null)
-				return;
-			pushMember(param.ParameterType);
-		}
-		void addParameterDefinition(ParameterDefinition param) {
-			if (param == null)
-				return;
-			addParameterReference(param);
-			pushMember(param.Method as MemberReference);
-			access(() => addCustomAttributes(param.CustomAttributes));
-		}
-		void addMethodReturnType(MethodReturnType methodReturnType) {
-			if (methodReturnType == null)
-				return;
-			pushMember(methodReturnType.Method as MemberReference);
-			pushMember(methodReturnType.ReturnType);
-			addParameterDefinition(methodReturnType.Parameter);
-		}
-		void addGenericParameter(GenericParameter param) {
-			if (param == null)
-				return;
-			addTypeReference(param);
-			pushMember(param.Owner as MemberReference);
-			access(() => addCustomAttributes(param.CustomAttributes));
-			addTypeReferences(param.Constraints);
-		}
-		void addTypeReference(TypeReference typeReference) {
-			if (typeReference == null)
-				return;
-			addMemberReference(typeReference);
-			addGenericParameters(typeReference.GenericParameters);
-		}
-		void addMethodDefinition(MethodDefinition methodDefinition) {
-			if (methodDefinition == null)
-				return;
-			addMethodReference(methodDefinition);
-			access(() => addCustomAttributes(methodDefinition.CustomAttributes));
-			addSecurityDeclarations(methodDefinition.SecurityDeclarations);
-			addMethodReferences(methodDefinition.Overrides);
-			addMethodBody(methodDefinition.Body);
-		}
-		void addSecurityDeclaration(SecurityDeclaration decl) {
-			if (decl == null)
-				return;
-			access(() => addSecurityAttributes(decl.SecurityAttributes));
-		}
-		void addSecurityAttribute(SecurityAttribute attr) {
-			if (attr == null)
-				return;
-			pushMember(attr.AttributeType);
-			addCustomAttributeNamedArguments(attr.Fields);
-			addCustomAttributeNamedArguments(attr.Properties);
-		}
-		void addMethodBody(MethodBody body) {
-			if (body == null)
-				return;
-			pushMember(body.Method);
-			addParameterDefinition(body.ThisParameter);
-			addExceptionHandlers(body.ExceptionHandlers);
-			addVariableDefinitions(body.Variables);
-			addScope(body.Scope);
-			addInstructions(body.Instructions);
-		}
-		void addExceptionHandler(ExceptionHandler handler) {
-			if (handler == null)
-				return;
-			pushMember(handler.CatchType);
-		}
-		void addVariableDefinition(VariableDefinition v) {
-			if (v == null)
-				return;
-			addVariableReference(v);
-		}
-		void addVariableReference(VariableReference v) {
-			if (v == null)
-				return;
-			pushMember(v.VariableType);
-		}
-		void addScope(Scope scope) {
-			if (scope == null)
-				return;
-			addVariableDefinitions(scope.Variables);
-			addScopes(scope.Scopes);
-		}
-		void addGenericInstanceMethod(GenericInstanceMethod genericInstanceMethod) {
-			if (genericInstanceMethod == null)
-				return;
-			addMethodSpecification(genericInstanceMethod);
-			addTypeReferences(genericInstanceMethod.GenericArguments);
-		}
-		void addMethodSpecification(MethodSpecification methodSpecification) {
-			if (methodSpecification == null)
-				return;
-			addMethodReference(methodSpecification);
-			pushMember(methodSpecification.ElementMethod);
-		}
-		void addPropertyReference(PropertyReference propertyReference) {
-			if (propertyReference == null)
-				return;
-			addMemberReference(propertyReference);
-			pushMember(propertyReference.PropertyType);
-		}
-		void addPropertyDefinition(PropertyDefinition propertyDefinition) {
-			if (propertyDefinition == null)
-				return;
-			addPropertyReference(propertyDefinition);
-			access(() => addCustomAttributes(propertyDefinition.CustomAttributes));
-			pushMember(propertyDefinition.GetMethod);
-			pushMember(propertyDefinition.SetMethod);
-			addMethodDefinitions(propertyDefinition.OtherMethods);
-		}
-		void addTypeDefinition(TypeDefinition typeDefinition) {
-			if (typeDefinition == null)
-				return;
-			addTypeReference(typeDefinition);
-			pushMember(typeDefinition.BaseType);
-			addTypeReferences(typeDefinition.Interfaces);
-			addTypeDefinitions(typeDefinition.NestedTypes);
-			addMethodDefinitions(typeDefinition.Methods);
-			addFieldDefinitions(typeDefinition.Fields);
-			addEventDefinitions(typeDefinition.Events);
-			addPropertyDefinitions(typeDefinition.Properties);
-			access(() => addCustomAttributes(typeDefinition.CustomAttributes));
-			addSecurityDeclarations(typeDefinition.SecurityDeclarations);
-		}
-		void addTypeSpecification(TypeSpecification ts) {
-			if (ts == null)
-				return;
-			addTypeReference(ts);
-			pushMember(ts.ElementType);
-		}
-		void addArrayType(ArrayType at) {
-			if (at == null)
-				return;
-			addTypeSpecification(at);
-		}
-		void addFunctionPointerType(FunctionPointerType fpt) {
-			if (fpt == null)
-				return;
-			addTypeSpecification(fpt);
-
-			// It's an anon MethodReference created by the class. Not useful to us.
-			//pushMember(fpt.function);
-		}
-		void addGenericInstanceType(GenericInstanceType git) {
-			if (git == null)
-				return;
-			addTypeSpecification(git);
-			addTypeReferences(git.GenericArguments);
-		}
-		void addOptionalModifierType(OptionalModifierType omt) {
-			if (omt == null)
-				return;
-			addTypeSpecification(omt);
-			pushMember(omt.ModifierType);
-		}
-		void addRequiredModifierType(RequiredModifierType rmt) {
-			if (rmt == null)
-				return;
-			addTypeSpecification(rmt);
-			pushMember(rmt.ModifierType);
-		}
-		void addPinnedType(PinnedType pt) {
-			if (pt == null)
-				return;
-			addTypeSpecification(pt);
-		}
-		void addPointerType(PointerType pt) {
-			if (pt == null)
-				return;
-			addTypeSpecification(pt);
-		}
-		void addByReferenceType(ByReferenceType brt) {
-			if (brt == null)
-				return;
-			addTypeSpecification(brt);
-		}
-		void addSentinelType(SentinelType st) {
-			if (st == null)
-				return;
-			addTypeSpecification(st);
-		}
-		void addCallSite(CallSite cs) {
-			if (cs == null)
-				return;
-			pushMember(cs.signature);
+			foreach (var eh in ehs)
+				push(eh.CatchType);
 		}
 
-		void doEventDefinition(EventDefinition eventDefinition) {
-			if (eventDefinitions.ContainsKey(eventDefinition))
+		void add(IEnumerable<Local> locals) {
+			if (locals == null)
 				return;
-			eventDefinitions[eventDefinition] = true;
-			addEventDefinition(eventDefinition);
+			foreach (var local in locals)
+				add(local);
 		}
-		void doFieldReference(FieldReference fieldReference) {
-			if (fieldReferences.ContainsKey(fieldReference))
+
+		void add(Local local) {
+			if (local == null)
 				return;
-			fieldReferences[fieldReference] = true;
-			addFieldReference(fieldReference);
+			add(local.Type);
 		}
-		void doFieldDefinition(FieldDefinition fieldDefinition) {
-			if (fieldDefinitions.ContainsKey(fieldDefinition))
+
+		void add(IEnumerable<Parameter> ps) {
+			if (ps == null)
 				return;
-			fieldDefinitions[fieldDefinition] = true;
-			addFieldDefinition(fieldDefinition);
+			foreach (var p in ps)
+				add(p);
 		}
-		void doMethodReference(MethodReference methodReference) {
-			if (methodReferences.ContainsKey(methodReference))
+
+		void add(Parameter param) {
+			if (param == null)
 				return;
-			methodReferences[methodReference] = true;
-			addMethodReference(methodReference);
+			add(param.Type);
+			add(param.Method);
 		}
-		void doMethodDefinition(MethodDefinition methodDefinition) {
-			if (methodDefinitions.ContainsKey(methodDefinition))
+
+		void add(IEnumerable<ParamDef> pds) {
+			if (pds == null)
 				return;
-			methodDefinitions[methodDefinition] = true;
-			addMethodDefinition(methodDefinition);
+			foreach (var pd in pds)
+				add(pd);
 		}
-		void doGenericInstanceMethod(GenericInstanceMethod genericInstanceMethod) {
-			if (genericInstanceMethods.ContainsKey(genericInstanceMethod))
+
+		void add(ParamDef pd) {
+			if (pd == null)
 				return;
-			genericInstanceMethods[genericInstanceMethod] = true;
-			addGenericInstanceMethod(genericInstanceMethod);
+			add(pd.DeclaringMethod);
+			add(pd.CustomAttributes);
 		}
-		void doPropertyDefinition(PropertyDefinition propertyDefinition) {
-			if (propertyDefinitions.ContainsKey(propertyDefinition))
+
+		void add(IEnumerable<MethodOverride> mos) {
+			if (mos == null)
 				return;
-			propertyDefinitions[propertyDefinition] = true;
-			addPropertyDefinition(propertyDefinition);
+			foreach (var mo in mos)
+				add(mo);
 		}
-		void doTypeReference(TypeReference typeReference) {
-			if (typeReferences.ContainsKey(typeReference))
-				return;
-			typeReferences[typeReference] = true;
-			addTypeReference(typeReference);
+
+		void add(MethodOverride mo) {
+			// It's a struct so can't be null
+			push(mo.MethodBody);
+			push(mo.MethodDeclaration);
 		}
-		void doTypeDefinition(TypeDefinition typeDefinition) {
-			if (typeDefinitions.ContainsKey(typeDefinition))
+
+		void add(MethodSpec ms) {
+			if (ms == null || methodSpecs.ContainsKey(ms))
 				return;
-			typeDefinitions[typeDefinition] = true;
-			addTypeDefinition(typeDefinition);
+			if (ms.Method != null && ms.Method.DeclaringType != null && ms.Method.DeclaringType.Module != validModule)
+				return;
+			methodSpecs[ms] = true;
+			push(ms.Method);
+			add(ms.Instantiation);
+			add(ms.CustomAttributes);
 		}
-		void doGenericParameter(GenericParameter genericParameter) {
-			if (genericParameters.ContainsKey(genericParameter))
+
+		void add(IEnumerable<PropertyDef> pds) {
+			if (pds == null)
 				return;
-			genericParameters[genericParameter] = true;
-			addGenericParameter(genericParameter);
+			foreach (var pd in pds)
+				add(pd);
 		}
-		void doArrayType(ArrayType arrayType) {
-			if (arrayTypes.ContainsKey(arrayType))
+
+		void add(PropertyDef pd) {
+			if (pd == null || propertyDefs.ContainsKey(pd))
 				return;
-			arrayTypes[arrayType] = true;
-			addArrayType(arrayType);
+			if (pd.DeclaringType != null && pd.DeclaringType.Module != validModule)
+				return;
+			propertyDefs[pd] = true;
+			add(pd.Type);
+			add(pd.CustomAttributes);
+			add(pd.GetMethod);
+			add(pd.SetMethod);
+			add(pd.OtherMethods);
+			add(pd.DeclaringType);
 		}
-		void doFunctionPointerType(FunctionPointerType functionPointerType) {
-			if (functionPointerTypes.ContainsKey(functionPointerType))
+
+		void add(IEnumerable<TypeDef> tds) {
+			if (tds == null)
 				return;
-			functionPointerTypes[functionPointerType] = true;
-			addFunctionPointerType(functionPointerType);
+			foreach (var td in tds)
+				add(td);
 		}
-		void doGenericInstanceType(GenericInstanceType genericInstanceType) {
-			if (genericInstanceTypes.ContainsKey(genericInstanceType))
+
+		void add(TypeDef td) {
+			if (td == null || typeDefs.ContainsKey(td))
 				return;
-			genericInstanceTypes[genericInstanceType] = true;
-			addGenericInstanceType(genericInstanceType);
+			if (td.Module != validModule)
+				return;
+			typeDefs[td] = true;
+			push(td.BaseType);
+			add(td.Fields);
+			add(td.Methods);
+			add(td.GenericParameters);
+			add(td.Interfaces);
+			add(td.DeclSecurities);
+			add(td.DeclaringType);
+			add(td.Events);
+			add(td.Properties);
+			add(td.NestedTypes);
+			add(td.CustomAttributes);
 		}
-		void doOptionalModifierType(OptionalModifierType optionalModifierType) {
-			if (optionalModifierTypes.ContainsKey(optionalModifierType))
+
+		void add(IEnumerable<InterfaceImpl> iis) {
+			if (iis == null)
 				return;
-			optionalModifierTypes[optionalModifierType] = true;
-			addOptionalModifierType(optionalModifierType);
+			foreach (var ii in iis)
+				add(ii);
 		}
-		void doRequiredModifierType(RequiredModifierType requiredModifierType) {
-			if (requiredModifierTypes.ContainsKey(requiredModifierType))
+
+		void add(InterfaceImpl ii) {
+			if (ii == null)
 				return;
-			requiredModifierTypes[requiredModifierType] = true;
-			addRequiredModifierType(requiredModifierType);
+			push(ii.Interface);
+			add(ii.CustomAttributes);
 		}
-		void doPinnedType(PinnedType pinnedType) {
-			if (pinnedTypes.ContainsKey(pinnedType))
+
+		void add(TypeRef tr) {
+			if (tr == null || typeRefs.ContainsKey(tr))
 				return;
-			pinnedTypes[pinnedType] = true;
-			addPinnedType(pinnedType);
+			if (tr.Module != validModule)
+				return;
+			typeRefs[tr] = true;
+			push(tr.ResolutionScope);
+			add(tr.CustomAttributes);
 		}
-		void doPointerType(PointerType pointerType) {
-			if (pointerTypes.ContainsKey(pointerType))
+
+		void add(IEnumerable<TypeSig> tss) {
+			if (tss == null)
 				return;
-			pointerTypes[pointerType] = true;
-			addPointerType(pointerType);
+			foreach (var ts in tss)
+				add(ts);
 		}
-		void doByReferenceType(ByReferenceType byReferenceType) {
-			if (byReferenceTypes.ContainsKey(byReferenceType))
+
+		void add(TypeSig ts) {
+			if (ts == null || typeSigs.ContainsKey(ts))
 				return;
-			byReferenceTypes[byReferenceType] = true;
-			addByReferenceType(byReferenceType);
+			if (ts.Module != validModule)
+				return;
+			typeSigs[ts] = true;
+
+			for (; ts != null; ts = ts.Next) {
+				switch (ts.ElementType) {
+				case ElementType.Void:
+				case ElementType.Boolean:
+				case ElementType.Char:
+				case ElementType.I1:
+				case ElementType.U1:
+				case ElementType.I2:
+				case ElementType.U2:
+				case ElementType.I4:
+				case ElementType.U4:
+				case ElementType.I8:
+				case ElementType.U8:
+				case ElementType.R4:
+				case ElementType.R8:
+				case ElementType.String:
+				case ElementType.ValueType:
+				case ElementType.Class:
+				case ElementType.TypedByRef:
+				case ElementType.I:
+				case ElementType.U:
+				case ElementType.Object:
+					var tdrs = (TypeDefOrRefSig)ts;
+					push(tdrs.TypeDefOrRef);
+					break;
+
+				case ElementType.FnPtr:
+					var fps = (FnPtrSig)ts;
+					add(fps.Signature);
+					break;
+
+				case ElementType.GenericInst:
+					var gis = (GenericInstSig)ts;
+					add(gis.GenericType);
+					add(gis.GenericArguments);
+					break;
+
+				case ElementType.CModReqd:
+				case ElementType.CModOpt:
+					var ms = (ModifierSig)ts;
+					push(ms.Modifier);
+					break;
+
+				case ElementType.End:
+				case ElementType.Ptr:
+				case ElementType.ByRef:
+				case ElementType.Var:
+				case ElementType.Array:
+				case ElementType.ValueArray:
+				case ElementType.R:
+				case ElementType.SZArray:
+				case ElementType.MVar:
+				case ElementType.Internal:
+				case ElementType.Module:
+				case ElementType.Sentinel:
+				case ElementType.Pinned:
+				default:
+					break;
+				}
+			}
 		}
-		void doSentinelType(SentinelType sentinelType) {
-			if (sentinelTypes.ContainsKey(sentinelType))
+
+		void add(TypeSpec ts) {
+			if (ts == null || typeSpecs.ContainsKey(ts))
 				return;
-			sentinelTypes[sentinelType] = true;
-			addSentinelType(sentinelType);
+			if (ts.Module != validModule)
+				return;
+			typeSpecs[ts] = true;
+			add(ts.TypeSig);
+			add(ts.CustomAttributes);
+		}
+
+		void add(IEnumerable<ExportedType> ets) {
+			if (ets == null)
+				return;
+			foreach (var et in ets)
+				add(et);
+		}
+
+		void add(ExportedType et) {
+			if (et == null || exportedTypes.ContainsKey(et))
+				return;
+			if (et.Module != validModule)
+				return;
+			exportedTypes[et] = true;
+			add(et.CustomAttributes);
+			push(et.Implementation);
 		}
 	}
 }
diff --git a/de4dot.code/renamer/asmmodules/MethodDef.cs b/de4dot.code/renamer/asmmodules/MethodDef.cs
index 29518dce..b365f20b 100644
--- a/de4dot.code/renamer/asmmodules/MethodDef.cs
+++ b/de4dot.code/renamer/asmmodules/MethodDef.cs
@@ -18,51 +18,78 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace de4dot.code.renamer.asmmodules {
-	class MethodDef : Ref {
-		IList<GenericParamDef> genericParams;
-		IList<ParamDef> paramDefs = new List<ParamDef>();
+	class MMethodDef : Ref {
+		IList<MGenericParamDef> genericParams;
+		IList<MParamDef> paramDefs = new List<MParamDef>();
+		MParamDef returnParamDef;
+		int visibleParamCount;
+		int visibleBaseIndex;
 
-		public PropertyDef Property { get; set; }
-		public EventDef Event { get; set; }
+		public MPropertyDef Property { get; set; }
+		public MEventDef Event { get; set; }
 
-		public IList<ParamDef> ParamDefs {
+		public int VisibleParameterCount {
+			get { return visibleParamCount; }
+		}
+
+		public int VisibleParameterBaseIndex {
+			get { return visibleBaseIndex; }
+		}
+
+		public IList<MParamDef> ParamDefs {
 			get { return paramDefs; }
 		}
 
-		public IList<GenericParamDef> GenericParams {
-			get { return genericParams; }
-		}
-
-		public MethodDefinition MethodDefinition {
-			get { return (MethodDefinition)memberReference; }
-		}
-
-		public MethodDef(MethodDefinition methodDefinition, TypeDef owner, int index)
-			: base(methodDefinition, owner, index) {
-			genericParams = GenericParamDef.createGenericParamDefList(MethodDefinition.GenericParameters);
-			for (int i = 0; i < methodDefinition.Parameters.Count; i++) {
-				var param = methodDefinition.Parameters[i];
-				paramDefs.Add(new ParamDef(param, i));
+		public IEnumerable<MParamDef> AllParamDefs {
+			get {
+				yield return returnParamDef;
+				foreach (var paramDef in paramDefs)
+					yield return paramDef;
 			}
 		}
 
+		public MParamDef ReturnParamDef {
+			get { return returnParamDef; }
+		}
+
+		public IList<MGenericParamDef> GenericParams {
+			get { return genericParams; }
+		}
+
+		public MethodDef MethodDef {
+			get { return (MethodDef)memberReference; }
+		}
+
+		public MMethodDef(MethodDef methodDefinition, MTypeDef owner, int index)
+			: base(methodDefinition, owner, index) {
+			genericParams = MGenericParamDef.createGenericParamDefList(MethodDef.GenericParameters);
+			visibleBaseIndex = methodDefinition.MethodSig != null && methodDefinition.MethodSig.HasThis ? 1 : 0;
+			for (int i = 0; i < methodDefinition.Parameters.Count; i++) {
+				var param = methodDefinition.Parameters[i];
+				if (param.IsNormalMethodParameter)
+					visibleParamCount++;
+				paramDefs.Add(new MParamDef(param, i));
+			}
+			returnParamDef = new MParamDef(methodDefinition.Parameters.ReturnParameter, -1);
+		}
+
 		public bool isPublic() {
-			return MethodDefinition.IsPublic;
+			return MethodDef.IsPublic;
 		}
 
 		public bool isVirtual() {
-			return MethodDefinition.IsVirtual;
+			return MethodDef.IsVirtual;
 		}
 
 		public bool isNewSlot() {
-			return MethodDefinition.IsNewSlot;
+			return MethodDef.IsNewSlot;
 		}
 
 		public bool isStatic() {
-			return MethodDefinition.IsStatic;
+			return MethodDef.IsStatic;
 		}
 	}
 }
diff --git a/de4dot.code/renamer/asmmodules/MethodNameGroups.cs b/de4dot.code/renamer/asmmodules/MethodNameGroups.cs
index aa10957c..eadb760e 100644
--- a/de4dot.code/renamer/asmmodules/MethodNameGroups.cs
+++ b/de4dot.code/renamer/asmmodules/MethodNameGroups.cs
@@ -22,9 +22,9 @@ using System.Collections.Generic;
 
 namespace de4dot.code.renamer.asmmodules {
 	class MethodNameGroup {
-		List<MethodDef> methods = new List<MethodDef>();
+		List<MMethodDef> methods = new List<MMethodDef>();
 
-		public List<MethodDef> Methods {
+		public List<MMethodDef> Methods {
 			get { return methods; }
 		}
 
@@ -32,7 +32,7 @@ namespace de4dot.code.renamer.asmmodules {
 			get { return methods.Count; }
 		}
 
-		public void add(MethodDef method) {
+		public void add(MMethodDef method) {
 			methods.Add(method);
 		}
 
@@ -52,7 +52,7 @@ namespace de4dot.code.renamer.asmmodules {
 
 		public bool hasInterfaceMethod() {
 			foreach (var method in methods) {
-				if (method.Owner.TypeDefinition.IsInterface)
+				if (method.Owner.TypeDef.IsInterface)
 					return true;
 			}
 			return false;
@@ -102,17 +102,17 @@ namespace de4dot.code.renamer.asmmodules {
 	}
 
 	class MethodNameGroups {
-		Dictionary<MethodDef, MethodNameGroup> methodGroups = new Dictionary<MethodDef, MethodNameGroup>();
+		Dictionary<MMethodDef, MethodNameGroup> methodGroups = new Dictionary<MMethodDef, MethodNameGroup>();
 
-		public void same(MethodDef a, MethodDef b) {
+		public void same(MMethodDef a, MMethodDef b) {
 			merge(get(a), get(b));
 		}
 
-		public void add(MethodDef methodDef) {
+		public void add(MMethodDef methodDef) {
 			get(methodDef);
 		}
 
-		public MethodNameGroup get(MethodDef method) {
+		public MethodNameGroup get(MMethodDef method) {
 			if (!method.isVirtual())
 				throw new ApplicationException("Not a virtual method");
 			MethodNameGroup group;
diff --git a/de4dot.code/renamer/asmmodules/Module.cs b/de4dot.code/renamer/asmmodules/Module.cs
index 1b94bd76..69ad8a91 100644
--- a/de4dot.code/renamer/asmmodules/Module.cs
+++ b/de4dot.code/renamer/asmmodules/Module.cs
@@ -19,7 +19,7 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.renamer.asmmodules {
@@ -27,25 +27,25 @@ namespace de4dot.code.renamer.asmmodules {
 		IObfuscatedFile obfuscatedFile;
 		TypeDefDict types = new TypeDefDict();
 		MemberRefFinder memberRefFinder;
-		IList<RefToDef<TypeReference, TypeDefinition>> typeRefsToRename = new List<RefToDef<TypeReference, TypeDefinition>>();
-		IList<RefToDef<MethodReference, MethodDefinition>> methodRefsToRename = new List<RefToDef<MethodReference, MethodDefinition>>();
-		IList<RefToDef<FieldReference, FieldDefinition>> fieldRefsToRename = new List<RefToDef<FieldReference, FieldDefinition>>();
+		IList<RefToDef<TypeRef, TypeDef>> typeRefsToRename = new List<RefToDef<TypeRef, TypeDef>>();
+		IList<RefToDef<MemberRef, MethodDef>> methodRefsToRename = new List<RefToDef<MemberRef, MethodDef>>();
+		IList<RefToDef<MemberRef, FieldDef>> fieldRefsToRename = new List<RefToDef<MemberRef, FieldDef>>();
 		List<CustomAttributeReference> customAttributeFieldReferences = new List<CustomAttributeReference>();
 		List<CustomAttributeReference> customAttributePropertyReferences = new List<CustomAttributeReference>();
-		List<MethodDefinition> allMethods;
+		List<MethodDef> allMethods;
 
 		public class CustomAttributeReference {
 			public CustomAttribute cattr;
 			public int index;
-			public MemberReference reference;
-			public CustomAttributeReference(CustomAttribute cattr, int index, MemberReference reference) {
+			public IMemberRef reference;
+			public CustomAttributeReference(CustomAttribute cattr, int index, IMemberRef reference) {
 				this.cattr = cattr;
 				this.index = index;
 				this.reference = reference;
 			}
 		}
 
-		public class RefToDef<R, D> where R : MemberReference where D : R {
+		public class RefToDef<R, D> where R : ICodedToken where D : ICodedToken {
 			public R reference;
 			public D definition;
 			public RefToDef(R reference, D definition) {
@@ -54,15 +54,15 @@ namespace de4dot.code.renamer.asmmodules {
 			}
 		}
 
-		public IEnumerable<RefToDef<TypeReference, TypeDefinition>> TypeRefsToRename {
+		public IEnumerable<RefToDef<TypeRef, TypeDef>> TypeRefsToRename {
 			get { return typeRefsToRename; }
 		}
 
-		public IEnumerable<RefToDef<MethodReference, MethodDefinition>> MethodRefsToRename {
+		public IEnumerable<RefToDef<MemberRef, MethodDef>> MethodRefsToRename {
 			get { return methodRefsToRename; }
 		}
 
-		public IEnumerable<RefToDef<FieldReference, FieldDefinition>> FieldRefsToRename {
+		public IEnumerable<RefToDef<MemberRef, FieldDef>> FieldRefsToRename {
 			get { return fieldRefsToRename; }
 		}
 
@@ -82,43 +82,43 @@ namespace de4dot.code.renamer.asmmodules {
 			get { return obfuscatedFile.Filename; }
 		}
 
-		public ModuleDefinition ModuleDefinition {
-			get { return obfuscatedFile.ModuleDefinition; }
+		public ModuleDefMD ModuleDefMD {
+			get { return obfuscatedFile.ModuleDefMD; }
 		}
 
 		public Module(IObfuscatedFile obfuscatedFile) {
 			this.obfuscatedFile = obfuscatedFile;
 		}
 
-		public IEnumerable<TypeDef> getAllTypes() {
+		public IEnumerable<MTypeDef> getAllTypes() {
 			return types.getValues();
 		}
 
-		public IEnumerable<MethodDefinition> getAllMethods() {
+		public IEnumerable<MethodDef> getAllMethods() {
 			return allMethods;
 		}
 
 		public void findAllMemberReferences(ref int typeIndex) {
 			memberRefFinder = new MemberRefFinder();
-			memberRefFinder.findAll(ModuleDefinition, ModuleDefinition.Types);
-			allMethods = new List<MethodDefinition>(memberRefFinder.methodDefinitions.Keys);
+			memberRefFinder.findAll(ModuleDefMD);
+			allMethods = new List<MethodDef>(memberRefFinder.methodDefs.Keys);
 
-			var allTypesList = new List<TypeDef>();
-			foreach (var type in memberRefFinder.typeDefinitions.Keys) {
-				var typeDef = new TypeDef(type, this, typeIndex++);
+			var allTypesList = new List<MTypeDef>();
+			foreach (var type in memberRefFinder.typeDefs.Keys) {
+				var typeDef = new MTypeDef(type, this, typeIndex++);
 				types.add(typeDef);
 				allTypesList.Add(typeDef);
 				typeDef.addMembers();
 			}
 
-			var allTypesCopy = new List<TypeDef>(allTypesList);
-			var typeToIndex = new Dictionary<TypeDefinition, int>();
+			var allTypesCopy = new List<MTypeDef>(allTypesList);
+			var typeToIndex = new Dictionary<TypeDef, int>();
 			for (int i = 0; i < allTypesList.Count; i++)
-				typeToIndex[allTypesList[i].TypeDefinition] = i;
+				typeToIndex[allTypesList[i].TypeDef] = i;
 			foreach (var typeDef in allTypesList) {
-				if (typeDef.TypeDefinition.NestedTypes == null)
+				if (typeDef.TypeDef.NestedTypes == null)
 					continue;
-				foreach (var nestedTypeDefinition in typeDef.TypeDefinition.NestedTypes) {
+				foreach (var nestedTypeDefinition in typeDef.TypeDef.NestedTypes) {
 					int index = typeToIndex[nestedTypeDefinition];
 					var nestedTypeDef = allTypesCopy[index];
 					allTypesCopy[index] = null;
@@ -131,67 +131,68 @@ namespace de4dot.code.renamer.asmmodules {
 		}
 
 		public void resolveAllRefs(IResolver resolver) {
-			foreach (var typeRef in memberRefFinder.typeReferences.Keys) {
-				var typeDef = resolver.resolve(typeRef);
+			foreach (var typeRef in memberRefFinder.typeRefs.Keys) {
+				var typeDef = resolver.resolveType(typeRef);
 				if (typeDef != null)
-					typeRefsToRename.Add(new RefToDef<TypeReference, TypeDefinition>(typeRef, typeDef.TypeDefinition));
+					typeRefsToRename.Add(new RefToDef<TypeRef, TypeDef>(typeRef, typeDef.TypeDef));
 			}
 
-			foreach (var methodRef in memberRefFinder.methodReferences.Keys) {
-				var methodDef = resolver.resolve(methodRef);
-				if (methodDef != null)
-					methodRefsToRename.Add(new RefToDef<MethodReference, MethodDefinition>(methodRef, methodDef.MethodDefinition));
-			}
-
-			foreach (var fieldRef in memberRefFinder.fieldReferences.Keys) {
-				var fieldDef = resolver.resolve(fieldRef);
-				if (fieldDef != null)
-					fieldRefsToRename.Add(new RefToDef<FieldReference, FieldDefinition>(fieldRef, fieldDef.FieldDefinition));
+			foreach (var memberRef in memberRefFinder.memberRefs.Keys) {
+				if (memberRef.IsMethodRef) {
+					var methodDef = resolver.resolveMethod(memberRef);
+					if (methodDef != null)
+						methodRefsToRename.Add(new RefToDef<MemberRef, MethodDef>(memberRef, methodDef.MethodDef));
+				}
+				else if (memberRef.IsFieldRef) {
+					var fieldDef = resolver.resolveField(memberRef);
+					if (fieldDef != null)
+						fieldRefsToRename.Add(new RefToDef<MemberRef, FieldDef>(memberRef, fieldDef.FieldDef));
+				}
 			}
 
 			foreach (var cattr in memberRefFinder.customAttributes.Keys) {
-				try {
-					var typeDef = resolver.resolve(cattr.AttributeType);
-					if (typeDef == null)
-						continue;
+				var typeDef = resolver.resolveType(cattr.AttributeType);
+				if (typeDef == null)
+					continue;
+				if (cattr.NamedArguments == null)
+					continue;
 
-					for (int i = 0; i < cattr.Fields.Count; i++) {
-						var field = cattr.Fields[i];
-						var fieldDef = findFieldByName(typeDef, field.Name);
+				for (int i = 0; i < cattr.NamedArguments.Count; i++) {
+					var namedArg = cattr.NamedArguments[i];
+					if (namedArg.IsField) {
+						var fieldDef = findField(typeDef, namedArg.Name, namedArg.Type);
 						if (fieldDef == null) {
-							Log.w("Could not find field {0} in attribute {1} ({2:X8})",
-									Utils.toCsharpString(field.Name),
-									Utils.toCsharpString(typeDef.TypeDefinition.Name),
-									typeDef.TypeDefinition.MetadataToken.ToInt32());
+							Logger.w("Could not find field {0} in attribute {1} ({2:X8})",
+									Utils.toCsharpString(namedArg.Name),
+									Utils.toCsharpString(typeDef.TypeDef.Name),
+									typeDef.TypeDef.MDToken.ToInt32());
 							continue;
 						}
 
-						customAttributeFieldReferences.Add(new CustomAttributeReference(cattr, i, fieldDef.FieldDefinition));
+						customAttributeFieldReferences.Add(new CustomAttributeReference(cattr, i, fieldDef.FieldDef));
 					}
-
-					for (int i = 0; i < cattr.Properties.Count; i++) {
-						var prop = cattr.Properties[i];
-						var propDef = findPropertyByName(typeDef, prop.Name);
+					else {
+						var propDef = findProperty(typeDef, namedArg.Name, namedArg.Type);
 						if (propDef == null) {
-							Log.w("Could not find property {0} in attribute {1} ({2:X8})",
-									Utils.toCsharpString(prop.Name),
-									Utils.toCsharpString(typeDef.TypeDefinition.Name),
-									typeDef.TypeDefinition.MetadataToken.ToInt32());
+							Logger.w("Could not find property {0} in attribute {1} ({2:X8})",
+									Utils.toCsharpString(namedArg.Name),
+									Utils.toCsharpString(typeDef.TypeDef.Name),
+									typeDef.TypeDef.MDToken.ToInt32());
 							continue;
 						}
 
-						customAttributePropertyReferences.Add(new CustomAttributeReference(cattr, i, propDef.PropertyDefinition));
+						customAttributePropertyReferences.Add(new CustomAttributeReference(cattr, i, propDef.PropertyDef));
 					}
 				}
-				catch {
-				}
 			}
 		}
 
-		static FieldDef findFieldByName(TypeDef typeDef, string name) {
+		static MFieldDef findField(MTypeDef typeDef, UTF8String name, TypeSig fieldType) {
 			while (typeDef != null) {
 				foreach (var fieldDef in typeDef.AllFields) {
-					if (fieldDef.FieldDefinition.Name == name)
+					if (fieldDef.FieldDef.Name != name)
+						continue;
+					if (new SigComparer().Equals(fieldDef.FieldDef.FieldSig.GetFieldType(), fieldType))
 						return fieldDef;
 				}
 
@@ -202,10 +203,12 @@ namespace de4dot.code.renamer.asmmodules {
 			return null;
 		}
 
-		static PropertyDef findPropertyByName(TypeDef typeDef, string name) {
+		static MPropertyDef findProperty(MTypeDef typeDef, UTF8String name, TypeSig propType) {
 			while (typeDef != null) {
 				foreach (var propDef in typeDef.AllProperties) {
-					if (propDef.PropertyDefinition.Name == name)
+					if (propDef.PropertyDef.Name != name)
+						continue;
+					if (new SigComparer().Equals(propDef.PropertyDef.PropertySig.GetRetType(), propType))
 						return propDef;
 				}
 
@@ -223,33 +226,38 @@ namespace de4dot.code.renamer.asmmodules {
 				newTypes.add(typeDef);
 			}
 			types = newTypes;
+
+			bool old = ModuleDefMD.EnableTypeDefFindCache;
+			ModuleDefMD.EnableTypeDefFindCache = false;
+			ModuleDefMD.EnableTypeDefFindCache = old;
 		}
 
-		static TypeReference getNonGenericTypeReference(TypeReference typeReference) {
-			if (typeReference == null)
-				return null;
-			if (!typeReference.IsGenericInstance)
-				return typeReference;
-			var type = (GenericInstanceType)typeReference;
-			return type.ElementType;
+		static ITypeDefOrRef getNonGenericTypeReference(ITypeDefOrRef typeRef) {
+			var ts = typeRef as TypeSpec;
+			if (ts == null)
+				return typeRef;
+			var gis = ts.ToGenericInstSig();
+			if (gis == null || gis.GenericType == null)
+				return typeRef;
+			return gis.GenericType.TypeDefOrRef;
 		}
 
-		public TypeDef resolve(TypeReference typeReference) {
+		public MTypeDef resolveType(ITypeDefOrRef typeReference) {
 			return this.types.find(getNonGenericTypeReference(typeReference));
 		}
 
-		public MethodDef resolve(MethodReference methodReference) {
-			var typeDef = this.types.find(getNonGenericTypeReference(methodReference.DeclaringType));
+		public MMethodDef resolveMethod(IMethodDefOrRef methodRef) {
+			var typeDef = this.types.find(getNonGenericTypeReference(methodRef.DeclaringType));
 			if (typeDef == null)
 				return null;
-			return typeDef.find(methodReference);
+			return typeDef.findMethod(methodRef);
 		}
 
-		public FieldDef resolve(FieldReference fieldReference) {
-			var typeDef = this.types.find(getNonGenericTypeReference(fieldReference.DeclaringType));
+		public MFieldDef resolveField(MemberRef fieldRef) {
+			var typeDef = this.types.find(getNonGenericTypeReference(fieldRef.DeclaringType));
 			if (typeDef == null)
 				return null;
-			return typeDef.find(fieldReference);
+			return typeDef.findField(fieldRef);
 		}
 	}
 }
diff --git a/de4dot.code/renamer/asmmodules/Modules.cs b/de4dot.code/renamer/asmmodules/Modules.cs
index 9cc0bd1d..1fecf5a6 100644
--- a/de4dot.code/renamer/asmmodules/Modules.cs
+++ b/de4dot.code/renamer/asmmodules/Modules.cs
@@ -19,7 +19,7 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.renamer.asmmodules {
@@ -27,26 +27,26 @@ namespace de4dot.code.renamer.asmmodules {
 		bool initializeCalled = false;
 		IDeobfuscatorContext deobfuscatorContext;
 		List<Module> modules = new List<Module>();
-		Dictionary<ModuleDefinition, Module> modulesDict = new Dictionary<ModuleDefinition, Module>();
+		Dictionary<ModuleDef, Module> modulesDict = new Dictionary<ModuleDef, Module>();
 		AssemblyHash assemblyHash = new AssemblyHash();
 
-		List<TypeDef> allTypes = new List<TypeDef>();
-		List<TypeDef> baseTypes = new List<TypeDef>();
-		List<TypeDef> nonNestedTypes;
+		List<MTypeDef> allTypes = new List<MTypeDef>();
+		List<MTypeDef> baseTypes = new List<MTypeDef>();
+		List<MTypeDef> nonNestedTypes;
 
 		public IList<Module> TheModules {
 			get { return modules; }
 		}
 
-		public IEnumerable<TypeDef> AllTypes {
+		public IEnumerable<MTypeDef> AllTypes {
 			get { return allTypes; }
 		}
 
-		public IEnumerable<TypeDef> BaseTypes {
+		public IEnumerable<MTypeDef> BaseTypes {
 			get { return baseTypes; }
 		}
 
-		public List<TypeDef> NonNestedTypes {
+		public List<MTypeDef> NonNestedTypes {
 			get { return nonNestedTypes; }
 		}
 
@@ -62,9 +62,9 @@ namespace de4dot.code.renamer.asmmodules {
 			}
 
 			string getModuleKey(Module module) {
-				if (module.ModuleDefinition.Assembly != null)
-					return module.ModuleDefinition.Assembly.ToString();
-				return Utils.getBaseName(module.ModuleDefinition.FullyQualifiedName);
+				if (module.ModuleDefMD.Assembly != null)
+					return module.ModuleDefMD.Assembly.ToString();
+				return Utils.getBaseName(module.ModuleDefMD.Location);
 			}
 
 			public ModuleHash lookup(string assemblyName) {
@@ -80,16 +80,16 @@ namespace de4dot.code.renamer.asmmodules {
 			Module mainModule = null;
 
 			public void add(Module module) {
-				var asm = module.ModuleDefinition.Assembly;
-				if (asm != null && ReferenceEquals(asm.MainModule, module.ModuleDefinition)) {
+				var asm = module.ModuleDefMD.Assembly;
+				if (asm != null && ReferenceEquals(asm.ManifestModule, module.ModuleDefMD)) {
 					if (mainModule != null) {
 						throw new UserException(string.Format(
 							"Two modules in the same assembly are main modules.\n" +
 							"Is one 32-bit and the other 64-bit?\n" +
 							"  Module1: \"{0}\"" +
 							"  Module2: \"{1}\"",
-							module.ModuleDefinition.FullyQualifiedName,
-							mainModule.ModuleDefinition.FullyQualifiedName));
+							module.ModuleDefMD.Location,
+							mainModule.ModuleDefMD.Location));
 					}
 					mainModule = module;
 				}
@@ -110,7 +110,7 @@ namespace de4dot.code.renamer.asmmodules {
 			IDictionary<string, Module> modulesDict = new Dictionary<string, Module>(StringComparer.Ordinal);
 
 			public void add(Module module) {
-				var moduleName = module.ModuleDefinition.Name;
+				var moduleName = module.ModuleDefMD.Name.String;
 				if (lookup(moduleName) != null)
 					throw new ApplicationException(string.Format("Module \"{0}\" was found twice", moduleName));
 				modulesDict[moduleName] = module;
@@ -140,9 +140,9 @@ namespace de4dot.code.renamer.asmmodules {
 			if (initializeCalled)
 				throw new ApplicationException("initialize() has been called");
 			Module otherModule;
-			if (modulesDict.TryGetValue(module.ModuleDefinition, out otherModule))
+			if (modulesDict.TryGetValue(module.ModuleDefMD, out otherModule))
 				return;
-			modulesDict[module.ModuleDefinition] = module;
+			modulesDict[module.ModuleDefMD] = module;
 			modules.Add(module);
 			assemblyHash.add(module);
 		}
@@ -155,25 +155,25 @@ namespace de4dot.code.renamer.asmmodules {
 		}
 
 		void findAllMemberReferences() {
-			Log.v("Finding all MemberReferences");
+			Logger.v("Finding all MemberReferences");
 			int index = 0;
 			foreach (var module in modules) {
 				if (modules.Count > 1)
-					Log.v("Finding all MemberReferences ({0})", module.Filename);
-				Log.indent();
+					Logger.v("Finding all MemberReferences ({0})", module.Filename);
+				Logger.Instance.indent();
 				module.findAllMemberReferences(ref index);
-				Log.deIndent();
+				Logger.Instance.deIndent();
 			}
 		}
 
 		void resolveAllRefs() {
-			Log.v("Resolving references");
+			Logger.v("Resolving references");
 			foreach (var module in modules) {
 				if (modules.Count > 1)
-					Log.v("Resolving references ({0})", module.Filename);
-				Log.indent();
+					Logger.v("Resolving references ({0})", module.Filename);
+				Logger.Instance.indent();
 				module.resolveAllRefs(this);
-				Log.deIndent();
+				Logger.Instance.deIndent();
 			}
 		}
 
@@ -181,22 +181,22 @@ namespace de4dot.code.renamer.asmmodules {
 			foreach (var module in modules)
 				allTypes.AddRange(module.getAllTypes());
 
-			var typeToTypeDef = new Dictionary<TypeDefinition, TypeDef>(allTypes.Count);
+			var typeToTypeDef = new Dictionary<TypeDef, MTypeDef>(allTypes.Count);
 			foreach (var typeDef in allTypes)
-				typeToTypeDef[typeDef.TypeDefinition] = typeDef;
+				typeToTypeDef[typeDef.TypeDef] = typeDef;
 
 			// Initialize Owner
 			foreach (var typeDef in allTypes) {
-				if (typeDef.TypeDefinition.DeclaringType != null)
-					typeDef.Owner = typeToTypeDef[typeDef.TypeDefinition.DeclaringType];
+				if (typeDef.TypeDef.DeclaringType != null)
+					typeDef.Owner = typeToTypeDef[typeDef.TypeDef.DeclaringType];
 			}
 
 			// Initialize baseType and derivedTypes
 			foreach (var typeDef in allTypes) {
-				var baseType = typeDef.TypeDefinition.BaseType;
+				var baseType = typeDef.TypeDef.BaseType;
 				if (baseType == null)
 					continue;
-				var baseTypeDef = resolve(baseType) ?? resolveOther(baseType);
+				var baseTypeDef = resolveType(baseType) ?? resolveOther(baseType);
 				if (baseTypeDef != null) {
 					typeDef.addBaseType(baseTypeDef, baseType);
 					baseTypeDef.derivedTypes.Add(typeDef);
@@ -205,24 +205,22 @@ namespace de4dot.code.renamer.asmmodules {
 
 			// Initialize interfaces
 			foreach (var typeDef in allTypes) {
-				if (typeDef.TypeDefinition.Interfaces == null)
-					continue;
-				foreach (var iface in typeDef.TypeDefinition.Interfaces) {
-					var ifaceTypeDef = resolve(iface) ?? resolveOther(iface);
+				foreach (var iface in typeDef.TypeDef.Interfaces) {
+					var ifaceTypeDef = resolveType(iface.Interface) ?? resolveOther(iface.Interface);
 					if (ifaceTypeDef != null)
-						typeDef.addInterface(ifaceTypeDef, iface);
+						typeDef.addInterface(ifaceTypeDef, iface.Interface);
 				}
 			}
 
 			// Find all non-nested types
-			var allTypesDict = new Dictionary<TypeDef, bool>();
+			var allTypesDict = new Dictionary<MTypeDef, bool>();
 			foreach (var t in allTypes)
 				allTypesDict[t] = true;
 			foreach (var t in allTypes) {
 				foreach (var t2 in t.NestedTypes)
 					allTypesDict.Remove(t2);
 			}
-			nonNestedTypes = new List<TypeDef>(allTypesDict.Keys);
+			nonNestedTypes = new List<MTypeDef>(allTypesDict.Keys);
 
 			foreach (var typeDef in allTypes) {
 				if (typeDef.baseType == null || !typeDef.baseType.typeDef.HasModule)
@@ -231,10 +229,10 @@ namespace de4dot.code.renamer.asmmodules {
 		}
 
 		class AssemblyKeyDictionary<T> where T : class {
-			Dictionary<TypeReferenceSameVersionKey, T> dict = new Dictionary<TypeReferenceSameVersionKey, T>();
-			Dictionary<TypeReferenceKey, List<TypeReference>> refs = new Dictionary<TypeReferenceKey, List<TypeReference>>();
+			Dictionary<ITypeDefOrRef, T> dict = new Dictionary<ITypeDefOrRef, T>(new TypeEqualityComparer(SigComparerOptions.CompareAssemblyVersion));
+			Dictionary<ITypeDefOrRef, List<ITypeDefOrRef>> refs = new Dictionary<ITypeDefOrRef, List<ITypeDefOrRef>>(TypeEqualityComparer.Instance);
 
-			public T this[TypeReference type] {
+			public T this[ITypeDefOrRef type] {
 				get {
 					T value;
 					if (tryGetValue(type, out value))
@@ -242,39 +240,35 @@ namespace de4dot.code.renamer.asmmodules {
 					throw new KeyNotFoundException();
 				}
 				set {
-					var key = new TypeReferenceSameVersionKey(type);
-					dict[key] = value;
+					dict[type] = value;
 
 					if (value != null) {
-						var key2 = new TypeReferenceKey(type);
-						List<TypeReference> list;
-						if (!refs.TryGetValue(key2, out list))
-							refs[key2] = list = new List<TypeReference>();
+						List<ITypeDefOrRef> list;
+						if (!refs.TryGetValue(type, out list))
+							refs[type] = list = new List<ITypeDefOrRef>();
 						list.Add(type);
 					}
 				}
 			}
 
-			public bool tryGetValue(TypeReference type, out T value) {
-				return dict.TryGetValue(new TypeReferenceSameVersionKey(type), out value);
+			public bool tryGetValue(ITypeDefOrRef type, out T value) {
+				return dict.TryGetValue(type, out value);
 			}
 
-			public bool tryGetSimilarValue(TypeReference type, out T value) {
-				var key2 = new TypeReferenceKey(type);
-				List<TypeReference> list;
-				if (!refs.TryGetValue(key2, out list)) {
+			public bool tryGetSimilarValue(ITypeDefOrRef type, out T value) {
+				List<ITypeDefOrRef> list;
+				if (!refs.TryGetValue(type, out list)) {
 					value = default(T);
 					return false;
 				}
 
 				// Find a type whose version is >= type's version and closest to it.
 
-				TypeReference foundType = null;
-				var typeAsmName = MemberReferenceHelper.getAssemblyNameReference(type.Scope);
-				AssemblyNameReference foundAsmName = null;
+				ITypeDefOrRef foundType = null;
+				var typeAsmName = type.DefinitionAssembly;
+				IAssembly foundAsmName = null;
 				foreach (var otherRef in list) {
-					var key = new TypeReferenceSameVersionKey(otherRef);
-					if (!dict.TryGetValue(key, out value))
+					if (!dict.TryGetValue(otherRef, out value))
 						continue;
 
 					if (typeAsmName == null) {
@@ -282,11 +276,11 @@ namespace de4dot.code.renamer.asmmodules {
 						break;
 					}
 
-					var otherAsmName = MemberReferenceHelper.getAssemblyNameReference(otherRef.Scope);
+					var otherAsmName = otherRef.DefinitionAssembly;
 					if (otherAsmName == null)
 						continue;
 					// Check pkt or we could return a type in eg. a SL assembly when it's not a SL app.
-					if (!same(typeAsmName.PublicKeyToken, otherAsmName.PublicKeyToken))
+					if (!PublicKeyBase.TokenEquals(typeAsmName.PublicKeyOrToken, otherAsmName.PublicKeyOrToken))
 						continue;
 					if (typeAsmName.Version > otherAsmName.Version)
 						continue;	// old version
@@ -304,40 +298,28 @@ namespace de4dot.code.renamer.asmmodules {
 				}
 
 				if (foundType != null) {
-					value = dict[new TypeReferenceSameVersionKey(foundType)];
+					value = dict[foundType];
 					return true;
 				}
 
 				value = default(T);
 				return false;
 			}
-
-			bool same(byte[] a, byte[] b) {
-				if (ReferenceEquals(a, b))
-					return true;
-				if (a == null || b == null)
-					return false;
-				if (a.Length != b.Length)
-					return false;
-				for (int i = 0; i < a.Length; i++) {
-					if (a[i] != b[i])
-						return false;
-				}
-				return true;
-			}
 		}
 
-		AssemblyKeyDictionary<TypeDef> typeToTypeDefDict = new AssemblyKeyDictionary<TypeDef>();
-		public TypeDef resolveOther(TypeReference type) {
+		AssemblyKeyDictionary<MTypeDef> typeToTypeDefDict = new AssemblyKeyDictionary<MTypeDef>();
+		public MTypeDef resolveOther(ITypeDefOrRef type) {
+			if (type == null)
+				return null;
+			type = type.ScopeType;
 			if (type == null)
 				return null;
-			type = type.GetElementType();
 
-			TypeDef typeDef;
+			MTypeDef typeDef;
 			if (typeToTypeDefDict.tryGetValue(type, out typeDef))
 				return typeDef;
 
-			var typeDefinition = deobfuscatorContext.resolve(type);
+			var typeDefinition = deobfuscatorContext.resolveType(type);
 			if (typeDefinition == null) {
 				typeToTypeDefDict.tryGetSimilarValue(type, out typeDef);
 				typeToTypeDefDict[type] = typeDef;
@@ -352,17 +334,17 @@ namespace de4dot.code.renamer.asmmodules {
 			typeToTypeDefDict[type] = null;	// In case of a circular reference
 			typeToTypeDefDict[typeDefinition] = null;
 
-			typeDef = new TypeDef(typeDefinition, null, 0);
+			typeDef = new MTypeDef(typeDefinition, null, 0);
 			typeDef.addMembers();
-			foreach (var iface in typeDef.TypeDefinition.Interfaces) {
-				var ifaceDef = resolveOther(iface);
+			foreach (var iface in typeDef.TypeDef.Interfaces) {
+				var ifaceDef = resolveOther(iface.Interface);
 				if (ifaceDef == null)
 					continue;
-				typeDef.addInterface(ifaceDef, iface);
+				typeDef.addInterface(ifaceDef, iface.Interface);
 			}
-			var baseDef = resolveOther(typeDef.TypeDefinition.BaseType);
+			var baseDef = resolveOther(typeDef.TypeDef.BaseType);
 			if (baseDef != null)
-				typeDef.addBaseType(baseDef, typeDef.TypeDefinition.BaseType);
+				typeDef.addBaseType(baseDef, typeDef.TypeDef.BaseType);
 
 			typeToTypeDefDict[type] = typeDef;
 			if (type != typeDefinition)
@@ -383,40 +365,47 @@ namespace de4dot.code.renamer.asmmodules {
 		}
 
 		public void cleanUp() {
+#if PORT
 			foreach (var module in DotNetUtils.typeCaches.invalidateAll())
 				AssemblyResolver.Instance.removeModule(module);
+#endif
 		}
 
 		// Returns null if it's a non-loaded module/assembly
-		IEnumerable<Module> findModules(TypeReference type) {
+		IEnumerable<Module> findModules(ITypeDefOrRef type) {
+			if (type == null)
+				return null;
 			var scope = type.Scope;
 			if (scope == null)
 				return null;
 
-			if (scope is AssemblyNameReference)
-				return findModules((AssemblyNameReference)scope);
+			var scopeType = scope.ScopeType;
+			if (scopeType == ScopeType.AssemblyRef)
+				return findModules((AssemblyRef)scope);
 
-			if (scope is ModuleDefinition) {
-				var modules = findModules((ModuleDefinition)scope);
+			if (scopeType == ScopeType.ModuleDef) {
+				var modules = findModules((ModuleDef)scope);
 				if (modules != null)
 					return modules;
 			}
 
-			if (scope is ModuleReference) {
-				var moduleReference = (ModuleReference)scope;
-				if (moduleReference.Name == type.Module.Name) {
+			if (scopeType == ScopeType.ModuleRef) {
+				var moduleRef = (ModuleRef)scope;
+				if (moduleRef.Name == type.Module.Name) {
 					var modules = findModules(type.Module);
 					if (modules != null)
 						return modules;
 				}
+			}
 
+			if (scopeType == ScopeType.ModuleRef || scopeType == ScopeType.ModuleDef) {
 				var asm = type.Module.Assembly;
 				if (asm == null)
 					return null;
-				var moduleHash = assemblyHash.lookup(asm.ToString());
+				var moduleHash = assemblyHash.lookup(asm.FullName);
 				if (moduleHash == null)
 					return null;
-				var module = moduleHash.lookup(moduleReference.Name);
+				var module = moduleHash.lookup(scope.ScopeName);
 				if (module == null)
 					return null;
 				return new List<Module> { module };
@@ -425,80 +414,86 @@ namespace de4dot.code.renamer.asmmodules {
 			throw new ApplicationException(string.Format("scope is an unsupported type: {0}", scope.GetType()));
 		}
 
-		IEnumerable<Module> findModules(AssemblyNameReference assemblyRef) {
-			var moduleHash = assemblyHash.lookup(assemblyRef.ToString());
+		IEnumerable<Module> findModules(AssemblyRef assemblyRef) {
+			var moduleHash = assemblyHash.lookup(assemblyRef.FullName);
 			if (moduleHash != null)
 				return moduleHash.Modules;
 			return null;
 		}
 
-		IEnumerable<Module> findModules(ModuleDefinition moduleDefinition) {
+		IEnumerable<Module> findModules(ModuleDef moduleDef) {
 			Module module;
-			if (modulesDict.TryGetValue(moduleDefinition, out module))
+			if (modulesDict.TryGetValue(moduleDef, out module))
 				return new List<Module> { module };
 			return null;
 		}
 
-		bool isAutoCreatedType(TypeReference typeReference) {
-			return typeReference is ArrayType || typeReference is PointerType || typeReference is FunctionPointerType;
+		bool isAutoCreatedType(ITypeDefOrRef typeRef) {
+			var ts = typeRef as TypeSpec;
+			if (ts == null)
+				return false;
+			var sig = ts.TypeSig;
+			if (sig == null)
+				return false;
+			return sig.IsSZArray || sig.IsArray || sig.IsPointer;
 		}
 
-		public TypeDef resolve(TypeReference typeReference) {
-			var modules = findModules(typeReference);
+		public MTypeDef resolveType(ITypeDefOrRef typeRef) {
+			var modules = findModules(typeRef);
 			if (modules == null)
 				return null;
 			foreach (var module in modules) {
-				var rv = module.resolve(typeReference);
+				var rv = module.resolveType(typeRef);
 				if (rv != null)
 					return rv;
 			}
-			if (isAutoCreatedType(typeReference))
+			if (isAutoCreatedType(typeRef))
 				return null;
-			Log.e("Could not resolve TypeReference {0} ({1:X8}) (from {2} -> {3})",
-						Utils.removeNewlines(typeReference),
-						typeReference.MetadataToken.ToInt32(),
-						typeReference.Module,
-						typeReference.Scope);
+			Logger.e("Could not resolve TypeReference {0} ({1:X8}) (from {2} -> {3})",
+						Utils.removeNewlines(typeRef),
+						typeRef.MDToken.ToInt32(),
+						typeRef.Module,
+						typeRef.Scope);
 			return null;
 		}
 
-		public MethodDef resolve(MethodReference methodReference) {
-			if (methodReference.DeclaringType == null)
+		public MMethodDef resolveMethod(IMethodDefOrRef methodRef) {
+			if (methodRef.DeclaringType == null)
 				return null;
-			var modules = findModules(methodReference.DeclaringType);
+			var modules = findModules(methodRef.DeclaringType);
 			if (modules == null)
 				return null;
 			foreach (var module in modules) {
-				var rv = module.resolve(methodReference);
+				var rv = module.resolveMethod(methodRef);
 				if (rv != null)
 					return rv;
 			}
-			if (isAutoCreatedType(methodReference.DeclaringType))
+			if (isAutoCreatedType(methodRef.DeclaringType))
 				return null;
-			Log.e("Could not resolve MethodReference {0} ({1:X8}) (from {2} -> {3})",
-						Utils.removeNewlines(methodReference),
-						methodReference.MetadataToken.ToInt32(),
-						methodReference.DeclaringType.Module,
-						methodReference.DeclaringType.Scope);
+			Logger.e("Could not resolve MethodReference {0} ({1:X8}) (from {2} -> {3})",
+						Utils.removeNewlines(methodRef),
+						methodRef.MDToken.ToInt32(),
+						methodRef.DeclaringType.Module,
+						methodRef.DeclaringType.Scope);
 			return null;
 		}
 
-		public FieldDef resolve(FieldReference fieldReference) {
+		public MFieldDef resolveField(MemberRef fieldReference) {
 			if (fieldReference.DeclaringType == null)
 				return null;
 			var modules = findModules(fieldReference.DeclaringType);
 			if (modules == null)
 				return null;
 			foreach (var module in modules) {
-				var rv = module.resolve(fieldReference);
+				var rv = module.resolveField(fieldReference);
 				if (rv != null)
 					return rv;
 			}
 			if (isAutoCreatedType(fieldReference.DeclaringType))
 				return null;
-			Log.e("Could not resolve FieldReference {0} ({1:X8}) (from {2} -> {3})",
+			Logger.e("Could not resolve FieldReference {0} ({1:X8}) (from {2} -> {3})",
 						Utils.removeNewlines(fieldReference),
-						fieldReference.MetadataToken.ToInt32(),
+						fieldReference.MDToken.ToInt32(),
 						fieldReference.DeclaringType.Module,
 						fieldReference.DeclaringType.Scope);
 			return null;
diff --git a/de4dot.code/renamer/asmmodules/ParamDef.cs b/de4dot.code/renamer/asmmodules/ParamDef.cs
index 4302da06..376bde46 100644
--- a/de4dot.code/renamer/asmmodules/ParamDef.cs
+++ b/de4dot.code/renamer/asmmodules/ParamDef.cs
@@ -17,14 +17,20 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace de4dot.code.renamer.asmmodules {
-	class ParamDef {
-		public ParameterDefinition ParameterDefinition { get; set; }
+	class MParamDef {
+		public Parameter ParameterDefinition { get; set; }
 		public int Index { get; private set; }
+		public bool IsReturnParameter {
+			get { return ParameterDefinition.IsReturnTypeParameter; }
+		}
+		public bool IsHiddenThisParameter {
+			get { return ParameterDefinition.IsHiddenThisParameter; }
+		}
 
-		public ParamDef(ParameterDefinition parameterDefinition, int index) {
+		public MParamDef(Parameter parameterDefinition, int index) {
 			this.ParameterDefinition = parameterDefinition;
 			Index = index;
 		}
diff --git a/de4dot.code/renamer/asmmodules/PropertyDef.cs b/de4dot.code/renamer/asmmodules/PropertyDef.cs
index 44e7e60f..52d303f7 100644
--- a/de4dot.code/renamer/asmmodules/PropertyDef.cs
+++ b/de4dot.code/renamer/asmmodules/PropertyDef.cs
@@ -18,28 +18,28 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace de4dot.code.renamer.asmmodules {
-	class PropertyDef : Ref {
-		public MethodDef GetMethod { get; set; }
-		public MethodDef SetMethod { get; set; }
+	class MPropertyDef : Ref {
+		public MMethodDef GetMethod { get; set; }
+		public MMethodDef SetMethod { get; set; }
 
-		public PropertyDefinition PropertyDefinition {
-			get { return (PropertyDefinition)memberReference; }
+		public PropertyDef PropertyDef {
+			get { return (PropertyDef)memberReference; }
 		}
 
-		public PropertyDef(PropertyDefinition propertyDefinition, TypeDef owner, int index)
+		public MPropertyDef(PropertyDef propertyDefinition, MTypeDef owner, int index)
 			: base(propertyDefinition, owner, index) {
 		}
 
-		public IEnumerable<MethodDefinition> methodDefinitions() {
-			if (PropertyDefinition.GetMethod != null)
-				yield return PropertyDefinition.GetMethod;
-			if (PropertyDefinition.SetMethod != null)
-				yield return PropertyDefinition.SetMethod;
-			if (PropertyDefinition.OtherMethods != null) {
-				foreach (var m in PropertyDefinition.OtherMethods)
+		public IEnumerable<MethodDef> methodDefinitions() {
+			if (PropertyDef.GetMethod != null)
+				yield return PropertyDef.GetMethod;
+			if (PropertyDef.SetMethod != null)
+				yield return PropertyDef.SetMethod;
+			if (PropertyDef.OtherMethods != null) {
+				foreach (var m in PropertyDef.OtherMethods)
 					yield return m;
 			}
 		}
@@ -53,9 +53,9 @@ namespace de4dot.code.renamer.asmmodules {
 		}
 
 		public bool isItemProperty() {
-			if (GetMethod != null && GetMethod.ParamDefs.Count >= 1)
+			if (GetMethod != null && GetMethod.VisibleParameterCount >= 1)
 				return true;
-			if (SetMethod != null && SetMethod.ParamDefs.Count >= 2)
+			if (SetMethod != null && SetMethod.VisibleParameterCount >= 2)
 				return true;
 			return false;
 		}
diff --git a/de4dot.code/renamer/asmmodules/Ref.cs b/de4dot.code/renamer/asmmodules/Ref.cs
index c19ab949..ba7528bc 100644
--- a/de4dot.code/renamer/asmmodules/Ref.cs
+++ b/de4dot.code/renamer/asmmodules/Ref.cs
@@ -17,15 +17,15 @@
     along with de4dot.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace de4dot.code.renamer.asmmodules {
 	abstract class Ref {
-		public readonly MemberReference memberReference;
+		public readonly IMemberRef memberReference;
 		public int Index { get; set; }
-		public TypeDef Owner { get; set; }
+		public MTypeDef Owner { get; set; }
 
-		protected Ref(MemberReference memberReference, TypeDef owner, int index) {
+		protected Ref(IMemberRef memberReference, MTypeDef owner, int index) {
 			this.memberReference = memberReference;
 			Owner = owner;
 			Index = index;
diff --git a/de4dot.code/renamer/asmmodules/RefDict.cs b/de4dot.code/renamer/asmmodules/RefDict.cs
index 1ba85b5c..3d378713 100644
--- a/de4dot.code/renamer/asmmodules/RefDict.cs
+++ b/de4dot.code/renamer/asmmodules/RefDict.cs
@@ -18,65 +18,64 @@
 */
 
 using System.Collections.Generic;
-using Mono.Cecil;
 using de4dot.blocks;
 
 namespace de4dot.code.renamer.asmmodules {
 	static class DictHelper {
 		public static IEnumerable<T> getSorted<T>(IEnumerable<T> values) where T : Ref {
 			var list = new List<T>(values);
-			list.Sort((a, b) => Utils.compareInt32(a.Index, b.Index));
+			list.Sort((a, b) => a.Index.CompareTo(b.Index));
 			return list;
 		}
 	}
 
-	class TypeDefDict : TypeDefinitionDict<TypeDef> {
-		public IEnumerable<TypeDef> getSorted() {
+	class TypeDefDict : TypeDefinitionDict<MTypeDef> {
+		public IEnumerable<MTypeDef> getSorted() {
 			return DictHelper.getSorted(getValues());
 		}
 
-		public void add(TypeDef typeDef) {
-			add(typeDef.TypeDefinition, typeDef);
+		public void add(MTypeDef typeDef) {
+			add(typeDef.TypeDef, typeDef);
 		}
 	}
 
-	class FieldDefDict : FieldDefinitionDict<FieldDef> {
-		public IEnumerable<FieldDef> getSorted() {
+	class FieldDefDict : FieldDefinitionDict<MFieldDef> {
+		public IEnumerable<MFieldDef> getSorted() {
 			return DictHelper.getSorted(getValues());
 		}
 
-		public void add(FieldDef fieldDef) {
-			add(fieldDef.FieldDefinition, fieldDef);
+		public void add(MFieldDef fieldDef) {
+			add(fieldDef.FieldDef, fieldDef);
 		}
 	}
 
-	class MethodDefDict : MethodDefinitionDict<MethodDef> {
-		public IEnumerable<MethodDef> getSorted() {
+	class MethodDefDict : MethodDefinitionDict<MMethodDef> {
+		public IEnumerable<MMethodDef> getSorted() {
 			return DictHelper.getSorted(getValues());
 		}
 
-		public void add(MethodDef methodDef) {
-			add(methodDef.MethodDefinition, methodDef);
+		public void add(MMethodDef methodDef) {
+			add(methodDef.MethodDef, methodDef);
 		}
 	}
 
-	class PropertyDefDict : PropertyDefinitionDict<PropertyDef> {
-		public IEnumerable<PropertyDef> getSorted() {
+	class PropertyDefDict : PropertyDefinitionDict<MPropertyDef> {
+		public IEnumerable<MPropertyDef> getSorted() {
 			return DictHelper.getSorted(getValues());
 		}
 
-		public void add(PropertyDef propDef) {
-			add(propDef.PropertyDefinition, propDef);
+		public void add(MPropertyDef propDef) {
+			add(propDef.PropertyDef, propDef);
 		}
 	}
 
-	class EventDefDict : EventDefinitionDict<EventDef> {
-		public IEnumerable<EventDef> getSorted() {
+	class EventDefDict : EventDefinitionDict<MEventDef> {
+		public IEnumerable<MEventDef> getSorted() {
 			return DictHelper.getSorted(getValues());
 		}
 
-		public void add(EventDef eventDef) {
-			add(eventDef.EventDefinition, eventDef);
+		public void add(MEventDef eventDef) {
+			add(eventDef.EventDef, eventDef);
 		}
 	}
 }
diff --git a/de4dot.code/renamer/asmmodules/TypeDef.cs b/de4dot.code/renamer/asmmodules/TypeDef.cs
index 7572365c..61ef2e26 100644
--- a/de4dot.code/renamer/asmmodules/TypeDef.cs
+++ b/de4dot.code/renamer/asmmodules/TypeDef.cs
@@ -19,26 +19,26 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 
 namespace de4dot.code.renamer.asmmodules {
 	class TypeInfo {
-		public TypeReference typeReference;
-		public TypeDef typeDef;
-		public TypeInfo(TypeReference typeReference, TypeDef typeDef) {
+		public ITypeDefOrRef typeReference;
+		public MTypeDef typeDef;
+		public TypeInfo(ITypeDefOrRef typeReference, MTypeDef typeDef) {
 			this.typeReference = typeReference;
 			this.typeDef = typeDef;
 		}
 
-		public TypeInfo(TypeInfo other, GenericInstanceType git) {
-			this.typeReference = TypeReferenceInstance.make(other.typeReference, git);
+		public TypeInfo(TypeInfo other, GenericInstSig git) {
+			this.typeReference = GenericArgsSubstitutor.create(other.typeReference, git);
 			this.typeDef = other.typeDef;
 		}
 
 		public override int GetHashCode() {
 			return typeDef.GetHashCode() +
-					MemberReferenceHelper.typeHashCode(typeReference);
+					new SigComparer().GetHashCode(typeReference);
 		}
 
 		public override bool Equals(object obj) {
@@ -46,7 +46,7 @@ namespace de4dot.code.renamer.asmmodules {
 			if (other == null)
 				return false;
 			return typeDef == other.typeDef &&
-				MemberReferenceHelper.compareTypes(typeReference, other.typeReference);
+				new SigComparer().Equals(typeReference, other.typeReference);
 		}
 
 		public override string ToString() {
@@ -55,29 +55,29 @@ namespace de4dot.code.renamer.asmmodules {
 	}
 
 	class MethodDefKey {
-		public readonly MethodDef methodDef;
+		public readonly MMethodDef methodDef;
 
-		public MethodDefKey(MethodDef methodDef) {
+		public MethodDefKey(MMethodDef methodDef) {
 			this.methodDef = methodDef;
 		}
 
 		public override int GetHashCode() {
-			return MemberReferenceHelper.methodReferenceAndDeclaringTypeHashCode(methodDef.MethodDefinition);
+			return MethodEqualityComparer.CompareDeclaringTypes.GetHashCode(methodDef.MethodDef);
 		}
 
 		public override bool Equals(object obj) {
 			var other = obj as MethodDefKey;
 			if (other == null)
 				return false;
-			return MemberReferenceHelper.compareMethodReferenceAndDeclaringType(methodDef.MethodDefinition, other.methodDef.MethodDefinition);
+			return MethodEqualityComparer.CompareDeclaringTypes.Equals(methodDef.MethodDef, other.methodDef.MethodDef);
 		}
 	}
 
 	class MethodInst {
-		public MethodDef origMethodDef;
-		public MethodReference methodReference;
+		public MMethodDef origMethodDef;
+		public IMethodDefOrRef methodReference;
 
-		public MethodInst(MethodDef origMethodDef, MethodReference methodReference) {
+		public MethodInst(MMethodDef origMethodDef, IMethodDefOrRef methodReference) {
 			this.origMethodDef = origMethodDef;
 			this.methodReference = methodReference;
 		}
@@ -88,12 +88,12 @@ namespace de4dot.code.renamer.asmmodules {
 	}
 
 	class MethodInstances {
-		Dictionary<MethodReferenceKey, List<MethodInst>> methodInstances = new Dictionary<MethodReferenceKey, List<MethodInst>>();
+		Dictionary<IMethodDefOrRef, List<MethodInst>> methodInstances = new Dictionary<IMethodDefOrRef, List<MethodInst>>(MethodEqualityComparer.DontCompareDeclaringTypes);
 
-		public void initializeFrom(MethodInstances other, GenericInstanceType git) {
+		public void initializeFrom(MethodInstances other, GenericInstSig git) {
 			foreach (var list in other.methodInstances.Values) {
 				foreach (var methodInst in list) {
-					MethodReference newMethod = MethodReferenceInstance.make(methodInst.methodReference, git);
+					var newMethod = GenericArgsSubstitutor.create(methodInst.methodReference, git);
 					add(new MethodInst(methodInst.origMethodDef, newMethod));
 				}
 			}
@@ -101,15 +101,15 @@ namespace de4dot.code.renamer.asmmodules {
 
 		public void add(MethodInst methodInst) {
 			List<MethodInst> list;
-			var key = new MethodReferenceKey(methodInst.methodReference);
+			var key = methodInst.methodReference;
 			if (methodInst.origMethodDef.isNewSlot() || !methodInstances.TryGetValue(key, out list))
 				methodInstances[key] = list = new List<MethodInst>();
 			list.Add(methodInst);
 		}
 
-		public List<MethodInst> lookup(MethodReference methodReference) {
+		public List<MethodInst> lookup(IMethodDefOrRef methodReference) {
 			List<MethodInst> list;
-			methodInstances.TryGetValue(new MethodReferenceKey(methodReference), out list);
+			methodInstances.TryGetValue(methodReference, out list);
 			return list;
 		}
 
@@ -121,13 +121,13 @@ namespace de4dot.code.renamer.asmmodules {
 	// Keeps track of which methods of an interface that have been implemented
 	class InterfaceMethodInfo {
 		TypeInfo iface;
-		Dictionary<MethodDefKey, MethodDef> ifaceMethodToClassMethod = new Dictionary<MethodDefKey, MethodDef>();
+		Dictionary<MethodDefKey, MMethodDef> ifaceMethodToClassMethod = new Dictionary<MethodDefKey, MMethodDef>();
 
 		public TypeInfo IFace {
 			get { return iface; }
 		}
 
-		public Dictionary<MethodDefKey, MethodDef> IfaceMethodToClassMethod {
+		public Dictionary<MethodDefKey, MMethodDef> IfaceMethodToClassMethod {
 			get { return ifaceMethodToClassMethod; }
 		}
 
@@ -154,18 +154,18 @@ namespace de4dot.code.renamer.asmmodules {
 		}
 
 		// Returns the previous method, or null if none
-		public MethodDef addMethod(MethodDef ifaceMethod, MethodDef classMethod) {
+		public MMethodDef addMethod(MMethodDef ifaceMethod, MMethodDef classMethod) {
 			var ifaceKey = new MethodDefKey(ifaceMethod);
 			if (!ifaceMethodToClassMethod.ContainsKey(ifaceKey))
 				throw new ApplicationException("Could not find interface method");
 
-			MethodDef oldMethod;
+			MMethodDef oldMethod;
 			ifaceMethodToClassMethod.TryGetValue(ifaceKey, out oldMethod);
 			ifaceMethodToClassMethod[ifaceKey] = classMethod;
 			return oldMethod;
 		}
 
-		public void addMethodIfEmpty(MethodDef ifaceMethod, MethodDef classMethod) {
+		public void addMethodIfEmpty(MMethodDef ifaceMethod, MMethodDef classMethod) {
 			if (ifaceMethodToClassMethod[new MethodDefKey(ifaceMethod)] == null)
 				addMethod(ifaceMethod, classMethod);
 		}
@@ -176,18 +176,18 @@ namespace de4dot.code.renamer.asmmodules {
 	}
 
 	class InterfaceMethodInfos {
-		Dictionary<TypeReferenceKey, InterfaceMethodInfo> interfaceMethods = new Dictionary<TypeReferenceKey, InterfaceMethodInfo>();
+		Dictionary<ITypeDefOrRef, InterfaceMethodInfo> interfaceMethods = new Dictionary<ITypeDefOrRef, InterfaceMethodInfo>(TypeEqualityComparer.Instance);
 
 		public IEnumerable<InterfaceMethodInfo> AllInfos {
 			get { return interfaceMethods.Values; }
 		}
 
-		public void initializeFrom(InterfaceMethodInfos other, GenericInstanceType git) {
+		public void initializeFrom(InterfaceMethodInfos other, GenericInstSig git) {
 			foreach (var pair in other.interfaceMethods) {
 				var oldTypeInfo = pair.Value.IFace;
 				var newTypeInfo = new TypeInfo(oldTypeInfo, git);
-				var oldKey = new TypeReferenceKey(oldTypeInfo.typeReference);
-				var newKey = new TypeReferenceKey(newTypeInfo.typeReference);
+				var oldKey = oldTypeInfo.typeReference;
+				var newKey = newTypeInfo.typeReference;
 
 				InterfaceMethodInfo newMethodsInfo = new InterfaceMethodInfo(newTypeInfo, other.interfaceMethods[oldKey]);
 				if (interfaceMethods.ContainsKey(newKey))
@@ -197,44 +197,42 @@ namespace de4dot.code.renamer.asmmodules {
 		}
 
 		public void addInterface(TypeInfo iface) {
-			var key = new TypeReferenceKey(iface.typeReference);
+			var key = iface.typeReference;
 			if (!interfaceMethods.ContainsKey(key))
 				interfaceMethods[key] = new InterfaceMethodInfo(iface);
 		}
 
 		// Returns the previous classMethod, or null if none
-		public MethodDef addMethod(TypeInfo iface, MethodDef ifaceMethod, MethodDef classMethod) {
+		public MMethodDef addMethod(TypeInfo iface, MMethodDef ifaceMethod, MMethodDef classMethod) {
 			return addMethod(iface.typeReference, ifaceMethod, classMethod);
 		}
 
 		// Returns the previous classMethod, or null if none
-		public MethodDef addMethod(TypeReference iface, MethodDef ifaceMethod, MethodDef classMethod) {
+		public MMethodDef addMethod(ITypeDefOrRef iface, MMethodDef ifaceMethod, MMethodDef classMethod) {
 			InterfaceMethodInfo info;
-			var key = new TypeReferenceKey(iface);
-			if (!interfaceMethods.TryGetValue(key, out info))
+			if (!interfaceMethods.TryGetValue(iface, out info))
 				throw new ApplicationException("Could not find interface");
 			return info.addMethod(ifaceMethod, classMethod);
 		}
 
-		public void addMethodIfEmpty(TypeInfo iface, MethodDef ifaceMethod, MethodDef classMethod) {
+		public void addMethodIfEmpty(TypeInfo iface, MMethodDef ifaceMethod, MMethodDef classMethod) {
 			InterfaceMethodInfo info;
-			var key = new TypeReferenceKey(iface.typeReference);
-			if (!interfaceMethods.TryGetValue(key, out info))
+			if (!interfaceMethods.TryGetValue(iface.typeReference, out info))
 				throw new ApplicationException("Could not find interface");
 			info.addMethodIfEmpty(ifaceMethod, classMethod);
 		}
 	}
 
-	class TypeDef : Ref {
+	class MTypeDef : Ref {
 		EventDefDict events = new EventDefDict();
 		FieldDefDict fields = new FieldDefDict();
 		MethodDefDict methods = new MethodDefDict();
 		PropertyDefDict properties = new PropertyDefDict();
 		TypeDefDict types = new TypeDefDict();
-		List<GenericParamDef> genericParams;
+		List<MGenericParamDef> genericParams;
 		internal TypeInfo baseType = null;
 		internal IList<TypeInfo> interfaces = new List<TypeInfo>();	// directly implemented interfaces
-		internal IList<TypeDef> derivedTypes = new List<TypeDef>();
+		internal IList<MTypeDef> derivedTypes = new List<MTypeDef>();
 		Module module;
 
 		bool initializeVirtualMembersCalled = false;
@@ -251,178 +249,186 @@ namespace de4dot.code.renamer.asmmodules {
 			get { return module != null; }
 		}
 
-		public IList<GenericParamDef> GenericParams {
+		public IList<MGenericParamDef> GenericParams {
 			get { return genericParams; }
 		}
 
-		public IEnumerable<TypeDef> NestedTypes {
+		public IEnumerable<MTypeDef> NestedTypes {
 			get { return types.getSorted(); }
 		}
 
-		public TypeDef NestingType { get; set; }
+		public MTypeDef NestingType { get; set; }
 
-		public TypeDefinition TypeDefinition {
-			get { return (TypeDefinition)memberReference; }
+		public TypeDef TypeDef {
+			get { return (TypeDef)memberReference; }
 		}
 
-		public IEnumerable<EventDef> AllEvents {
+		public IEnumerable<MEventDef> AllEvents {
 			get { return events.getValues(); }
 		}
 
-		public IEnumerable<FieldDef> AllFields {
+		public IEnumerable<MFieldDef> AllFields {
 			get { return fields.getValues(); }
 		}
 
-		public IEnumerable<MethodDef> AllMethods {
+		public IEnumerable<MMethodDef> AllMethods {
 			get { return methods.getValues(); }
 		}
 
-		public IEnumerable<PropertyDef> AllProperties {
+		public IEnumerable<MPropertyDef> AllProperties {
 			get { return properties.getValues(); }
 		}
 
-		public IEnumerable<EventDef> AllEventsSorted {
+		public IEnumerable<MEventDef> AllEventsSorted {
 			get { return events.getSorted(); }
 		}
 
-		public IEnumerable<FieldDef> AllFieldsSorted {
+		public IEnumerable<MFieldDef> AllFieldsSorted {
 			get { return fields.getSorted(); }
 		}
 
-		public IEnumerable<MethodDef> AllMethodsSorted {
+		public IEnumerable<MMethodDef> AllMethodsSorted {
 			get { return methods.getSorted(); }
 		}
 
-		public IEnumerable<PropertyDef> AllPropertiesSorted {
+		public IEnumerable<MPropertyDef> AllPropertiesSorted {
 			get { return properties.getSorted(); }
 		}
 
-		public TypeDef(TypeDefinition typeDefinition, Module module, int index)
+		public MTypeDef(TypeDef typeDefinition, Module module, int index)
 			: base(typeDefinition, null, index) {
 			this.module = module;
-			genericParams = GenericParamDef.createGenericParamDefList(TypeDefinition.GenericParameters);
+			genericParams = MGenericParamDef.createGenericParamDefList(TypeDef.GenericParameters);
 		}
 
-		public void addInterface(TypeDef ifaceDef, TypeReference iface) {
+		public void addInterface(MTypeDef ifaceDef, ITypeDefOrRef iface) {
 			if (ifaceDef == null || iface == null)
 				return;
 			interfaces.Add(new TypeInfo(iface, ifaceDef));
 		}
 
-		public void addBaseType(TypeDef baseDef, TypeReference baseRef) {
+		public void addBaseType(MTypeDef baseDef, ITypeDefOrRef baseRef) {
 			if (baseDef == null || baseRef == null)
 				return;
 			baseType = new TypeInfo(baseRef, baseDef);
 		}
 
-		public void add(EventDef e) {
+		public void add(MEventDef e) {
 			events.add(e);
 		}
 
-		public void add(FieldDef f) {
+		public void add(MFieldDef f) {
 			fields.add(f);
 		}
 
-		public void add(MethodDef m) {
+		public void add(MMethodDef m) {
 			methods.add(m);
 		}
 
-		public void add(PropertyDef p) {
+		public void add(MPropertyDef p) {
 			properties.add(p);
 		}
 
-		public void add(TypeDef t) {
+		public void add(MTypeDef t) {
 			types.add(t);
 		}
 
-		public MethodDef find(MethodReference mr) {
+		public MMethodDef findMethod(MemberRef mr) {
 			return methods.find(mr);
 		}
 
-		public MethodDef findAny(MethodReference mr) {
+		public MMethodDef findMethod(IMethodDefOrRef md) {
+			return methods.find(md);
+		}
+
+		public MMethodDef findMethod(MethodDef md) {
+			return methods.find(md);
+		}
+
+		public MMethodDef findAnyMethod(MemberRef mr) {
 			return methods.findAny(mr);
 		}
 
-		public FieldDef find(FieldReference fr) {
+		public MFieldDef findField(MemberRef fr) {
 			return fields.find(fr);
 		}
 
-		public FieldDef findAny(FieldReference fr) {
+		public MFieldDef findAnyField(MemberRef fr) {
 			return fields.findAny(fr);
 		}
 
-		public PropertyDef find(PropertyReference pr) {
+		public MPropertyDef find(PropertyDef pr) {
 			return properties.find(pr);
 		}
 
-		public PropertyDef findAny(PropertyReference pr) {
+		public MPropertyDef findAny(PropertyDef pr) {
 			return properties.findAny(pr);
 		}
 
-		public EventDef find(EventReference er) {
+		public MEventDef find(EventDef er) {
 			return events.find(er);
 		}
 
-		public EventDef findAny(EventReference er) {
+		public MEventDef findAny(EventDef er) {
 			return events.findAny(er);
 		}
 
-		public PropertyDef create(PropertyDefinition newProp) {
+		public MPropertyDef create(PropertyDef newProp) {
 			if (findAny(newProp) != null)
 				throw new ApplicationException("Can't add a property when it's already been added");
 
-			var propDef = new PropertyDef(newProp, this, properties.Count);
+			var propDef = new MPropertyDef(newProp, this, properties.Count);
 			add(propDef);
-			TypeDefinition.Properties.Add(newProp);
+			TypeDef.Properties.Add(newProp);
 			return propDef;
 		}
 
-		public EventDef create(EventDefinition newEvent) {
+		public MEventDef create(EventDef newEvent) {
 			if (findAny(newEvent) != null)
 				throw new ApplicationException("Can't add an event when it's already been added");
 
-			var eventDef = new EventDef(newEvent, this, events.Count);
+			var eventDef = new MEventDef(newEvent, this, events.Count);
 			add(eventDef);
-			TypeDefinition.Events.Add(newEvent);
+			TypeDef.Events.Add(newEvent);
 			return eventDef;
 		}
 
 		public void addMembers() {
-			var type = TypeDefinition;
+			var type = TypeDef;
 
 			for (int i = 0; i < type.Events.Count; i++)
-				add(new EventDef(type.Events[i], this, i));
+				add(new MEventDef(type.Events[i], this, i));
 			for (int i = 0; i < type.Fields.Count; i++)
-				add(new FieldDef(type.Fields[i], this, i));
+				add(new MFieldDef(type.Fields[i], this, i));
 			for (int i = 0; i < type.Methods.Count; i++)
-				add(new MethodDef(type.Methods[i], this, i));
+				add(new MMethodDef(type.Methods[i], this, i));
 			for (int i = 0; i < type.Properties.Count; i++)
-				add(new PropertyDef(type.Properties[i], this, i));
+				add(new MPropertyDef(type.Properties[i], this, i));
 
 			foreach (var propDef in properties.getValues()) {
 				foreach (var method in propDef.methodDefinitions()) {
-					var methodDef = find(method);
+					var methodDef = findMethod(method);
 					if (methodDef == null)
 						throw new ApplicationException("Could not find property method");
 					methodDef.Property = propDef;
-					if (method == propDef.PropertyDefinition.GetMethod)
+					if (method == propDef.PropertyDef.GetMethod)
 						propDef.GetMethod = methodDef;
-					if (method == propDef.PropertyDefinition.SetMethod)
+					if (method == propDef.PropertyDef.SetMethod)
 						propDef.SetMethod = methodDef;
 				}
 			}
 
 			foreach (var eventDef in events.getValues()) {
 				foreach (var method in eventDef.methodDefinitions()) {
-					var methodDef = find(method);
+					var methodDef = findMethod(method);
 					if (methodDef == null)
 						throw new ApplicationException("Could not find event method");
 					methodDef.Event = eventDef;
-					if (method == eventDef.EventDefinition.AddMethod)
+					if (method == eventDef.EventDef.AddMethod)
 						eventDef.AddMethod = methodDef;
-					if (method == eventDef.EventDefinition.RemoveMethod)
+					if (method == eventDef.EventDef.RemoveMethod)
 						eventDef.RemoveMethod = methodDef;
-					if (method == eventDef.EventDefinition.InvokeMethod)
+					if (method == eventDef.EventDef.InvokeMethod)
 						eventDef.RaiseMethod = methodDef;
 				}
 			}
@@ -442,9 +448,8 @@ namespace de4dot.code.renamer.asmmodules {
 
 		public bool isGlobalType() {
 			if (!isNested())
-				return TypeDefinition.IsPublic;
-			var mask = TypeDefinition.Attributes & TypeAttributes.VisibilityMask;
-			switch (mask) {
+				return TypeDef.IsPublic;
+			switch (TypeDef.Visibility) {
 			case TypeAttributes.NestedPrivate:
 			case TypeAttributes.NestedAssembly:
 			case TypeAttributes.NestedFamANDAssem:
@@ -489,7 +494,7 @@ namespace de4dot.code.renamer.asmmodules {
 		}
 
 		void initializeInterfaces(TypeInfo typeInfo) {
-			var git = typeInfo.typeReference as GenericInstanceType;
+			var git = typeInfo.typeReference.ToGenericInstSig();
 			interfaceMethodInfos.initializeFrom(typeInfo.typeDef.interfaceMethodInfos, git);
 			foreach (var info in typeInfo.typeDef.allImplementedInterfaces.Keys) {
 				var newTypeInfo = new TypeInfo(info, git);
@@ -500,7 +505,7 @@ namespace de4dot.code.renamer.asmmodules {
 		void initializeInterfaceMethods(MethodNameGroups groups) {
 			initializeAllInterfaces();
 
-			if (TypeDefinition.IsInterface)
+			if (TypeDef.IsInterface)
 				return;
 
 			//--- Partition II 12.2 Implementing virtual methods on interfaces:
@@ -512,7 +517,7 @@ namespace de4dot.code.renamer.asmmodules {
 			//---	virtual functions.
 			// Done. See initializeAllInterfaces().
 
-			var methodsDict = new Dictionary<MethodReferenceKey, MethodDef>();
+			var methodsDict = new Dictionary<IMethodDefOrRef, MMethodDef>(MethodEqualityComparer.DontCompareDeclaringTypes);
 
 			//--- * If this class explicitly specifies that it implements the interface (i.e., the
 			//---	interfaces that appear in this class‘ InterfaceImpl table, §22.23)
@@ -524,21 +529,20 @@ namespace de4dot.code.renamer.asmmodules {
 				foreach (var method in methods.getValues()) {
 					if (!method.isPublic() || !method.isVirtual() || !method.isNewSlot())
 						continue;
-					methodsDict[new MethodReferenceKey(method.MethodDefinition)] = method;
+					methodsDict[method.MethodDef] = method;
 				}
 
 				foreach (var ifaceInfo in interfaces) {
 					foreach (var methodsList in ifaceInfo.typeDef.virtualMethodInstances.getMethods()) {
-						if (methodsList.Count != 1)	// Never happens
-							throw new ApplicationException("Interface with more than one method in the list");
+						if (methodsList.Count < 1)
+							continue;
 						var methodInst = methodsList[0];
 						var ifaceMethod = methodInst.origMethodDef;
 						if (!ifaceMethod.isVirtual())
 							continue;
-						var ifaceMethodReference = MethodReferenceInstance.make(methodInst.methodReference, ifaceInfo.typeReference as GenericInstanceType);
-						MethodDef classMethod;
-						var key = new MethodReferenceKey(ifaceMethodReference);
-						if (!methodsDict.TryGetValue(key, out classMethod))
+						var ifaceMethodReference = GenericArgsSubstitutor.create(methodInst.methodReference, ifaceInfo.typeReference.ToGenericInstSig());
+						MMethodDef classMethod;
+						if (!methodsDict.TryGetValue(ifaceMethodReference, out classMethod))
 							continue;
 						interfaceMethodInfos.addMethod(ifaceInfo, ifaceMethod, classMethod);
 					}
@@ -559,21 +563,20 @@ namespace de4dot.code.renamer.asmmodules {
 					// We should allow newslot methods, despite what the official doc says.
 					if (!classMethod.origMethodDef.isPublic())
 						continue;
-					methodsDict[new MethodReferenceKey(classMethod.methodReference)] = classMethod.origMethodDef;
+					methodsDict[classMethod.methodReference] = classMethod.origMethodDef;
 					break;
 				}
 			}
 			foreach (var ifaceInfo in allImplementedInterfaces.Keys) {
 				foreach (var methodsList in ifaceInfo.typeDef.virtualMethodInstances.getMethods()) {
-					if (methodsList.Count != 1)	// Never happens
-						throw new ApplicationException("Interface with more than one method in the list");
+					if (methodsList.Count < 1)
+						continue;
 					var ifaceMethod = methodsList[0].origMethodDef;
 					if (!ifaceMethod.isVirtual())
 						continue;
-					var ifaceMethodRef = MethodReferenceInstance.make(ifaceMethod.MethodDefinition, ifaceInfo.typeReference as GenericInstanceType);
-					MethodDef classMethod;
-					var key = new MethodReferenceKey(ifaceMethodRef);
-					if (!methodsDict.TryGetValue(key, out classMethod))
+					var ifaceMethodRef = GenericArgsSubstitutor.create(ifaceMethod.MethodDef, ifaceInfo.typeReference.ToGenericInstSig());
+					MMethodDef classMethod;
+					if (!methodsDict.TryGetValue(ifaceMethodRef, out classMethod))
 						continue;
 					interfaceMethodInfos.addMethodIfEmpty(ifaceInfo, ifaceMethod, classMethod);
 				}
@@ -583,29 +586,28 @@ namespace de4dot.code.renamer.asmmodules {
 			//---	explicitly specified virtual methods into the interface in preference to those
 			//---	inherited or chosen by name matching.
 			methodsDict.Clear();
-			var ifaceMethodsDict = new Dictionary<MethodReferenceAndDeclaringTypeKey, MethodDef>();
+			var ifaceMethodsDict = new Dictionary<IMethodDefOrRef, MMethodDef>(MethodEqualityComparer.CompareDeclaringTypes);
 			foreach (var ifaceInfo in allImplementedInterfaces.Keys) {
-				var git = ifaceInfo.typeReference as GenericInstanceType;
+				var git = ifaceInfo.typeReference.ToGenericInstSig();
 				foreach (var ifaceMethod in ifaceInfo.typeDef.methods.getValues()) {
-					MethodReference ifaceMethodReference = ifaceMethod.MethodDefinition;
+					IMethodDefOrRef ifaceMethodReference = ifaceMethod.MethodDef;
 					if (git != null)
-						ifaceMethodReference = simpleClone(ifaceMethod.MethodDefinition, git);
-					ifaceMethodsDict[new MethodReferenceAndDeclaringTypeKey(ifaceMethodReference)] = ifaceMethod;
+						ifaceMethodReference = simpleClone(ifaceMethod.MethodDef, ifaceInfo.typeReference);
+					ifaceMethodsDict[ifaceMethodReference] = ifaceMethod;
 				}
 			}
 			foreach (var classMethod in methods.getValues()) {
 				if (!classMethod.isVirtual())
 					continue;
-				foreach (var overrideMethod in classMethod.MethodDefinition.Overrides) {
-					MethodDef ifaceMethod;
-					var key = new MethodReferenceAndDeclaringTypeKey(overrideMethod);
-					if (!ifaceMethodsDict.TryGetValue(key, out ifaceMethod)) {
+				foreach (var overrideMethod in classMethod.MethodDef.Overrides) {
+					MMethodDef ifaceMethod;
+					if (!ifaceMethodsDict.TryGetValue(overrideMethod.MethodDeclaration, out ifaceMethod)) {
 						// We couldn't find the interface method (eg. interface not resolved) or
 						// it overrides a base class method, and not an interface method.
 						continue;
 					}
 
-					interfaceMethodInfos.addMethod(overrideMethod.DeclaringType, ifaceMethod, classMethod);
+					interfaceMethodInfos.addMethod(overrideMethod.MethodDeclaration.DeclaringType, ifaceMethod, classMethod);
 				}
 			}
 
@@ -620,14 +622,14 @@ namespace de4dot.code.renamer.asmmodules {
 					if (!resolvedAllInterfaces() || !resolvedBaseClasses())
 						continue;
 					// Ignore if COM class
-					if (!TypeDefinition.IsImport &&
+					if (!TypeDef.IsImport &&
 						!hasAttribute("System.Runtime.InteropServices.ComImportAttribute") &&
 						!hasAttribute("System.Runtime.InteropServices.TypeLibTypeAttribute")) {
-						Log.w("Could not find interface method {0} ({1:X8}). Type: {2} ({3:X8})",
-								Utils.removeNewlines(pair.Key.methodDef.MethodDefinition),
-								pair.Key.methodDef.MethodDefinition.MetadataToken.ToInt32(),
-								Utils.removeNewlines(TypeDefinition),
-								TypeDefinition.MetadataToken.ToInt32());
+						Logger.w("Could not find interface method {0} ({1:X8}). Type: {2} ({3:X8})",
+								Utils.removeNewlines(pair.Key.methodDef.MethodDef),
+								pair.Key.methodDef.MethodDef.MDToken.ToInt32(),
+								Utils.removeNewlines(TypeDef),
+								TypeDef.MDToken.ToInt32());
 					}
 				}
 			}
@@ -636,7 +638,7 @@ namespace de4dot.code.renamer.asmmodules {
 				foreach (var pair in info.IfaceMethodToClassMethod) {
 					if (pair.Value == null)
 						continue;
-					if (pair.Key.methodDef.MethodDefinition.Name != pair.Value.MethodDefinition.Name)
+					if (pair.Key.methodDef.MethodDef.Name != pair.Value.MethodDef.Name)
 						continue;
 					groups.same(pair.Key.methodDef, pair.Value);
 				}
@@ -644,8 +646,8 @@ namespace de4dot.code.renamer.asmmodules {
 		}
 
 		bool hasAttribute(string name) {
-			foreach (var attr in TypeDefinition.CustomAttributes) {
-				if (attr.AttributeType.FullName == name)
+			foreach (var attr in TypeDef.CustomAttributes) {
+				if (attr.TypeFullName == name)
 					return true;
 			}
 			return false;
@@ -661,7 +663,7 @@ namespace de4dot.code.renamer.asmmodules {
 			return resolvedAllInterfacesResult.Value;
 		}
 		bool resolvedAllInterfacesInternal() {
-			if (TypeDefinition.Interfaces.Count != interfaces.Count)
+			if (TypeDef.Interfaces.Count != interfaces.Count)
 				return false;
 			foreach (var ifaceInfo in interfaces) {
 				if (!ifaceInfo.typeDef.resolvedAllInterfaces())
@@ -680,36 +682,30 @@ namespace de4dot.code.renamer.asmmodules {
 			return resolvedBaseClassesResult.Value;
 		}
 		bool resolvedBaseClassesInternal() {
-			if (TypeDefinition.BaseType == null)
+			if (TypeDef.BaseType == null)
 				return true;
 			if (baseType == null)
 				return false;
 			return baseType.typeDef.resolvedBaseClasses();
 		}
 
-		MethodReference simpleClone(MethodReference methodReference, TypeReference declaringType) {
-			var m = new MethodReference(methodReference.Name, methodReference.MethodReturnType.ReturnType, declaringType);
-			m.MethodReturnType.ReturnType = methodReference.MethodReturnType.ReturnType;
-			m.HasThis = methodReference.HasThis;
-			m.ExplicitThis = methodReference.ExplicitThis;
-			m.CallingConvention = methodReference.CallingConvention;
-			foreach (var p in methodReference.Parameters)
-				m.Parameters.Add(new ParameterDefinition(p.Name, p.Attributes, p.ParameterType));
-			foreach (var gp in methodReference.GenericParameters)
-				m.GenericParameters.Add(new GenericParameter(declaringType));
-			return m;
+		MemberRef simpleClone(MethodDef methodRef, ITypeDefOrRef declaringType) {
+			if (module == null)
+				return new MemberRefUser(null, methodRef.Name, methodRef.MethodSig, declaringType);
+			var mr = new MemberRefUser(module.ModuleDefMD, methodRef.Name, methodRef.MethodSig, declaringType);
+			return module.ModuleDefMD.UpdateRowId(mr);
 		}
 
 		void instantiateVirtualMembers(MethodNameGroups groups) {
-			if (!TypeDefinition.IsInterface) {
+			if (!TypeDef.IsInterface) {
 				if (baseType != null)
-					virtualMethodInstances.initializeFrom(baseType.typeDef.virtualMethodInstances, baseType.typeReference as GenericInstanceType);
+					virtualMethodInstances.initializeFrom(baseType.typeDef.virtualMethodInstances, baseType.typeReference.ToGenericInstSig());
 
 				// Figure out which methods we override in the base class
 				foreach (var methodDef in methods.getValues()) {
 					if (!methodDef.isVirtual() || methodDef.isNewSlot())
 						continue;
-					var methodInstList = virtualMethodInstances.lookup(methodDef.MethodDefinition);
+					var methodInstList = virtualMethodInstances.lookup(methodDef.MethodDef);
 					if (methodInstList == null)
 						continue;
 					foreach (var methodInst in methodInstList)
@@ -720,7 +716,7 @@ namespace de4dot.code.renamer.asmmodules {
 			foreach (var methodDef in methods.getValues()) {
 				if (!methodDef.isVirtual())
 					continue;
-				virtualMethodInstances.add(new MethodInst(methodDef, methodDef.MethodDefinition));
+				virtualMethodInstances.add(new MethodInst(methodDef, methodDef.MethodDef));
 			}
 		}
 	}
diff --git a/de4dot.code/resources/ResourceDataCreator.cs b/de4dot.code/resources/ResourceDataCreator.cs
index a00278da..6e2d6940 100644
--- a/de4dot.code/resources/ResourceDataCreator.cs
+++ b/de4dot.code/resources/ResourceDataCreator.cs
@@ -22,15 +22,15 @@ using System.Collections.Generic;
 using System.IO;
 using System.Runtime.Serialization;
 using System.Runtime.Serialization.Formatters.Binary;
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace de4dot.code.resources {
 	class ResourceDataCreator {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		Dictionary<string, UserResourceType> dict = new Dictionary<string, UserResourceType>(StringComparer.Ordinal);
 		Dictionary<string, string> asmNameToAsmFullName = new Dictionary<string, string>(StringComparer.Ordinal);
 
-		public ResourceDataCreator(ModuleDefinition module) {
+		public ResourceDataCreator(ModuleDefMD module) {
 			this.module = module;
 		}
 
@@ -210,24 +210,17 @@ namespace de4dot.code.resources {
 		string tryGetRealAssemblyName(string assemblyName) {
 			var simpleName = Utils.getAssemblySimpleName(assemblyName);
 
-			foreach (var asmRef in module.AssemblyReferences) {
-				if (asmRef.Name == simpleName)
-					return asmRef.FullName;
-			}
+			var asmRef = module.GetAssemblyRef(simpleName);
+			if (asmRef != null)
+				return asmRef.FullName;
 
-			try {
-				return AssemblyResolver.Instance.Resolve(simpleName).FullName;
-			}
-			catch (ResolutionException) {
-			}
-			catch (AssemblyResolutionException) {
-			}
-			return null;
+			var asm = TheAssemblyResolver.Instance.Resolve(new AssemblyNameInfo(simpleName), module);
+			return asm == null ? null : asm.FullName;
 		}
 
 		public List<UserResourceType> getSortedTypes() {
 			var list = new List<UserResourceType>(dict.Values);
-			list.Sort((a, b) => Utils.compareInt32((int)a.Code, (int)b.Code));
+			list.Sort((a, b) => ((int)a.Code).CompareTo((int)b.Code));
 			return list;
 		}
 	}
diff --git a/de4dot.code/resources/ResourceReader.cs b/de4dot.code/resources/ResourceReader.cs
index e56c0746..ef922b3b 100644
--- a/de4dot.code/resources/ResourceReader.cs
+++ b/de4dot.code/resources/ResourceReader.cs
@@ -22,7 +22,8 @@ using System.Collections.Generic;
 using System.IO;
 using System.Text;
 using System.Text.RegularExpressions;
-using Mono.Cecil;
+using dot10.DotNet;
+using dot10.IO;
 
 namespace de4dot.code.resources {
 	[Serializable]
@@ -32,19 +33,19 @@ namespace de4dot.code.resources {
 		}
 	}
 
-	class ResourceReader {
-		ModuleDefinition module;
-		BinaryReader reader;
+	struct ResourceReader {
+		ModuleDefMD module;
+		IBinaryReader reader;
 		ResourceDataCreator resourceDataCreator;
 
-		ResourceReader(ModuleDefinition module, Stream stream) {
+		ResourceReader(ModuleDefMD module, IBinaryReader reader) {
 			this.module = module;
-			this.reader = new BinaryReader(stream);
+			this.reader = reader;
 			this.resourceDataCreator = new ResourceDataCreator(module);
 		}
 
-		public static ResourceElementSet read(ModuleDefinition module, Stream stream) {
-			return new ResourceReader(module, stream).read();
+		public static ResourceElementSet read(ModuleDefMD module, IBinaryReader reader) {
+			return new ResourceReader(module, reader).read();
 		}
 
 		ResourceElementSet read() {
@@ -68,7 +69,7 @@ namespace de4dot.code.resources {
 			var userTypes = new List<UserResourceType>();
 			for (int i = 0; i < numUserTypes; i++)
 				userTypes.Add(new UserResourceType(reader.ReadString(), ResourceTypeCode.UserTypes + i));
-			reader.BaseStream.Position = (reader.BaseStream.Position + 7) & ~7;
+			reader.Position = (reader.Position + 7) & ~7;
 
 			var hashes = new int[numResources];
 			for (int i = 0; i < numResources; i++)
@@ -77,27 +78,26 @@ namespace de4dot.code.resources {
 			for (int i = 0; i < numResources; i++)
 				offsets[i] = reader.ReadInt32();
 
-			long baseOffset = reader.BaseStream.Position;
+			long baseOffset = reader.Position;
 			long dataBaseOffset = reader.ReadInt32();
-			long nameBaseOffset = reader.BaseStream.Position;
-			long end = reader.BaseStream.Length;
+			long nameBaseOffset = reader.Position;
+			long end = reader.Length;
 
 			var infos = new List<ResourceInfo>(numResources);
 
-			var nameReader = new BinaryReader(reader.BaseStream, Encoding.Unicode);
 			for (int i = 0; i < numResources; i++) {
-				nameReader.BaseStream.Position = nameBaseOffset + offsets[i];
-				var name = nameReader.ReadString();
-				long offset = dataBaseOffset + nameReader.ReadInt32();
+				reader.Position = nameBaseOffset + offsets[i];
+				var name = reader.ReadString(Encoding.Unicode);
+				long offset = dataBaseOffset + reader.ReadInt32();
 				infos.Add(new ResourceInfo(name, offset));
 			}
 
-			infos.Sort(sortResourceInfo);
+			infos.Sort((a, b) => a.offset.CompareTo(b.offset));
 			for (int i = 0; i < infos.Count; i++) {
 				var info = infos[i];
 				var element = new ResourceElement();
 				element.Name = info.name;
-				reader.BaseStream.Position = info.offset;
+				reader.Position = info.offset;
 				long nextDataOffset = i == infos.Count - 1 ? end : infos[i + 1].offset;
 				int size = (int)(nextDataOffset - info.offset);
 				element.ResourceData = readResourceData(userTypes, size);
@@ -108,10 +108,6 @@ namespace de4dot.code.resources {
 			return resources;
 		}
 
-		static int sortResourceInfo(ResourceInfo a, ResourceInfo b) {
-			return Utils.compareInt32((int)a.offset, (int)b.offset);
-		}
-
 		class ResourceInfo {
 			public string name;
 			public long offset;
@@ -153,9 +149,9 @@ namespace de4dot.code.resources {
 			}
 		}
 
-		static uint readUInt32(BinaryReader reader) {
+		static uint readUInt32(IBinaryReader reader) {
 			try {
-				return Utils.readEncodedUInt32(reader);
+				return reader.Read7BitEncodedUInt32();
 			}
 			catch {
 				throw new ResourceReaderException("Invalid encoded int32");
diff --git a/de4dot.code/resources/ResourceWriter.cs b/de4dot.code/resources/ResourceWriter.cs
index b3e60f30..ab418d88 100644
--- a/de4dot.code/resources/ResourceWriter.cs
+++ b/de4dot.code/resources/ResourceWriter.cs
@@ -23,24 +23,24 @@ using System.IO;
 using System.Runtime.Serialization;
 using System.Runtime.Serialization.Formatters.Binary;
 using System.Text;
-using Mono.Cecil;
+using dot10.DotNet;
 
 namespace de4dot.code.resources {
 	class ResourceWriter {
-		ModuleDefinition module;
+		ModuleDefMD module;
 		BinaryWriter writer;
 		ResourceElementSet resources;
 		ResourceDataCreator typeCreator;
 		Dictionary<UserResourceData, UserResourceType> dataToNewType = new Dictionary<UserResourceData, UserResourceType>();
 
-		ResourceWriter(ModuleDefinition module, Stream stream, ResourceElementSet resources) {
+		ResourceWriter(ModuleDefMD module, Stream stream, ResourceElementSet resources) {
 			this.module = module;
 			this.typeCreator = new ResourceDataCreator(module);
 			this.writer = new BinaryWriter(stream);
 			this.resources = resources;
 		}
 
-		public static void write(ModuleDefinition module, Stream stream, ResourceElementSet resources) {
+		public static void write(ModuleDefMD module, Stream stream, ResourceElementSet resources) {
 			new ResourceWriter(module, stream, resources).write();
 		}
 
@@ -138,13 +138,7 @@ namespace de4dot.code.resources {
 		}
 
 		string getMscorlibFullname() {
-			AssemblyNameReference mscorlibRef = null;
-			foreach (var asmRef in module.AssemblyReferences) {
-				if (asmRef.Name != "mscorlib")
-					continue;
-				if (mscorlibRef == null || mscorlibRef.Version == null || (asmRef.Version != null && asmRef.Version >= mscorlibRef.Version))
-					mscorlibRef = asmRef;
-			}
+			var mscorlibRef = module.GetAssemblyRef("mscorlib");
 			if (mscorlibRef != null)
 				return mscorlibRef.FullName;
 
diff --git a/de4dot.cui/CommandLineParser.cs b/de4dot.cui/CommandLineParser.cs
index 028e65ca..42ce5233 100644
--- a/de4dot.cui/CommandLineParser.cs
+++ b/de4dot.cui/CommandLineParser.cs
@@ -20,6 +20,7 @@
 using System;
 using System.IO;
 using System.Collections.Generic;
+using dot10.DotNet;
 using de4dot.code;
 using de4dot.code.deobfuscators;
 using de4dot.code.AssemblyClient;
@@ -114,7 +115,7 @@ namespace de4dot.cui {
 				filesOptions.DetectObfuscators = true;
 			}));
 			miscOptions.Add(new OneArgOption(null, "asm-path", "Add an assembly search path", "path", (val) => {
-				AssemblyResolver.Instance.addSearchDirectory(val);
+				TheAssemblyResolver.Instance.addSearchDirectory(val);
 			}));
 			miscOptions.Add(new NoArgOption(null, "dont-rename", "Don't rename classes, methods, etc.", () => {
 				filesOptions.RenameSymbols = false;
@@ -144,10 +145,12 @@ namespace de4dot.cui {
 				filesOptions.OneFileAtATime = true;
 			}));
 			miscOptions.Add(new NoArgOption("v", null, "Verbose", () => {
-				Log.logLevel = Log.LogLevel.verbose;
+				Logger.Instance.MaxLoggerEvent = LoggerEvent.Verbose;
+				Logger.Instance.CanIgnoreMessages = false;
 			}));
 			miscOptions.Add(new NoArgOption("vv", null, "Very verbose", () => {
-				Log.logLevel = Log.LogLevel.veryverbose;
+				Logger.Instance.MaxLoggerEvent = LoggerEvent.VeryVerbose;
+				Logger.Instance.CanIgnoreMessages = false;
 			}));
 			miscOptions.Add(new NoArgOption("h", "help", "Show this help message", () => {
 				usage();
@@ -254,7 +257,7 @@ namespace de4dot.cui {
 		void addFile() {
 			if (newFileOptions == null)
 				return;
-			files.Add(new ObfuscatedFile(newFileOptions, filesOptions.AssemblyClientFactory));
+			files.Add(new ObfuscatedFile(newFileOptions, filesOptions.ModuleContext, filesOptions.AssemblyClientFactory));
 			newFileOptions = null;
 		}
 
@@ -275,7 +278,7 @@ namespace de4dot.cui {
 
 		void exitError(string msg) {
 			usage();
-			Log.e("\n\nERROR: {0}\n", msg);
+			Logger.Instance.LogErrorDontIgnore("\n\nERROR: {0}\n", msg);
 			exit(2);
 		}
 
@@ -285,35 +288,35 @@ namespace de4dot.cui {
 
 		void usage() {
 			string progName = getProgramBaseName();
-			Log.n("Some of the advanced options may be incompatible, causing a nice exception.");
-			Log.n("With great power comes great responsibility.");
-			Log.n("");
-			Log.n("{0} <options> <file options>", progName);
-			Log.n("Options:");
+			Logger.n("Some of the advanced options may be incompatible, causing a nice exception.");
+			Logger.n("With great power comes great responsibility.");
+			Logger.n("");
+			Logger.n("{0} <options> <file options>", progName);
+			Logger.n("Options:");
 			foreach (var option in miscOptions)
 				printOption(option);
-			Log.n("");
-			Log.n("File options:");
+			Logger.n("");
+			Logger.n("File options:");
 			foreach (var option in fileOptions)
 				printOption(option);
-			Log.n("");
-			Log.n("Deobfuscator options:");
+			Logger.n("");
+			Logger.n("Deobfuscator options:");
 			foreach (var info in deobfuscatorInfos) {
-				Log.n("Type {0} ({1})", info.Type, info.Name);
+				Logger.n("Type {0} ({1})", info.Type, info.Name);
 				foreach (var option in info.getOptions())
 					printOption(option);
-				Log.n("");
+				Logger.n("");
 			}
 			printInfos("String decrypter types", stringDecrypterTypes);
-			Log.n("");
-			Log.n("Multiple regexes can be used if separated by '{0}'.", NameRegexes.regexSeparatorChar);
-			Log.n("Use '{0}' if you want to invert the regex. Example: {0}^[a-z\\d]{{1,2}}${1}{0}^[A-Z]_\\d+${1}^[\\w.]+$", NameRegex.invertChar, NameRegexes.regexSeparatorChar);
-			Log.n("");
-			Log.n("Examples:");
-			Log.n("{0} -r c:\\my\\files -ro c:\\my\\output", progName);
-			Log.n("{0} file1 file2 file3", progName);
-			Log.n("{0} file1 -f file2 -o file2.out -f file3 -o file3.out", progName);
-			Log.n("{0} file1 --strtyp delegate --strtok 06000123", progName);
+			Logger.n("");
+			Logger.n("Multiple regexes can be used if separated by '{0}'.", NameRegexes.regexSeparatorChar);
+			Logger.n("Use '{0}' if you want to invert the regex. Example: {0}^[a-z\\d]{{1,2}}${1}{0}^[A-Z]_\\d+${1}^[\\w.]+$", NameRegex.invertChar, NameRegexes.regexSeparatorChar);
+			Logger.n("");
+			Logger.n("Examples:");
+			Logger.n("{0} -r c:\\my\\files -ro c:\\my\\output", progName);
+			Logger.n("{0} file1 file2 file3", progName);
+			Logger.n("{0} file1 -f file2 -o file2.out -f file3 -o file3.out", progName);
+			Logger.n("{0} file1 --strtyp delegate --strtok 06000123", progName);
 		}
 
 		string getProgramBaseName() {
@@ -321,7 +324,7 @@ namespace de4dot.cui {
 		}
 
 		void printInfos(string desc, Infos infos) {
-			Log.n("{0}", desc);
+			Logger.n("{0}", desc);
 			foreach (var info in infos.getInfos())
 				printOptionAndExplanation(info.name, info.desc);
 		}
@@ -342,11 +345,11 @@ namespace de4dot.cui {
 			const string prefix = "  ";
 			string left = string.Format(string.Format("{{0,-{0}}}", maxCols), option);
 			if (option.Length > maxCols) {
-				Log.n("{0}{1}", prefix, left);
-				Log.n("{0}{1} {2}", prefix, new string(' ', maxCols), explanation);
+				Logger.n("{0}{1}", prefix, left);
+				Logger.n("{0}{1} {2}", prefix, new string(' ', maxCols), explanation);
 			}
 			else
-				Log.n("{0}{1} {2}", prefix, left, explanation);
+				Logger.n("{0}{1} {2}", prefix, left, explanation);
 		}
 
 		string getOptionAndArgName(Option option, string optionName) {
diff --git a/de4dot.cui/FilesDeobfuscator.cs b/de4dot.cui/FilesDeobfuscator.cs
index 29077397..f5f88514 100644
--- a/de4dot.cui/FilesDeobfuscator.cs
+++ b/de4dot.cui/FilesDeobfuscator.cs
@@ -20,7 +20,7 @@
 using System;
 using System.IO;
 using System.Collections.Generic;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 using de4dot.code;
 using de4dot.code.renamer;
@@ -33,6 +33,7 @@ namespace de4dot.cui {
 		IDeobfuscatorContext deobfuscatorContext = new DeobfuscatorContext();
 
 		public class Options {
+			public ModuleContext ModuleContext { get; set; }
 			public IList<IDeobfuscatorInfo> DeobfuscatorInfos { get; set; }
 			public IList<IObfuscatedFile> Files { get; set; }
 			public IList<SearchDir> SearchDirs { get; set; }
@@ -47,6 +48,7 @@ namespace de4dot.cui {
 			public IAssemblyClientFactory AssemblyClientFactory { get; set; }
 
 			public Options() {
+				ModuleContext = new ModuleContext(TheAssemblyResolver.Instance);
 				DeobfuscatorInfos = new List<IDeobfuscatorInfo>();
 				Files = new List<IObfuscatedFile>();
 				SearchDirs = new List<SearchDir>();
@@ -76,21 +78,21 @@ namespace de4dot.cui {
 				deobfuscateAll();
 		}
 
-		static void removeModule(ModuleDefinition module) {
-			AssemblyResolver.Instance.removeModule(module);
-			DotNetUtils.typeCaches.invalidate(module);
+		static void removeModule(ModuleDef module) {
+			TheAssemblyResolver.Instance.removeModule(module);
 		}
 
 		void detectObfuscators() {
 			foreach (var file in loadAllFiles(true)) {
-				removeModule(file.ModuleDefinition);
+				removeModule(file.ModuleDefMD);
+				file.Dispose();
 				deobfuscatorContext.clear();
 			}
 		}
 
 		void deobfuscateOneAtATime() {
 			foreach (var file in loadAllFiles()) {
-				int oldIndentLevel = Log.indentLevel;
+				int oldIndentLevel = Logger.Instance.IndentLevel;
 				try {
 					file.deobfuscateBegin();
 					file.deobfuscate();
@@ -98,26 +100,34 @@ namespace de4dot.cui {
 					rename(new List<IObfuscatedFile> { file });
 					file.save();
 
-					removeModule(file.ModuleDefinition);
-					AssemblyResolver.Instance.clearAll();
+					removeModule(file.ModuleDefMD);
+					TheAssemblyResolver.Instance.clearAll();
 					deobfuscatorContext.clear();
 				}
 				catch (Exception ex) {
-					Log.w("Could not deobfuscate {0}. Use -v to see stack trace", file.Filename);
-					Program.printStackTrace(ex, Log.LogLevel.verbose);
+					Logger.Instance.Log(false, null, LoggerEvent.Warning, "Could not deobfuscate {0}. Use -v to see stack trace", file.Filename);
+					Program.printStackTrace(ex, LoggerEvent.Verbose);
 				}
 				finally {
-					file.deobfuscateCleanUp();
-					Log.indentLevel = oldIndentLevel;
+					file.Dispose();
+					Logger.Instance.IndentLevel = oldIndentLevel;
 				}
 			}
 		}
 
 		void deobfuscateAll() {
 			var allFiles = new List<IObfuscatedFile>(loadAllFiles());
-			deobfuscateAllFiles(allFiles);
-			rename(allFiles);
-			saveAllFiles(allFiles);
+			try {
+				deobfuscateAllFiles(allFiles);
+				rename(allFiles);
+				saveAllFiles(allFiles);
+			}
+			finally {
+				foreach (var file in allFiles) {
+					if (file != null)
+						file.Dispose();
+				}
+			}
 		}
 
 		IEnumerable<IObfuscatedFile> loadAllFiles() {
@@ -126,6 +136,7 @@ namespace de4dot.cui {
 
 		IEnumerable<IObfuscatedFile> loadAllFiles(bool onlyScan) {
 			var loader = new DotNetFileLoader(new DotNetFileLoader.Options {
+				ModuleContext = options.ModuleContext,
 				PossibleFiles  = options.Files,
 				SearchDirs = options.SearchDirs,
 				CreateDeobfuscators = () => createDeobfuscators(),
@@ -148,6 +159,7 @@ namespace de4dot.cui {
 			Dictionary<string, bool> visitedDirectory = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase);
 
 			public class Options {
+				public ModuleContext ModuleContext { get; set; }
 				public IEnumerable<IObfuscatedFile> PossibleFiles { get; set; }
 				public IEnumerable<SearchDir> SearchDirs { get; set; }
 				public Func<IEnumerable<IDeobfuscator>> CreateDeobfuscators { get; set; }
@@ -179,12 +191,12 @@ namespace de4dot.cui {
 			bool add(IObfuscatedFile file, bool skipUnknownObfuscator, bool isFromPossibleFiles) {
 				var key = Utils.getFullPath(file.Filename);
 				if (allFiles.ContainsKey(key)) {
-					Log.w("Ingoring duplicate file: {0}", file.Filename);
+					Logger.Instance.Log(false, null, LoggerEvent.Warning, "Ingoring duplicate file: {0}", file.Filename);
 					return false;
 				}
 				allFiles[key] = true;
 
-				int oldIndentLevel = Log.indentLevel;
+				int oldIndentLevel = Logger.Instance.IndentLevel;
 				try {
 					file.DeobfuscatorContext = options.DeobfuscatorContext;
 					file.load(options.CreateDeobfuscators());
@@ -194,28 +206,28 @@ namespace de4dot.cui {
 				}
 				catch (BadImageFormatException) {
 					if (isFromPossibleFiles)
-						Log.w("The file isn't a .NET PE file: {0}", file.Filename);
+						Logger.Instance.Log(false, null, LoggerEvent.Warning, "The file isn't a .NET PE file: {0}", file.Filename);
 					return false;	// Not a .NET file
 				}
 				catch (EndOfStreamException) {
 					return false;
 				}
 				catch (Exception ex) {
-					Log.w("Could not load file ({0}): {1}", ex.GetType(), file.Filename);
+					Logger.Instance.Log(false, null, LoggerEvent.Warning, "Could not load file ({0}): {1}", ex.GetType(), file.Filename);
 					return false;
 				}
 				finally {
-					Log.indentLevel = oldIndentLevel;
+					Logger.Instance.IndentLevel = oldIndentLevel;
 				}
 
 				var deob = file.Deobfuscator;
 				if (skipUnknownObfuscator && deob.Type == "un") {
-					Log.v("Skipping unknown obfuscator: {0}", file.Filename);
-					removeModule(file.ModuleDefinition);
+					Logger.v("Skipping unknown obfuscator: {0}", file.Filename);
+					removeModule(file.ModuleDefMD);
 					return false;
 				}
 				else {
-					Log.n("Detected {0} ({1})", deob.Name, file.Filename);
+					Logger.n("Detected {0} ({1})", deob.Name, file.Filename);
 					if (options.CreateDestinationDir)
 						createDirectories(Path.GetDirectoryName(file.NewFilename));
 					return true;
@@ -245,7 +257,7 @@ namespace de4dot.cui {
 
 			IEnumerable<string> recursiveAdd(SearchDir searchDir, IEnumerable<FileSystemInfo> fileSystemInfos) {
 				foreach (var fsi in fileSystemInfos) {
-					if ((int)(fsi.Attributes & FileAttributes.Directory) != 0) {
+					if ((int)(fsi.Attributes & System.IO.FileAttributes.Directory) != 0) {
 						foreach (var filename in doDirectoryInfo(searchDir, (DirectoryInfo)fsi))
 							yield return filename;
 					}
@@ -304,9 +316,10 @@ namespace de4dot.cui {
 						throw new UserException(string.Format("Input and output filename is the same: {0}", fileOptions.Filename));
 				}
 
-				var obfuscatedFile = new ObfuscatedFile(fileOptions, options.AssemblyClientFactory);
+				var obfuscatedFile = new ObfuscatedFile(fileOptions, options.ModuleContext, options.AssemblyClientFactory);
 				if (add(obfuscatedFile, searchDir.SkipUnknownObfuscators, false))
 					return obfuscatedFile;
+				obfuscatedFile.Dispose();
 				return null;
 			}
 
diff --git a/de4dot.cui/Program.cs b/de4dot.cui/Program.cs
index 285f89bc..64da4a87 100644
--- a/de4dot.cui/Program.cs
+++ b/de4dot.cui/Program.cs
@@ -20,6 +20,7 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
+using dot10.DotNet;
 using de4dot.code;
 using de4dot.code.deobfuscators;
 
@@ -37,8 +38,8 @@ namespace de4dot.cui {
 		static IList<IDeobfuscatorInfo> createDeobfuscatorInfos() {
 			return new List<IDeobfuscatorInfo> {
 				new de4dot.code.deobfuscators.Unknown.DeobfuscatorInfo(),
+				new de4dot.code.deobfuscators.Agile_NET.DeobfuscatorInfo(),
 				new de4dot.code.deobfuscators.Babel_NET.DeobfuscatorInfo(),
-				new de4dot.code.deobfuscators.CliSecure.DeobfuscatorInfo(),
 				new de4dot.code.deobfuscators.CodeFort.DeobfuscatorInfo(),
 				new de4dot.code.deobfuscators.CodeVeil.DeobfuscatorInfo(),
 				new de4dot.code.deobfuscators.CodeWall.DeobfuscatorInfo(),
@@ -64,14 +65,17 @@ namespace de4dot.cui {
 		public static int main(string[] args) {
 			int exitCode = 0;
 
+			const string showAllMessagesEnvName = "SHOWALLMESSAGES";
 			try {
 				if (Console.OutputEncoding.IsSingleByte)
 					Console.OutputEncoding = new UTF8Encoding(false);
 
-				Log.n("");
-				Log.n("de4dot v{0} Copyright (C) 2011-2012 de4dot@gmail.com", System.Reflection.Assembly.GetExecutingAssembly().GetName().Version);
-				Log.n("Latest version and source code: https://github.com/0xd4d/de4dot");
-				Log.n("");
+				Logger.Instance.CanIgnoreMessages = !hasEnv(showAllMessagesEnvName);
+
+				Logger.n("");
+				Logger.n("de4dot v{0} Copyright (C) 2011-2012 de4dot@gmail.com", System.Reflection.Assembly.GetExecutingAssembly().GetName().Version);
+				Logger.n("Latest version and source code: https://github.com/0xd4d/de4dot");
+				Logger.n("");
 
 				var options = new FilesDeobfuscator.Options();
 				parseCommandLine(args, options);
@@ -81,26 +85,31 @@ namespace de4dot.cui {
 				exitCode = ex.code;
 			}
 			catch (UserException ex) {
-				Log.e("ERROR: {0}", ex.Message);
+				Logger.Instance.LogErrorDontIgnore("ERROR: {0}", ex.Message);
 				exitCode = 1;
 			}
 			catch (Exception ex) {
 				if (printFullStackTrace()) {
 					printStackTrace(ex);
-					Log.e("\nTry the latest version before reporting this problem!");
-					Log.e("Send bug reports to de4dot@gmail.com or go to https://github.com/0xd4d/de4dot/issues");
+					Logger.Instance.LogErrorDontIgnore("\nTry the latest version before reporting this problem!");
+					Logger.Instance.LogErrorDontIgnore("Send bug reports to de4dot@gmail.com or go to https://github.com/0xd4d/de4dot/issues");
 				}
 				else {
-					Log.e("\n\n");
-					Log.e("Hmmmm... something didn't work. Try the latest version.");
-					Log.e("    EX: {0} : message: {1}", ex.GetType(), ex.Message);
-					Log.e("If it's a supported obfuscator, it could be a bug or a new obfuscator version.");
-					Log.e("If it's an unsupported obfuscator, make sure the methods are decrypted!");
-					Log.e("Send bug reports to de4dot@gmail.com or go to https://github.com/0xd4d/de4dot/issues");
+					Logger.Instance.LogErrorDontIgnore("\n\n");
+					Logger.Instance.LogErrorDontIgnore("Hmmmm... something didn't work. Try the latest version.");
+					Logger.Instance.LogErrorDontIgnore("    EX: {0} : message: {1}", ex.GetType(), ex.Message);
+					Logger.Instance.LogErrorDontIgnore("If it's a supported obfuscator, it could be a bug or a new obfuscator version.");
+					Logger.Instance.LogErrorDontIgnore("If it's an unsupported obfuscator, make sure the methods are decrypted!");
+					Logger.Instance.LogErrorDontIgnore("Send bug reports to de4dot@gmail.com or go to https://github.com/0xd4d/de4dot/issues");
 				}
 				exitCode = 1;
 			}
 
+			if (Logger.Instance.NumIgnoredMessages > 0) {
+				Logger.n("Ignored {0} warnings/errors", Logger.Instance.NumIgnoredMessages);
+				Logger.n("Use -v/-vv option or set environment variable {0}=1 to see all messages", showAllMessagesEnvName);
+			}
+
 			if (isN00bUser()) {
 				Console.Error.WriteLine("\n\nPress any key to exit...\n");
 				try {
@@ -114,7 +123,7 @@ namespace de4dot.cui {
 		}
 
 		static bool printFullStackTrace() {
-			if (Log.isAtLeast(Log.LogLevel.verbose))
+			if (!Logger.Instance.IgnoresEvent(LoggerEvent.Verbose))
 				return true;
 			if (hasEnv("STACKTRACE"))
 				return true;
@@ -140,31 +149,31 @@ namespace de4dot.cui {
 		}
 
 		public static void printStackTrace(Exception ex) {
-			printStackTrace(ex, Log.LogLevel.error);
+			printStackTrace(ex, LoggerEvent.Error);
 		}
 
-		public static void printStackTrace(Exception ex, Log.LogLevel logLevel) {
+		public static void printStackTrace(Exception ex, LoggerEvent loggerEvent) {
 			var line = new string('-', 78);
-			Log.log(logLevel, "\n\n");
-			Log.log(logLevel, line);
-			Log.log(logLevel, "Stack trace:\n{0}", ex.StackTrace);
-			Log.log(logLevel, "\n\nERROR: Caught an exception:\n");
-			Log.log(logLevel, line);
-			Log.log(logLevel, "Message:");
-			Log.log(logLevel, "  {0}", ex.Message);
-			Log.log(logLevel, "Type:");
-			Log.log(logLevel, "  {0}", ex.GetType());
-			Log.log(logLevel, line);
+			Logger.Instance.Log(false, null, loggerEvent, "\n\n");
+			Logger.Instance.Log(false, null, loggerEvent, line);
+			Logger.Instance.Log(false, null, loggerEvent, "Stack trace:\n{0}", ex.StackTrace);
+			Logger.Instance.Log(false, null, loggerEvent, "\n\nERROR: Caught an exception:\n");
+			Logger.Instance.Log(false, null, loggerEvent, line);
+			Logger.Instance.Log(false, null, loggerEvent, "Message:");
+			Logger.Instance.Log(false, null, loggerEvent, "  {0}", ex.Message);
+			Logger.Instance.Log(false, null, loggerEvent, "Type:");
+			Logger.Instance.Log(false, null, loggerEvent, "  {0}", ex.GetType());
+			Logger.Instance.Log(false, null, loggerEvent, line);
 		}
 
 		static void parseCommandLine(string[] args, FilesDeobfuscator.Options options) {
 			new CommandLineParser(deobfuscatorInfos, options).parse(args);
 
-			Log.vv("Args:");
-			Log.indent();
+			Logger.vv("Args:");
+			Logger.Instance.indent();
 			foreach (var arg in args)
-				Log.vv("{0}", Utils.toCsharpString(arg));
-			Log.deIndent();
+				Logger.vv("{0}", Utils.toCsharpString(arg));
+			Logger.Instance.deIndent();
 		}
 	}
 }
diff --git a/de4dot.cui/de4dot.cui.csproj b/de4dot.cui/de4dot.cui.csproj
index f10e18e5..5a8eb7e9 100644
--- a/de4dot.cui/de4dot.cui.csproj
+++ b/de4dot.cui/de4dot.cui.csproj
@@ -47,14 +47,14 @@
       <Project>{045B96F2-AF80-4C4C-8D27-E38635AC705E}</Project>
       <Name>blocks</Name>
     </ProjectReference>
-    <ProjectReference Include="..\cecil\Mono.Cecil.csproj">
-      <Project>{D68133BD-1E63-496E-9EDE-4FBDBF77B486}</Project>
-      <Name>Mono.Cecil</Name>
-    </ProjectReference>
     <ProjectReference Include="..\de4dot.code\de4dot.code.csproj">
       <Project>{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}</Project>
       <Name>de4dot.code</Name>
     </ProjectReference>
+    <ProjectReference Include="..\dot10\src\dot10.csproj">
+      <Project>{FDFC1237-143F-4919-8318-4926901F4639}</Project>
+      <Name>dot10</Name>
+    </ProjectReference>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/de4dot.mdecrypt/DecryptMethodsInfo.cs b/de4dot.mdecrypt/DecryptMethodsInfo.cs
index 72cce7f8..45f9d468 100644
--- a/de4dot.mdecrypt/DecryptMethodsInfo.cs
+++ b/de4dot.mdecrypt/DecryptMethodsInfo.cs
@@ -19,7 +19,6 @@
 
 using System;
 using System.Collections.Generic;
-using Mono.MyStuff;
 
 namespace de4dot.mdecrypt {
 	[Serializable]
diff --git a/de4dot.mdecrypt/DynamicMethodsDecrypter.cs b/de4dot.mdecrypt/DynamicMethodsDecrypter.cs
index 4c24861e..5b2855af 100644
--- a/de4dot.mdecrypt/DynamicMethodsDecrypter.cs
+++ b/de4dot.mdecrypt/DynamicMethodsDecrypter.cs
@@ -22,8 +22,7 @@ using System.IO;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Reflection;
-using Mono.MyStuff;
-using Mono.Cecil;
+using dot10.DotNet;
 using de4dot.blocks;
 using de4dot.PE;
 
@@ -70,7 +69,7 @@ namespace de4dot.mdecrypt {
 
 		class DecryptContext {
 			public DumpedMethod dm;
-			public MethodDefinition method;
+			public MethodDef method;
 		}
 
 		FuncPtrInfo<CompileMethod> ourCompileMethodInfo = new FuncPtrInfo<CompileMethod>();
@@ -93,8 +92,8 @@ namespace de4dot.mdecrypt {
 
 		de4dot.PE.MetadataType methodDefTable;
 		IntPtr methodDefTablePtr;
-		ModuleDefinition monoModule;
-		MethodDefinition moduleCctor;
+		ModuleDefMD dot10Module;
+		MethodDef moduleCctor;
 		uint moduleCctorCodeRva;
 		IntPtr moduleToDecryptScope;
 
@@ -175,16 +174,16 @@ namespace de4dot.mdecrypt {
 		}
 
 		unsafe void initializeMonoCecilMethods() {
-			monoModule = ModuleDefinition.ReadModule(moduleToDecrypt.FullyQualifiedName);
-			moduleCctor = DotNetUtils.getModuleTypeCctor(monoModule);
+			dot10Module = ModuleDefMD.Load(moduleToDecrypt.FullyQualifiedName);
+			moduleCctor = DotNetUtils.getModuleTypeCctor(dot10Module);
 			if (moduleCctor == null)
 				moduleCctorCodeRva = 0;
 			else {
-				byte* p = (byte*)hInstModule + moduleCctor.RVA;
+				byte* p = (byte*)hInstModule + (uint)moduleCctor.RVA;
 				if ((*p & 3) == 2)
 					moduleCctorCodeRva = (uint)moduleCctor.RVA + 1;
 				else
-					moduleCctorCodeRva = (uint)(moduleCctor.RVA + (p[1] >> 4) * 4);
+					moduleCctorCodeRva = (uint)((uint)moduleCctor.RVA + (p[1] >> 4) * 4);
 			}
 		}
 
@@ -425,6 +424,7 @@ namespace de4dot.mdecrypt {
 		unsafe void updateFromMethodDefTableRow() {
 			int methodIndex = (int)(ctx.dm.token - 0x06000001);
 			byte* row = (byte*)methodDefTablePtr + methodIndex * methodDefTable.totalSize;
+			ctx.dm.mdRVA = read(row, methodDefTable.fields[0]);
 			ctx.dm.mdImplFlags = (ushort)read(row, methodDefTable.fields[1]);
 			ctx.dm.mdFlags = (ushort)read(row, methodDefTable.fields[2]);
 			ctx.dm.mdName = read(row, methodDefTable.fields[3]);
@@ -442,11 +442,11 @@ namespace de4dot.mdecrypt {
 		}
 
 		string returnNameOfMethod() {
-			return ctx.method.Name;
+			return ctx.method.Name.String;
 		}
 
 		int returnMethodToken() {
-			return ctx.method.MetadataToken.ToInt32();
+			return ctx.method.MDToken.ToInt32();
 		}
 
 		public DumpedMethods decryptMethods() {
@@ -476,11 +476,11 @@ namespace de4dot.mdecrypt {
 			ctx.dm = new DumpedMethod();
 			ctx.dm.token = token;
 
-			ctx.method = monoModule.LookupToken((int)token) as MethodDefinition;
+			ctx.method = dot10Module.ResolveToken(token) as MethodDef;
 			if (ctx.method == null)
 				throw new ApplicationException(string.Format("Could not find method {0:X8}", token));
 
-			byte* mh = (byte*)hInstModule + ctx.method.RVA;
+			byte* mh = (byte*)hInstModule + (uint)ctx.method.RVA;
 			byte* code;
 			if (mh == (byte*)hInstModule) {
 				ctx.dm.mhMaxStack = 0;
diff --git a/de4dot.mdecrypt/de4dot.mdecrypt.csproj b/de4dot.mdecrypt/de4dot.mdecrypt.csproj
index 7fa1d592..fbaf34a2 100644
--- a/de4dot.mdecrypt/de4dot.mdecrypt.csproj
+++ b/de4dot.mdecrypt/de4dot.mdecrypt.csproj
@@ -46,9 +46,9 @@
       <Project>{045B96F2-AF80-4C4C-8D27-E38635AC705E}</Project>
       <Name>blocks</Name>
     </ProjectReference>
-    <ProjectReference Include="..\cecil\Mono.Cecil.csproj">
-      <Project>{D68133BD-1E63-496E-9EDE-4FBDBF77B486}</Project>
-      <Name>Mono.Cecil</Name>
+    <ProjectReference Include="..\dot10\src\dot10.csproj">
+      <Project>{FDFC1237-143F-4919-8318-4926901F4639}</Project>
+      <Name>dot10</Name>
     </ProjectReference>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
diff --git a/de4dot.sln b/de4dot.sln
index f6106896..3f1b237b 100644
--- a/de4dot.sln
+++ b/de4dot.sln
@@ -1,8 +1,6 @@
 
 Microsoft Visual Studio Solution File, Format Version 11.00
 # Visual Studio 2010
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Mono.Cecil", "cecil\Mono.Cecil.csproj", "{D68133BD-1E63-496E-9EDE-4FBDBF77B486}"
-EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "de4dot.code", "de4dot.code\de4dot.code.csproj", "{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Test.Rename", "Test.Rename\Test.Rename.csproj", "{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}"
@@ -25,922 +23,164 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "de4dot.cui", "de4dot.cui\de
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "de4dot.mdecrypt", "de4dot.mdecrypt\de4dot.mdecrypt.csproj", "{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "dot10", "dot10\src\dot10.csproj", "{FDFC1237-143F-4919-8318-4926901F4639}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
 		Debug|Mixed Platforms = Debug|Mixed Platforms
 		Debug|Win32 = Debug|Win32
 		Debug|x86 = Debug|x86
-		net_2_0_Debug|Any CPU = net_2_0_Debug|Any CPU
-		net_2_0_Debug|Mixed Platforms = net_2_0_Debug|Mixed Platforms
-		net_2_0_Debug|Win32 = net_2_0_Debug|Win32
-		net_2_0_Debug|x86 = net_2_0_Debug|x86
-		net_2_0_Release|Any CPU = net_2_0_Release|Any CPU
-		net_2_0_Release|Mixed Platforms = net_2_0_Release|Mixed Platforms
-		net_2_0_Release|Win32 = net_2_0_Release|Win32
-		net_2_0_Release|x86 = net_2_0_Release|x86
-		net_3_5_Debug|Any CPU = net_3_5_Debug|Any CPU
-		net_3_5_Debug|Mixed Platforms = net_3_5_Debug|Mixed Platforms
-		net_3_5_Debug|Win32 = net_3_5_Debug|Win32
-		net_3_5_Debug|x86 = net_3_5_Debug|x86
-		net_3_5_Release|Any CPU = net_3_5_Release|Any CPU
-		net_3_5_Release|Mixed Platforms = net_3_5_Release|Mixed Platforms
-		net_3_5_Release|Win32 = net_3_5_Release|Win32
-		net_3_5_Release|x86 = net_3_5_Release|x86
-		net_4_0_Debug|Any CPU = net_4_0_Debug|Any CPU
-		net_4_0_Debug|Mixed Platforms = net_4_0_Debug|Mixed Platforms
-		net_4_0_Debug|Win32 = net_4_0_Debug|Win32
-		net_4_0_Debug|x86 = net_4_0_Debug|x86
-		net_4_0_Release|Any CPU = net_4_0_Release|Any CPU
-		net_4_0_Release|Mixed Platforms = net_4_0_Release|Mixed Platforms
-		net_4_0_Release|Win32 = net_4_0_Release|Win32
-		net_4_0_Release|x86 = net_4_0_Release|x86
 		Release|Any CPU = Release|Any CPU
 		Release|Mixed Platforms = Release|Mixed Platforms
 		Release|Win32 = Release|Win32
 		Release|x86 = Release|x86
-		silverlight_Debug|Any CPU = silverlight_Debug|Any CPU
-		silverlight_Debug|Mixed Platforms = silverlight_Debug|Mixed Platforms
-		silverlight_Debug|Win32 = silverlight_Debug|Win32
-		silverlight_Debug|x86 = silverlight_Debug|x86
-		silverlight_Release|Any CPU = silverlight_Release|Any CPU
-		silverlight_Release|Mixed Platforms = silverlight_Release|Mixed Platforms
-		silverlight_Release|Win32 = silverlight_Release|Win32
-		silverlight_Release|x86 = silverlight_Release|x86
-		winphone_Debug|Any CPU = winphone_Debug|Any CPU
-		winphone_Debug|Mixed Platforms = winphone_Debug|Mixed Platforms
-		winphone_Debug|Win32 = winphone_Debug|Win32
-		winphone_Debug|x86 = winphone_Debug|x86
-		winphone_Release|Any CPU = winphone_Release|Any CPU
-		winphone_Release|Mixed Platforms = winphone_Release|Mixed Platforms
-		winphone_Release|Win32 = winphone_Release|Win32
-		winphone_Release|x86 = winphone_Release|x86
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Debug|Any CPU.ActiveCfg = winphone_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Debug|Any CPU.Build.0 = winphone_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Debug|Mixed Platforms.ActiveCfg = net_2_0_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Debug|Mixed Platforms.Build.0 = net_2_0_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Debug|Win32.ActiveCfg = winphone_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Debug|x86.ActiveCfg = winphone_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_2_0_Debug|Any CPU.ActiveCfg = net_2_0_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_2_0_Debug|Any CPU.Build.0 = net_2_0_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_2_0_Debug|Mixed Platforms.ActiveCfg = net_2_0_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_2_0_Debug|Mixed Platforms.Build.0 = net_2_0_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_2_0_Debug|Win32.ActiveCfg = net_2_0_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_2_0_Debug|x86.ActiveCfg = net_2_0_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_2_0_Release|Any CPU.ActiveCfg = net_2_0_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_2_0_Release|Any CPU.Build.0 = net_2_0_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_2_0_Release|Mixed Platforms.ActiveCfg = net_2_0_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_2_0_Release|Mixed Platforms.Build.0 = net_2_0_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_2_0_Release|Win32.ActiveCfg = net_2_0_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_2_0_Release|x86.ActiveCfg = net_2_0_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_3_5_Debug|Any CPU.ActiveCfg = net_3_5_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_3_5_Debug|Any CPU.Build.0 = net_3_5_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_3_5_Debug|Mixed Platforms.ActiveCfg = net_3_5_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_3_5_Debug|Mixed Platforms.Build.0 = net_3_5_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_3_5_Debug|Win32.ActiveCfg = net_3_5_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_3_5_Debug|x86.ActiveCfg = net_3_5_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_3_5_Release|Any CPU.ActiveCfg = net_3_5_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_3_5_Release|Any CPU.Build.0 = net_3_5_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_3_5_Release|Mixed Platforms.ActiveCfg = net_3_5_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_3_5_Release|Mixed Platforms.Build.0 = net_3_5_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_3_5_Release|Win32.ActiveCfg = net_3_5_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_3_5_Release|x86.ActiveCfg = net_3_5_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_4_0_Debug|Any CPU.ActiveCfg = net_4_0_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_4_0_Debug|Any CPU.Build.0 = net_4_0_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_4_0_Debug|Mixed Platforms.ActiveCfg = net_4_0_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_4_0_Debug|Mixed Platforms.Build.0 = net_4_0_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_4_0_Debug|Win32.ActiveCfg = net_4_0_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_4_0_Debug|x86.ActiveCfg = net_4_0_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_4_0_Release|Any CPU.ActiveCfg = net_4_0_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_4_0_Release|Any CPU.Build.0 = net_4_0_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_4_0_Release|Mixed Platforms.ActiveCfg = net_4_0_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_4_0_Release|Mixed Platforms.Build.0 = net_4_0_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_4_0_Release|Win32.ActiveCfg = net_4_0_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.net_4_0_Release|x86.ActiveCfg = net_4_0_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Release|Any CPU.ActiveCfg = winphone_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Release|Any CPU.Build.0 = winphone_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Release|Mixed Platforms.ActiveCfg = net_2_0_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Release|Mixed Platforms.Build.0 = net_2_0_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Release|Win32.ActiveCfg = winphone_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Release|x86.ActiveCfg = winphone_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.silverlight_Debug|Any CPU.ActiveCfg = silverlight_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.silverlight_Debug|Any CPU.Build.0 = silverlight_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.silverlight_Debug|Mixed Platforms.ActiveCfg = silverlight_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.silverlight_Debug|Mixed Platforms.Build.0 = silverlight_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.silverlight_Debug|Win32.ActiveCfg = silverlight_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.silverlight_Debug|x86.ActiveCfg = silverlight_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.silverlight_Release|Any CPU.ActiveCfg = silverlight_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.silverlight_Release|Any CPU.Build.0 = silverlight_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.silverlight_Release|Mixed Platforms.ActiveCfg = silverlight_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.silverlight_Release|Mixed Platforms.Build.0 = silverlight_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.silverlight_Release|Win32.ActiveCfg = silverlight_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.silverlight_Release|x86.ActiveCfg = silverlight_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.winphone_Debug|Any CPU.ActiveCfg = winphone_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.winphone_Debug|Any CPU.Build.0 = winphone_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.winphone_Debug|Mixed Platforms.ActiveCfg = winphone_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.winphone_Debug|Mixed Platforms.Build.0 = winphone_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.winphone_Debug|Win32.ActiveCfg = winphone_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.winphone_Debug|x86.ActiveCfg = winphone_Debug|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.winphone_Release|Any CPU.ActiveCfg = winphone_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.winphone_Release|Any CPU.Build.0 = winphone_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.winphone_Release|Mixed Platforms.ActiveCfg = winphone_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.winphone_Release|Mixed Platforms.Build.0 = winphone_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.winphone_Release|Win32.ActiveCfg = winphone_Release|Any CPU
-		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.winphone_Release|x86.ActiveCfg = winphone_Release|Any CPU
 		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
 		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
 		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.Debug|Win32.ActiveCfg = Debug|Any CPU
 		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_2_0_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_2_0_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_2_0_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_2_0_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_2_0_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_2_0_Debug|x86.ActiveCfg = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_2_0_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_2_0_Release|Any CPU.Build.0 = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_2_0_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_2_0_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_2_0_Release|Win32.ActiveCfg = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_2_0_Release|x86.ActiveCfg = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_3_5_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_3_5_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_3_5_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_3_5_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_3_5_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_3_5_Debug|x86.ActiveCfg = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_3_5_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_3_5_Release|Any CPU.Build.0 = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_3_5_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_3_5_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_3_5_Release|Win32.ActiveCfg = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_3_5_Release|x86.ActiveCfg = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_4_0_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_4_0_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_4_0_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_4_0_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_4_0_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_4_0_Debug|x86.ActiveCfg = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_4_0_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_4_0_Release|Any CPU.Build.0 = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_4_0_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_4_0_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_4_0_Release|Win32.ActiveCfg = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.net_4_0_Release|x86.ActiveCfg = Release|Any CPU
 		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.Release|Any CPU.Build.0 = Release|Any CPU
 		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
 		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.Release|Mixed Platforms.Build.0 = Release|Any CPU
 		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.Release|Win32.ActiveCfg = Release|Any CPU
 		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.Release|x86.ActiveCfg = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.silverlight_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.silverlight_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.silverlight_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.silverlight_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.silverlight_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.silverlight_Debug|x86.ActiveCfg = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.silverlight_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.silverlight_Release|Any CPU.Build.0 = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.silverlight_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.silverlight_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.silverlight_Release|Win32.ActiveCfg = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.silverlight_Release|x86.ActiveCfg = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.winphone_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.winphone_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.winphone_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.winphone_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.winphone_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.winphone_Debug|x86.ActiveCfg = Debug|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.winphone_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.winphone_Release|Any CPU.Build.0 = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.winphone_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.winphone_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.winphone_Release|Win32.ActiveCfg = Release|Any CPU
-		{4D10B9EB-3BF1-4D61-A389-CB019E8C9622}.winphone_Release|x86.ActiveCfg = Release|Any CPU
 		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
 		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
 		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.Debug|Win32.ActiveCfg = Debug|Any CPU
 		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_2_0_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_2_0_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_2_0_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_2_0_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_2_0_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_2_0_Debug|x86.ActiveCfg = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_2_0_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_2_0_Release|Any CPU.Build.0 = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_2_0_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_2_0_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_2_0_Release|Win32.ActiveCfg = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_2_0_Release|x86.ActiveCfg = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_3_5_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_3_5_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_3_5_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_3_5_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_3_5_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_3_5_Debug|x86.ActiveCfg = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_3_5_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_3_5_Release|Any CPU.Build.0 = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_3_5_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_3_5_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_3_5_Release|Win32.ActiveCfg = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_3_5_Release|x86.ActiveCfg = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_4_0_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_4_0_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_4_0_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_4_0_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_4_0_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_4_0_Debug|x86.ActiveCfg = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_4_0_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_4_0_Release|Any CPU.Build.0 = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_4_0_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_4_0_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_4_0_Release|Win32.ActiveCfg = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.net_4_0_Release|x86.ActiveCfg = Release|Any CPU
 		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.Release|Any CPU.Build.0 = Release|Any CPU
 		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
 		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.Release|Mixed Platforms.Build.0 = Release|Any CPU
 		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.Release|Win32.ActiveCfg = Release|Any CPU
 		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.Release|x86.ActiveCfg = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.silverlight_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.silverlight_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.silverlight_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.silverlight_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.silverlight_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.silverlight_Debug|x86.ActiveCfg = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.silverlight_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.silverlight_Release|Any CPU.Build.0 = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.silverlight_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.silverlight_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.silverlight_Release|Win32.ActiveCfg = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.silverlight_Release|x86.ActiveCfg = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.winphone_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.winphone_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.winphone_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.winphone_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.winphone_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.winphone_Debug|x86.ActiveCfg = Debug|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.winphone_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.winphone_Release|Any CPU.Build.0 = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.winphone_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.winphone_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.winphone_Release|Win32.ActiveCfg = Release|Any CPU
-		{3FEB2023-B4B0-4DF3-BECF-AD727B55FF37}.winphone_Release|x86.ActiveCfg = Release|Any CPU
 		{3B408415-5203-4618-ABC1-F88D0BBE849B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{3B408415-5203-4618-ABC1-F88D0BBE849B}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{3B408415-5203-4618-ABC1-F88D0BBE849B}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
 		{3B408415-5203-4618-ABC1-F88D0BBE849B}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
 		{3B408415-5203-4618-ABC1-F88D0BBE849B}.Debug|Win32.ActiveCfg = Debug|Any CPU
 		{3B408415-5203-4618-ABC1-F88D0BBE849B}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_2_0_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_2_0_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_2_0_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_2_0_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_2_0_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_2_0_Debug|x86.ActiveCfg = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_2_0_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_2_0_Release|Any CPU.Build.0 = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_2_0_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_2_0_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_2_0_Release|Win32.ActiveCfg = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_2_0_Release|x86.ActiveCfg = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_3_5_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_3_5_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_3_5_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_3_5_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_3_5_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_3_5_Debug|x86.ActiveCfg = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_3_5_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_3_5_Release|Any CPU.Build.0 = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_3_5_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_3_5_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_3_5_Release|Win32.ActiveCfg = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_3_5_Release|x86.ActiveCfg = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_4_0_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_4_0_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_4_0_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_4_0_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_4_0_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_4_0_Debug|x86.ActiveCfg = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_4_0_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_4_0_Release|Any CPU.Build.0 = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_4_0_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_4_0_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_4_0_Release|Win32.ActiveCfg = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.net_4_0_Release|x86.ActiveCfg = Release|Any CPU
 		{3B408415-5203-4618-ABC1-F88D0BBE849B}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{3B408415-5203-4618-ABC1-F88D0BBE849B}.Release|Any CPU.Build.0 = Release|Any CPU
 		{3B408415-5203-4618-ABC1-F88D0BBE849B}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
 		{3B408415-5203-4618-ABC1-F88D0BBE849B}.Release|Mixed Platforms.Build.0 = Release|Any CPU
 		{3B408415-5203-4618-ABC1-F88D0BBE849B}.Release|Win32.ActiveCfg = Release|Any CPU
 		{3B408415-5203-4618-ABC1-F88D0BBE849B}.Release|x86.ActiveCfg = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.silverlight_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.silverlight_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.silverlight_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.silverlight_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.silverlight_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.silverlight_Debug|x86.ActiveCfg = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.silverlight_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.silverlight_Release|Any CPU.Build.0 = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.silverlight_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.silverlight_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.silverlight_Release|Win32.ActiveCfg = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.silverlight_Release|x86.ActiveCfg = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.winphone_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.winphone_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.winphone_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.winphone_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.winphone_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.winphone_Debug|x86.ActiveCfg = Debug|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.winphone_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.winphone_Release|Any CPU.Build.0 = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.winphone_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.winphone_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.winphone_Release|Win32.ActiveCfg = Release|Any CPU
-		{3B408415-5203-4618-ABC1-F88D0BBE849B}.winphone_Release|x86.ActiveCfg = Release|Any CPU
 		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
 		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
 		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.Debug|Win32.ActiveCfg = Debug|Any CPU
 		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_2_0_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_2_0_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_2_0_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_2_0_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_2_0_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_2_0_Debug|x86.ActiveCfg = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_2_0_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_2_0_Release|Any CPU.Build.0 = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_2_0_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_2_0_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_2_0_Release|Win32.ActiveCfg = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_2_0_Release|x86.ActiveCfg = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_3_5_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_3_5_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_3_5_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_3_5_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_3_5_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_3_5_Debug|x86.ActiveCfg = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_3_5_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_3_5_Release|Any CPU.Build.0 = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_3_5_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_3_5_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_3_5_Release|Win32.ActiveCfg = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_3_5_Release|x86.ActiveCfg = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_4_0_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_4_0_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_4_0_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_4_0_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_4_0_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_4_0_Debug|x86.ActiveCfg = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_4_0_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_4_0_Release|Any CPU.Build.0 = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_4_0_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_4_0_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_4_0_Release|Win32.ActiveCfg = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.net_4_0_Release|x86.ActiveCfg = Release|Any CPU
 		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.Release|Any CPU.Build.0 = Release|Any CPU
 		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
 		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.Release|Mixed Platforms.Build.0 = Release|Any CPU
 		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.Release|Win32.ActiveCfg = Release|Any CPU
 		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.Release|x86.ActiveCfg = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.silverlight_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.silverlight_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.silverlight_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.silverlight_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.silverlight_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.silverlight_Debug|x86.ActiveCfg = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.silverlight_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.silverlight_Release|Any CPU.Build.0 = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.silverlight_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.silverlight_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.silverlight_Release|Win32.ActiveCfg = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.silverlight_Release|x86.ActiveCfg = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.winphone_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.winphone_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.winphone_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.winphone_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.winphone_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.winphone_Debug|x86.ActiveCfg = Debug|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.winphone_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.winphone_Release|Any CPU.Build.0 = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.winphone_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.winphone_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.winphone_Release|Win32.ActiveCfg = Release|Any CPU
-		{FBD84077-9D35-41FE-89DF-8D79EFE0B595}.winphone_Release|x86.ActiveCfg = Release|Any CPU
 		{004EB657-252C-4361-A2D2-2E514130C7FC}.Debug|Any CPU.ActiveCfg = Debug|x86
 		{004EB657-252C-4361-A2D2-2E514130C7FC}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
 		{004EB657-252C-4361-A2D2-2E514130C7FC}.Debug|Mixed Platforms.Build.0 = Debug|x86
 		{004EB657-252C-4361-A2D2-2E514130C7FC}.Debug|Win32.ActiveCfg = Debug|x86
 		{004EB657-252C-4361-A2D2-2E514130C7FC}.Debug|x86.ActiveCfg = Debug|x86
 		{004EB657-252C-4361-A2D2-2E514130C7FC}.Debug|x86.Build.0 = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_2_0_Debug|Any CPU.ActiveCfg = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_2_0_Debug|Mixed Platforms.ActiveCfg = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_2_0_Debug|Mixed Platforms.Build.0 = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_2_0_Debug|Win32.ActiveCfg = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_2_0_Debug|x86.ActiveCfg = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_2_0_Debug|x86.Build.0 = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_2_0_Release|Any CPU.ActiveCfg = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_2_0_Release|Mixed Platforms.ActiveCfg = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_2_0_Release|Mixed Platforms.Build.0 = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_2_0_Release|Win32.ActiveCfg = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_2_0_Release|x86.ActiveCfg = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_2_0_Release|x86.Build.0 = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_3_5_Debug|Any CPU.ActiveCfg = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_3_5_Debug|Mixed Platforms.ActiveCfg = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_3_5_Debug|Mixed Platforms.Build.0 = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_3_5_Debug|Win32.ActiveCfg = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_3_5_Debug|x86.ActiveCfg = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_3_5_Debug|x86.Build.0 = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_3_5_Release|Any CPU.ActiveCfg = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_3_5_Release|Mixed Platforms.ActiveCfg = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_3_5_Release|Mixed Platforms.Build.0 = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_3_5_Release|Win32.ActiveCfg = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_3_5_Release|x86.ActiveCfg = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_3_5_Release|x86.Build.0 = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_4_0_Debug|Any CPU.ActiveCfg = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_4_0_Debug|Mixed Platforms.ActiveCfg = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_4_0_Debug|Mixed Platforms.Build.0 = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_4_0_Debug|Win32.ActiveCfg = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_4_0_Debug|x86.ActiveCfg = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_4_0_Debug|x86.Build.0 = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_4_0_Release|Any CPU.ActiveCfg = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_4_0_Release|Mixed Platforms.ActiveCfg = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_4_0_Release|Mixed Platforms.Build.0 = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_4_0_Release|Win32.ActiveCfg = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_4_0_Release|x86.ActiveCfg = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.net_4_0_Release|x86.Build.0 = Release|x86
 		{004EB657-252C-4361-A2D2-2E514130C7FC}.Release|Any CPU.ActiveCfg = Release|x86
 		{004EB657-252C-4361-A2D2-2E514130C7FC}.Release|Mixed Platforms.ActiveCfg = Release|x86
 		{004EB657-252C-4361-A2D2-2E514130C7FC}.Release|Mixed Platforms.Build.0 = Release|x86
 		{004EB657-252C-4361-A2D2-2E514130C7FC}.Release|Win32.ActiveCfg = Release|x86
 		{004EB657-252C-4361-A2D2-2E514130C7FC}.Release|x86.ActiveCfg = Release|x86
 		{004EB657-252C-4361-A2D2-2E514130C7FC}.Release|x86.Build.0 = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.silverlight_Debug|Any CPU.ActiveCfg = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.silverlight_Debug|Mixed Platforms.ActiveCfg = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.silverlight_Debug|Mixed Platforms.Build.0 = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.silverlight_Debug|Win32.ActiveCfg = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.silverlight_Debug|x86.ActiveCfg = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.silverlight_Debug|x86.Build.0 = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.silverlight_Release|Any CPU.ActiveCfg = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.silverlight_Release|Mixed Platforms.ActiveCfg = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.silverlight_Release|Mixed Platforms.Build.0 = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.silverlight_Release|Win32.ActiveCfg = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.silverlight_Release|x86.ActiveCfg = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.silverlight_Release|x86.Build.0 = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.winphone_Debug|Any CPU.ActiveCfg = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.winphone_Debug|Mixed Platforms.ActiveCfg = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.winphone_Debug|Mixed Platforms.Build.0 = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.winphone_Debug|Win32.ActiveCfg = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.winphone_Debug|x86.ActiveCfg = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.winphone_Debug|x86.Build.0 = Debug|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.winphone_Release|Any CPU.ActiveCfg = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.winphone_Release|Mixed Platforms.ActiveCfg = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.winphone_Release|Mixed Platforms.Build.0 = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.winphone_Release|Win32.ActiveCfg = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.winphone_Release|x86.ActiveCfg = Release|x86
-		{004EB657-252C-4361-A2D2-2E514130C7FC}.winphone_Release|x86.Build.0 = Release|x86
 		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.Debug|Any CPU.ActiveCfg = Debug|x86
 		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
 		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.Debug|Mixed Platforms.Build.0 = Debug|x86
 		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.Debug|Win32.ActiveCfg = Debug|x86
 		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.Debug|x86.ActiveCfg = Debug|x86
 		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.Debug|x86.Build.0 = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_2_0_Debug|Any CPU.ActiveCfg = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_2_0_Debug|Mixed Platforms.ActiveCfg = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_2_0_Debug|Mixed Platforms.Build.0 = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_2_0_Debug|Win32.ActiveCfg = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_2_0_Debug|x86.ActiveCfg = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_2_0_Debug|x86.Build.0 = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_2_0_Release|Any CPU.ActiveCfg = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_2_0_Release|Mixed Platforms.ActiveCfg = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_2_0_Release|Mixed Platforms.Build.0 = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_2_0_Release|Win32.ActiveCfg = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_2_0_Release|x86.ActiveCfg = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_2_0_Release|x86.Build.0 = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_3_5_Debug|Any CPU.ActiveCfg = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_3_5_Debug|Mixed Platforms.ActiveCfg = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_3_5_Debug|Mixed Platforms.Build.0 = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_3_5_Debug|Win32.ActiveCfg = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_3_5_Debug|x86.ActiveCfg = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_3_5_Debug|x86.Build.0 = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_3_5_Release|Any CPU.ActiveCfg = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_3_5_Release|Mixed Platforms.ActiveCfg = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_3_5_Release|Mixed Platforms.Build.0 = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_3_5_Release|Win32.ActiveCfg = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_3_5_Release|x86.ActiveCfg = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_3_5_Release|x86.Build.0 = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_4_0_Debug|Any CPU.ActiveCfg = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_4_0_Debug|Mixed Platforms.ActiveCfg = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_4_0_Debug|Mixed Platforms.Build.0 = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_4_0_Debug|Win32.ActiveCfg = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_4_0_Debug|x86.ActiveCfg = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_4_0_Debug|x86.Build.0 = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_4_0_Release|Any CPU.ActiveCfg = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_4_0_Release|Mixed Platforms.ActiveCfg = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_4_0_Release|Mixed Platforms.Build.0 = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_4_0_Release|Win32.ActiveCfg = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_4_0_Release|x86.ActiveCfg = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.net_4_0_Release|x86.Build.0 = Release|x86
 		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.Release|Any CPU.ActiveCfg = Release|x86
 		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.Release|Mixed Platforms.ActiveCfg = Release|x86
 		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.Release|Mixed Platforms.Build.0 = Release|x86
 		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.Release|Win32.ActiveCfg = Release|x86
 		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.Release|x86.ActiveCfg = Release|x86
 		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.Release|x86.Build.0 = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.silverlight_Debug|Any CPU.ActiveCfg = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.silverlight_Debug|Mixed Platforms.ActiveCfg = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.silverlight_Debug|Mixed Platforms.Build.0 = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.silverlight_Debug|Win32.ActiveCfg = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.silverlight_Debug|x86.ActiveCfg = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.silverlight_Debug|x86.Build.0 = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.silverlight_Release|Any CPU.ActiveCfg = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.silverlight_Release|Mixed Platforms.ActiveCfg = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.silverlight_Release|Mixed Platforms.Build.0 = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.silverlight_Release|Win32.ActiveCfg = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.silverlight_Release|x86.ActiveCfg = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.silverlight_Release|x86.Build.0 = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.winphone_Debug|Any CPU.ActiveCfg = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.winphone_Debug|Mixed Platforms.ActiveCfg = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.winphone_Debug|Mixed Platforms.Build.0 = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.winphone_Debug|Win32.ActiveCfg = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.winphone_Debug|x86.ActiveCfg = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.winphone_Debug|x86.Build.0 = Debug|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.winphone_Release|Any CPU.ActiveCfg = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.winphone_Release|Mixed Platforms.ActiveCfg = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.winphone_Release|Mixed Platforms.Build.0 = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.winphone_Release|Win32.ActiveCfg = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.winphone_Release|x86.ActiveCfg = Release|x86
-		{A9F35AC2-D016-444B-B7E6-FC1D55569021}.winphone_Release|x86.Build.0 = Release|x86
 		{593AB87D-7B92-47CF-8201-3574CF6A6457}.Debug|Any CPU.ActiveCfg = Debug|x86
 		{593AB87D-7B92-47CF-8201-3574CF6A6457}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
 		{593AB87D-7B92-47CF-8201-3574CF6A6457}.Debug|Mixed Platforms.Build.0 = Debug|x86
 		{593AB87D-7B92-47CF-8201-3574CF6A6457}.Debug|Win32.ActiveCfg = Debug|x86
 		{593AB87D-7B92-47CF-8201-3574CF6A6457}.Debug|x86.ActiveCfg = Debug|x86
 		{593AB87D-7B92-47CF-8201-3574CF6A6457}.Debug|x86.Build.0 = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_2_0_Debug|Any CPU.ActiveCfg = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_2_0_Debug|Mixed Platforms.ActiveCfg = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_2_0_Debug|Mixed Platforms.Build.0 = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_2_0_Debug|Win32.ActiveCfg = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_2_0_Debug|x86.ActiveCfg = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_2_0_Debug|x86.Build.0 = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_2_0_Release|Any CPU.ActiveCfg = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_2_0_Release|Mixed Platforms.ActiveCfg = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_2_0_Release|Mixed Platforms.Build.0 = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_2_0_Release|Win32.ActiveCfg = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_2_0_Release|x86.ActiveCfg = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_2_0_Release|x86.Build.0 = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_3_5_Debug|Any CPU.ActiveCfg = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_3_5_Debug|Mixed Platforms.ActiveCfg = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_3_5_Debug|Mixed Platforms.Build.0 = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_3_5_Debug|Win32.ActiveCfg = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_3_5_Debug|x86.ActiveCfg = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_3_5_Debug|x86.Build.0 = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_3_5_Release|Any CPU.ActiveCfg = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_3_5_Release|Mixed Platforms.ActiveCfg = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_3_5_Release|Mixed Platforms.Build.0 = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_3_5_Release|Win32.ActiveCfg = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_3_5_Release|x86.ActiveCfg = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_3_5_Release|x86.Build.0 = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_4_0_Debug|Any CPU.ActiveCfg = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_4_0_Debug|Mixed Platforms.ActiveCfg = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_4_0_Debug|Mixed Platforms.Build.0 = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_4_0_Debug|Win32.ActiveCfg = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_4_0_Debug|x86.ActiveCfg = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_4_0_Debug|x86.Build.0 = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_4_0_Release|Any CPU.ActiveCfg = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_4_0_Release|Mixed Platforms.ActiveCfg = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_4_0_Release|Mixed Platforms.Build.0 = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_4_0_Release|Win32.ActiveCfg = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_4_0_Release|x86.ActiveCfg = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.net_4_0_Release|x86.Build.0 = Release|x86
 		{593AB87D-7B92-47CF-8201-3574CF6A6457}.Release|Any CPU.ActiveCfg = Release|x86
 		{593AB87D-7B92-47CF-8201-3574CF6A6457}.Release|Mixed Platforms.ActiveCfg = Release|x86
 		{593AB87D-7B92-47CF-8201-3574CF6A6457}.Release|Mixed Platforms.Build.0 = Release|x86
 		{593AB87D-7B92-47CF-8201-3574CF6A6457}.Release|Win32.ActiveCfg = Release|x86
 		{593AB87D-7B92-47CF-8201-3574CF6A6457}.Release|x86.ActiveCfg = Release|x86
 		{593AB87D-7B92-47CF-8201-3574CF6A6457}.Release|x86.Build.0 = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.silverlight_Debug|Any CPU.ActiveCfg = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.silverlight_Debug|Mixed Platforms.ActiveCfg = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.silverlight_Debug|Mixed Platforms.Build.0 = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.silverlight_Debug|Win32.ActiveCfg = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.silverlight_Debug|x86.ActiveCfg = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.silverlight_Debug|x86.Build.0 = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.silverlight_Release|Any CPU.ActiveCfg = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.silverlight_Release|Mixed Platforms.ActiveCfg = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.silverlight_Release|Mixed Platforms.Build.0 = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.silverlight_Release|Win32.ActiveCfg = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.silverlight_Release|x86.ActiveCfg = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.silverlight_Release|x86.Build.0 = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.winphone_Debug|Any CPU.ActiveCfg = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.winphone_Debug|Mixed Platforms.ActiveCfg = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.winphone_Debug|Mixed Platforms.Build.0 = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.winphone_Debug|Win32.ActiveCfg = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.winphone_Debug|x86.ActiveCfg = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.winphone_Debug|x86.Build.0 = Debug|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.winphone_Release|Any CPU.ActiveCfg = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.winphone_Release|Mixed Platforms.ActiveCfg = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.winphone_Release|Mixed Platforms.Build.0 = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.winphone_Release|Win32.ActiveCfg = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.winphone_Release|x86.ActiveCfg = Release|x86
-		{593AB87D-7B92-47CF-8201-3574CF6A6457}.winphone_Release|x86.Build.0 = Release|x86
 		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.Debug|Any CPU.ActiveCfg = Debug|x86
 		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
 		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.Debug|Mixed Platforms.Build.0 = Debug|x86
 		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.Debug|Win32.ActiveCfg = Debug|x86
 		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.Debug|x86.ActiveCfg = Debug|x86
 		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.Debug|x86.Build.0 = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_2_0_Debug|Any CPU.ActiveCfg = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_2_0_Debug|Mixed Platforms.ActiveCfg = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_2_0_Debug|Mixed Platforms.Build.0 = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_2_0_Debug|Win32.ActiveCfg = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_2_0_Debug|x86.ActiveCfg = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_2_0_Debug|x86.Build.0 = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_2_0_Release|Any CPU.ActiveCfg = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_2_0_Release|Mixed Platforms.ActiveCfg = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_2_0_Release|Mixed Platforms.Build.0 = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_2_0_Release|Win32.ActiveCfg = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_2_0_Release|x86.ActiveCfg = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_2_0_Release|x86.Build.0 = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_3_5_Debug|Any CPU.ActiveCfg = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_3_5_Debug|Mixed Platforms.ActiveCfg = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_3_5_Debug|Mixed Platforms.Build.0 = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_3_5_Debug|Win32.ActiveCfg = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_3_5_Debug|x86.ActiveCfg = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_3_5_Debug|x86.Build.0 = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_3_5_Release|Any CPU.ActiveCfg = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_3_5_Release|Mixed Platforms.ActiveCfg = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_3_5_Release|Mixed Platforms.Build.0 = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_3_5_Release|Win32.ActiveCfg = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_3_5_Release|x86.ActiveCfg = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_3_5_Release|x86.Build.0 = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_4_0_Debug|Any CPU.ActiveCfg = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_4_0_Debug|Mixed Platforms.ActiveCfg = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_4_0_Debug|Mixed Platforms.Build.0 = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_4_0_Debug|Win32.ActiveCfg = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_4_0_Debug|x86.ActiveCfg = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_4_0_Debug|x86.Build.0 = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_4_0_Release|Any CPU.ActiveCfg = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_4_0_Release|Mixed Platforms.ActiveCfg = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_4_0_Release|Mixed Platforms.Build.0 = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_4_0_Release|Win32.ActiveCfg = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_4_0_Release|x86.ActiveCfg = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.net_4_0_Release|x86.Build.0 = Release|x86
 		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.Release|Any CPU.ActiveCfg = Release|x86
 		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.Release|Mixed Platforms.ActiveCfg = Release|x86
 		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.Release|Mixed Platforms.Build.0 = Release|x86
 		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.Release|Win32.ActiveCfg = Release|x86
 		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.Release|x86.ActiveCfg = Release|x86
 		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.Release|x86.Build.0 = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.silverlight_Debug|Any CPU.ActiveCfg = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.silverlight_Debug|Mixed Platforms.ActiveCfg = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.silverlight_Debug|Mixed Platforms.Build.0 = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.silverlight_Debug|Win32.ActiveCfg = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.silverlight_Debug|x86.ActiveCfg = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.silverlight_Debug|x86.Build.0 = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.silverlight_Release|Any CPU.ActiveCfg = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.silverlight_Release|Mixed Platforms.ActiveCfg = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.silverlight_Release|Mixed Platforms.Build.0 = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.silverlight_Release|Win32.ActiveCfg = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.silverlight_Release|x86.ActiveCfg = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.silverlight_Release|x86.Build.0 = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.winphone_Debug|Any CPU.ActiveCfg = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.winphone_Debug|Mixed Platforms.ActiveCfg = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.winphone_Debug|Mixed Platforms.Build.0 = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.winphone_Debug|Win32.ActiveCfg = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.winphone_Debug|x86.ActiveCfg = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.winphone_Debug|x86.Build.0 = Debug|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.winphone_Release|Any CPU.ActiveCfg = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.winphone_Release|Mixed Platforms.ActiveCfg = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.winphone_Release|Mixed Platforms.Build.0 = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.winphone_Release|Win32.ActiveCfg = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.winphone_Release|x86.ActiveCfg = Release|x86
-		{F458A89A-AEAB-4965-AA4D-393C9F7411D0}.winphone_Release|x86.Build.0 = Release|x86
 		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
 		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
 		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.Debug|Win32.ActiveCfg = Debug|Any CPU
 		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_2_0_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_2_0_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_2_0_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_2_0_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_2_0_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_2_0_Debug|x86.ActiveCfg = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_2_0_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_2_0_Release|Any CPU.Build.0 = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_2_0_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_2_0_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_2_0_Release|Win32.ActiveCfg = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_2_0_Release|x86.ActiveCfg = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_3_5_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_3_5_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_3_5_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_3_5_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_3_5_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_3_5_Debug|x86.ActiveCfg = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_3_5_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_3_5_Release|Any CPU.Build.0 = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_3_5_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_3_5_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_3_5_Release|Win32.ActiveCfg = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_3_5_Release|x86.ActiveCfg = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_4_0_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_4_0_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_4_0_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_4_0_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_4_0_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_4_0_Debug|x86.ActiveCfg = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_4_0_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_4_0_Release|Any CPU.Build.0 = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_4_0_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_4_0_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_4_0_Release|Win32.ActiveCfg = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.net_4_0_Release|x86.ActiveCfg = Release|Any CPU
 		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.Release|Any CPU.Build.0 = Release|Any CPU
 		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
 		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.Release|Mixed Platforms.Build.0 = Release|Any CPU
 		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.Release|Win32.ActiveCfg = Release|Any CPU
 		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.Release|x86.ActiveCfg = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.silverlight_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.silverlight_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.silverlight_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.silverlight_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.silverlight_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.silverlight_Debug|x86.ActiveCfg = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.silverlight_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.silverlight_Release|Any CPU.Build.0 = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.silverlight_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.silverlight_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.silverlight_Release|Win32.ActiveCfg = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.silverlight_Release|x86.ActiveCfg = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.winphone_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.winphone_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.winphone_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.winphone_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.winphone_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.winphone_Debug|x86.ActiveCfg = Debug|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.winphone_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.winphone_Release|Any CPU.Build.0 = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.winphone_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.winphone_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.winphone_Release|Win32.ActiveCfg = Release|Any CPU
-		{045B96F2-AF80-4C4C-8D27-E38635AC705E}.winphone_Release|x86.ActiveCfg = Release|Any CPU
 		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
 		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
 		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.Debug|Win32.ActiveCfg = Debug|Any CPU
 		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_2_0_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_2_0_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_2_0_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_2_0_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_2_0_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_2_0_Debug|x86.ActiveCfg = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_2_0_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_2_0_Release|Any CPU.Build.0 = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_2_0_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_2_0_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_2_0_Release|Win32.ActiveCfg = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_2_0_Release|x86.ActiveCfg = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_3_5_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_3_5_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_3_5_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_3_5_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_3_5_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_3_5_Debug|x86.ActiveCfg = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_3_5_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_3_5_Release|Any CPU.Build.0 = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_3_5_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_3_5_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_3_5_Release|Win32.ActiveCfg = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_3_5_Release|x86.ActiveCfg = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_4_0_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_4_0_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_4_0_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_4_0_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_4_0_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_4_0_Debug|x86.ActiveCfg = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_4_0_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_4_0_Release|Any CPU.Build.0 = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_4_0_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_4_0_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_4_0_Release|Win32.ActiveCfg = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.net_4_0_Release|x86.ActiveCfg = Release|Any CPU
 		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.Release|Any CPU.Build.0 = Release|Any CPU
 		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
 		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.Release|Mixed Platforms.Build.0 = Release|Any CPU
 		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.Release|Win32.ActiveCfg = Release|Any CPU
 		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.Release|x86.ActiveCfg = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.silverlight_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.silverlight_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.silverlight_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.silverlight_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.silverlight_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.silverlight_Debug|x86.ActiveCfg = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.silverlight_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.silverlight_Release|Any CPU.Build.0 = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.silverlight_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.silverlight_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.silverlight_Release|Win32.ActiveCfg = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.silverlight_Release|x86.ActiveCfg = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.winphone_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.winphone_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.winphone_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.winphone_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.winphone_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.winphone_Debug|x86.ActiveCfg = Debug|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.winphone_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.winphone_Release|Any CPU.Build.0 = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.winphone_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.winphone_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.winphone_Release|Win32.ActiveCfg = Release|Any CPU
-		{879E4A7E-C320-42D2-8275-4F1E44CE64AA}.winphone_Release|x86.ActiveCfg = Release|Any CPU
 		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
 		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
 		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.Debug|Win32.ActiveCfg = Debug|Any CPU
 		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_2_0_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_2_0_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_2_0_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_2_0_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_2_0_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_2_0_Debug|x86.ActiveCfg = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_2_0_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_2_0_Release|Any CPU.Build.0 = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_2_0_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_2_0_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_2_0_Release|Win32.ActiveCfg = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_2_0_Release|x86.ActiveCfg = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_3_5_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_3_5_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_3_5_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_3_5_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_3_5_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_3_5_Debug|x86.ActiveCfg = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_3_5_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_3_5_Release|Any CPU.Build.0 = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_3_5_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_3_5_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_3_5_Release|Win32.ActiveCfg = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_3_5_Release|x86.ActiveCfg = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_4_0_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_4_0_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_4_0_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_4_0_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_4_0_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_4_0_Debug|x86.ActiveCfg = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_4_0_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_4_0_Release|Any CPU.Build.0 = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_4_0_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_4_0_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_4_0_Release|Win32.ActiveCfg = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.net_4_0_Release|x86.ActiveCfg = Release|Any CPU
 		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.Release|Any CPU.Build.0 = Release|Any CPU
 		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
 		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.Release|Mixed Platforms.Build.0 = Release|Any CPU
 		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.Release|Win32.ActiveCfg = Release|Any CPU
 		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.Release|x86.ActiveCfg = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.silverlight_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.silverlight_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.silverlight_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.silverlight_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.silverlight_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.silverlight_Debug|x86.ActiveCfg = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.silverlight_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.silverlight_Release|Any CPU.Build.0 = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.silverlight_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.silverlight_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.silverlight_Release|Win32.ActiveCfg = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.silverlight_Release|x86.ActiveCfg = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.winphone_Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.winphone_Debug|Any CPU.Build.0 = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.winphone_Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.winphone_Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.winphone_Debug|Win32.ActiveCfg = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.winphone_Debug|x86.ActiveCfg = Debug|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.winphone_Release|Any CPU.ActiveCfg = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.winphone_Release|Any CPU.Build.0 = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.winphone_Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.winphone_Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.winphone_Release|Win32.ActiveCfg = Release|Any CPU
-		{5C93C5E2-196F-4877-BF65-96FEBFCEFCA1}.winphone_Release|x86.ActiveCfg = Release|Any CPU
+		{FDFC1237-143F-4919-8318-4926901F4639}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{FDFC1237-143F-4919-8318-4926901F4639}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{FDFC1237-143F-4919-8318-4926901F4639}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
+		{FDFC1237-143F-4919-8318-4926901F4639}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+		{FDFC1237-143F-4919-8318-4926901F4639}.Debug|Win32.ActiveCfg = Debug|Any CPU
+		{FDFC1237-143F-4919-8318-4926901F4639}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{FDFC1237-143F-4919-8318-4926901F4639}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{FDFC1237-143F-4919-8318-4926901F4639}.Release|Any CPU.Build.0 = Release|Any CPU
+		{FDFC1237-143F-4919-8318-4926901F4639}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
+		{FDFC1237-143F-4919-8318-4926901F4639}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+		{FDFC1237-143F-4919-8318-4926901F4639}.Release|Win32.ActiveCfg = Release|Any CPU
+		{FDFC1237-143F-4919-8318-4926901F4639}.Release|x86.ActiveCfg = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/dot10 b/dot10
new file mode 160000
index 00000000..2bad4b56
--- /dev/null
+++ b/dot10
@@ -0,0 +1 @@
+Subproject commit 2bad4b5692ecbb412e679bf1c01a4313d32b8856