diff --git a/AssemblyData/AssemblyResolver.cs b/AssemblyData/AssemblyResolver.cs
index 2af5f8fc..f2a85f23 100644
--- a/AssemblyData/AssemblyResolver.cs
+++ b/AssemblyData/AssemblyResolver.cs
@@ -30,17 +30,17 @@ namespace AssemblyData {
 		List<string> assemblySearchPaths = new List<string>();
 
 		public AssemblyResolver() {
-			AppDomain.CurrentDomain.AssemblyResolve += assemblyResolve;
+			AppDomain.CurrentDomain.AssemblyResolve += AssemblyResolve;
 		}
 
-		void addAssemblySearchPath(string path) {
+		void AddAssemblySearchPath(string path) {
 			if (assemblySearchPathsDict.ContainsKey(path))
 				return;
 			assemblySearchPathsDict[path] = true;
 			assemblySearchPaths.Add(path);
 		}
 
-		Assembly get(string assemblyFullName) {
+		Assembly Get(string assemblyFullName) {
 			var asmName = new AssemblyName(assemblyFullName);
 
 			Assembly assembly;
@@ -53,8 +53,8 @@ namespace AssemblyData {
 		}
 
 		static string[] assemblyExtensions = new string[] { ".dll", ".exe" };
-		Assembly assemblyResolve(object sender, ResolveEventArgs args) {
-			var assembly = get(args.Name);
+		Assembly AssemblyResolve(object sender, ResolveEventArgs args) {
+			var assembly = Get(args.Name);
 			if (assembly != null)
 				return assembly;
 
@@ -65,8 +65,8 @@ namespace AssemblyData {
 						var filename = Path.Combine(path, asmName.Name + ext);
 						if (!new FileInfo(filename).Exists)
 							continue;
-						addConfigFile(filename + ".config");
-						return addAssembly(Assembly.LoadFile(filename));
+						AddConfigFile(filename + ".config");
+						return AddAssembly(Assembly.LoadFile(filename));
 					}
 					catch (IOException) {
 					}
@@ -86,12 +86,12 @@ namespace AssemblyData {
 			return null;
 		}
 
-		public Assembly load(string filename) {
-			addConfigFile(filename + ".config");
-			return addAssembly(loadFile(filename));
+		public Assembly Load(string filename) {
+			AddConfigFile(filename + ".config");
+			return AddAssembly(LoadFile(filename));
 		}
 
-		Assembly loadFile(string filename) {
+		Assembly LoadFile(string filename) {
 			try {
 				return Assembly.LoadFrom(filename);
 			}
@@ -101,16 +101,16 @@ namespace AssemblyData {
 			}
 		}
 
-		Assembly addAssembly(Assembly assembly) {
+		Assembly AddAssembly(Assembly assembly) {
 			var asmName = assembly.GetName();
 			assemblies[asmName.FullName] = assembly;
 			assemblies[asmName.Name] = assembly;
 			return assembly;
 		}
 
-		void addConfigFile(string configFilename) {
-			var dirName = Utils.getDirName(Utils.getFullPath(configFilename));
-			addAssemblySearchPath(dirName);
+		void AddConfigFile(string configFilename) {
+			var dirName = Utils.GetDirName(Utils.GetFullPath(configFilename));
+			AddAssemblySearchPath(dirName);
 
 			try {
 				using (var xmlStream = new FileStream(configFilename, FileMode.Open, FileAccess.Read, FileShare.Read)) {
@@ -124,7 +124,7 @@ namespace AssemblyData {
 						if (string.IsNullOrEmpty(privatePath))
 							continue;
 						foreach (var path in privatePath.Split(';'))
-							addAssemblySearchPath(Path.Combine(dirName, path));
+							AddAssemblySearchPath(Path.Combine(dirName, path));
 					}
 				}
 			}
diff --git a/AssemblyData/AssemblyServer.cs b/AssemblyData/AssemblyServer.cs
index 1c1d1c3a..44c9ce0b 100644
--- a/AssemblyData/AssemblyServer.cs
+++ b/AssemblyData/AssemblyServer.cs
@@ -26,19 +26,19 @@ using AssemblyData;
 
 namespace AssemblyServer {
 	public static class Start {
-		public static int main(string[] args) {
+		public static int Main2(string[] args) {
 			if (args.Length != 2)
 				Environment.Exit(1);
 			var channelName = args[0];
 			var uri = args[1];
 
 			var service = new AssemblyService();
-			startServer(service, channelName, uri);
-			service.waitExit();
+			StartServer(service, channelName, uri);
+			service.WaitExit();
 			return 0;
 		}
 
-		static void startServer(AssemblyService service, string name, string uri) {
+		static void StartServer(AssemblyService service, string name, string uri) {
 			var props = new Hashtable();
 			props["portName"] = name;
 			var provider = new BinaryServerFormatterSinkProvider();
diff --git a/AssemblyData/AssemblyService.cs b/AssemblyData/AssemblyService.cs
index befe6f35..7b691efc 100644
--- a/AssemblyData/AssemblyService.cs
+++ b/AssemblyData/AssemblyService.cs
@@ -33,14 +33,14 @@ namespace AssemblyData {
 		AssemblyResolver assemblyResolver = new AssemblyResolver();
 		bool installCompileMethodCalled = false;
 
-		public void doNothing() {
+		public void DoNothing() {
 		}
 
-		public void exit() {
+		public void Exit() {
 			exitEvent.Set();
 		}
 
-		public void waitExit() {
+		public void WaitExit() {
 			exitEvent.WaitOne();
 		}
 
@@ -48,28 +48,28 @@ namespace AssemblyData {
 			return null;
 		}
 
-		void checkStringDecrypter() {
+		void CheckStringDecrypter() {
 			if (stringDecrypter == null)
 				throw new ApplicationException("setStringDecrypterType() hasn't been called yet.");
 		}
 
-		void checkAssembly() {
+		void CheckAssembly() {
 			if (assembly == null)
 				throw new ApplicationException("loadAssembly() hasn't been called yet.");
 		}
 
-		public void loadAssembly(string filename) {
+		public void LoadAssembly(string filename) {
 			if (assembly != null)
 				throw new ApplicationException("Only one assembly can be explicitly loaded");
 			try {
-				assembly = assemblyResolver.load(filename);
+				assembly = assemblyResolver.Load(filename);
 			}
 			catch (BadImageFormatException) {
 				throw new ApplicationException(string.Format("Could not load assembly {0}. Maybe it's 32-bit or 64-bit only?", filename));
 			}
 		}
 
-		public void setStringDecrypterType(StringDecrypterType type) {
+		public void SetStringDecrypterType(StringDecrypterType type) {
 			if (stringDecrypter != null)
 				throw new ApplicationException("StringDecrypterType already set");
 
@@ -87,25 +87,25 @@ namespace AssemblyData {
 			}
 		}
 
-		public int defineStringDecrypter(int methodToken) {
-			checkStringDecrypter();
-			var methodInfo = findMethod(methodToken);
+		public int DefineStringDecrypter(int methodToken) {
+			CheckStringDecrypter();
+			var methodInfo = FindMethod(methodToken);
 			if (methodInfo == null)
 				throw new ApplicationException(string.Format("Could not find method {0:X8}", methodToken));
 			if (methodInfo.ReturnType != typeof(string) && methodInfo.ReturnType != typeof(object))
 				throw new ApplicationException(string.Format("Method return type must be string or object: {0}", methodInfo));
-			return stringDecrypter.defineStringDecrypter(methodInfo);
+			return stringDecrypter.DefineStringDecrypter(methodInfo);
 		}
 
-		public object[] decryptStrings(int stringDecrypterMethod, object[] args, int callerToken) {
-			checkStringDecrypter();
-			var caller = getCaller(callerToken);
+		public object[] DecryptStrings(int stringDecrypterMethod, object[] args, int callerToken) {
+			CheckStringDecrypter();
+			var caller = GetCaller(callerToken);
 			foreach (var arg in args)
-				SimpleData.unpack((object[])arg);
-			return SimpleData.pack(stringDecrypter.decryptStrings(stringDecrypterMethod, args, caller));
+				SimpleData.Unpack((object[])arg);
+			return SimpleData.Pack(stringDecrypter.DecryptStrings(stringDecrypterMethod, args, caller));
 		}
 
-		MethodBase getCaller(int callerToken) {
+		MethodBase GetCaller(int callerToken) {
 			try {
 				return assembly.GetModules()[0].ResolveMethod(callerToken);
 			}
@@ -114,8 +114,8 @@ namespace AssemblyData {
 			}
 		}
 
-		MethodInfo findMethod(int methodToken) {
-			checkAssembly();
+		MethodInfo FindMethod(int methodToken) {
+			CheckAssembly();
 
 			foreach (var module in assembly.GetModules()) {
 				var method = module.ResolveMethod(methodToken) as MethodInfo;
@@ -126,28 +126,28 @@ namespace AssemblyData {
 			return null;
 		}
 
-		public void installCompileMethod(DecryptMethodsInfo decryptMethodsInfo) {
+		public void InstallCompileMethod(DecryptMethodsInfo decryptMethodsInfo) {
 			if (installCompileMethodCalled)
 				throw new ApplicationException("installCompileMethod() has already been called");
 			installCompileMethodCalled = true;
 			DynamicMethodsDecrypter.Instance.DecryptMethodsInfo = decryptMethodsInfo;
-			DynamicMethodsDecrypter.Instance.installCompileMethod();
+			DynamicMethodsDecrypter.Instance.InstallCompileMethod();
 		}
 
-		public void loadObfuscator(string filename) {
-			loadAssembly(filename);
+		public void LoadObfuscator(string filename) {
+			LoadAssembly(filename);
 			DynamicMethodsDecrypter.Instance.Module = assembly.ManifestModule;
-			DynamicMethodsDecrypter.Instance.loadObfuscator();
+			DynamicMethodsDecrypter.Instance.LoadObfuscator();
 		}
 
-		public bool canDecryptMethods() {
-			checkAssembly();
-			return DynamicMethodsDecrypter.Instance.canDecryptMethods();
+		public bool CanDecryptMethods() {
+			CheckAssembly();
+			return DynamicMethodsDecrypter.Instance.CanDecryptMethods();
 		}
 
-		public DumpedMethods decryptMethods() {
-			checkAssembly();
-			return DynamicMethodsDecrypter.Instance.decryptMethods();
+		public DumpedMethods DecryptMethods() {
+			CheckAssembly();
+			return DynamicMethodsDecrypter.Instance.DecryptMethods();
 		}
 	}
 }
diff --git a/AssemblyData/DelegateStringDecrypter.cs b/AssemblyData/DelegateStringDecrypter.cs
index 4dcfd29d..65996f5d 100644
--- a/AssemblyData/DelegateStringDecrypter.cs
+++ b/AssemblyData/DelegateStringDecrypter.cs
@@ -27,12 +27,12 @@ namespace AssemblyData {
 		delegate string DecryptString(object[] args);
 		List<DecryptString> stringDecryptMethods = new List<DecryptString>();
 
-		public int defineStringDecrypter(MethodInfo method) {
-			stringDecryptMethods.Add(buildDynamicMethod(method));
+		public int DefineStringDecrypter(MethodInfo method) {
+			stringDecryptMethods.Add(BuildDynamicMethod(method));
 			return stringDecryptMethods.Count - 1;
 		}
 
-		public object[] decryptStrings(int stringDecrypterMethod, object[] args, MethodBase caller) {
+		public object[] DecryptStrings(int stringDecrypterMethod, object[] args, MethodBase caller) {
 			if (stringDecrypterMethod > stringDecryptMethods.Count)
 				throw new ApplicationException("Invalid string decrypter method");
 
@@ -43,9 +43,9 @@ namespace AssemblyData {
 			return rv;
 		}
 
-		DecryptString buildDynamicMethod(MethodInfo method) {
+		DecryptString BuildDynamicMethod(MethodInfo method) {
 			var dm = new DynamicMethod("", typeof(string), new Type[] { typeof(object[]) }, typeof(DelegateStringDecrypter), true);
-			Utils.addCallStringDecrypterMethodInstructions(method, dm.GetILGenerator());
+			Utils.AddCallStringDecrypterMethodInstructions(method, dm.GetILGenerator());
 			return (DecryptString)dm.CreateDelegate(typeof(DecryptString));
 		}
 	}
diff --git a/AssemblyData/EmuStringDecrypter.cs b/AssemblyData/EmuStringDecrypter.cs
index a9c4ff64..866873b2 100644
--- a/AssemblyData/EmuStringDecrypter.cs
+++ b/AssemblyData/EmuStringDecrypter.cs
@@ -36,26 +36,26 @@ namespace AssemblyData {
 			}
 		}
 
-		public int defineStringDecrypter(MethodInfo method) {
+		public int DefineStringDecrypter(MethodInfo method) {
 			decryptInfos.Add(new DecryptInfo(method));
 			return decryptInfos.Count - 1;
 		}
 
-		public object[] decryptStrings(int stringDecrypterMethod, object[] args, MethodBase caller) {
+		public object[] DecryptStrings(int stringDecrypterMethod, object[] args, MethodBase caller) {
 			var decryptInfo = decryptInfos[stringDecrypterMethod];
 			if (decryptInfo.decryptString == null)
-				decryptInfo.decryptString = createDecryptString(decryptInfo.method);
+				decryptInfo.decryptString = CreateDecryptString(decryptInfo.method);
 
-			methodsRewriter.setCaller(decryptInfo.decryptString, caller);
+			methodsRewriter.SetCaller(decryptInfo.decryptString, caller);
 			var result = new object[args.Length];
 			for (int i = 0; i < args.Length; i++)
 				result[i] = decryptInfo.decryptString((object[])args[i]);
 			return result;
 		}
 
-		RewrittenMethod createDecryptString(MethodInfo method) {
-			methodsRewriter.createMethod(method);
-			return methodsRewriter.createDelegate(method);
+		RewrittenMethod CreateDecryptString(MethodInfo method) {
+			methodsRewriter.CreateMethod(method);
+			return methodsRewriter.CreateDelegate(method);
 		}
 	}
 }
diff --git a/AssemblyData/IAssemblyService.cs b/AssemblyData/IAssemblyService.cs
index 70bb1023..2867531b 100644
--- a/AssemblyData/IAssemblyService.cs
+++ b/AssemblyData/IAssemblyService.cs
@@ -28,18 +28,18 @@ namespace AssemblyData {
 	}
 
 	public interface IAssemblyService {
-		void doNothing();
-		void exit();
+		void DoNothing();
+		void Exit();
 
-		void loadAssembly(string filename);
+		void LoadAssembly(string filename);
 
-		void setStringDecrypterType(StringDecrypterType type);
-		int defineStringDecrypter(int methodToken);
-		object[] decryptStrings(int stringDecrypterMethod, object[] args, int callerToken);
+		void SetStringDecrypterType(StringDecrypterType type);
+		int DefineStringDecrypter(int methodToken);
+		object[] DecryptStrings(int stringDecrypterMethod, object[] args, int callerToken);
 
-		void installCompileMethod(DecryptMethodsInfo decryptMethodsInfo);
-		void loadObfuscator(string filename);
-		bool canDecryptMethods();
-		DumpedMethods decryptMethods();
+		void InstallCompileMethod(DecryptMethodsInfo decryptMethodsInfo);
+		void LoadObfuscator(string filename);
+		bool CanDecryptMethods();
+		DumpedMethods DecryptMethods();
 	}
 }
diff --git a/AssemblyData/IStringDecrypter.cs b/AssemblyData/IStringDecrypter.cs
index daf7bfcf..5798c563 100644
--- a/AssemblyData/IStringDecrypter.cs
+++ b/AssemblyData/IStringDecrypter.cs
@@ -21,7 +21,7 @@ using System.Reflection;
 
 namespace AssemblyData {
 	interface IStringDecrypter {
-		int defineStringDecrypter(MethodInfo method);
-		object[] decryptStrings(int stringDecrypterMethod, object[] args, MethodBase caller);
+		int DefineStringDecrypter(MethodInfo method);
+		object[] DecryptStrings(int stringDecrypterMethod, object[] args, MethodBase caller);
 	}
 }
diff --git a/AssemblyData/SimpleData.cs b/AssemblyData/SimpleData.cs
index 2d2e7384..8f4147d1 100644
--- a/AssemblyData/SimpleData.cs
+++ b/AssemblyData/SimpleData.cs
@@ -51,7 +51,7 @@ namespace AssemblyData {
 	}
 
 	public static class SimpleData {
-		public static object[] pack(object[] args) {
+		public static object[] Pack(object[] args) {
 			for (int i = 0; i < args.Length; i++) {
 				var s = args[i] as string;
 				if (s != null)
@@ -60,7 +60,7 @@ namespace AssemblyData {
 			return args;
 		}
 
-		public static object[] unpack(object[] args) {
+		public static object[] Unpack(object[] args) {
 			for (int i = 0; i < args.Length; i++) {
 				var s = args[i] as MyString;
 				if (s != null)
diff --git a/AssemblyData/Utils.cs b/AssemblyData/Utils.cs
index ec7458a4..470a14b8 100644
--- a/AssemblyData/Utils.cs
+++ b/AssemblyData/Utils.cs
@@ -68,11 +68,11 @@ namespace AssemblyData {
 	static class Utils {
 		static Random random = new Random();
 
-		public static uint getRandomUint() {
+		public static uint GetRandomUint() {
 			return (uint)(random.NextDouble() * uint.MaxValue);
 		}
 
-		public static Type getDelegateType(Type returnType, Type[] args) {
+		public static Type GetDelegateType(Type returnType, Type[] args) {
 			Type[] types;
 			if (returnType == typeof(void)) {
 				types = args;
@@ -133,7 +133,7 @@ namespace AssemblyData {
 			}
 		}
 
-		public static string randomName(int min, int max) {
+		public static string RandomName(int min, int max) {
 			int numChars = random.Next(min, max + 1);
 			var sb = new StringBuilder(numChars);
 			int numLower = 0;
@@ -153,7 +153,7 @@ namespace AssemblyData {
 			return sb.ToString();
 		}
 
-		public static void addCallStringDecrypterMethodInstructions(MethodInfo method, ILGenerator ilg) {
+		public static void AddCallStringDecrypterMethodInstructions(MethodInfo method, ILGenerator ilg) {
 			var args = method.GetParameters();
 			for (int i = 0; i < args.Length; i++) {
 				var arg = args[i].ParameterType;
@@ -171,7 +171,7 @@ namespace AssemblyData {
 			ilg.Emit(OpCodes.Ret);
 		}
 
-		public static string getFullPath(string path) {
+		public static string GetFullPath(string path) {
 			try {
 				return Path.GetFullPath(path);
 			}
@@ -180,7 +180,7 @@ namespace AssemblyData {
 			}
 		}
 
-		public static string getDirName(string name) {
+		public static string GetDirName(string name) {
 			return Path.GetDirectoryName(name);
 		}
 	}
diff --git a/AssemblyData/methodsrewriter/AssemblyResolver.cs b/AssemblyData/methodsrewriter/AssemblyResolver.cs
index 37688e78..37751599 100644
--- a/AssemblyData/methodsrewriter/AssemblyResolver.cs
+++ b/AssemblyData/methodsrewriter/AssemblyResolver.cs
@@ -35,10 +35,10 @@ namespace AssemblyData.methodsrewriter {
 
 		public AssemblyResolver(string asmName) {
 			assembly = Assembly.Load(new AssemblyName(asmName));
-			initTypes();
+			InitTypes();
 		}
 
-		void initTypes() {
+		void InitTypes() {
 			foreach (var type in assembly.GetTypes()) {
 				string key = (type.Namespace ?? "") + "." + type.Name;
 				List<TypeResolver> list;
@@ -48,7 +48,7 @@ namespace AssemblyData.methodsrewriter {
 			}
 		}
 
-		TypeResolver getTypeResolver(ITypeDefOrRef typeRef) {
+		TypeResolver GetTypeResolver(ITypeDefOrRef typeRef) {
 			if (typeRef == null)
 				return null;
 			var scopeType = typeRef.ScopeType;
@@ -65,30 +65,30 @@ namespace AssemblyData.methodsrewriter {
 			}
 
 			foreach (var resolver in list) {
-				if (ResolverUtils.compareTypes(resolver.type, scopeType))
+				if (ResolverUtils.CompareTypes(resolver.type, scopeType))
 					return resolver;
 			}
 
 			return null;
 		}
 
-		public FieldInfo resolve(IField fieldRef) {
-			var resolver = getTypeResolver(fieldRef.DeclaringType);
+		public FieldInfo Resolve(IField fieldRef) {
+			var resolver = GetTypeResolver(fieldRef.DeclaringType);
 			if (resolver != null)
-				return resolver.resolve(fieldRef);
-			return resolveGlobalField(fieldRef);
+				return resolver.Resolve(fieldRef);
+			return ResolveGlobalField(fieldRef);
 		}
 
-		FieldInfo resolveGlobalField(IField fieldRef) {
-			initGlobalFields();
+		FieldInfo ResolveGlobalField(IField fieldRef) {
+			InitGlobalFields();
 			foreach (var globalField in globalFields) {
-				if (ResolverUtils.compareFields(globalField, fieldRef))
+				if (ResolverUtils.CompareFields(globalField, fieldRef))
 					return globalField;
 			}
 			return null;
 		}
 
-		void initGlobalFields() {
+		void InitGlobalFields() {
 			if (globalFields != null)
 				return;
 			globalFields = new List<FieldInfo>();
@@ -100,23 +100,23 @@ namespace AssemblyData.methodsrewriter {
 			}
 		}
 
-		public MethodBase resolve(IMethod methodRef) {
-			var resolver = getTypeResolver(methodRef.DeclaringType);
+		public MethodBase Resolve(IMethod methodRef) {
+			var resolver = GetTypeResolver(methodRef.DeclaringType);
 			if (resolver != null)
-				return resolver.resolve(methodRef);
-			return resolveGlobalMethod(methodRef);
+				return resolver.Resolve(methodRef);
+			return ResolveGlobalMethod(methodRef);
 		}
 
-		MethodBase resolveGlobalMethod(IMethod methodRef) {
-			initGlobalMethods();
+		MethodBase ResolveGlobalMethod(IMethod methodRef) {
+			InitGlobalMethods();
 			foreach (var globalMethod in globalMethods) {
-				if (ResolverUtils.compareMethods(globalMethod, methodRef))
+				if (ResolverUtils.CompareMethods(globalMethod, methodRef))
 					return globalMethod;
 			}
 			return null;
 		}
 
-		void initGlobalMethods() {
+		void InitGlobalMethods() {
 			if (globalMethods != null)
 				return;
 			globalMethods = new List<MethodBase>();
@@ -128,8 +128,8 @@ namespace AssemblyData.methodsrewriter {
 			}
 		}
 
-		public Type resolve(ITypeDefOrRef typeRef) {
-			var resolver = getTypeResolver(typeRef);
+		public Type Resolve(ITypeDefOrRef typeRef) {
+			var resolver = GetTypeResolver(typeRef);
 			if (resolver != null)
 				return resolver.type;
 
diff --git a/AssemblyData/methodsrewriter/CodeGenerator.cs b/AssemblyData/methodsrewriter/CodeGenerator.cs
index a567b415..e8c30846 100644
--- a/AssemblyData/methodsrewriter/CodeGenerator.cs
+++ b/AssemblyData/methodsrewriter/CodeGenerator.cs
@@ -81,14 +81,14 @@ namespace AssemblyData.methodsrewriter {
 			this.methodName = methodName;
 		}
 
-		public void setMethodInfo(MMethod methodInfo) {
+		public void SetMethodInfo(MMethod methodInfo) {
 			this.methodInfo = methodInfo;
-			methodReturnType = ResolverUtils.getReturnType(methodInfo.methodBase);
-			methodParameters = getMethodParameterTypes(methodInfo.methodBase);
-			delegateType = Utils.getDelegateType(methodReturnType, methodParameters);
+			methodReturnType = ResolverUtils.GetReturnType(methodInfo.methodBase);
+			methodParameters = GetMethodParameterTypes(methodInfo.methodBase);
+			delegateType = Utils.GetDelegateType(methodReturnType, methodParameters);
 		}
 
-		public Delegate generate(IList<Instruction> allInstructions, IList<ExceptionHandler> allExceptionHandlers) {
+		public Delegate Generate(IList<Instruction> allInstructions, IList<ExceptionHandler> allExceptionHandlers) {
 			this.allInstructions = allInstructions;
 			this.allExceptionHandlers = allExceptionHandlers;
 
@@ -96,37 +96,37 @@ namespace AssemblyData.methodsrewriter {
 			var lastInstr = allInstructions[allInstructions.Count - 1];
 			ilg = dm.GetILGenerator((int)lastInstr.Offset + lastInstr.GetSize());
 
-			initInstrToIndex();
-			initLocals();
-			initLabels();
+			InitInstrToIndex();
+			InitLocals();
+			InitLabels();
 
 			exceptionHandlersStack = new Stack<ExceptionHandler>();
 			for (int i = 0; i < allInstructions.Count; i++) {
-				updateExceptionHandlers(i);
+				UpdateExceptionHandlers(i);
 				var instr = allInstructions[i];
 				ilg.MarkLabel(labels[i]);
 				if (instr.Operand is Operand)
-					writeSpecialInstr(instr, (Operand)instr.Operand);
+					WriteSpecialInstr(instr, (Operand)instr.Operand);
 				else
-					writeInstr(instr);
+					WriteInstr(instr);
 			}
-			updateExceptionHandlers(-1);
+			UpdateExceptionHandlers(-1);
 
 			return dm.CreateDelegate(delegateType);
 		}
 
-		Instruction getExceptionInstruction(int instructionIndex) {
+		Instruction GetExceptionInstruction(int instructionIndex) {
 			return instructionIndex < 0 ? null : allInstructions[instructionIndex];
 		}
 
-		void updateExceptionHandlers(int instructionIndex) {
-			var instr = getExceptionInstruction(instructionIndex);
-			updateExceptionHandlers(instr);
-			if (addTryStart(instr))
-				updateExceptionHandlers(instr);
+		void UpdateExceptionHandlers(int instructionIndex) {
+			var instr = GetExceptionInstruction(instructionIndex);
+			UpdateExceptionHandlers(instr);
+			if (AddTryStart(instr))
+				UpdateExceptionHandlers(instr);
 		}
 
-		void updateExceptionHandlers(Instruction instr) {
+		void UpdateExceptionHandlers(Instruction instr) {
 			while (exceptionHandlersStack.Count > 0) {
 				var ex = exceptionHandlersStack.Peek();
 				if (ex.TryEnd == instr) {
@@ -137,11 +137,11 @@ namespace AssemblyData.methodsrewriter {
 					if (ex.HandlerType == ExceptionHandlerType.Finally)
 						ilg.BeginFinallyBlock();
 					else
-						ilg.BeginCatchBlock(Resolver.getRtType(ex.CatchType));
+						ilg.BeginCatchBlock(Resolver.GetRtType(ex.CatchType));
 				}
 				if (ex.HandlerEnd == instr) {
 					exceptionHandlersStack.Pop();
-					if (exceptionHandlersStack.Count == 0 || !isSameTryBlock(ex, exceptionHandlersStack.Peek()))
+					if (exceptionHandlersStack.Count == 0 || !IsSameTryBlock(ex, exceptionHandlersStack.Peek()))
 						ilg.EndExceptionBlock();
 				}
 				else
@@ -149,7 +149,7 @@ namespace AssemblyData.methodsrewriter {
 			}
 		}
 
-		bool addTryStart(Instruction instr) {
+		bool AddTryStart(Instruction instr) {
 			var list = new List<ExceptionHandler>();
 			foreach (var ex in allExceptionHandlers) {
 				if (ex.TryStart == instr)
@@ -158,7 +158,7 @@ namespace AssemblyData.methodsrewriter {
 			list.Reverse();
 
 			foreach (var ex in list) {
-				if (exceptionHandlersStack.Count == 0 || !isSameTryBlock(ex, exceptionHandlersStack.Peek()))
+				if (exceptionHandlersStack.Count == 0 || !IsSameTryBlock(ex, exceptionHandlersStack.Peek()))
 					ilg.BeginExceptionBlock();
 				exceptionHandlersStack.Push(ex);
 			}
@@ -166,33 +166,33 @@ namespace AssemblyData.methodsrewriter {
 			return list.Count > 0;
 		}
 
-		static bool isSameTryBlock(ExceptionHandler ex1, ExceptionHandler ex2) {
+		static bool IsSameTryBlock(ExceptionHandler ex1, ExceptionHandler ex2) {
 			return ex1.TryStart == ex2.TryStart && ex1.TryEnd == ex2.TryEnd;
 		}
 
-		void initInstrToIndex() {
+		void InitInstrToIndex() {
 			instrToIndex = new Dictionary<Instruction, int>(allInstructions.Count);
 			for (int i = 0; i < allInstructions.Count; i++)
 				instrToIndex[allInstructions[i]] = i;
 		}
 
-		void initLocals() {
+		void InitLocals() {
 			locals = new List<LocalBuilder>();
 			foreach (var local in methodInfo.methodDef.Body.Variables)
-				locals.Add(ilg.DeclareLocal(Resolver.getRtType(local.Type), local.Type.RemoveModifiers().IsPinned));
+				locals.Add(ilg.DeclareLocal(Resolver.GetRtType(local.Type), local.Type.RemoveModifiers().IsPinned));
 			tempObjLocal = ilg.DeclareLocal(typeof(object));
 			tempObjArrayLocal = ilg.DeclareLocal(typeof(object[]));
 		}
 
-		void initLabels() {
+		void InitLabels() {
 			labels = new List<Label>(allInstructions.Count);
 			for (int i = 0; i < allInstructions.Count; i++)
 				labels.Add(ilg.DefineLabel());
 		}
 
-		Type[] getMethodParameterTypes(MethodBase method) {
+		Type[] GetMethodParameterTypes(MethodBase method) {
 			var list = new List<Type>();
-			if (ResolverUtils.hasThis(method))
+			if (ResolverUtils.HasThis(method))
 				list.Add(method.DeclaringType);
 
 			foreach (var param in method.GetParameters())
@@ -204,19 +204,19 @@ namespace AssemblyData.methodsrewriter {
 			return list.ToArray();
 		}
 
-		void writeSpecialInstr(Instruction instr, Operand operand) {
+		void WriteSpecialInstr(Instruction instr, Operand operand) {
 			BindingFlags flags;
 			switch (operand.type) {
 			case Operand.Type.ThisArg:
-				ilg.Emit(convertOpCode(instr.OpCode), (short)thisArgIndex);
+				ilg.Emit(ConvertOpCode(instr.OpCode), (short)thisArgIndex);
 				break;
 
 			case Operand.Type.TempObj:
-				ilg.Emit(convertOpCode(instr.OpCode), tempObjLocal);
+				ilg.Emit(ConvertOpCode(instr.OpCode), tempObjLocal);
 				break;
 
 			case Operand.Type.TempObjArray:
-				ilg.Emit(convertOpCode(instr.OpCode), tempObjArrayLocal);
+				ilg.Emit(ConvertOpCode(instr.OpCode), tempObjArrayLocal);
 				break;
 
 			case Operand.Type.OurMethod:
@@ -225,19 +225,19 @@ namespace AssemblyData.methodsrewriter {
 				var ourMethod = methodsRewriter.GetType().GetMethod(methodName, flags);
 				if (ourMethod == null)
 					throw new ApplicationException(string.Format("Could not find method {0}", methodName));
-				ilg.Emit(convertOpCode(instr.OpCode), ourMethod);
+				ilg.Emit(ConvertOpCode(instr.OpCode), ourMethod);
 				break;
 
 			case Operand.Type.NewMethod:
 				var methodBase = (MethodBase)operand.data;
-				var delegateType = methodsRewriter.getDelegateType(methodBase);
+				var delegateType = methodsRewriter.GetDelegateType(methodBase);
 				flags = BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance;
 				var invokeMethod = delegateType.GetMethod("Invoke", flags);
-				ilg.Emit(convertOpCode(instr.OpCode), invokeMethod);
+				ilg.Emit(ConvertOpCode(instr.OpCode), invokeMethod);
 				break;
 
 			case Operand.Type.ReflectionType:
-				ilg.Emit(convertOpCode(instr.OpCode), (Type)operand.data);
+				ilg.Emit(ConvertOpCode(instr.OpCode), (Type)operand.data);
 				break;
 
 			default:
@@ -245,19 +245,19 @@ namespace AssemblyData.methodsrewriter {
 			}
 		}
 
-		Label getLabel(Instruction target) {
+		Label GetLabel(Instruction target) {
 			return labels[instrToIndex[target]];
 		}
 
-		Label[] getLabels(Instruction[] targets) {
+		Label[] GetLabels(Instruction[] targets) {
 			var labels = new Label[targets.Length];
 			for (int i = 0; i < labels.Length; i++)
-				labels[i] = getLabel(targets[i]);
+				labels[i] = GetLabel(targets[i]);
 			return labels;
 		}
 
-		void writeInstr(Instruction instr) {
-			var opcode = convertOpCode(instr.OpCode);
+		void WriteInstr(Instruction instr) {
+			var opcode = ConvertOpCode(instr.OpCode);
 			switch (instr.OpCode.OperandType) {
 			case OperandType.InlineNone:
 				ilg.Emit(opcode);
@@ -265,11 +265,11 @@ namespace AssemblyData.methodsrewriter {
 
 			case OperandType.InlineBrTarget:
 			case OperandType.ShortInlineBrTarget:
-				ilg.Emit(opcode, getLabel((Instruction)instr.Operand));
+				ilg.Emit(opcode, GetLabel((Instruction)instr.Operand));
 				break;
 
 			case OperandType.InlineSwitch:
-				ilg.Emit(opcode, getLabels((Instruction[])instr.Operand));
+				ilg.Emit(opcode, GetLabels((Instruction[])instr.Operand));
 				break;
 
 			case OperandType.ShortInlineI:
@@ -303,7 +303,7 @@ namespace AssemblyData.methodsrewriter {
 			case OperandType.InlineType:
 			case OperandType.InlineMethod:
 			case OperandType.InlineField:
-				var obj = Resolver.getRtObject((ITokenOperand)instr.Operand);
+				var obj = Resolver.GetRtObject((ITokenOperand)instr.Operand);
 				if (obj is ConstructorInfo)
 					ilg.Emit(opcode, (ConstructorInfo)obj);
 				else if (obj is MethodInfo)
@@ -330,7 +330,7 @@ namespace AssemblyData.methodsrewriter {
 			}
 		}
 
-		ROpCode convertOpCode(OpCode opcode) {
+		ROpCode ConvertOpCode(OpCode opcode) {
 			ROpCode ropcode;
 			if (dnlibToReflection.TryGetValue(opcode, out ropcode))
 				return ropcode;
diff --git a/AssemblyData/methodsrewriter/IMethodsRewriter.cs b/AssemblyData/methodsrewriter/IMethodsRewriter.cs
index b6cf366c..5d242629 100644
--- a/AssemblyData/methodsrewriter/IMethodsRewriter.cs
+++ b/AssemblyData/methodsrewriter/IMethodsRewriter.cs
@@ -22,6 +22,6 @@ using System.Reflection;
 
 namespace AssemblyData.methodsrewriter {
 	interface IMethodsRewriter {
-		Type getDelegateType(MethodBase methodBase);
+		Type GetDelegateType(MethodBase methodBase);
 	}
 }
diff --git a/AssemblyData/methodsrewriter/MMethod.cs b/AssemblyData/methodsrewriter/MMethod.cs
index 84500200..4818ba7c 100644
--- a/AssemblyData/methodsrewriter/MMethod.cs
+++ b/AssemblyData/methodsrewriter/MMethod.cs
@@ -29,7 +29,7 @@ namespace AssemblyData.methodsrewriter {
 			this.methodDef = methodDef;
 		}
 
-		public bool hasInstructions() {
+		public bool HasInstructions() {
 			return methodDef.Body != null && methodDef.Body.Instructions.Count != 0;
 		}
 
diff --git a/AssemblyData/methodsrewriter/MModule.cs b/AssemblyData/methodsrewriter/MModule.cs
index 0629bb78..5929bff4 100644
--- a/AssemblyData/methodsrewriter/MModule.cs
+++ b/AssemblyData/methodsrewriter/MModule.cs
@@ -36,10 +36,10 @@ namespace AssemblyData.methodsrewriter {
 		public MModule(Module module, ModuleDefMD moduleDef) {
 			this.module = module;
 			this.moduleDef = moduleDef;
-			initTokenToType();
+			InitTokenToType();
 		}
 
-		void initTokenToType() {
+		void InitTokenToType() {
 			moduleType = moduleDef.Types[0];
 			foreach (var typeDef in moduleDef.GetTypes()) {
 				int token = (int)typeDef.MDToken.Raw;
@@ -49,27 +49,27 @@ namespace AssemblyData.methodsrewriter {
 				}
 				catch {
 					tokenToType[token] = null;
-					typeRefToType.add(typeDef, null);
+					typeRefToType.Add(typeDef, null);
 					continue;
 				}
 				var mtype = new MType(type, typeDef);
 				tokenToType[token] = mtype;
-				typeRefToType.add(typeDef, mtype);
+				typeRefToType.Add(typeDef, mtype);
 			}
 		}
 
-		public MType getType(IType typeRef) {
-			return typeRefToType.find(typeRef);
+		public MType GetType(IType typeRef) {
+			return typeRefToType.Find(typeRef);
 		}
 
-		public MMethod getMethod(IMethod methodRef) {
-			var type = getType(methodRef.DeclaringType);
+		public MMethod GetMethod(IMethod methodRef) {
+			var type = GetType(methodRef.DeclaringType);
 			if (type != null)
-				return type.getMethod(methodRef);
+				return type.GetMethod(methodRef);
 			if (!new SigComparer().Equals(moduleType, methodRef.DeclaringType))
 				return null;
 
-			initGlobalMethods();
+			InitGlobalMethods();
 			foreach (var method in tokenToGlobalMethod.Values) {
 				if (new SigComparer().Equals(methodRef, method.methodDef))
 					return method;
@@ -78,14 +78,14 @@ namespace AssemblyData.methodsrewriter {
 			return null;
 		}
 
-		public MField getField(IField fieldRef) {
-			var type = getType(fieldRef.DeclaringType);
+		public MField GetField(IField fieldRef) {
+			var type = GetType(fieldRef.DeclaringType);
 			if (type != null)
-				return type.getField(fieldRef);
+				return type.GetField(fieldRef);
 			if (!new SigComparer().Equals(moduleType, fieldRef.DeclaringType))
 				return null;
 
-			initGlobalFields();
+			InitGlobalFields();
 			foreach (var field in tokenToGlobalField.Values) {
 				if (new SigComparer().Equals(fieldRef, field.fieldDef))
 					return field;
@@ -94,21 +94,21 @@ namespace AssemblyData.methodsrewriter {
 			return null;
 		}
 
-		public MMethod getMethod(MethodBase method) {
+		public MMethod GetMethod(MethodBase method) {
 			if (method.Module != module)
 				throw new ApplicationException("Not our module");
 			if (method.DeclaringType == null)
-				return getGlobalMethod(method);
+				return GetGlobalMethod(method);
 			var type = tokenToType[method.DeclaringType.MetadataToken];
-			return type.getMethod(method.MetadataToken);
+			return type.GetMethod(method.MetadataToken);
 		}
 
-		public MMethod getGlobalMethod(MethodBase method) {
-			initGlobalMethods();
+		public MMethod GetGlobalMethod(MethodBase method) {
+			InitGlobalMethods();
 			return tokenToGlobalMethod[method.MetadataToken];
 		}
 
-		void initGlobalMethods() {
+		void InitGlobalMethods() {
 			if (tokenToGlobalMethod != null)
 				return;
 			tokenToGlobalMethod = new Dictionary<int, MMethod>();
@@ -125,7 +125,7 @@ namespace AssemblyData.methodsrewriter {
 			}
 		}
 
-		void initGlobalFields() {
+		void InitGlobalFields() {
 			if (tokenToGlobalField != null)
 				return;
 			tokenToGlobalField = new Dictionary<int, MField>();
diff --git a/AssemblyData/methodsrewriter/MType.cs b/AssemblyData/methodsrewriter/MType.cs
index 114a1633..60b2235e 100644
--- a/AssemblyData/methodsrewriter/MType.cs
+++ b/AssemblyData/methodsrewriter/MType.cs
@@ -37,27 +37,27 @@ namespace AssemblyData.methodsrewriter {
 			this.typeDef = typeDef;
 		}
 
-		public MMethod getMethod(IMethod methodRef) {
-			initMethods();
-			return methodRefToMethod.find(methodRef);
+		public MMethod GetMethod(IMethod methodRef) {
+			InitMethods();
+			return methodRefToMethod.Find(methodRef);
 		}
 
-		public MField getField(IField fieldRef) {
-			initFields();
-			return fieldRefToField.find(fieldRef);
+		public MField GetField(IField fieldRef) {
+			InitFields();
+			return fieldRefToField.Find(fieldRef);
 		}
 
-		public MMethod getMethod(int token) {
-			initMethods();
+		public MMethod GetMethod(int token) {
+			InitMethods();
 			return tokenToMethod[token];
 		}
 
-		public MField getField(int token) {
-			initFields();
+		public MField GetField(int token) {
+			InitFields();
 			return tokenToField[token];
 		}
 
-		void initMethods() {
+		void InitMethods() {
 			if (tokenToMethod != null)
 				return;
 			tokenToMethod = new Dictionary<int, MMethod>(typeDef.Methods.Count);
@@ -65,17 +65,17 @@ namespace AssemblyData.methodsrewriter {
 
 			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))
+			foreach (var m in ResolverUtils.GetMethodBases(type, flags))
 				tmpTokenToMethod[m.MetadataToken] = m;
 			foreach (var m in typeDef.Methods) {
 				var token = (int)m.MDToken.Raw;
 				var method = new MMethod(tmpTokenToMethod[token], m);
 				tokenToMethod[token] = method;
-				methodRefToMethod.add(method.methodDef, method);
+				methodRefToMethod.Add(method.methodDef, method);
 			}
 		}
 
-		void initFields() {
+		void InitFields() {
 			if (tokenToField != null)
 				return;
 			tokenToField = new Dictionary<int, MField>(typeDef.Fields.Count);
@@ -89,7 +89,7 @@ namespace AssemblyData.methodsrewriter {
 				var token = (int)f.MDToken.Raw;
 				var field = new MField(tmpTokenToField[token], f);
 				tokenToField[token] = field;
-				fieldRefToField.add(field.fieldDef, field);
+				fieldRefToField.Add(field.fieldDef, field);
 			}
 		}
 
diff --git a/AssemblyData/methodsrewriter/MethodsRewriter.cs b/AssemblyData/methodsrewriter/MethodsRewriter.cs
index 88c84df4..117128ff 100644
--- a/AssemblyData/methodsrewriter/MethodsRewriter.cs
+++ b/AssemblyData/methodsrewriter/MethodsRewriter.cs
@@ -62,16 +62,16 @@ namespace AssemblyData.methodsrewriter {
 				}
 			}
 
-			public MethodBase getNext() {
+			public MethodBase GetNext() {
 				return methods[next++ % methods.Count];
 			}
 		}
 
-		public MethodBase getMethod(Module module) {
+		public MethodBase GetMethod(Module module) {
 			MethodsModule methodsModule;
 			if (!moduleToMethods.TryGetValue(module, out methodsModule))
 				moduleToMethods[module] = methodsModule = new MethodsModule(module);
-			return methodsModule.getNext();
+			return methodsModule.GetNext();
 		}
 	}
 
@@ -112,20 +112,20 @@ namespace AssemblyData.methodsrewriter {
 				this.rewrittenMethodName = rewrittenMethodName;
 			}
 
-			public bool isRewrittenMethod(string name) {
+			public bool IsRewrittenMethod(string name) {
 				return name == rewrittenMethodName;
 			}
 
-			public bool isDelegateMethod(string name) {
+			public bool IsDelegateMethod(string name) {
 				return name == delegateMethodName;
 			}
 		}
 
-		public Type getDelegateType(MethodBase methodBase) {
+		public Type GetDelegateType(MethodBase methodBase) {
 			return realMethodToNewMethod[methodBase].delegateType;
 		}
 
-		public RewrittenMethod createDelegate(MethodBase realMethod) {
+		public RewrittenMethod CreateDelegate(MethodBase realMethod) {
 			var newMethodInfo = realMethodToNewMethod[realMethod];
 			if (newMethodInfo.rewrittenMethod != null)
 				return newMethodInfo.rewrittenMethod;
@@ -135,7 +135,7 @@ namespace AssemblyData.methodsrewriter {
 
 			ilg.Emit(ROpCodes.Ldarg_0);
 			ilg.Emit(ROpCodes.Ldc_I4, newMethodInfo.delegateIndex);
-			ilg.Emit(ROpCodes.Call, GetType().GetMethod("rtGetDelegateInstance", BindingFlags.DeclaredOnly | BindingFlags.NonPublic | BindingFlags.Instance));
+			ilg.Emit(ROpCodes.Call, GetType().GetMethod("RtGetDelegateInstance", BindingFlags.DeclaredOnly | BindingFlags.NonPublic | BindingFlags.Instance));
 			ilg.Emit(ROpCodes.Castclass, newMethodInfo.delegateType);
 
 			var args = newMethodInfo.oldMethod.GetParameters();
@@ -156,7 +156,7 @@ namespace AssemblyData.methodsrewriter {
 			var flags = BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance;
 			var invokeMethod = newMethodInfo.delegateType.GetMethod("Invoke", flags);
 			ilg.Emit(ROpCodes.Call, invokeMethod);
-			if (ResolverUtils.getReturnType(newMethodInfo.oldMethod) == typeof(void))
+			if (ResolverUtils.GetReturnType(newMethodInfo.oldMethod) == typeof(void))
 				ilg.Emit(ROpCodes.Ldnull);
 			ilg.Emit(ROpCodes.Ret);
 
@@ -164,50 +164,50 @@ namespace AssemblyData.methodsrewriter {
 			return newMethodInfo.rewrittenMethod;
 		}
 
-		public void setCaller(RewrittenMethod rewrittenMethod, MethodBase caller) {
+		public void SetCaller(RewrittenMethod rewrittenMethod, MethodBase caller) {
 			if (caller == null)
 				return;
-			var newMethodInfo = getNewMethodInfo(rewrittenMethod.Method.Name);
+			var newMethodInfo = GetNewMethodInfo(rewrittenMethod.Method.Name);
 			newStackMethodDict[newMethodInfo] = caller;
 		}
 
-		string getDelegateMethodName(MethodBase method) {
+		string GetDelegateMethodName(MethodBase method) {
 			string name = null;
 			do {
-				name = string.Format(" {0} {1:X8} DMN {2:X8} ", method.Name, method.MetadataToken, Utils.getRandomUint());
+				name = string.Format(" {0} {1:X8} DMN {2:X8} ", method.Name, method.MetadataToken, Utils.GetRandomUint());
 			} while (delegateNameToNewMethodInfo.ContainsKey(name));
 			return name;
 		}
 
-		public void createMethod(MethodBase realMethod) {
+		public void CreateMethod(MethodBase realMethod) {
 			if (realMethodToNewMethod.ContainsKey(realMethod))
 				return;
-			var newMethodInfo = new NewMethodInfo(realMethod, newMethodInfos.Count, getDelegateMethodName(realMethod), getDelegateMethodName(realMethod));
+			var newMethodInfo = new NewMethodInfo(realMethod, newMethodInfos.Count, GetDelegateMethodName(realMethod), GetDelegateMethodName(realMethod));
 			newMethodInfos.Add(newMethodInfo);
 			delegateNameToNewMethodInfo[newMethodInfo.delegateMethodName] = newMethodInfo;
 			delegateNameToNewMethodInfo[newMethodInfo.rewrittenMethodName] = newMethodInfo;
 			realMethodToNewMethod[realMethod] = newMethodInfo;
 
-			var moduleInfo = Resolver.loadAssembly(realMethod.Module);
-			var methodInfo = moduleInfo.getMethod(realMethod);
-			if (!methodInfo.hasInstructions())
+			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.methodDef, methodInfo.methodDef.MDToken.Raw));
 
 			var codeGenerator = new CodeGenerator(this, newMethodInfo.delegateMethodName);
-			codeGenerator.setMethodInfo(methodInfo);
+			codeGenerator.SetMethodInfo(methodInfo);
 			newMethodInfo.delegateType = codeGenerator.DelegateType;
 
 			var blocks = new Blocks(methodInfo.methodDef);
-			foreach (var block in blocks.MethodBlocks.getAllBlocks())
-				update(block, newMethodInfo);
+			foreach (var block in blocks.MethodBlocks.GetAllBlocks())
+				Update(block, newMethodInfo);
 
 			IList<Instruction> allInstructions;
 			IList<ExceptionHandler> allExceptionHandlers;
-			blocks.getCode(out allInstructions, out allExceptionHandlers);
-			newMethodInfo.delegateInstance = codeGenerator.generate(allInstructions, allExceptionHandlers);
+			blocks.GetCode(out allInstructions, out allExceptionHandlers);
+			newMethodInfo.delegateInstance = codeGenerator.Generate(allInstructions, allExceptionHandlers);
 		}
 
-		static Instruction create(OpCode opcode, object operand) {
+		static Instruction Create(OpCode opcode, object operand) {
 			return new Instruction {
 				OpCode = opcode,
 				Operand = operand,
@@ -215,17 +215,17 @@ namespace AssemblyData.methodsrewriter {
 		}
 
 		// Inserts ldarg THIS, and returns number of instructions inserted at 'i'
-		int insertLoadThis(Block block, int i) {
-			block.insert(i, create(OpCodes.Ldarg, new Operand(Operand.Type.ThisArg)));
+		int InsertLoadThis(Block block, int i) {
+			block.Insert(i, Create(OpCodes.Ldarg, new Operand(Operand.Type.ThisArg)));
 			return 1;
 		}
 
-		int insertCallOurMethod(Block block, int i, string methodName) {
-			block.insert(i, create(OpCodes.Call, new Operand(Operand.Type.OurMethod, methodName)));
+		int InsertCallOurMethod(Block block, int i, string methodName) {
+			block.Insert(i, Create(OpCodes.Call, new Operand(Operand.Type.OurMethod, methodName)));
 			return 1;
 		}
 
-		void update(Block block, NewMethodInfo currentMethodInfo) {
+		void Update(Block block, NewMethodInfo currentMethodInfo) {
 			var instrs = block.Instructions;
 			for (int i = 0; i < instrs.Count; i++) {
 				var instr = instrs[i];
@@ -233,14 +233,14 @@ namespace AssemblyData.methodsrewriter {
 					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");
+						InsertLoadThis(block, i + 1);
+						InsertCallOurMethod(block, i + 2, "static_RtFixStackTrace");
 						i += 2;
 						continue;
 					}
 					else if (ctorTypeFullName == "System.Diagnostics.StackFrame") {
-						insertLoadThis(block, i + 1);
-						insertCallOurMethod(block, i + 2, "static_rtFixStackFrame");
+						InsertLoadThis(block, i + 1);
+						InsertCallOurMethod(block, i + 2, "static_RtFixStackFrame");
 						i += 2;
 						continue;
 					}
@@ -251,67 +251,67 @@ namespace AssemblyData.methodsrewriter {
 					if (calledMethod.DeclaringType.DefinitionAssembly.IsCorLib()) {
 						var calledMethodFullName = calledMethod.FullName;
 						if (calledMethodFullName == "System.Reflection.Assembly System.Reflection.Assembly::GetAssembly(System.Type)") {
-							block.replace(i, 1, OpCodes.Nop.ToInstruction());
-							insertLoadThis(block, i + 1);
-							insertCallOurMethod(block, i + 2, "static_rtGetAssembly_TypeArg");
+							block.Replace(i, 1, OpCodes.Nop.ToInstruction());
+							InsertLoadThis(block, i + 1);
+							InsertCallOurMethod(block, i + 2, "static_RtGetAssembly_TypeArg");
 							i += 2;
 							continue;
 						}
 						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, OpCodes.Nop.ToInstruction());
-							insertLoadThis(block, i + 1);
-							block.insert(i + 2, OpCodes.Ldc_I4.ToInstruction(currentMethodInfo.delegateIndex));
-							insertCallOurMethod(block, i + 3, "rtGetAssembly");
+							block.Replace(i, 1, OpCodes.Nop.ToInstruction());
+							InsertLoadThis(block, i + 1);
+							block.Insert(i + 2, OpCodes.Ldc_I4.ToInstruction(currentMethodInfo.delegateIndex));
+							InsertCallOurMethod(block, i + 3, "RtGetAssembly");
 							i += 3;
 							continue;
 						}
 					}
 
-					var method = Resolver.getMethod((IMethod)instr.Operand);
+					var method = Resolver.GetMethod((IMethod)instr.Operand);
 					if (method != null) {
-						createMethod(method.methodBase);
+						CreateMethod(method.methodBase);
 						var newMethodInfo = realMethodToNewMethod[method.methodBase];
 
-						block.replace(i, 1, OpCodes.Nop.ToInstruction());
+						block.Replace(i, 1, OpCodes.Nop.ToInstruction());
 						int n = i + 1;
 
 						// Pop all pushed args to a temp array
-						var mparams = getParameters(method.methodDef);
+						var mparams = GetParameters(method.methodDef);
 						if (mparams.Count > 0) {
-							block.insert(n++, OpCodes.Ldc_I4.ToInstruction(mparams.Count));
+							block.Insert(n++, OpCodes.Ldc_I4.ToInstruction(mparams.Count));
 							var objectType = method.methodDef.DeclaringType.Module.CorLibTypes.Object;
-							block.insert(n++, OpCodes.Newarr.ToInstruction(objectType));
-							block.insert(n++, create(OpCodes.Stloc, new Operand(Operand.Type.TempObjArray)));
+							block.Insert(n++, OpCodes.Newarr.ToInstruction(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.RemovePinnedAndModifiers().IsValueType)
-									block.insert(n++, OpCodes.Box.ToInstruction(((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++, OpCodes.Ldc_I4.ToInstruction(j));
-								block.insert(n++, create(OpCodes.Ldloc, new Operand(Operand.Type.TempObj)));
-								block.insert(n++, OpCodes.Stelem_Ref.ToInstruction());
+									block.Insert(n++, OpCodes.Box.ToInstruction(((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++, OpCodes.Ldc_I4.ToInstruction(j));
+								block.Insert(n++, Create(OpCodes.Ldloc, new Operand(Operand.Type.TempObj)));
+								block.Insert(n++, OpCodes.Stelem_Ref.ToInstruction());
 							}
 						}
 
 						// Push delegate instance
-						insertLoadThis(block, n++);
-						block.insert(n++, OpCodes.Ldc_I4.ToInstruction(newMethodInfo.delegateIndex));
-						insertCallOurMethod(block, n++, "rtGetDelegateInstance");
-						block.insert(n++, create(OpCodes.Castclass, new Operand(Operand.Type.ReflectionType, newMethodInfo.delegateType)));
+						InsertLoadThis(block, n++);
+						block.Insert(n++, OpCodes.Ldc_I4.ToInstruction(newMethodInfo.delegateIndex));
+						InsertCallOurMethod(block, n++, "RtGetDelegateInstance");
+						block.Insert(n++, Create(OpCodes.Castclass, new Operand(Operand.Type.ReflectionType, newMethodInfo.delegateType)));
 
 						// Push all popped args
 						if (mparams.Count > 0) {
 							for (int j = 0; j < mparams.Count; j++) {
-								block.insert(n++, create(OpCodes.Ldloc, new Operand(Operand.Type.TempObjArray)));
-								block.insert(n++, OpCodes.Ldc_I4.ToInstruction(j));
-								block.insert(n++, OpCodes.Ldelem_Ref.ToInstruction());
+								block.Insert(n++, Create(OpCodes.Ldloc, new Operand(Operand.Type.TempObjArray)));
+								block.Insert(n++, OpCodes.Ldc_I4.ToInstruction(j));
+								block.Insert(n++, OpCodes.Ldelem_Ref.ToInstruction());
 								var argType = mparams[j];
 								if (argType.RemovePinnedAndModifiers().IsValueType)
-									block.insert(n++, OpCodes.Unbox_Any.ToInstruction(((TypeDefOrRefSig)argType).TypeDefOrRef));
+									block.Insert(n++, OpCodes.Unbox_Any.ToInstruction(((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
@@ -322,8 +322,8 @@ namespace AssemblyData.methodsrewriter {
 							}
 						}
 
-						insertLoadThis(block, n++);
-						block.insert(n++, create(OpCodes.Call, new Operand(Operand.Type.NewMethod, method.methodBase)));
+						InsertLoadThis(block, n++);
+						block.Insert(n++, Create(OpCodes.Call, new Operand(Operand.Type.NewMethod, method.methodBase)));
 						i = n - 1;
 						continue;
 					}
@@ -331,48 +331,48 @@ namespace AssemblyData.methodsrewriter {
 			}
 		}
 
-		static IList<TypeSig> getParameters(MethodDef method) {
+		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;
 		}
 
-		static FieldInfo getStackTraceStackFramesField() {
+		static FieldInfo GgetStackTraceStackFramesField() {
 			var flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
-			return ResolverUtils.getFieldThrow(typeof(StackTrace), typeof(StackFrame[]), flags, "Could not find StackTrace's frames (StackFrame[]) field");
+			return ResolverUtils.GetFieldThrow(typeof(StackTrace), typeof(StackFrame[]), flags, "Could not find StackTrace's frames (StackFrame[]) field");
 		}
 
-		static FieldInfo getStackFrameMethodField() {
+		static FieldInfo GetStackFrameMethodField() {
 			var flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
-			return ResolverUtils.getFieldThrow(typeof(StackFrame), typeof(MethodBase), flags, "Could not find StackFrame's method (MethodBase) field");
+			return ResolverUtils.GetFieldThrow(typeof(StackFrame), typeof(MethodBase), flags, "Could not find StackFrame's method (MethodBase) field");
 		}
 
-		static void writeMethodBase(StackFrame frame, MethodBase method) {
-			var methodField = getStackFrameMethodField();
+		static void WriteMethodBase(StackFrame frame, MethodBase method) {
+			var methodField = GetStackFrameMethodField();
 			methodField.SetValue(frame, method);
 			if (frame.GetMethod() != method)
 				throw new ApplicationException(string.Format("Could not set new method: {0}", method));
 		}
 
-		NewMethodInfo getNewMethodInfo(string name) {
+		NewMethodInfo GetNewMethodInfo(string name) {
 			NewMethodInfo info;
 			delegateNameToNewMethodInfo.TryGetValue(name, out info);
 			return info;
 		}
 
 		// Called after the StackTrace ctor has been called.
-		static StackTrace static_rtFixStackTrace(StackTrace stackTrace, MethodsRewriter self) {
-			return self.rtFixStackTrace(stackTrace);
+		static StackTrace static_RtFixStackTrace(StackTrace stackTrace, MethodsRewriter self) {
+			return self.RtFixStackTrace(stackTrace);
 		}
 
-		StackTrace rtFixStackTrace(StackTrace stackTrace) {
-			var framesField = getStackTraceStackFramesField();
+		StackTrace RtFixStackTrace(StackTrace stackTrace) {
+			var framesField = GgetStackTraceStackFramesField();
 			var frames = (StackFrame[])framesField.GetValue(stackTrace);
 
 			var newFrames = new List<StackFrame>(frames.Length);
 			foreach (var frame in frames) {
-				fixStackFrame(frame);
+				FixStackFrame(frame);
 				newFrames.Add(frame);
 			}
 
@@ -380,52 +380,52 @@ namespace AssemblyData.methodsrewriter {
 			return stackTrace;
 		}
 
-		static StackFrame static_rtFixStackFrame(StackFrame stackFrame, MethodsRewriter self) {
-			return self.rtFixStackFrame(stackFrame);
+		static StackFrame static_RtFixStackFrame(StackFrame stackFrame, MethodsRewriter self) {
+			return self.RtFixStackFrame(stackFrame);
 		}
 
-		StackFrame rtFixStackFrame(StackFrame frame) {
-			fixStackFrame(frame);
+		StackFrame RtFixStackFrame(StackFrame frame) {
+			FixStackFrame(frame);
 			return frame;
 		}
 
-		void fixStackFrame(StackFrame frame) {
+		void FixStackFrame(StackFrame frame) {
 			var method = frame.GetMethod();
-			var info = getNewMethodInfo(method.Name);
+			var info = GetNewMethodInfo(method.Name);
 			if (info == null)
 				return;
 
 			MethodBase stackMethod;
 			if (newStackMethodDict.TryGetValue(info, out stackMethod)) {
-				writeMethodBase(frame, stackMethod);
+				WriteMethodBase(frame, stackMethod);
 			}
-			else if (info.isRewrittenMethod(method.Name)) {
+			else if (info.IsRewrittenMethod(method.Name)) {
 				// Write random method from the same module
-				writeMethodBase(frame, methodsFinder.getMethod(info.oldMethod.Module));
+				WriteMethodBase(frame, methodsFinder.GetMethod(info.oldMethod.Module));
 			}
-			else if (info.isDelegateMethod(method.Name)) {
+			else if (info.IsDelegateMethod(method.Name)) {
 				// Write original method
-				writeMethodBase(frame, info.oldMethod);
+				WriteMethodBase(frame, info.oldMethod);
 			}
 			else
 				throw new ApplicationException("BUG: Shouldn't be here");
 		}
 
 		// Called when the code calls GetCallingAssembly(), GetEntryAssembly(), or GetExecutingAssembly()
-		Assembly rtGetAssembly(int delegateIndex) {
+		Assembly RtGetAssembly(int delegateIndex) {
 			return newMethodInfos[delegateIndex].oldMethod.Module.Assembly;
 		}
 
 		// Called when the code calls GetAssembly(Type)
-		static Assembly static_rtGetAssembly_TypeArg(Type type, MethodsRewriter self) {
-			return self.rtGetAssembly_TypeArg(type);
+		static Assembly static_RtGetAssembly_TypeArg(Type type, MethodsRewriter self) {
+			return self.RtGetAssembly_TypeArg(type);
 		}
 
-		Assembly rtGetAssembly_TypeArg(Type type) {
+		Assembly RtGetAssembly_TypeArg(Type type) {
 			return Assembly.GetAssembly(type);
 		}
 
-		Delegate rtGetDelegateInstance(int delegateIndex) {
+		Delegate RtGetDelegateInstance(int delegateIndex) {
 			return newMethodInfos[delegateIndex].delegateInstance;
 		}
 	}
diff --git a/AssemblyData/methodsrewriter/Resolver.cs b/AssemblyData/methodsrewriter/Resolver.cs
index b67f856f..fb48bf3f 100644
--- a/AssemblyData/methodsrewriter/Resolver.cs
+++ b/AssemblyData/methodsrewriter/Resolver.cs
@@ -28,7 +28,7 @@ namespace AssemblyData.methodsrewriter {
 		static Dictionary<string, AssemblyResolver> assemblyResolvers = new Dictionary<string, AssemblyResolver>(StringComparer.Ordinal);
 		static Dictionary<Module, MModule> modules = new Dictionary<Module, MModule>();
 
-		public static MModule loadAssembly(Module module) {
+		public static MModule LoadAssembly(Module module) {
 			MModule info;
 			if (modules.TryGetValue(module, out info))
 				return info;
@@ -38,7 +38,7 @@ namespace AssemblyData.methodsrewriter {
 			return info;
 		}
 
-		static MModule getModule(ModuleDef moduleDef) {
+		static MModule GetModule(ModuleDef moduleDef) {
 			foreach (var mm in modules.Values) {
 				if (mm.moduleDef == moduleDef)
 					return mm;
@@ -46,7 +46,7 @@ namespace AssemblyData.methodsrewriter {
 			return null;
 		}
 
-		static MModule getModule(AssemblyRef asmRef) {
+		static MModule GetModule(AssemblyRef asmRef) {
 			foreach (var mm in modules.Values) {
 				var asm = mm.moduleDef.Assembly;
 				if (asm != null && asm.FullName == asmRef.FullName)
@@ -55,83 +55,83 @@ namespace AssemblyData.methodsrewriter {
 			return null;
 		}
 
-		public static MModule getModule(IScope scope) {
+		public static MModule GetModule(IScope scope) {
 			if (scope.ScopeType == ScopeType.ModuleDef)
-				return getModule((ModuleDef)scope);
+				return GetModule((ModuleDef)scope);
 			else if (scope.ScopeType == ScopeType.AssemblyRef)
-				return getModule((AssemblyRef)scope);
+				return GetModule((AssemblyRef)scope);
 
 			return null;
 		}
 
-		public static MType getType(IType typeRef) {
+		public static MType GetType(IType typeRef) {
 			if (typeRef == null)
 				return null;
-			var module = getModule(typeRef.Scope);
+			var module = GetModule(typeRef.Scope);
 			if (module != null)
-				return module.getType(typeRef);
+				return module.GetType(typeRef);
 			return null;
 		}
 
-		public static MMethod getMethod(IMethod methodRef) {
+		public static MMethod GetMethod(IMethod methodRef) {
 			if (methodRef == null)
 				return null;
-			var module = getModule(methodRef.DeclaringType.Scope);
+			var module = GetModule(methodRef.DeclaringType.Scope);
 			if (module != null)
-				return module.getMethod(methodRef);
+				return module.GetMethod(methodRef);
 			return null;
 		}
 
-		public static MField getField(IField fieldRef) {
+		public static MField GetField(IField fieldRef) {
 			if (fieldRef == null)
 				return null;
-			var module = getModule(fieldRef.DeclaringType.Scope);
+			var module = GetModule(fieldRef.DeclaringType.Scope);
 			if (module != null)
-				return module.getField(fieldRef);
+				return module.GetField(fieldRef);
 			return null;
 		}
 
-		public static object getRtObject(ITokenOperand memberRef) {
+		public static object GetRtObject(ITokenOperand memberRef) {
 			if (memberRef == null)
 				return null;
 			var tdr = memberRef as ITypeDefOrRef;
 			if (tdr != null)
-				return getRtType(tdr);
+				return GetRtType(tdr);
 			var field = memberRef as IField;
 			if (field != null && field.FieldSig != null)
-				return getRtField(field);
+				return GetRtField(field);
 			var method = memberRef as IMethod;
 			if (method != null && method.MethodSig != null)
-				return getRtMethod(method);
+				return GetRtMethod(method);
 
 			throw new ApplicationException(string.Format("Unknown MemberRef: {0}", memberRef));
 		}
 
-		public static Type getRtType(IType typeRef) {
-			var mtype = getType(typeRef);
+		public static Type GetRtType(IType typeRef) {
+			var mtype = GetType(typeRef);
 			if (mtype != null)
 				return mtype.type;
 
-			return Resolver.resolve(typeRef);
+			return Resolver.Resolve(typeRef);
 		}
 
-		public static FieldInfo getRtField(IField fieldRef) {
-			var mfield = getField(fieldRef);
+		public static FieldInfo GetRtField(IField fieldRef) {
+			var mfield = GetField(fieldRef);
 			if (mfield != null)
 				return mfield.fieldInfo;
 
-			return Resolver.resolve(fieldRef);
+			return Resolver.Resolve(fieldRef);
 		}
 
-		public static MethodBase getRtMethod(IMethod methodRef) {
-			var mmethod = getMethod(methodRef);
+		public static MethodBase GetRtMethod(IMethod methodRef) {
+			var mmethod = GetMethod(methodRef);
 			if (mmethod != null)
 				return mmethod.methodBase;
 
-			return Resolver.resolve(methodRef);
+			return Resolver.Resolve(methodRef);
 		}
 
-		static AssemblyResolver getAssemblyResolver(ITypeDefOrRef type) {
+		static AssemblyResolver GetAssemblyResolver(ITypeDefOrRef type) {
 			var asmName = type.DefinitionAssembly.FullName;
 			AssemblyResolver resolver;
 			if (!assemblyResolvers.TryGetValue(asmName, out resolver))
@@ -139,38 +139,38 @@ namespace AssemblyData.methodsrewriter {
 			return resolver;
 		}
 
-		static Type resolve(IType typeRef) {
+		static Type Resolve(IType typeRef) {
 			if (typeRef == null)
 				return null;
 			var scopeType = typeRef.ScopeType;
-			var resolver = getAssemblyResolver(scopeType);
-			var resolvedType = resolver.resolve(scopeType);
+			var resolver = GetAssemblyResolver(scopeType);
+			var resolvedType = resolver.Resolve(scopeType);
 			if (resolvedType != null)
-				return fixType(typeRef, resolvedType);
+				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(IField fieldRef) {
+		static FieldInfo Resolve(IField fieldRef) {
 			if (fieldRef == null)
 				return null;
-			var resolver = getAssemblyResolver(fieldRef.DeclaringType);
-			var fieldInfo = resolver.resolve(fieldRef);
+			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}", fieldRef, fieldRef.MDToken.Raw, resolver));
 		}
 
-		static MethodBase resolve(IMethod methodRef) {
+		static MethodBase Resolve(IMethod methodRef) {
 			if (methodRef == null)
 				return null;
-			var resolver = getAssemblyResolver(methodRef.DeclaringType);
-			var methodBase = resolver.resolve(methodRef);
+			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}", methodRef, methodRef.MDToken.Raw, resolver));
 		}
 
-		static Type fixType(IType typeRef, Type type) {
+		static Type FixType(IType typeRef, Type type) {
 			var sig = typeRef as TypeSig;
 			if (sig == null) {
 				var ts = typeRef as TypeSpec;
@@ -203,7 +203,7 @@ namespace AssemblyData.methodsrewriter {
 						var arg = git.GenericArguments[i];
 						if (!(arg is GenericSig))
 							isGenericTypeDef = false;
-						args[i] = Resolver.resolve(arg);
+						args[i] = Resolver.Resolve(arg);
 					}
 					if (!isGenericTypeDef)
 						type = type.MakeGenericType(args);
diff --git a/AssemblyData/methodsrewriter/ResolverUtils.cs b/AssemblyData/methodsrewriter/ResolverUtils.cs
index f938cce1..cff21337 100644
--- a/AssemblyData/methodsrewriter/ResolverUtils.cs
+++ b/AssemblyData/methodsrewriter/ResolverUtils.cs
@@ -25,27 +25,27 @@ using de4dot.blocks;
 
 namespace AssemblyData.methodsrewriter {
 	static class ResolverUtils {
-		public static bool compareTypes(Type a, IType b) {
+		public static bool CompareTypes(Type a, IType b) {
 			return new SigComparer().Equals(a, b);
 		}
 
-		public static bool compareFields(FieldInfo a, IField b) {
+		public static bool CompareFields(FieldInfo a, IField b) {
 			return new SigComparer().Equals(a, b);
 		}
 
-		public static bool hasThis(MethodBase method) {
+		public static bool HasThis(MethodBase method) {
 			return (method.CallingConvention & CallingConventions.HasThis) != 0;
 		}
 
-		public static bool explicitThis(MethodBase method) {
+		public static bool ExplicitThis(MethodBase method) {
 			return (method.CallingConvention & CallingConventions.ExplicitThis) != 0;
 		}
 
-		public static bool compareMethods(MethodBase a, IMethod b) {
+		public static bool CompareMethods(MethodBase a, IMethod b) {
 			return new SigComparer().Equals(a, b);
 		}
 
-		public static Type getReturnType(MethodBase methodBase) {
+		public static Type GetReturnType(MethodBase methodBase) {
 			var methodInfo = methodBase as MethodInfo;
 			if (methodInfo != null)
 				return methodInfo.ReturnType;
@@ -57,7 +57,7 @@ namespace AssemblyData.methodsrewriter {
 			throw new ApplicationException(string.Format("Could not figure out return type: {0} ({1:X8})", methodBase, methodBase.MetadataToken));
 		}
 
-		public static Type[] getGenericArguments(MethodBase methodBase) {
+		public static Type[] GetGenericArguments(MethodBase methodBase) {
 			try {
 				return methodBase.GetGenericArguments();
 			}
@@ -66,7 +66,7 @@ namespace AssemblyData.methodsrewriter {
 			}
 		}
 
-		public static IEnumerable<MethodBase> getMethodBases(Type type, BindingFlags flags) {
+		public static IEnumerable<MethodBase> GetMethodBases(Type type, BindingFlags flags) {
 			if (type.TypeInitializer != null)
 				yield return type.TypeInitializer;
 			foreach (var ctor in type.GetConstructors(flags))
@@ -96,7 +96,7 @@ namespace AssemblyData.methodsrewriter {
 		}
 
 		static Dictionary<CachedMemberInfo, FieldInfo> cachedFieldInfos = new Dictionary<CachedMemberInfo, FieldInfo>();
-		public static FieldInfo getField(Type type, Type fieldType, BindingFlags flags) {
+		public static FieldInfo GetField(Type type, Type fieldType, BindingFlags flags) {
 			var key = new CachedMemberInfo(type, fieldType);
 			FieldInfo fieldInfo;
 			if (cachedFieldInfos.TryGetValue(key, out fieldInfo))
@@ -111,14 +111,14 @@ namespace AssemblyData.methodsrewriter {
 			return null;
 		}
 
-		public static FieldInfo getFieldThrow(Type type, Type fieldType, BindingFlags flags, string msg) {
-			var info = getField(type, fieldType, flags);
+		public static FieldInfo GetFieldThrow(Type type, Type fieldType, BindingFlags flags, string msg) {
+			var info = GetField(type, fieldType, flags);
 			if (info != null)
 				return info;
 			throw new ApplicationException(msg);
 		}
 
-		public static List<FieldInfo> getFields(Type type, Type fieldType, BindingFlags flags) {
+		public static List<FieldInfo> GetFields(Type type, Type fieldType, BindingFlags flags) {
 			var list = new List<FieldInfo>();
 			foreach (var field in type.GetFields(flags)) {
 				if (field.FieldType == fieldType)
@@ -127,7 +127,7 @@ namespace AssemblyData.methodsrewriter {
 			return list;
 		}
 
-		public static Type makeInstanceType(Type type, ITypeDefOrRef typeRef) {
+		public static Type MakeInstanceType(Type type, ITypeDefOrRef typeRef) {
 			var ts = typeRef as TypeSpec;
 			if (ts == null)
 				return type;
@@ -140,7 +140,7 @@ namespace AssemblyData.methodsrewriter {
 				var arg = git.GenericArguments[i];
 				if (!(arg is GenericSig))
 					isTypeDef = false;
-				types[i] = Resolver.getRtType(arg);
+				types[i] = Resolver.GetRtType(arg);
 			}
 			if (isTypeDef)
 				return type;
diff --git a/AssemblyData/methodsrewriter/TypeInstanceResolver.cs b/AssemblyData/methodsrewriter/TypeInstanceResolver.cs
index 53b1b57f..a9e2de13 100644
--- a/AssemblyData/methodsrewriter/TypeInstanceResolver.cs
+++ b/AssemblyData/methodsrewriter/TypeInstanceResolver.cs
@@ -30,27 +30,27 @@ namespace AssemblyData.methodsrewriter {
 		Dictionary<string, List<FieldInfo>> fields;
 
 		public TypeInstanceResolver(Type type, ITypeDefOrRef typeRef) {
-			this.type = ResolverUtils.makeInstanceType(type, typeRef);
+			this.type = ResolverUtils.MakeInstanceType(type, typeRef);
 		}
 
-		public FieldInfo resolve(IField fieldRef) {
-			initFields();
+		public FieldInfo Resolve(IField fieldRef) {
+			InitFields();
 
 			List<FieldInfo> list;
 			if (!fields.TryGetValue(fieldRef.Name.String, out list))
 				return null;
 
-			fieldRef = GenericArgsSubstitutor.create(fieldRef, fieldRef.DeclaringType.TryGetGenericInstSig());
+			fieldRef = GenericArgsSubstitutor.Create(fieldRef, fieldRef.DeclaringType.TryGetGenericInstSig());
 
 			foreach (var field in list) {
-				if (ResolverUtils.compareFields(field, fieldRef))
+				if (ResolverUtils.CompareFields(field, fieldRef))
 					return field;
 			}
 
 			return null;
 		}
 
-		void initFields() {
+		void InitFields() {
 			if (fields != null)
 				return;
 			fields = new Dictionary<string, List<FieldInfo>>(StringComparer.Ordinal);
@@ -64,30 +64,30 @@ namespace AssemblyData.methodsrewriter {
 			}
 		}
 
-		public MethodBase resolve(IMethod methodRef) {
-			initMethods();
+		public MethodBase Resolve(IMethod methodRef) {
+			InitMethods();
 
 			List<MethodBase> list;
 			if (!methods.TryGetValue(methodRef.Name.String, out list))
 				return null;
 
-			methodRef = GenericArgsSubstitutor.create(methodRef, methodRef.DeclaringType.TryGetGenericInstSig());
+			methodRef = GenericArgsSubstitutor.Create(methodRef, methodRef.DeclaringType.TryGetGenericInstSig());
 
 			foreach (var method in list) {
-				if (ResolverUtils.compareMethods(method, methodRef))
+				if (ResolverUtils.CompareMethods(method, methodRef))
 					return method;
 			}
 
 			return null;
 		}
 
-		void initMethods() {
+		void InitMethods() {
 			if (methods != null)
 				return;
 			methods = new Dictionary<string, List<MethodBase>>(StringComparer.Ordinal);
 
 			var flags = BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance;
-			foreach (var method in ResolverUtils.getMethodBases(type, flags)) {
+			foreach (var method in ResolverUtils.GetMethodBases(type, flags)) {
 				List<MethodBase> list;
 				if (!methods.TryGetValue(method.Name, out list))
 					methods[method.Name] = list = new List<MethodBase>();
diff --git a/AssemblyData/methodsrewriter/TypeResolver.cs b/AssemblyData/methodsrewriter/TypeResolver.cs
index 7f96ea0f..f209a028 100644
--- a/AssemblyData/methodsrewriter/TypeResolver.cs
+++ b/AssemblyData/methodsrewriter/TypeResolver.cs
@@ -32,19 +32,19 @@ namespace AssemblyData.methodsrewriter {
 			this.type = type;
 		}
 
-		TypeInstanceResolver getTypeInstance(ITypeDefOrRef typeRef) {
+		TypeInstanceResolver GetTypeInstance(ITypeDefOrRef typeRef) {
 			TypeInstanceResolver instance;
 			if (!typeRefToInstance.TryGetValue(typeRef, out instance))
 				typeRefToInstance[typeRef] = instance = new TypeInstanceResolver(type, typeRef);
 			return instance;
 		}
 
-		public FieldInfo resolve(IField fieldRef) {
-			return getTypeInstance(fieldRef.DeclaringType).resolve(fieldRef);
+		public FieldInfo Resolve(IField fieldRef) {
+			return GetTypeInstance(fieldRef.DeclaringType).Resolve(fieldRef);
 		}
 
-		public MethodBase resolve(IMethod methodRef) {
-			return getTypeInstance(methodRef.DeclaringType).resolve(methodRef);
+		public MethodBase Resolve(IMethod methodRef) {
+			return GetTypeInstance(methodRef.DeclaringType).Resolve(methodRef);
 		}
 	}
 }
diff --git a/AssemblyServer-CLR20-x64/Program.cs b/AssemblyServer-CLR20-x64/Program.cs
index ed53ded9..0db8f1ad 100644
--- a/AssemblyServer-CLR20-x64/Program.cs
+++ b/AssemblyServer-CLR20-x64/Program.cs
@@ -20,7 +20,7 @@
 namespace AssemblyServer_CLR20_x64 {
 	class Program {
 		static int Main(string[] args) {
-			return AssemblyServer.Start.main(args);
+			return AssemblyServer.Start.Main2(args);
 		}
 	}
 }
diff --git a/AssemblyServer-CLR20/Program.cs b/AssemblyServer-CLR20/Program.cs
index 8b95c2b0..c580a88d 100644
--- a/AssemblyServer-CLR20/Program.cs
+++ b/AssemblyServer-CLR20/Program.cs
@@ -20,7 +20,7 @@
 namespace AssemblyServer_CLR20 {
 	class Program {
 		static int Main(string[] args) {
-			return AssemblyServer.Start.main(args);
+			return AssemblyServer.Start.Main2(args);
 		}
 	}
 }
diff --git a/AssemblyServer-CLR40-x64/Program.cs b/AssemblyServer-CLR40-x64/Program.cs
index ec107d0c..30f37320 100644
--- a/AssemblyServer-CLR40-x64/Program.cs
+++ b/AssemblyServer-CLR40-x64/Program.cs
@@ -20,7 +20,7 @@
 namespace AssemblyServer_CLR40_x64 {
 	class Program {
 		static int Main(string[] args) {
-			return AssemblyServer.Start.main(args);
+			return AssemblyServer.Start.Main2(args);
 		}
 	}
 }
diff --git a/AssemblyServer-CLR40/Program.cs b/AssemblyServer-CLR40/Program.cs
index 07fc6079..433a8c72 100644
--- a/AssemblyServer-CLR40/Program.cs
+++ b/AssemblyServer-CLR40/Program.cs
@@ -20,7 +20,7 @@
 namespace AssemblyServer_CLR40 {
 	class Program {
 		static int Main(string[] args) {
-			return AssemblyServer.Start.main(args);
+			return AssemblyServer.Start.Main2(args);
 		}
 	}
 }
diff --git a/AssemblyServer-x64/Program.cs b/AssemblyServer-x64/Program.cs
index 8ee9e1bd..b58d0c0a 100644
--- a/AssemblyServer-x64/Program.cs
+++ b/AssemblyServer-x64/Program.cs
@@ -20,7 +20,7 @@
 namespace AssemblyServer_x64 {
 	class Program {
 		static int Main(string[] args) {
-			return AssemblyServer.Start.main(args);
+			return AssemblyServer.Start.Main2(args);
 		}
 	}
 }
diff --git a/AssemblyServer/Program.cs b/AssemblyServer/Program.cs
index 57107839..01f60a63 100644
--- a/AssemblyServer/Program.cs
+++ b/AssemblyServer/Program.cs
@@ -20,7 +20,7 @@
 namespace AssemblyServer_x86 {
 	class Program {
 		static int Main(string[] args) {
-			return AssemblyServer.Start.main(args);
+			return AssemblyServer.Start.Main2(args);
 		}
 	}
 }
diff --git a/blocks/Block.cs b/blocks/Block.cs
index 24eb9f93..7abf41f9 100644
--- a/blocks/Block.cs
+++ b/blocks/Block.cs
@@ -52,7 +52,7 @@ namespace de4dot.blocks {
 		public Instr FirstInstr {
 			get {
 				if (instructions.Count == 0)
-					add(new Instr(OpCodes.Nop.ToInstruction()));
+					Add(new Instr(OpCodes.Nop.ToInstruction()));
 				return instructions[0];
 			}
 		}
@@ -60,16 +60,16 @@ namespace de4dot.blocks {
 		public Instr LastInstr {
 			get {
 				if (instructions.Count == 0)
-					add(new Instr(OpCodes.Nop.ToInstruction()));
+					Add(new Instr(OpCodes.Nop.ToInstruction()));
 				return instructions[instructions.Count - 1];
 			}
 		}
 
-		public void add(Instr instr) {
+		public void Add(Instr instr) {
 			instructions.Add(instr);
 		}
 
-		public void insert(int index, Instruction instr) {
+		public void Insert(int index, Instruction instr) {
 			instructions.Insert(index, new Instr(instr));
 		}
 
@@ -78,8 +78,8 @@ namespace de4dot.blocks {
 		}
 
 		// If last instr is a br/br.s, removes it and replaces it with a fall through
-		public void removeLastBr() {
-			if (!LastInstr.isBr())
+		public void RemoveLastBr() {
+			if (!LastInstr.IsBr())
 				return;
 
 			if (fallThrough != null || (LastInstr.Operand != null && (targets == null || targets.Count != 1)))
@@ -89,111 +89,111 @@ namespace de4dot.blocks {
 			instructions.RemoveAt(instructions.Count - 1);
 		}
 
-		public void replace(int index, int num, Instruction instruction) {
+		public void Replace(int index, int num, Instruction instruction) {
 			if (num <= 0)
 				throw new ArgumentOutOfRangeException("num");
-			remove(index, num);
+			Remove(index, num);
 			instructions.Insert(index, new Instr(instruction));
 		}
 
-		public void remove(int index, int num) {
+		public void Remove(int index, int num) {
 			if (index + num > instructions.Count)
 				throw new ApplicationException("Overflow");
-			if (num > 0 && index + num == instructions.Count && LastInstr.isConditionalBranch())
-				disconnectFromFallThroughAndTargets();
+			if (num > 0 && index + num == instructions.Count && LastInstr.IsConditionalBranch())
+				DisconnectFromFallThroughAndTargets();
 			instructions.RemoveRange(index, num);
 		}
 
-		public void remove(IEnumerable<int> indexes) {
-			var instrsToDelete = new List<int>(Utils.unique(indexes));
+		public void Remove(IEnumerable<int> indexes) {
+			var instrsToDelete = new List<int>(Utils.Unique(indexes));
 			instrsToDelete.Sort();
 			instrsToDelete.Reverse();
 			foreach (var index in instrsToDelete)
-				remove(index, 1);
+				Remove(index, 1);
 		}
 
 		// Replace the last instructions with a branch to target
-		public void replaceLastInstrsWithBranch(int numInstrs, Block target) {
+		public void ReplaceLastInstrsWithBranch(int numInstrs, Block target) {
 			if (numInstrs < 0 || numInstrs > instructions.Count)
 				throw new ApplicationException("Invalid numInstrs to replace with branch");
 			if (target == null)
 				throw new ApplicationException("Invalid new target, it's null");
 
-			disconnectFromFallThroughAndTargets();
+			DisconnectFromFallThroughAndTargets();
 			if (numInstrs > 0)
 				instructions.RemoveRange(instructions.Count - numInstrs, numInstrs);
 			fallThrough = target;
 			target.sources.Add(this);
 		}
 
-		public void replaceLastNonBranchWithBranch(int numInstrs, Block target) {
-			if (LastInstr.isBr())
+		public void ReplaceLastNonBranchWithBranch(int numInstrs, Block target) {
+			if (LastInstr.IsBr())
 				numInstrs++;
-			replaceLastInstrsWithBranch(numInstrs, target);
+			ReplaceLastInstrsWithBranch(numInstrs, target);
 		}
 
-		public void replaceBccWithBranch(bool isTaken) {
+		public void ReplaceBccWithBranch(bool isTaken) {
 			Block target = isTaken ? targets[0] : fallThrough;
-			replaceLastInstrsWithBranch(1, target);
+			ReplaceLastInstrsWithBranch(1, target);
 		}
 
-		public void replaceSwitchWithBranch(Block target) {
+		public void ReplaceSwitchWithBranch(Block target) {
 			if (LastInstr.OpCode.Code != Code.Switch)
 				throw new ApplicationException("Last instruction is not a switch");
-			replaceLastInstrsWithBranch(1, target);
+			ReplaceLastInstrsWithBranch(1, target);
 		}
 
-		public void setNewFallThrough(Block newFallThrough) {
-			disconnectFromFallThrough();
+		public void SetNewFallThrough(Block newFallThrough) {
+			DisconnectFromFallThrough();
 			fallThrough = newFallThrough;
 			newFallThrough.sources.Add(this);
 		}
 
-		public void setNewTarget(int index, Block newTarget) {
-			disconnectFromBlock(targets[index]);
+		public void SetNewTarget(int index, Block newTarget) {
+			DisconnectFromBlock(targets[index]);
 			targets[index] = newTarget;
 			newTarget.sources.Add(this);
 		}
 
-		public void removeDeadBlock() {
+		public void RemoveDeadBlock() {
 			if (sources.Count != 0)
 				throw new ApplicationException("Trying to remove a non-dead block");
-			removeGuaranteedDeadBlock();
+			RemoveGuaranteedDeadBlock();
 		}
 
 		// Removes a block that has been guaranteed to be dead. This method won't verify
 		// that it really is dead.
-		public void removeGuaranteedDeadBlock() {
-			disconnectFromFallThroughAndTargets();
+		public void RemoveGuaranteedDeadBlock() {
+			DisconnectFromFallThroughAndTargets();
 			Parent = null;
 		}
 
-		void disconnectFromFallThroughAndTargets() {
-			disconnectFromFallThrough();
-			disconnectFromTargets();
+		void DisconnectFromFallThroughAndTargets() {
+			DisconnectFromFallThrough();
+			DisconnectFromTargets();
 		}
 
-		void disconnectFromFallThrough() {
+		void DisconnectFromFallThrough() {
 			if (fallThrough != null) {
-				disconnectFromBlock(fallThrough);
+				DisconnectFromBlock(fallThrough);
 				fallThrough = null;
 			}
 		}
 
-		void disconnectFromTargets() {
+		void DisconnectFromTargets() {
 			if (targets != null) {
 				foreach (var target in targets)
-					disconnectFromBlock(target);
+					DisconnectFromBlock(target);
 				targets = null;
 			}
 		}
 
-		void disconnectFromBlock(Block target) {
+		void DisconnectFromBlock(Block target) {
 			if (!target.sources.Remove(this))
 				throw new ApplicationException("Could not remove the block from its target block");
 		}
 
-		public int countTargets() {
+		public int CountTargets() {
 			int count = fallThrough != null ? 1 : 0;
 			if (targets != null)
 				count += targets.Count;
@@ -201,8 +201,8 @@ namespace de4dot.blocks {
 		}
 
 		// Returns the target iff it has only ONE target. Else it returns null.
-		public Block getOnlyTarget() {
-			if (countTargets() != 1)
+		public Block GetOnlyTarget() {
+			if (CountTargets() != 1)
 				return null;
 			if (fallThrough != null)
 				return fallThrough;
@@ -210,7 +210,7 @@ namespace de4dot.blocks {
 		}
 
 		// Returns all targets. FallThrough (if not null) is always returned first!
-		public IEnumerable<Block> getTargets() {
+		public IEnumerable<Block> GetTargets() {
 			if (fallThrough != null)
 				yield return fallThrough;
 			if (targets != null) {
@@ -220,52 +220,52 @@ namespace de4dot.blocks {
 		}
 
 		// Returns true iff other is the only block in Sources
-		public bool isOnlySource(Block other) {
+		public bool IsOnlySource(Block other) {
 			return sources.Count == 1 && sources[0] == other;
 		}
 
 		// Returns true if we can merge other with this
-		public bool canMerge(Block other) {
-			return canAppend(other) && other.isOnlySource(this);
+		public bool CanMerge(Block other) {
+			return CanAppend(other) && other.IsOnlySource(this);
 		}
 
 		// Merge two blocks into one
-		public void merge(Block other) {
-			if (!canMerge(other))
+		public void Merge(Block other) {
+			if (!CanMerge(other))
 				throw new ApplicationException("Can't merge the two blocks!");
-			append(other);
-			other.disconnectFromFallThroughAndTargets();
+			Append(other);
+			other.DisconnectFromFallThroughAndTargets();
 			other.Parent = null;
 		}
 
-		public bool canAppend(Block other) {
-			if (other == null || other == this || getOnlyTarget() != other)
+		public bool CanAppend(Block other) {
+			if (other == null || other == this || GetOnlyTarget() != other)
 				return false;
 			// If it's eg. a leave, then don't merge them since it clears the stack.
-			return LastInstr.isBr() || Instr.isFallThrough(LastInstr.OpCode);
+			return LastInstr.IsBr() || Instr.IsFallThrough(LastInstr.OpCode);
 		}
 
-		public void append(Block other) {
-			if (!canAppend(other))
+		public void Append(Block other) {
+			if (!CanAppend(other))
 				throw new ApplicationException("Can't append the block!");
 
-			removeLastBr();		// Get rid of last br/br.s if present
+			RemoveLastBr();		// Get rid of last br/br.s if present
 
 			var newInstructions = new List<Instr>(instructions.Count + other.instructions.Count);
-			addInstructions(newInstructions, instructions, false);
-			addInstructions(newInstructions, other.instructions, true);
+			AddInstructions(newInstructions, instructions, false);
+			AddInstructions(newInstructions, other.instructions, true);
 			instructions = newInstructions;
 
-			disconnectFromFallThroughAndTargets();
+			DisconnectFromFallThroughAndTargets();
 			if (other.targets != null)
 				targets = new List<Block>(other.targets);
 			else
 				targets = null;
 			fallThrough = other.fallThrough;
-			updateSources();
+			UpdateSources();
 		}
 
-		void addInstructions(IList<Instr> dest, IList<Instr> instrs, bool clone) {
+		void AddInstructions(IList<Instr> dest, IList<Instr> instrs, bool clone) {
 			for (int i = 0; i < instrs.Count; i++) {
 				var instr = instrs[i];
 				if (instr.OpCode != OpCodes.Nop)
@@ -275,7 +275,7 @@ namespace de4dot.blocks {
 
 		// Update each target's Sources property. Must only be called if this isn't in the
 		// Sources list!
-		public void updateSources() {
+		public void UpdateSources() {
 			if (fallThrough != null)
 				fallThrough.sources.Add(this);
 			if (targets != null) {
@@ -285,30 +285,30 @@ namespace de4dot.blocks {
 		}
 
 		// Returns true if it falls through
-		public bool isFallThrough() {
+		public bool IsFallThrough() {
 			return targets == null && fallThrough != null;
 		}
 
-		public bool canFlipConditionalBranch() {
-			return LastInstr.canFlipConditionalBranch();
+		public bool CanFlipConditionalBranch() {
+			return LastInstr.CanFlipConditionalBranch();
 		}
 
-		public void flipConditionalBranch() {
+		public void FlipConditionalBranch() {
 			if (fallThrough == null || targets == null || targets.Count != 1)
 				throw new ApplicationException("Invalid bcc block state");
-			LastInstr.flipConditonalBranch();
+			LastInstr.FlipConditonalBranch();
 			var oldFallThrough = fallThrough;
 			fallThrough = targets[0];
 			targets[0] = oldFallThrough;
 		}
 
 		// Returns true if it's a conditional branch
-		public bool isConditionalBranch() {
-			return LastInstr.isConditionalBranch();
+		public bool IsConditionalBranch() {
+			return LastInstr.IsConditionalBranch();
 		}
 
-		public bool isNopBlock() {
-			if (!isFallThrough())
+		public bool IsNopBlock() {
+			if (!IsFallThrough())
 				return false;
 			foreach (var instr in instructions) {
 				if (instr.OpCode.Code != Code.Nop)
diff --git a/blocks/Blocks.cs b/blocks/Blocks.cs
index 8c6fe2a6..bf555bd7 100644
--- a/blocks/Blocks.cs
+++ b/blocks/Blocks.cs
@@ -42,28 +42,28 @@ namespace de4dot.blocks {
 
 		public Blocks(MethodDef method) {
 			this.method = method;
-			updateBlocks();
+			UpdateBlocks();
 		}
 
-		public void updateBlocks() {
+		public void UpdateBlocks() {
 			var body = method.Body;
 			locals = body.Variables;
-			methodBlocks = new InstructionListParser(body.Instructions, body.ExceptionHandlers).parse();
+			methodBlocks = new InstructionListParser(body.Instructions, body.ExceptionHandlers).Parse();
 		}
 
-		IEnumerable<ScopeBlock> getAllScopeBlocks(ScopeBlock scopeBlock) {
+		IEnumerable<ScopeBlock> GetAllScopeBlocks(ScopeBlock scopeBlock) {
 			var list = new List<ScopeBlock>();
 			list.Add(scopeBlock);
-			list.AddRange(scopeBlock.getAllScopeBlocks());
+			list.AddRange(scopeBlock.GetAllScopeBlocks());
 			return list;
 		}
 
-		public int removeDeadBlocks() {
-			return new DeadBlocksRemover(methodBlocks).remove();
+		public int RemoveDeadBlocks() {
+			return new DeadBlocksRemover(methodBlocks).Remove();
 		}
 
-		public void getCode(out IList<Instruction> allInstructions, out IList<ExceptionHandler> allExceptionHandlers) {
-			new CodeGenerator(methodBlocks).getCode(out allInstructions, out allExceptionHandlers);
+		public void GetCode(out IList<Instruction> allInstructions, out IList<ExceptionHandler> allExceptionHandlers) {
+			new CodeGenerator(methodBlocks).GetCode(out allInstructions, out allExceptionHandlers);
 		}
 
 		struct LocalVariableInfo {
@@ -75,12 +75,12 @@ namespace de4dot.blocks {
 			}
 		}
 
-		public int optimizeLocals() {
+		public int OptimizeLocals() {
 			if (locals.Count == 0)
 				return 0;
 
 			var usedLocals = new Dictionary<Local, List<LocalVariableInfo>>();
-			foreach (var block in methodBlocks.getAllBlocks()) {
+			foreach (var block in methodBlocks.GetAllBlocks()) {
 				for (int i = 0; i < block.Instructions.Count; i++) {
 					var instr = block.Instructions[i];
 					Local local;
@@ -97,7 +97,7 @@ namespace de4dot.blocks {
 					case Code.Stloc_1:
 					case Code.Stloc_2:
 					case Code.Stloc_3:
-						local = Instr.getLocalVar(locals, instr);
+						local = Instr.GetLocalVar(locals, instr);
 						break;
 
 					case Code.Ldloca_S:
@@ -129,7 +129,7 @@ namespace de4dot.blocks {
 				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));
+					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
@@ -162,7 +162,7 @@ namespace de4dot.blocks {
 			return numRemoved;
 		}
 
-		static Instruction optimizeLocalInstr(Instr instr, Local local, uint newIndex) {
+		static Instruction OptimizeLocalInstr(Instr instr, Local local, uint newIndex) {
 			switch (instr.OpCode.Code) {
 			case Code.Ldloc:
 			case Code.Ldloc_S:
@@ -211,11 +211,11 @@ namespace de4dot.blocks {
 			}
 		}
 
-		public void repartitionBlocks() {
-			mergeNopBlocks();
-			foreach (var scopeBlock in getAllScopeBlocks(methodBlocks)) {
+		public void RepartitionBlocks() {
+			MergeNopBlocks();
+			foreach (var scopeBlock in GetAllScopeBlocks(methodBlocks)) {
 				try {
-					scopeBlock.repartitionBlocks();
+					scopeBlock.RepartitionBlocks();
 				}
 				catch (NullReferenceException) {
 					//TODO: Send this message to the log
@@ -225,12 +225,12 @@ namespace de4dot.blocks {
 			}
 		}
 
-		void mergeNopBlocks() {
-			var allBlocks = methodBlocks.getAllBlocks();
+		void MergeNopBlocks() {
+			var allBlocks = methodBlocks.GetAllBlocks();
 
 			var nopBlocks = new Dictionary<Block, bool>();
 			foreach (var nopBlock in allBlocks) {
-				if (nopBlock.isNopBlock())
+				if (nopBlock.IsNopBlock())
 					nopBlocks[nopBlock] = true;
 			}
 
@@ -243,18 +243,18 @@ namespace de4dot.blocks {
 				foreach (var block in allBlocks) {
 					Block nopBlockTarget;
 
-					nopBlockTarget = getNopBlockTarget(nopBlocks, block, block.FallThrough);
+					nopBlockTarget = GetNopBlockTarget(nopBlocks, block, block.FallThrough);
 					if (nopBlockTarget != null) {
-						block.setNewFallThrough(nopBlockTarget);
+						block.SetNewFallThrough(nopBlockTarget);
 						changed = true;
 					}
 
 					if (block.Targets != null) {
 						for (int targetIndex = 0; targetIndex < block.Targets.Count; targetIndex++) {
-							nopBlockTarget = getNopBlockTarget(nopBlocks, block, block.Targets[targetIndex]);
+							nopBlockTarget = GetNopBlockTarget(nopBlocks, block, block.Targets[targetIndex]);
 							if (nopBlockTarget == null)
 								continue;
-							block.setNewTarget(targetIndex, nopBlockTarget);
+							block.SetNewTarget(targetIndex, nopBlockTarget);
 							changed = true;
 						}
 					}
@@ -265,10 +265,10 @@ namespace de4dot.blocks {
 			}
 
 			foreach (var nopBlock in nopBlocks.Keys)
-				nopBlock.Parent.removeDeadBlock(nopBlock);
+				nopBlock.Parent.RemoveDeadBlock(nopBlock);
 		}
 
-		static Block getNopBlockTarget(Dictionary<Block, bool> nopBlocks, Block source, Block nopBlock) {
+		static Block GetNopBlockTarget(Dictionary<Block, bool> nopBlocks, Block source, Block nopBlock) {
 			if (nopBlock == null || !nopBlocks.ContainsKey(nopBlock) || source == nopBlock.FallThrough)
 				return null;
 			if (nopBlock.Parent.BaseBlocks[0] == nopBlock)
diff --git a/blocks/BlocksSorter.cs b/blocks/BlocksSorter.cs
index 14c113f9..2bf6aec2 100644
--- a/blocks/BlocksSorter.cs
+++ b/blocks/BlocksSorter.cs
@@ -34,7 +34,7 @@ namespace de4dot.blocks {
 				this.baseBlock = baseBlock;
 			}
 
-			public bool visited() {
+			public bool Visited() {
 				return dfsNumber >= 0;
 			}
 
@@ -62,7 +62,7 @@ namespace de4dot.blocks {
 				this.skipFirstBlock = skipFirstBlock;
 			}
 
-			public List<BaseBlock> sort() {
+			public List<BaseBlock> Sort() {
 				if (validBlocks.Count == 0)
 					return new List<BaseBlock>();
 				if (skipFirstBlock)
@@ -77,14 +77,14 @@ namespace de4dot.blocks {
 				var finalList = new List<BaseBlock>(validBlocks.Count);
 
 				if (firstBlock is Block) {
-					foreach (var target in getTargets(firstBlock)) {
-						visit(target);
+					foreach (var target in GetTargets(firstBlock)) {
+						Visit(target);
 						finalList.AddRange(sorted);
 						sorted.Clear();
 					}
 				}
 				foreach (var bb in validBlocks) {
-					visit(bb);
+					Visit(bb);
 					finalList.AddRange(sorted);
 					sorted.Clear();
 				}
@@ -103,19 +103,19 @@ namespace de4dot.blocks {
 				return finalList;
 			}
 
-			void visit(BaseBlock bb) {
-				var info = getInfo(bb);
+			void Visit(BaseBlock bb) {
+				var info = GetInfo(bb);
 				if (info == null)
 					return;
 				if (info.baseBlock == firstBlock)
 					return;
-				if (info.visited())
+				if (info.Visited())
 					return;
-				visit(info);
+				Visit(info);
 			}
 
-			BlockInfo getInfo(BaseBlock baseBlock) {
-				baseBlock = scopeBlock.toChild(baseBlock);
+			BlockInfo GetInfo(BaseBlock baseBlock) {
+				baseBlock = scopeBlock.ToChild(baseBlock);
 				if (baseBlock == null)
 					return null;
 				BlockInfo info;
@@ -123,54 +123,54 @@ namespace de4dot.blocks {
 				return info;
 			}
 
-			List<BaseBlock> getTargets(BaseBlock baseBlock) {
+			List<BaseBlock> GetTargets(BaseBlock baseBlock) {
 				var list = new List<BaseBlock>();
 
 				if (baseBlock is Block) {
 					var block = (Block)baseBlock;
-					addTargets(list, block.getTargets());
+					AddTargets(list, block.GetTargets());
 				}
 				else if (baseBlock is TryBlock)
-					addTargets(list, (TryBlock)baseBlock);
+					AddTargets(list, (TryBlock)baseBlock);
 				else if (baseBlock is TryHandlerBlock)
-					addTargets(list, (TryHandlerBlock)baseBlock);
+					AddTargets(list, (TryHandlerBlock)baseBlock);
 				else
-					addTargets(list, (ScopeBlock)baseBlock);
+					AddTargets(list, (ScopeBlock)baseBlock);
 
 				return list;
 			}
 
-			void addTargets(List<BaseBlock> dest, TryBlock tryBlock) {
-				addTargets(dest, (ScopeBlock)tryBlock);
+			void AddTargets(List<BaseBlock> dest, TryBlock tryBlock) {
+				AddTargets(dest, (ScopeBlock)tryBlock);
 				foreach (var tryHandlerBlock in tryBlock.TryHandlerBlocks) {
 					dest.Add(tryHandlerBlock);
-					addTargets(dest, tryHandlerBlock);
+					AddTargets(dest, tryHandlerBlock);
 				}
 			}
 
-			void addTargets(List<BaseBlock> dest, TryHandlerBlock tryHandlerBlock) {
-				addTargets(dest, (ScopeBlock)tryHandlerBlock);
+			void AddTargets(List<BaseBlock> dest, TryHandlerBlock tryHandlerBlock) {
+				AddTargets(dest, (ScopeBlock)tryHandlerBlock);
 
 				dest.Add(tryHandlerBlock.FilterHandlerBlock);
-				addTargets(dest, tryHandlerBlock.FilterHandlerBlock);
+				AddTargets(dest, tryHandlerBlock.FilterHandlerBlock);
 
 				dest.Add(tryHandlerBlock.HandlerBlock);
-				addTargets(dest, tryHandlerBlock.HandlerBlock);
+				AddTargets(dest, tryHandlerBlock.HandlerBlock);
 			}
 
-			void addTargets(List<BaseBlock> dest, ScopeBlock scopeBlock) {
-				foreach (var block in scopeBlock.getAllBlocks())
-					addTargets(dest, block.getTargets());
+			void AddTargets(List<BaseBlock> dest, ScopeBlock scopeBlock) {
+				foreach (var block in scopeBlock.GetAllBlocks())
+					AddTargets(dest, block.GetTargets());
 			}
 
-			void addTargets(List<BaseBlock> dest, IEnumerable<Block> source) {
+			void AddTargets(List<BaseBlock> dest, IEnumerable<Block> source) {
 				var list = new List<Block>(source);
 				list.Reverse();
 				foreach (var block in list)
 					dest.Add(block);
 			}
 
-			void visit(BlockInfo info) {
+			void Visit(BlockInfo info) {
 				if (info.baseBlock == firstBlock)
 					throw new ApplicationException("Can't visit firstBlock");
 				stack.Push(info);
@@ -179,15 +179,15 @@ namespace de4dot.blocks {
 				info.low = dfsNumber;
 				dfsNumber++;
 
-				foreach (var tmp in getTargets(info.baseBlock)) {
-					var targetInfo = getInfo(tmp);
+				foreach (var tmp in GetTargets(info.baseBlock)) {
+					var targetInfo = GetInfo(tmp);
 					if (targetInfo == null)
 						continue;
 					if (targetInfo.baseBlock == firstBlock)
 						continue;
 
-					if (!targetInfo.visited()) {
-						visit(targetInfo);
+					if (!targetInfo.Visited()) {
+						Visit(targetInfo);
 						info.low = Math.Min(info.low, targetInfo.low);
 					}
 					else if (targetInfo.onStack)
@@ -206,8 +206,8 @@ namespace de4dot.blocks {
 				}
 				if (sccBlocks.Count > 1) {
 					sccBlocks.Reverse();
-					var result = new Sorter(scopeBlock, sccBlocks, true).sort();
-					sortLoopBlock(result);
+					var result = new Sorter(scopeBlock, sccBlocks, true).Sort();
+					SortLoopBlock(result);
 					sorted.InsertRange(0, result);
 				}
 				else {
@@ -215,12 +215,12 @@ namespace de4dot.blocks {
 				}
 			}
 
-			void sortLoopBlock(List<BaseBlock> list) {
+			void SortLoopBlock(List<BaseBlock> list) {
 				// Some popular decompilers sometimes produce bad output unless the loop condition
 				// checker block is at the end of the loop. Eg., they may use a while loop when
 				// it's really a for/foreach loop.
 
-				var loopStart = getLoopStartBlock(list);
+				var loopStart = GetLoopStartBlock(list);
 				if (loopStart == null)
 					return;
 
@@ -229,7 +229,7 @@ namespace de4dot.blocks {
 				list.Add(loopStart);
 			}
 
-			Block getLoopStartBlock(List<BaseBlock> list) {
+			Block GetLoopStartBlock(List<BaseBlock> list) {
 				var loopBlocks = new Dictionary<Block, bool>(list.Count);
 				foreach (var bb in list) {
 					var block = bb as Block;
@@ -268,9 +268,9 @@ namespace de4dot.blocks {
 			this.scopeBlock = scopeBlock;
 		}
 
-		public List<BaseBlock> sort() {
-			var sorted = new Sorter(scopeBlock, scopeBlock.BaseBlocks, false).sort();
-			return new ForwardScanOrder(scopeBlock, sorted).fix();
+		public List<BaseBlock> Sort() {
+			var sorted = new Sorter(scopeBlock, scopeBlock.BaseBlocks, false).Sort();
+			return new ForwardScanOrder(scopeBlock, sorted).Fix();
 		}
 	}
 }
diff --git a/blocks/CodeGenerator.cs b/blocks/CodeGenerator.cs
index 7dbba879..09a822b4 100644
--- a/blocks/CodeGenerator.cs
+++ b/blocks/CodeGenerator.cs
@@ -67,11 +67,11 @@ namespace de4dot.blocks {
 			this.methodBlocks = methodBlocks;
 		}
 
-		public void getCode(out IList<Instruction> allInstructions, out IList<ExceptionHandler> allExceptionHandlers) {
-			fixEmptyBlocks();
-			layOutBlocks();
-			sortExceptions();
-			layOutInstructions(out allInstructions, out allExceptionHandlers);
+		public void GetCode(out IList<Instruction> allInstructions, out IList<ExceptionHandler> allExceptionHandlers) {
+			FixEmptyBlocks();
+			LayOutBlocks();
+			SortExceptions();
+			LayOutInstructions(out allInstructions, out allExceptionHandlers);
 
 			allInstructions.SimplifyBranches();
 			allInstructions.OptimizeBranches();
@@ -87,7 +87,7 @@ namespace de4dot.blocks {
 			}
 		}
 
-		void layOutInstructions(out IList<Instruction> allInstructions, out IList<ExceptionHandler> allExceptionHandlers) {
+		void LayOutInstructions(out IList<Instruction> allInstructions, out IList<ExceptionHandler> allExceptionHandlers) {
 			allInstructions = new List<Instruction>();
 			allExceptionHandlers = new List<ExceptionHandler>();
 
@@ -103,20 +103,20 @@ namespace de4dot.blocks {
 					var targets = new List<Instr>();
 					foreach (var target in block.Targets)
 						targets.Add(target.FirstInstr);
-					block.LastInstr.updateTargets(targets);
+					block.LastInstr.UpdateTargets(targets);
 				}
 				allInstructions.Add(block.LastInstr.Instruction);
 
 				var next = i + 1 < blocks.Count ? blocks[i + 1] : null;
 
 				// If eg. ble next, then change it to bgt XYZ and fall through to next.
-				if (block.Targets != null && block.canFlipConditionalBranch() && block.Targets[0] == next) {
-					block.flipConditionalBranch();
-					block.LastInstr.updateTargets(new List<Instr> { block.Targets[0].FirstInstr });
+				if (block.Targets != null && block.CanFlipConditionalBranch() && block.Targets[0] == next) {
+					block.FlipConditionalBranch();
+					block.LastInstr.UpdateTargets(new List<Instr> { block.Targets[0].FirstInstr });
 				}
 				else if (block.FallThrough != null && block.FallThrough != next) {
 					var instr = new Instr(OpCodes.Br.ToInstruction(block.FallThrough.FirstInstr.Instruction));
-					instr.updateTargets(new List<Instr> { block.FallThrough.FirstInstr });
+					instr.UpdateTargets(new List<Instr> { block.FallThrough.FirstInstr });
 					allInstructions.Add(instr.Instruction);
 				}
 
@@ -126,25 +126,25 @@ namespace de4dot.blocks {
 			}
 
 			foreach (var ex in exceptions) {
-				var tryStart = getBlockInfo(blockInfos, ex.tryStart).start;
-				var tryEnd = getBlockInfo(blockInfos, ex.tryEnd).end;
-				var filterStart = ex.filterStart == -1 ? -1 : getBlockInfo(blockInfos, ex.filterStart).start;
-				var handlerStart = getBlockInfo(blockInfos, ex.handlerStart).start;
-				var handlerEnd = getBlockInfo(blockInfos, ex.handlerEnd).end;
+				var tryStart = GetBlockInfo(blockInfos, ex.tryStart).start;
+				var tryEnd = GetBlockInfo(blockInfos, ex.tryEnd).end;
+				var filterStart = ex.filterStart == -1 ? -1 : GetBlockInfo(blockInfos, ex.filterStart).start;
+				var handlerStart = GetBlockInfo(blockInfos, ex.handlerStart).start;
+				var handlerEnd = GetBlockInfo(blockInfos, ex.handlerEnd).end;
 
 				var eh = new ExceptionHandler(ex.handlerType);
 				eh.CatchType = ex.catchType;
-				eh.TryStart = getInstruction(allInstructions, tryStart);
-				eh.TryEnd = getInstruction(allInstructions, tryEnd + 1);
-				eh.FilterStart = filterStart == -1 ? null : getInstruction(allInstructions, filterStart);
-				eh.HandlerStart = getInstruction(allInstructions, handlerStart);
-				eh.HandlerEnd = getInstruction(allInstructions, handlerEnd + 1);
+				eh.TryStart = GetInstruction(allInstructions, tryStart);
+				eh.TryEnd = GetInstruction(allInstructions, tryEnd + 1);
+				eh.FilterStart = filterStart == -1 ? null : GetInstruction(allInstructions, filterStart);
+				eh.HandlerStart = GetInstruction(allInstructions, handlerStart);
+				eh.HandlerEnd = GetInstruction(allInstructions, handlerEnd + 1);
 
 				allExceptionHandlers.Add(eh);
 			}
 		}
 
-		static BlockInfo getBlockInfo(List<BlockInfo> blockInfos, int index) {
+		static BlockInfo GetBlockInfo(List<BlockInfo> blockInfos, int index) {
 			if (index >= blockInfos.Count)
 				index = blockInfos.Count - 1;
 			if (index < 0)
@@ -152,13 +152,13 @@ namespace de4dot.blocks {
 			return blockInfos[index];
 		}
 
-		static Instruction getInstruction(IList<Instruction> allInstructions, int i) {
+		static Instruction GetInstruction(IList<Instruction> allInstructions, int i) {
 			if (i < allInstructions.Count)
 				return allInstructions[i];
 			return null;
 		}
 
-		void sortExceptions() {
+		void SortExceptions() {
 			exceptions.Sort((a, b) => {
 				// Make sure nested try blocks are sorted before the outer try block.
 				if (a.tryStart > b.tryStart) return -1;	// a could be nested, but b is not
@@ -184,8 +184,8 @@ namespace de4dot.blocks {
 			});
 		}
 
-		void fixEmptyBlocks() {
-			foreach (var block in methodBlocks.getAllBlocks()) {
+		void FixEmptyBlocks() {
+			foreach (var block in methodBlocks.GetAllBlocks()) {
 				if (block.Instructions.Count == 0) {
 					block.Instructions.Add(new Instr(OpCodes.Nop.ToInstruction()));
 				}
@@ -193,12 +193,12 @@ namespace de4dot.blocks {
 		}
 
 		// Write all blocks to the blocks list
-		void layOutBlocks() {
+		void LayOutBlocks() {
 			if (methodBlocks.BaseBlocks.Count == 0)
 				return;
 
 			stateStack.Push(new BlockState(methodBlocks));
-			processBaseBlocks(methodBlocks.BaseBlocks, (block) => {
+			ProcessBaseBlocks(methodBlocks.BaseBlocks, (block) => {
 				return block.LastInstr.OpCode == OpCodes.Ret;
 			});
 
@@ -212,7 +212,7 @@ namespace de4dot.blocks {
 			}
 		}
 
-		void processBaseBlocks(List<BaseBlock> lb, Func<Block, bool> placeLast) {
+		void ProcessBaseBlocks(List<BaseBlock> lb, Func<Block, bool> placeLast) {
 			var bbs = new List<BaseBlock>();
 			int lastIndex = -1;
 			for (int i = 0; i < lb.Count; i++) {
@@ -228,22 +228,22 @@ namespace de4dot.blocks {
 				bbs.Add(block);
 			}
 			foreach (var bb in bbs)
-				doBaseBlock(bb);
+				DoBaseBlock(bb);
 		}
 
 		// Returns the BaseBlock's ScopeBlock. The return value is either current ScopeBlock,
 		// the ScopeBlock one step below current (current one's child), or null.
-		ScopeBlock getScopeBlock(BaseBlock bb) {
+		ScopeBlock GetScopeBlock(BaseBlock bb) {
 			BlockState current = stateStack.Peek();
 
-			if (current.scopeBlock.isOurBaseBlock(bb))
+			if (current.scopeBlock.IsOurBaseBlock(bb))
 				return current.scopeBlock;
-			return (ScopeBlock)current.scopeBlock.toChild(bb);
+			return (ScopeBlock)current.scopeBlock.ToChild(bb);
 		}
 
-		void doBaseBlock(BaseBlock bb) {
+		void DoBaseBlock(BaseBlock bb) {
 			BlockState current = stateStack.Peek();
-			ScopeBlock newOne = getScopeBlock(bb);
+			ScopeBlock newOne = GetScopeBlock(bb);
 			if (newOne == null)
 				return;		// Not a BaseBlock somewhere inside this ScopeBlock
 			if (newOne != current.scopeBlock)
@@ -257,13 +257,13 @@ namespace de4dot.blocks {
 			visited[bb] = true;
 
 			if (bb is Block)
-				doBlock(bb as Block);
+				DoBlock(bb as Block);
 			else if (bb is TryBlock)
-				doTryBlock(bb as TryBlock);
+				DoTryBlock(bb as TryBlock);
 			else if (bb is FilterHandlerBlock)
-				doFilterHandlerBlock(bb as FilterHandlerBlock);
+				DoFilterHandlerBlock(bb as FilterHandlerBlock);
 			else if (bb is HandlerBlock)
-				doHandlerBlock(bb as HandlerBlock);
+				DoHandlerBlock(bb as HandlerBlock);
 			else if (bb is TryHandlerBlock) {
 				// The try handler block is usually after the try block, but sometimes it isn't...
 				// Handle that case here.
@@ -274,14 +274,14 @@ namespace de4dot.blocks {
 				throw new ApplicationException("Invalid block found");
 		}
 
-		void doBlock(Block block) {
+		void DoBlock(Block block) {
 			blocks.Add(block);
 		}
 
-		void doTryBlock(TryBlock tryBlock) {
+		void DoTryBlock(TryBlock tryBlock) {
 			var tryStart = blocks.Count;
 			stateStack.Push(new BlockState(tryBlock));
-			processBaseBlocks(tryBlock.BaseBlocks, (block) => {
+			ProcessBaseBlocks(tryBlock.BaseBlocks, (block) => {
 				return block.LastInstr.OpCode == OpCodes.Leave ||
 						block.LastInstr.OpCode == OpCodes.Leave_S;
 			});
@@ -298,10 +298,10 @@ namespace de4dot.blocks {
 
 				var filterStart = blocks.Count;
 				if (handlerBlock.FilterHandlerBlock.BaseBlocks != null)
-					doBaseBlock(handlerBlock.FilterHandlerBlock);
+					DoBaseBlock(handlerBlock.FilterHandlerBlock);
 
 				var handlerStart = blocks.Count;
-				doBaseBlock(handlerBlock.HandlerBlock);
+				DoBaseBlock(handlerBlock.HandlerBlock);
 				var handlerEnd = blocks.Count - 1;
 
 				exceptions.Add(new ExceptionInfo(tryStart, tryEnd, filterStart, handlerStart, handlerEnd, handlerBlock.CatchType, handlerBlock.HandlerType));
@@ -310,17 +310,17 @@ namespace de4dot.blocks {
 			}
 		}
 
-		void doFilterHandlerBlock(FilterHandlerBlock filterHandlerBlock) {
+		void DoFilterHandlerBlock(FilterHandlerBlock filterHandlerBlock) {
 			stateStack.Push(new BlockState(filterHandlerBlock));
-			processBaseBlocks(filterHandlerBlock.BaseBlocks, (block) => {
+			ProcessBaseBlocks(filterHandlerBlock.BaseBlocks, (block) => {
 				return block.LastInstr.OpCode == OpCodes.Endfilter;	// MUST end with endfilter!
 			});
 			stateStack.Pop();
 		}
 
-		void doHandlerBlock(HandlerBlock handlerBlock) {
+		void DoHandlerBlock(HandlerBlock handlerBlock) {
 			stateStack.Push(new BlockState(handlerBlock));
-			processBaseBlocks(handlerBlock.BaseBlocks, (block) => {
+			ProcessBaseBlocks(handlerBlock.BaseBlocks, (block) => {
 				return block.LastInstr.OpCode == OpCodes.Endfinally ||
 						block.LastInstr.OpCode == OpCodes.Leave ||
 						block.LastInstr.OpCode == OpCodes.Leave_S;
diff --git a/blocks/DeadBlocksRemover.cs b/blocks/DeadBlocksRemover.cs
index f4034b09..b89836b4 100644
--- a/blocks/DeadBlocksRemover.cs
+++ b/blocks/DeadBlocksRemover.cs
@@ -32,10 +32,10 @@ namespace de4dot.blocks {
 			this.methodBlocks = methodBlocks;
 		}
 
-		public int remove() {
-			addScopeBlock(methodBlocks);
-			processAll();
-			return removeDeadBlocks();
+		public int Remove() {
+			AddScopeBlock(methodBlocks);
+			ProcessAll();
+			return RemoveDeadBlocks();
 		}
 
 		class ScopeBlockInfo {
@@ -46,12 +46,12 @@ namespace de4dot.blocks {
 			}
 		}
 
-		int removeDeadBlocks() {
+		int RemoveDeadBlocks() {
 			int numDeadBlocks = 0;
 
 			var infos = new Dictionary<ScopeBlock, ScopeBlockInfo>();
 			var deadBlocksDict = new Dictionary<BaseBlock, bool>();
-			foreach (var baseBlock in findDeadBlocks()) {
+			foreach (var baseBlock in FindDeadBlocks()) {
 				deadBlocksDict[baseBlock] = true;
 				ScopeBlock parent = baseBlock.Parent;
 				ScopeBlockInfo info;
@@ -62,15 +62,15 @@ namespace de4dot.blocks {
 			}
 
 			foreach (var info in infos.Values)
-				info.scopeBlock.removeAllDeadBlocks(info.deadBlocks, deadBlocksDict);
+				info.scopeBlock.RemoveAllDeadBlocks(info.deadBlocks, deadBlocksDict);
 
 			return numDeadBlocks;
 		}
 
-		IList<BaseBlock> findDeadBlocks() {
+		IList<BaseBlock> FindDeadBlocks() {
 			var deadBlocks = new List<BaseBlock>();
 
-			foreach (var bb in methodBlocks.getAllBaseBlocks()) {
+			foreach (var bb in methodBlocks.GetAllBaseBlocks()) {
 				if (!checkedBaseBlocks.ContainsKey(bb))
 					deadBlocks.Add(bb);
 			}
@@ -78,66 +78,66 @@ namespace de4dot.blocks {
 			return deadBlocks;
 		}
 
-		void addScopeBlock(ScopeBlock scopeBlock) {
+		void AddScopeBlock(ScopeBlock scopeBlock) {
 			scopeBlocksToCheck.Push(scopeBlock);
 		}
 
-		void processAll() {
+		void ProcessAll() {
 			bool didSomething;
 			do {
 				didSomething = false;
 				while (baseBlocksToCheck.Count > 0) {
-					processBaseBlock(baseBlocksToCheck.Pop());
+					ProcessBaseBlock(baseBlocksToCheck.Pop());
 					didSomething = true;
 				}
 				while (scopeBlocksToCheck.Count > 0) {
-					processScopeBlock(scopeBlocksToCheck.Pop());
+					ProcessScopeBlock(scopeBlocksToCheck.Pop());
 					didSomething = true;
 				}
 			} while (didSomething);
 		}
 
-		void processBaseBlock(BaseBlock baseBlock) {
+		void ProcessBaseBlock(BaseBlock baseBlock) {
 			if (baseBlock == null || checkedBaseBlocks.ContainsKey(baseBlock))
 				return;
 			checkedBaseBlocks[baseBlock] = true;
 
 			if (baseBlock is Block) {
 				var block = (Block)baseBlock;
-				foreach (var block2 in block.getTargets())
-					addBaseBlock(block2);
+				foreach (var block2 in block.GetTargets())
+					AddBaseBlock(block2);
 			}
 			else if (baseBlock is ScopeBlock) {
 				var scopeBlock = (ScopeBlock)baseBlock;
-				addScopeBlock(scopeBlock);
+				AddScopeBlock(scopeBlock);
 				if (scopeBlock.BaseBlocks != null && scopeBlock.BaseBlocks.Count > 0)
-					addBaseBlock(scopeBlock.BaseBlocks[0]);
+					AddBaseBlock(scopeBlock.BaseBlocks[0]);
 			}
 			else
 				throw new ApplicationException(string.Format("Unknown BaseBlock type {0}", baseBlock.GetType()));
 		}
 
 		// Add a block to be processed later, including all its enclosing ScopeBlocks.
-		void addBaseBlock(BaseBlock baseBlock) {
+		void AddBaseBlock(BaseBlock baseBlock) {
 			for (BaseBlock bb = baseBlock; bb != null; bb = bb.Parent)
 				baseBlocksToCheck.Push(bb);
 		}
 
-		void processScopeBlock(ScopeBlock scopeBlock) {
+		void ProcessScopeBlock(ScopeBlock scopeBlock) {
 			if (scopeBlock == null || checkedScopeBlocks.ContainsKey(scopeBlock))
 				return;
 			checkedScopeBlocks[scopeBlock] = true;
-			addBaseBlock(scopeBlock);
+			AddBaseBlock(scopeBlock);
 
 			if (scopeBlock is TryBlock) {
 				var tryBlock = (TryBlock)scopeBlock;
 				foreach (var handler in tryBlock.TryHandlerBlocks)
-					addScopeBlock(handler);
+					AddScopeBlock(handler);
 			}
 			else if (scopeBlock is TryHandlerBlock) {
 				var tryHandlerBlock = (TryHandlerBlock)scopeBlock;
-				addScopeBlock(tryHandlerBlock.FilterHandlerBlock);
-				addScopeBlock(tryHandlerBlock.HandlerBlock);
+				AddScopeBlock(tryHandlerBlock.FilterHandlerBlock);
+				AddScopeBlock(tryHandlerBlock.HandlerBlock);
 			}
 		}
 	}
diff --git a/blocks/DotNetUtils.cs b/blocks/DotNetUtils.cs
index 44ad66ea..55ba7276 100644
--- a/blocks/DotNetUtils.cs
+++ b/blocks/DotNetUtils.cs
@@ -35,18 +35,18 @@ namespace de4dot.blocks {
 	public class CallCounter {
 		Dictionary<IMethod, int> calls = new Dictionary<IMethod, int>(MethodEqualityComparer.CompareDeclaringTypes);
 
-		public void add(IMethod calledMethod) {
+		public void Add(IMethod calledMethod) {
 			int count;
 			calls.TryGetValue(calledMethod, out count);
 			calls[calledMethod] = count + 1;
 		}
 
-		public IMethod most() {
+		public IMethod Most() {
 			int numCalls;
-			return most(out numCalls);
+			return Most(out numCalls);
 		}
 
-		public IMethod most(out int numCalls) {
+		public IMethod Most(out int numCalls) {
 			IMethod method = null;
 			int callCount = 0;
 			foreach (var key in calls.Keys) {
@@ -61,15 +61,15 @@ namespace de4dot.blocks {
 	}
 
 	public static class DotNetUtils {
-		public static TypeDef getModuleType(ModuleDef module) {
+		public static TypeDef GetModuleType(ModuleDef module) {
 			return module.GlobalType;
 		}
 
-		public static MethodDef getModuleTypeCctor(ModuleDef module) {
+		public static MethodDef GetModuleTypeCctor(ModuleDef module) {
 			return module.GlobalType.FindStaticConstructor();
 		}
 
-		public static bool isEmpty(MethodDef method) {
+		public static bool IsEmpty(MethodDef method) {
 			if (method.Body == null)
 				return false;
 			foreach (var instr in method.Body.Instructions) {
@@ -80,18 +80,18 @@ namespace de4dot.blocks {
 			return true;
 		}
 
-		public static bool isEmptyObfuscated(MethodDef method) {
+		public static bool IsEmptyObfuscated(MethodDef method) {
 			if (method.Body == null)
 				return false;
 			int index = 0;
-			var instr = getInstruction(method.Body.Instructions, ref index);
+			var instr = GetInstruction(method.Body.Instructions, ref index);
 			if (instr == null || instr.OpCode.Code != Code.Ret)
 				return false;
 
 			return true;
 		}
 
-		public static FieldDef findFieldType(TypeDef typeDef, string typeName, bool isStatic) {
+		public static FieldDef FindFieldType(TypeDef typeDef, string typeName, bool isStatic) {
 			if (typeDef == null)
 				return null;
 			foreach (var field in typeDef.Fields) {
@@ -101,11 +101,11 @@ namespace de4dot.blocks {
 			return null;
 		}
 
-		public static IEnumerable<MethodDef> findMethods(IEnumerable<MethodDef> methods, string returnType, string[] argsTypes) {
-			return findMethods(methods, returnType, argsTypes, true);
+		public static IEnumerable<MethodDef> FindMethods(IEnumerable<MethodDef> methods, string returnType, string[] argsTypes) {
+			return FindMethods(methods, returnType, argsTypes, true);
 		}
 
-		public static IEnumerable<MethodDef> findMethods(IEnumerable<MethodDef> 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) {
 				var sig = method.MethodSig;
 				if (sig == null || !method.HasBody || !sig.IsDefault)
@@ -125,32 +125,32 @@ namespace de4dot.blocks {
 			}
 		}
 
-		public static bool isDelegate(IType type) {
+		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(TypeDef type) {
-			return type != null && isDelegate(type.BaseType);
+		public static bool DerivesFromDelegate(TypeDef type) {
+			return type != null && IsDelegate(type.BaseType);
 		}
 
-		public static bool isMethod(IMethod method, string returnType, string parameters) {
+		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) {
+		public static string GetDllName(string dll) {
 			if (dll.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
 				return dll.Substring(0, dll.Length - 4);
 			return dll;
 		}
 
-		public static bool hasPinvokeMethod(TypeDef type, string methodName) {
-			return getPInvokeMethod(type, methodName) != null;
+		public static bool HasPinvokeMethod(TypeDef type, string methodName) {
+			return GetPInvokeMethod(type, methodName) != null;
 		}
 
-		public static MethodDef getPInvokeMethod(TypeDef type, string methodName) {
+		public static MethodDef GetPInvokeMethod(TypeDef type, string methodName) {
 			if (type == null)
 				return null;
 			UTF8String mname = methodName;
@@ -163,69 +163,69 @@ namespace de4dot.blocks {
 			return null;
 		}
 
-		public static MethodDef getPInvokeMethod(TypeDef type, string dll, string funcName) {
+		public static MethodDef GetPInvokeMethod(TypeDef type, string dll, string funcName) {
 			foreach (var method in type.Methods) {
-				if (isPinvokeMethod(method, dll, funcName))
+				if (IsPinvokeMethod(method, dll, funcName))
 					return method;
 			}
 			return null;
 		}
 
-		public static bool isPinvokeMethod(MethodDef method, string dll, string funcName) {
+		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);
+			return GetDllName(dll).Equals(GetDllName(method.ImplMap.Module.Name.String), StringComparison.OrdinalIgnoreCase);
 		}
 
-		public static MethodDef getMethod(ModuleDefMD module, IMethod method) {
+		public static MethodDef GetMethod(ModuleDefMD module, IMethod method) {
 			if (method == null)
 				return null;
-			return getMethod(module, method, method.DeclaringType);
+			return GetMethod(module, method, method.DeclaringType);
 		}
 
-		public static MethodDef getMethod2(ModuleDefMD module, IMethod method) {
+		public static MethodDef GetMethod2(ModuleDefMD module, IMethod method) {
 			if (method == null)
 				return null;
 			if (method is MethodDef)
 				return (MethodDef)method;
 			var git = method.DeclaringType.TryGetGenericInstSig();
 			var dt = git == null ? method.DeclaringType : git.GenericType.TypeDefOrRef;
-			return getMethod(module, method, dt);
+			return GetMethod(module, method, dt);
 		}
 
-		static MethodDef getMethod(ModuleDefMD module, IMethod method, ITypeDefOrRef declaringType) {
+		static MethodDef GetMethod(ModuleDefMD module, IMethod method, ITypeDefOrRef declaringType) {
 			if (method == null)
 				return null;
 			if (method is MethodDef)
 				return (MethodDef)method;
-			return getMethod(getType(module, declaringType), method);
+			return GetMethod(GetType(module, declaringType), method);
 		}
 
-		public static MethodDef getMethod(TypeDef 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))
+				if (IsMethod(method, returnType, parameters))
 					return method;
 			}
 			return null;
 		}
 
-		public static MethodDef getMethod2(ModuleDef module, IMethod method) {
+		public static MethodDef GetMethod2(ModuleDef module, IMethod method) {
 			if (method == null)
 				return null;
-			return getMethod(module, method, method.DeclaringType.ScopeType);
+			return GetMethod(module, method, method.DeclaringType.ScopeType);
 		}
 
-		public static TypeDef getType(ModuleDef module, TypeSig type) {
+		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);
+			return GetType(module, tdr.TypeDefOrRef);
 		}
 
-		public static TypeDef getType(ModuleDef module, ITypeDefOrRef type) {
+		public static TypeDef GetType(ModuleDef module, ITypeDefOrRef type) {
 			var td = type as TypeDef;
 			if (td == null) {
 				var tr = type as TypeRef;
@@ -239,15 +239,15 @@ namespace de4dot.blocks {
 			return td != null && td.Module == module ? td : null;
 		}
 
-		static MethodDef getMethod(ModuleDef module, IMethod method, ITypeDefOrRef declaringType) {
+		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);
+			return GetMethod(GetType(module, declaringType), method);
 		}
 
-		public static MethodDef getMethod(TypeDef type, IMethod methodRef) {
+		public static MethodDef GetMethod(TypeDef type, IMethod methodRef) {
 			if (type == null || methodRef == null)
 				return null;
 			if (methodRef is MethodDef)
@@ -255,7 +255,7 @@ namespace de4dot.blocks {
 			return type.FindMethod(methodRef.Name, methodRef.MethodSig);
 		}
 
-		public static IEnumerable<MethodDef> getNormalMethods(TypeDef type) {
+		public static IEnumerable<MethodDef> GetNormalMethods(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (method.HasImplMap)
 					continue;
@@ -266,15 +266,15 @@ namespace de4dot.blocks {
 			}
 		}
 
-		public static FieldDef getField(ModuleDef module, IField field) {
+		public static FieldDef GetField(ModuleDef module, IField field) {
 			if (field == null)
 				return null;
 			if (field is FieldDef)
 				return (FieldDef)field;
-			return getField(getType(module, field.DeclaringType), field);
+			return GetField(GetType(module, field.DeclaringType), field);
 		}
 
-		public static FieldDef getField(TypeDef type, IField fieldRef) {
+		public static FieldDef GetField(TypeDef type, IField fieldRef) {
 			if (type == null || fieldRef == null)
 				return null;
 			if (fieldRef is FieldDef)
@@ -282,7 +282,7 @@ namespace de4dot.blocks {
 			return type.FindField(fieldRef.Name, fieldRef.FieldSig);
 		}
 
-		public static FieldDef getField(TypeDef type, string typeFullName) {
+		public static FieldDef GetField(TypeDef type, string typeFullName) {
 			if (type == null)
 				return null;
 			foreach (var field in type.Fields) {
@@ -292,7 +292,7 @@ namespace de4dot.blocks {
 			return null;
 		}
 
-		public static IEnumerable<IMethod> getMethodCalls(MethodDef method) {
+		public static IEnumerable<IMethod> GetMethodCalls(MethodDef method) {
 			var list = new List<IMethod>();
 			if (method.HasBody) {
 				foreach (var instr in method.Body.Instructions) {
@@ -304,7 +304,7 @@ namespace de4dot.blocks {
 			return list;
 		}
 
-		public static bool hasString(MethodDef 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) {
@@ -314,7 +314,7 @@ namespace de4dot.blocks {
 			return false;
 		}
 
-		public static IList<string> getCodeStrings(MethodDef 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) {
@@ -325,17 +325,17 @@ namespace de4dot.blocks {
 			return strings;
 		}
 
-		public static Resource getResource(ModuleDef module, string name) {
-			return getResource(module, new List<string> { name });
+		public static Resource GetResource(ModuleDef module, string name) {
+			return GetResource(module, new List<string> { name });
 		}
 
-		public static Resource getResource(ModuleDef module, IEnumerable<string> strings) {
+		public static Resource GetResource(ModuleDef module, IEnumerable<string> strings) {
 			if (!module.HasResources)
 				return null;
 
 			var resources = module.Resources;
 			foreach (var tmp in strings) {
-				var resourceName = removeFromNullChar(tmp);
+				var resourceName = RemoveFromNullChar(tmp);
 				if (resourceName == null)
 					continue;
 				UTF8String name = resourceName;
@@ -348,7 +348,7 @@ namespace de4dot.blocks {
 			return null;
 		}
 
-		static string removeFromNullChar(string s) {
+		static string RemoveFromNullChar(string s) {
 			int index = s.IndexOf((char)0);
 			if (index < 0)
 				return s;
@@ -356,7 +356,7 @@ namespace de4dot.blocks {
 		}
 
 		// Copies most things but not everything
-		public static MethodDef clone(MethodDef method) {
+		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;
@@ -369,11 +369,11 @@ namespace de4dot.blocks {
 				newMethod.GenericParameters.Add(newGp);
 			}
 			newMethod.Body = new CilBody();
-			copyBodyFromTo(method, newMethod);
+			CopyBodyFromTo(method, newMethod);
 			return newMethod;
 		}
 
-		public static void copyBody(MethodDef 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>();
@@ -384,7 +384,7 @@ namespace de4dot.blocks {
 			var oldExHandlers = method.Body.ExceptionHandlers;
 			instructions = new List<Instruction>(oldInstrs.Count);
 			exceptionHandlers = new List<ExceptionHandler>(oldExHandlers.Count);
-			var oldToIndex = Utils.createObjectToIndexDictionary(oldInstrs);
+			var oldToIndex = Utils.CreateObjectToIndexDictionary(oldInstrs);
 
 			foreach (var oldInstr in oldInstrs)
 				instructions.Add(oldInstr.Clone());
@@ -404,24 +404,24 @@ namespace de4dot.blocks {
 
 			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),
+					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) {
+		static Instruction GetInstruction(IList<Instruction> instructions, IDictionary<Instruction, int> instructionToIndex, Instruction instruction) {
 			if (instruction == null)
 				return null;
 			return instructions[instructionToIndex[instruction]];
 		}
 
-		public static void restoreBody(MethodDef method, IEnumerable<Instruction> instructions, IEnumerable<ExceptionHandler> exceptionHandlers) {
+		public static void RestoreBody(MethodDef method, IEnumerable<Instruction> instructions, IEnumerable<ExceptionHandler> exceptionHandlers) {
 			if (method == null || method.Body == null)
 				return;
 
@@ -436,19 +436,19 @@ namespace de4dot.blocks {
 				bodyExceptionHandlers.Add(eh);
 		}
 
-		public static void copyBodyFromTo(MethodDef fromMethod, MethodDef toMethod) {
+		public static void CopyBodyFromTo(MethodDef fromMethod, MethodDef toMethod) {
 			if (fromMethod == toMethod)
 				return;
 
 			IList<Instruction> instructions;
 			IList<ExceptionHandler> exceptionHandlers;
-			copyBody(fromMethod, out instructions, out exceptionHandlers);
-			restoreBody(toMethod, instructions, exceptionHandlers);
-			copyLocalsFromTo(fromMethod, toMethod);
-			updateInstructionOperands(fromMethod, toMethod);
+			CopyBody(fromMethod, out instructions, out exceptionHandlers);
+			RestoreBody(toMethod, instructions, exceptionHandlers);
+			CopyLocalsFromTo(fromMethod, toMethod);
+			UpdateInstructionOperands(fromMethod, toMethod);
 		}
 
-		static void copyLocalsFromTo(MethodDef fromMethod, MethodDef toMethod) {
+		static void CopyLocalsFromTo(MethodDef fromMethod, MethodDef toMethod) {
 			var fromBody = fromMethod.Body;
 			var toBody = toMethod.Body;
 
@@ -457,7 +457,7 @@ namespace de4dot.blocks {
 				toBody.Variables.Add(new Local(local.Type));
 		}
 
-		static void updateInstructionOperands(MethodDef fromMethod, MethodDef toMethod) {
+		static void UpdateInstructionOperands(MethodDef fromMethod, MethodDef toMethod) {
 			var fromBody = fromMethod.Body;
 			var toBody = toMethod.Body;
 
@@ -481,7 +481,7 @@ namespace de4dot.blocks {
 			}
 		}
 
-		public static string getCustomArgAsString(CustomAttribute cattr, int arg) {
+		public static string GetCustomArgAsString(CustomAttribute cattr, int arg) {
 			if (cattr == null || arg >= cattr.ConstructorArguments.Count)
 				return null;
 			var carg = cattr.ConstructorArguments[arg];
@@ -490,7 +490,7 @@ namespace de4dot.blocks {
 			return UTF8String.ToSystemStringOrEmpty((UTF8String)carg.Value);
 		}
 
-		public static IEnumerable<MethodDef> getCalledMethods(ModuleDef module, MethodDef 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)
@@ -498,15 +498,15 @@ namespace de4dot.blocks {
 					var methodRef = call.Operand as IMethod;
 					if (methodRef == null)
 						continue;
-					var type = getType(module, methodRef.DeclaringType);
-					var methodDef = getMethod(type, methodRef);
+					var type = GetType(module, methodRef.DeclaringType);
+					var methodDef = GetMethod(type, methodRef);
 					if (methodDef != null)
 						yield return methodDef;
 				}
 			}
 		}
 
-		public static IList<Instruction> getInstructions(IList<Instruction> instructions, int i, params OpCode[] opcodes) {
+		public static IList<Instruction> GetInstructions(IList<Instruction> instructions, int i, params OpCode[] opcodes) {
 			if (i + opcodes.Length > instructions.Count)
 				return null;
 			if (opcodes.Length == 0)
@@ -524,25 +524,25 @@ namespace de4dot.blocks {
 			return list;
 		}
 
-		public static bool hasReturnValue(IMethod method) {
+		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;
 		}
 
-		public static Parameter getParameter(IList<Parameter> parameters, int index) {
+		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) {
+		public static TypeSig GetArg(IList<TypeSig> args, int index) {
 			if (0 <= index && index < args.Count)
 				return args[index];
 			return null;
 		}
 
-		public static List<TypeSig> getArgs(IMethod method) {
+		public static List<TypeSig> GetArgs(IMethod method) {
 			var sig = method.MethodSig;
 			var args = new List<TypeSig>(sig.Params.Count + 1);
 			if (sig.ImplicitThis)
@@ -552,7 +552,7 @@ namespace de4dot.blocks {
 			return args;
 		}
 
-		public static int getArgsCount(IMethod method) {
+		public static int GetArgsCount(IMethod method) {
 			var sig = method.MethodSig;
 			if (sig == null)
 				return 0;
@@ -562,22 +562,22 @@ namespace de4dot.blocks {
 			return count;
 		}
 
-		public static IList<TypeSig> replaceGenericParameters(GenericInstSig typeOwner, MethodSpec methodOwner, IList<TypeSig> types) {
+		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]);
+				types[i] = GetGenericArgument(typeOwner, methodOwner, types[i]);
 			return types;
 		}
 
-		public static TypeSig getGenericArgument(GenericInstSig typeOwner, MethodSpec methodOwner, TypeSig 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);
+			return GenericArgsSubstitutor.Create(type, typeArgs, genMethodArgs);
 		}
 
-		public static Instruction getInstruction(IList<Instruction> instructions, ref int index) {
+		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;
@@ -596,7 +596,7 @@ namespace de4dot.blocks {
 			return null;
 		}
 
-		public static TypeDefOrRefSig findOrCreateTypeRef(ModuleDef module, AssemblyRef asmRef, string ns, string name, bool isValueType) {
+		public static TypeDefOrRefSig FindOrCreateTypeRef(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);
@@ -604,7 +604,7 @@ namespace de4dot.blocks {
 				return new ClassSig(typeRef);
 		}
 
-		public static FrameworkType getFrameworkType(ModuleDefMD module) {
+		public static FrameworkType GetFrameworkType(ModuleDefMD module) {
 			foreach (var modRef in module.GetAssemblyRefs()) {
 				if (modRef.Name != "mscorlib")
 					continue;
@@ -627,7 +627,7 @@ namespace de4dot.blocks {
 			return FrameworkType.Unknown;
 		}
 
-		public static int getMethodCalls(MethodDef method, string methodFullName) {
+		public static int GetMethodCalls(MethodDef method, string methodFullName) {
 			if (method == null || method.Body == null)
 				return 0;
 
@@ -645,7 +645,7 @@ namespace de4dot.blocks {
 			return count;
 		}
 
-		public static bool callsMethod(MethodDef method, string methodFullName) {
+		public static bool CallsMethod(MethodDef method, string methodFullName) {
 			if (method == null || method.Body == null)
 				return false;
 
@@ -662,25 +662,25 @@ namespace de4dot.blocks {
 			return false;
 		}
 
-		public static bool callsMethod(MethodDef 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 IMethod, returnType, parameters))
+				if (IsMethod(instr.Operand as IMethod, returnType, parameters))
 					return true;
 			}
 
 			return false;
 		}
 
-		public static IList<Instruction> getArgPushes(IList<Instruction> instrs, int index) {
-			return getArgPushes(instrs, ref index);
+		public static IList<Instruction> GetArgPushes(IList<Instruction> instrs, int index) {
+			return GetArgPushes(instrs, ref index);
 		}
 
-		public static IList<Instruction> getArgPushes(IList<Instruction> instrs, ref int index) {
+		public static IList<Instruction> GetArgPushes(IList<Instruction> instrs, ref int index) {
 			if (index < 0 || index >= instrs.Count)
 				return null;
 			var startInstr = instrs[index];
@@ -707,7 +707,7 @@ namespace de4dot.blocks {
 
 					if (pops != 0) {
 						index++;
-						if (getArgPushes(instrs, ref index) == null)
+						if (GetArgPushes(instrs, ref index) == null)
 							return null;
 					}
 				}
diff --git a/blocks/DumpedMethods.cs b/blocks/DumpedMethods.cs
index b90e0523..60a1e025 100644
--- a/blocks/DumpedMethods.cs
+++ b/blocks/DumpedMethods.cs
@@ -31,21 +31,21 @@ namespace de4dot.blocks {
 			get { return methods.Count; }
 		}
 
-		public void add(uint token, DumpedMethod info) {
+		public void Add(uint token, DumpedMethod info) {
 			methods[token] = info;
 		}
 
-		public DumpedMethod get(MethodDef method) {
-			return get(method.MDToken.ToUInt32());
+		public DumpedMethod Get(MethodDef method) {
+			return Get(method.MDToken.ToUInt32());
 		}
 
-		public DumpedMethod get(uint token) {
+		public DumpedMethod Get(uint token) {
 			DumpedMethod dm;
 			methods.TryGetValue(token, out dm);
 			return dm;
 		}
 
-		public void add(DumpedMethod 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/ForwardScanOrder.cs b/blocks/ForwardScanOrder.cs
index fef304ce..a46355e0 100644
--- a/blocks/ForwardScanOrder.cs
+++ b/blocks/ForwardScanOrder.cs
@@ -41,7 +41,7 @@ namespace de4dot.blocks {
 				this.stackStart = stackStart;
 			}
 
-			public void calculateStackUsage() {
+			public void CalculateStackUsage() {
 				Block block = baseBlock as Block;
 				if (block == null) {
 					stackEnd = stackStart;
@@ -60,17 +60,17 @@ namespace de4dot.blocks {
 			this.sorted = sorted;
 		}
 
-		public List<BaseBlock> fix() {
-			createBlockInfos();
-			createNewList();
+		public List<BaseBlock> Fix() {
+			CreateBlockInfos();
+			CreateNewList();
 			return newList;
 		}
 
-		void createBlockInfos() {
+		void CreateBlockInfos() {
 			int firstBlockStackStart = scopeBlock is TryHandlerBlock ? 1 : 0;
-			foreach (var bb in getStartBlocks()) {
+			foreach (var bb in GetStartBlocks()) {
 				int stackStart = ReferenceEquals(bb, sorted[0]) ? firstBlockStackStart : 0;
-				scanBaseBlock(bb, stackStart);
+				ScanBaseBlock(bb, stackStart);
 			}
 
 			// One reason for this to fail is if there are still dead blocks left. Could also
@@ -79,29 +79,29 @@ namespace de4dot.blocks {
 				throw new ApplicationException(string.Format("Didn't add all blocks: {0} vs {1}", blockInfos.Count, sorted.Count));
 		}
 
-		IEnumerable<BaseBlock> getStartBlocks() {
+		IEnumerable<BaseBlock> GetStartBlocks() {
 			if (sorted.Count > 0) {
 				yield return sorted[0];
 				foreach (var bb in sorted) {
 					if (ReferenceEquals(bb, sorted[0]))
 						continue;
 					var block = bb as Block;
-					if (block == null || block.Sources == null || isOneSourceInAnotherScopeBlock(block))
+					if (block == null || block.Sources == null || IsOneSourceInAnotherScopeBlock(block))
 						yield return bb;
 				}
 			}
 		}
 
-		bool isOneSourceInAnotherScopeBlock(Block block) {
+		bool IsOneSourceInAnotherScopeBlock(Block block) {
 			foreach (var source in block.Sources) {
-				if (!scopeBlock.isOurBaseBlock(source))
+				if (!scopeBlock.IsOurBaseBlock(source))
 					return true;
 			}
 			return false;
 		}
 
-		void scanBaseBlock(BaseBlock bb, int stackStart) {
-			if (blockInfos.ContainsKey(bb) || !scopeBlock.isOurBaseBlock(bb))
+		void ScanBaseBlock(BaseBlock bb, int stackStart) {
+			if (blockInfos.ContainsKey(bb) || !scopeBlock.IsOurBaseBlock(bb))
 				return;
 
 			var blockInfo = new BlockInfo(bb, stackStart);
@@ -115,38 +115,38 @@ namespace de4dot.blocks {
 				return;
 			}
 
-			blockInfo.calculateStackUsage();
+			blockInfo.CalculateStackUsage();
 
-			foreach (var target in block.getTargets())
-				scanBaseBlock(target, blockInfo.stackEnd);
+			foreach (var target in block.GetTargets())
+				ScanBaseBlock(target, blockInfo.stackEnd);
 		}
 
-		void createNewList() {
+		void CreateNewList() {
 			newList = new List<BaseBlock>(sorted.Count);
 			foreach (var bb in sorted)
-				addToNewList(bb);
+				AddToNewList(bb);
 			if (newList.Count != sorted.Count)
 				throw new ApplicationException(string.Format("Too many/few blocks after sorting: {0} vs {1}", newList.Count, sorted.Count));
 			if (newList.Count > 0 && !ReferenceEquals(newList[0], sorted[0]))
 				throw new ApplicationException("Start block is not first block after sorting");
 		}
 
-		void addToNewList(BaseBlock bb) {
-			if (inNewList.ContainsKey(bb) || !scopeBlock.isOurBaseBlock(bb))
+		void AddToNewList(BaseBlock bb) {
+			if (inNewList.ContainsKey(bb) || !scopeBlock.IsOurBaseBlock(bb))
 				return;
 			inNewList[bb] = false;
 
 			var blockInfo = blockInfos[bb];
 			var block = bb as Block;
 			if (blockInfo.stackStart == 0 || ReferenceEquals(bb, sorted[0]) ||
-				block == null || block.Sources == null || isInNewList(block.Sources)) {
+				block == null || block.Sources == null || IsInNewList(block.Sources)) {
 			}
 			else {
 				foreach (var source in block.Sources) {
-					if (!scopeBlock.isOurBaseBlock(source))
+					if (!scopeBlock.IsOurBaseBlock(source))
 						continue;
 					int oldCount = newList.Count;
-					addToNewList(source);	// Make sure it's before this block
+					AddToNewList(source);	// Make sure it's before this block
 					if (oldCount != newList.Count)
 						break;
 				}
@@ -156,7 +156,7 @@ namespace de4dot.blocks {
 			newList.Add(bb);
 		}
 
-		bool isInNewList(IEnumerable<Block> blocks) {
+		bool IsInNewList(IEnumerable<Block> blocks) {
 			foreach (var block in blocks) {
 				if (inNewList.ContainsKey(block) && inNewList[block])
 					return true;
diff --git a/blocks/GenericArgsSubstitutor.cs b/blocks/GenericArgsSubstitutor.cs
index 633cb713..c3eb01a2 100644
--- a/blocks/GenericArgsSubstitutor.cs
+++ b/blocks/GenericArgsSubstitutor.cs
@@ -26,115 +26,115 @@ namespace de4dot.blocks {
 		IList<TypeSig> genericMethodArgs;
 		bool updated;
 
-		public static ITypeDefOrRef create(ITypeDefOrRef type, GenericInstSig git) {
+		public static ITypeDefOrRef Create(ITypeDefOrRef type, GenericInstSig git) {
 			if (git == null)
 				return type;
-			return create(type, git.GenericArguments);
+			return Create(type, git.GenericArguments);
 		}
 
-		public static ITypeDefOrRef create(ITypeDefOrRef type, IList<TypeSig> genericArgs) {
+		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);
+			var newSig = Create(ts.TypeSig, genericArgs);
 			return newSig == ts.TypeSig ? type : new TypeSpecUser(newSig);
 		}
 
-		public static TypeSig create(TypeSig type, IList<TypeSig> genericArgs) {
+		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);
+			return new GenericArgsSubstitutor(genericArgs).Create(type);
 		}
 
-		public static TypeSig create(TypeSig type, IList<TypeSig> genericArgs, IList<TypeSig> genericMethodArgs) {
+		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);
+			return new GenericArgsSubstitutor(genericArgs, genericMethodArgs).Create(type);
 		}
 
-		public static IField create(IField field, GenericInstSig git) {
+		public static IField Create(IField field, GenericInstSig git) {
 			if (git == null)
 				return field;
-			return create(field, git.GenericArguments);
+			return Create(field, git.GenericArguments);
 		}
 
-		public static IField create(IField field, IList<TypeSig> genericArgs) {
+		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);
+			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) {
+		public static FieldSig Create(FieldSig sig, GenericInstSig git) {
 			if (git == null)
 				return sig;
-			return create(sig, git.GenericArguments);
+			return Create(sig, git.GenericArguments);
 		}
 
-		public static FieldSig create(FieldSig sig, IList<TypeSig> genericArgs) {
+		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);
+			return new GenericArgsSubstitutor(genericArgs).Create(sig);
 		}
 
-		public static IMethod create(IMethod method, GenericInstSig git) {
+		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);
+				return Create(mdr, git);
 
 			var ms = method as MethodSpec;
 			if (ms != null)
-				return create(ms, git);
+				return Create(ms, git);
 
 			return method;
 		}
 
-		public static MethodSpec create(MethodSpec method, GenericInstSig git) {
+		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);
+			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) {
+		public static GenericInstMethodSig Create(GenericInstMethodSig sig, GenericInstSig git) {
 			if (git == null)
 				return sig;
-			return create(sig, git.GenericArguments);
+			return Create(sig, git.GenericArguments);
 		}
 
-		public static GenericInstMethodSig create(GenericInstMethodSig sig, IList<TypeSig> genericArgs) {
+		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);
+			return new GenericArgsSubstitutor(genericArgs).Create(sig);
 		}
 
-		public static IMethodDefOrRef create(IMethodDefOrRef method, GenericInstSig git) {
+		public static IMethodDefOrRef Create(IMethodDefOrRef method, GenericInstSig git) {
 			if (git == null)
 				return method;
-			return create(method, git.GenericArguments);
+			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, 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);
+		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) {
+		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))
@@ -144,7 +144,7 @@ namespace de4dot.blocks {
 			if (sig == null)
 				return method;
 
-			var newSig = new GenericArgsSubstitutor(genericArgs, genericMethodArgs).create(sig);
+			var newSig = new GenericArgsSubstitutor(genericArgs, genericMethodArgs).Create(sig);
 			if (newSig == sig)
 				return method;
 
@@ -163,12 +163,12 @@ namespace de4dot.blocks {
 			this.updated = false;
 		}
 
-		TypeSig create(TypeSig type) {
-			var newType = create2(type);
+		TypeSig Create(TypeSig type) {
+			var newType = Create2(type);
 			return updated ? newType : type;
 		}
 
-		TypeSig create2(TypeSig type) {
+		TypeSig Create2(TypeSig type) {
 			if (type == null)
 				return type;
 			TypeSig result;
@@ -197,11 +197,11 @@ namespace de4dot.blocks {
 				break;
 
 			case ElementType.Ptr:
-				result = new PtrSig(create2(type.Next));
+				result = new PtrSig(Create2(type.Next));
 				break;
 
 			case ElementType.ByRef:
-				result = new ByRefSig(create2(type.Next));
+				result = new ByRefSig(Create2(type.Next));
 				break;
 
 			case ElementType.Array:
@@ -210,11 +210,11 @@ namespace de4dot.blocks {
 				break;
 
 			case ElementType.SZArray:
-				result = new SZArraySig(create2(type.Next));
+				result = new SZArraySig(Create2(type.Next));
 				break;
 
 			case ElementType.Pinned:
-				result = new PinnedSig(create2(type.Next));
+				result = new PinnedSig(Create2(type.Next));
 				break;
 
 			case ElementType.ValueType:
@@ -244,9 +244,9 @@ namespace de4dot.blocks {
 
 			case ElementType.GenericInst:
 				var gis = (GenericInstSig)type;
-				var newGis = new GenericInstSig(create2(gis.GenericType) as ClassOrValueTypeSig, gis.GenericArguments.Count);
+				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]));
+					newGis.GenericArguments.Add(Create2(gis.GenericArguments[i]));
 				result = newGis;
 				break;
 
@@ -267,7 +267,7 @@ namespace de4dot.blocks {
 				break;
 
 			case ElementType.FnPtr:
-				result = new FnPtrSig(create(((FnPtrSig)type).MethodSig));
+				result = new FnPtrSig(Create(((FnPtrSig)type).MethodSig));
 				break;
 
 			case ElementType.End:
@@ -282,31 +282,31 @@ namespace de4dot.blocks {
 			return result;
 		}
 
-		MethodSig create(MethodSig sig) {
+		MethodSig Create(MethodSig sig) {
 			if (sig == null)
 				return sig;
 			var newSig = new MethodSig(sig.GetCallingConvention());
-			newSig.RetType = create2(sig.RetType);
+			newSig.RetType = Create2(sig.RetType);
 			for (int i = 0; i < sig.Params.Count; i++)
-				newSig.Params.Add(create2(sig.Params[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]));
+					newSig.ParamsAfterSentinel.Add(Create2(sig.ParamsAfterSentinel[i]));
 			}
 			return updated ? newSig : sig;
 		}
 
-		GenericInstMethodSig create(GenericInstMethodSig 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]));
+				newSig.GenericArguments.Add(Create2(sig.GenericArguments[i]));
 			return updated ? newSig : sig;
 		}
 
-		FieldSig create(FieldSig sig) {
-			var newSig = new FieldSig(create2(sig.Type));
+		FieldSig Create(FieldSig sig) {
+			var newSig = new FieldSig(Create2(sig.Type));
 			return updated ? newSig : sig;
 		}
 	}
diff --git a/blocks/Instr.cs b/blocks/Instr.cs
index b1af0a16..6e166945 100644
--- a/blocks/Instr.cs
+++ b/blocks/Instr.cs
@@ -44,11 +44,11 @@ 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 Local getLocalVar(IList<Local> locals, Instr instr) {
+		public static Local GetLocalVar(IList<Local> locals, Instr instr) {
 			return instr.Instruction.GetLocal(locals);
 		}
 
-		static public bool isFallThrough(OpCode opCode) {
+		static public bool IsFallThrough(OpCode opCode) {
 			switch (opCode.FlowControl) {
 			case FlowControl.Call:
 				return opCode != OpCodes.Jmp;
@@ -61,7 +61,7 @@ namespace de4dot.blocks {
 		}
 
 		// Returns true if the instruction only pushes one value onto the stack and pops nothing
-		public bool isSimpleLoad() {
+		public bool IsSimpleLoad() {
 			switch (OpCode.Code) {
 			case Code.Ldarg:
 			case Code.Ldarg_S:
@@ -103,55 +103,55 @@ namespace de4dot.blocks {
 			}
 		}
 
-		public bool isLdcI4() {
+		public bool IsLdcI4() {
 			return instruction.IsLdcI4();
 		}
 
-		public int getLdcI4Value() {
+		public int GetLdcI4Value() {
 			return instruction.GetLdcI4Value();
 		}
 
-		public bool isLdarg() {
+		public bool IsLdarg() {
 			return instruction.IsLdarg();
 		}
 
-		public bool isStloc() {
+		public bool IsStloc() {
 			return instruction.IsStloc();
 		}
 
-		public bool isLdloc() {
+		public bool IsLdloc() {
 			return instruction.IsLdloc();
 		}
 
-		public bool isNop() {
+		public bool IsNop() {
 			return OpCode == OpCodes.Nop;
 		}
 
-		public bool isPop() {
+		public bool IsPop() {
 			return OpCode == OpCodes.Pop;
 		}
 
-		public bool isLeave() {
+		public bool IsLeave() {
 			return instruction.IsLeave();
 		}
 
-		public bool isBr() {
+		public bool IsBr() {
 			return instruction.IsBr();
 		}
 
-		public bool isBrfalse() {
+		public bool IsBrfalse() {
 			return instruction.IsBrfalse();
 		}
 
-		public bool isBrtrue() {
+		public bool IsBrtrue() {
 			return instruction.IsBrtrue();
 		}
 
-		public bool isConditionalBranch() {
+		public bool IsConditionalBranch() {
 			return instruction.IsConditionalBranch();
 		}
 
-		public bool getFlippedBranchOpCode(out OpCode opcode) {
+		public bool GetFlippedBranchOpCode(out OpCode opcode) {
 			switch (OpCode.Code) {
 			case Code.Bge:		opcode = OpCodes.Blt; return true;
 			case Code.Bge_S:	opcode = OpCodes.Blt_S; return true;
@@ -190,20 +190,20 @@ namespace de4dot.blocks {
 			}
 		}
 
-		public void flipConditonalBranch() {
+		public void FlipConditonalBranch() {
 			OpCode opcode;
-			if (!getFlippedBranchOpCode(out opcode))
+			if (!GetFlippedBranchOpCode(out opcode))
 				throw new ApplicationException("Can't flip conditional since it's not a supported conditional instruction");
 			instruction.OpCode = opcode;
 		}
 
 		// Returns true if we can flip a conditional branch
-		public bool canFlipConditionalBranch() {
+		public bool CanFlipConditionalBranch() {
 			OpCode opcode;
-			return getFlippedBranchOpCode(out opcode);
+			return GetFlippedBranchOpCode(out opcode);
 		}
 
-		public void updateTargets(List<Instr> targets) {
+		public void UpdateTargets(List<Instr> targets) {
 			switch (OpCode.OperandType) {
 			case OperandType.ShortInlineBrTarget:
 			case OperandType.InlineBrTarget:
diff --git a/blocks/InstructionListParser.cs b/blocks/InstructionListParser.cs
index 2e769f8d..b0f5ac6c 100644
--- a/blocks/InstructionListParser.cs
+++ b/blocks/InstructionListParser.cs
@@ -33,44 +33,44 @@ namespace de4dot.blocks {
 			this.exceptionHandlers = exceptionHandlers;
 			this.branches = new Dictionary<int, List<int>>();
 
-			createInstrToIndex();
-			createBranches();
-			createExceptionBranches();
+			CreateInstrToIndex();
+			CreateBranches();
+			CreateExceptionBranches();
 		}
 
-		void createInstrToIndex() {
+		void CreateInstrToIndex() {
 			instrToIndex = new Dictionary<Instruction, int>();
 
 			for (int i = 0; i < instructions.Count; i++)
 				instrToIndex[instructions[i]] = i;
 		}
 
-		List<int> getBranchTargetList(int index) {
+		List<int> GetBranchTargetList(int index) {
 			List<int> targetsList;
 			if (!branches.TryGetValue(index, out targetsList))
 				branches[index] = targetsList = new List<int>();
 			return targetsList;
 		}
 
-		void markAsBranchTarget(Instruction instr) {
+		void MarkAsBranchTarget(Instruction instr) {
 			if (instr == null)
 				return;
 
 			int index = instrToIndex[instr];
-			getBranchTargetList(index);	// Just create the list
+			GetBranchTargetList(index);	// Just create the list
 		}
 
-		void createExceptionBranches() {
+		void CreateExceptionBranches() {
 			foreach (var eh in exceptionHandlers) {
-				markAsBranchTarget(eh.TryStart);
-				markAsBranchTarget(eh.TryEnd);
-				markAsBranchTarget(eh.FilterStart);
-				markAsBranchTarget(eh.HandlerStart);
-				markAsBranchTarget(eh.HandlerEnd);
+				MarkAsBranchTarget(eh.TryStart);
+				MarkAsBranchTarget(eh.TryEnd);
+				MarkAsBranchTarget(eh.FilterStart);
+				MarkAsBranchTarget(eh.HandlerStart);
+				MarkAsBranchTarget(eh.HandlerEnd);
 			}
 		}
 
-		void createBranches() {
+		void CreateBranches() {
 			for (int i = 0; i < instructions.Count; i++) {
 				var instr = instructions[i];
 
@@ -113,13 +113,13 @@ namespace de4dot.blocks {
 						targets.Add(i + 1);
 					for (int j = 0; j < targets.Count; j++) {
 						int targetIndex = targets[j];
-						getBranchTargetList(targetIndex).Add(i);
+						GetBranchTargetList(targetIndex).Add(i);
 					}
 				}
 			}
 		}
 
-		void findBlocks(List<Block> instrToBlock, List<Block> allBlocks) {
+		void FindBlocks(List<Block> instrToBlock, List<Block> allBlocks) {
 			Block block = null;
 			for (var i = 0; i < instructions.Count; i++) {
 				List<int> branchSources;
@@ -128,7 +128,7 @@ namespace de4dot.blocks {
 					allBlocks.Add(block);
 				}
 
-				block.add(new Instr(this.instructions[i]));
+				block.Add(new Instr(this.instructions[i]));
 				instrToBlock.Add(block);
 			}
 		}
@@ -136,7 +136,7 @@ namespace de4dot.blocks {
 		// Fix all branches so they now point to a Block, and not an Instruction. The
 		// block's Targets field is updated, not the Instruction's Operand field.
 		// Also update Block.FallThrough with next Block if last instr falls through.
-		void fixBranchTargets(List<Block> instrToBlock, List<Block> allBlocks) {
+		void FixBranchTargets(List<Block> instrToBlock, List<Block> allBlocks) {
 			for (var i = 0; i < allBlocks.Count; i++) {
 				var block = allBlocks[i];
 				var lastInstr = block.LastInstr;
@@ -160,15 +160,15 @@ namespace de4dot.blocks {
 					break;
 				}
 
-				if (i + 1 < allBlocks.Count && Instr.isFallThrough(lastInstr.OpCode))
+				if (i + 1 < allBlocks.Count && Instr.IsFallThrough(lastInstr.OpCode))
 					block.FallThrough = allBlocks[i + 1];
 			}
 		}
 
 		// Updates the sources field of each block
-		void fixBlockSources(List<Block> allBlocks) {
+		void FixBlockSources(List<Block> allBlocks) {
 			foreach (var block in allBlocks) {
-				block.updateSources();
+				block.UpdateSources();
 			}
 		}
 
@@ -195,7 +195,7 @@ namespace de4dot.blocks {
 			}
 		}
 
-		List<List<ExceptionHandler>> getSortedExceptionInfos() {
+		List<List<ExceptionHandler>> GetSortedExceptionInfos() {
 			var exInfos = new Dictionary<EHInfo, List<ExceptionHandler>>();
 			foreach (var eh in exceptionHandlers) {
 				List<ExceptionHandler> handlers;
@@ -220,8 +220,8 @@ namespace de4dot.blocks {
 
 				// Same start instruction. The nested one is the one that ends earliest,
 				// so it should be sorted before the outer one.
-				ai = getInstrIndex(a[0].TryEnd);
-				bi = getInstrIndex(b[0].TryEnd);
+				ai = GetInstrIndex(a[0].TryEnd);
+				bi = GetInstrIndex(b[0].TryEnd);
 				if (ai < bi) return -1;
 				if (ai > bi) return 1;
 
@@ -245,7 +245,7 @@ namespace de4dot.blocks {
 
 			List<BaseBlockInfo> blocksLeft = new List<BaseBlockInfo>();
 
-			public void add(BaseBlock bb, int start, int end) {
+			public void Add(BaseBlock bb, int start, int end) {
 				if (start < 0 || end < 0 || end < start)
 					throw new ApplicationException("Invalid start and/or end index");
 				if (blocksLeft.Count != 0) {
@@ -256,7 +256,7 @@ namespace de4dot.blocks {
 				blocksLeft.Add(new BaseBlockInfo(start, end, bb));
 			}
 
-			int findStart(int instrIndex) {
+			int FindStart(int instrIndex) {
 				for (int i = 0; i < blocksLeft.Count; i++) {
 					if (blocksLeft[i].startInstr == instrIndex)
 						return i;
@@ -264,7 +264,7 @@ namespace de4dot.blocks {
 				throw new ApplicationException("Could not find start BaseBlockInfo");
 			}
 
-			int findEnd(int instrIndex) {
+			int FindEnd(int instrIndex) {
 				for (int i = 0; i < blocksLeft.Count; i++) {
 					if (blocksLeft[i].endInstr == instrIndex)
 						return i;
@@ -272,14 +272,14 @@ namespace de4dot.blocks {
 				throw new ApplicationException("Could not find end BaseBlockInfo");
 			}
 
-			List<BaseBlock> getBlocks(int startInstr, int endInstr, out int startIndex, out int endIndex) {
+			List<BaseBlock> GetBlocks(int startInstr, int endInstr, out int startIndex, out int endIndex) {
 				if (endInstr < startInstr || startInstr < 0 || endInstr < 0)
 					throw new ApplicationException("Invalid startInstr and/or endInstr");
 
 				var rv = new List<BaseBlock>();
 
-				startIndex = findStart(startInstr);
-				endIndex = findEnd(endInstr);
+				startIndex = FindStart(startInstr);
+				endIndex = FindEnd(endInstr);
 
 				for (int i = startIndex; i <= endIndex; i++)
 					rv.Add(blocksLeft[i].baseBlock);
@@ -288,13 +288,13 @@ namespace de4dot.blocks {
 			}
 
 			// Replace the BaseBlocks with a new BaseBlock, returning the old ones.
-			public List<BaseBlock> replace(int startInstr, int endInstr, ScopeBlock bb) {
+			public List<BaseBlock> Replace(int startInstr, int endInstr, ScopeBlock bb) {
 				if (endInstr < startInstr)
 					return new List<BaseBlock>();
 
 				int startIndex, endIndex;
-				var rv = getBlocks(startInstr, endInstr, out startIndex, out endIndex);
-				updateParent(rv, bb);
+				var rv = GetBlocks(startInstr, endInstr, out startIndex, out endIndex);
+				UpdateParent(rv, bb);
 
 				var bbi = new BaseBlockInfo(blocksLeft[startIndex].startInstr, blocksLeft[endIndex].endInstr, bb);
 				blocksLeft.RemoveRange(startIndex, endIndex - startIndex + 1);
@@ -303,78 +303,78 @@ namespace de4dot.blocks {
 				return rv;
 			}
 
-			public List<BaseBlock> getBlocks(ScopeBlock parent) {
+			public List<BaseBlock> GetBlocks(ScopeBlock parent) {
 				if (blocksLeft.Count == 0)
 					return new List<BaseBlock>();
 				int startIndex, endIndex;
-				var lb = getBlocks(0, blocksLeft[blocksLeft.Count - 1].endInstr, out startIndex, out endIndex);
-				return updateParent(lb, parent);
+				var lb = GetBlocks(0, blocksLeft[blocksLeft.Count - 1].endInstr, out startIndex, out endIndex);
+				return UpdateParent(lb, parent);
 			}
 
-			List<BaseBlock> updateParent(List<BaseBlock> lb, ScopeBlock parent) {
+			List<BaseBlock> UpdateParent(List<BaseBlock> lb, ScopeBlock parent) {
 				foreach (var bb in lb)
 					bb.Parent = parent;
 				return lb;
 			}
 		}
 
-		BaseBlocksList createBaseBlockList(List<Block> allBlocks, List<List<ExceptionHandler>> exSorted) {
+		BaseBlocksList CreateBaseBlockList(List<Block> allBlocks, List<List<ExceptionHandler>> exSorted) {
 			var bbl = new BaseBlocksList();
 			foreach (var block in allBlocks) {
 				int start = instrToIndex[block.FirstInstr.Instruction];
 				int end = instrToIndex[block.LastInstr.Instruction];
-				bbl.add(block, start, end);
+				bbl.Add(block, start, end);
 			}
 
 			foreach (var exHandlers in exSorted) {
 				var tryBlock = new TryBlock();
 				var tryStart = instrToIndex[exHandlers[0].TryStart];
-				var tryEnd = getInstrIndex(exHandlers[0].TryEnd) - 1;
-				tryBlock.BaseBlocks = bbl.replace(tryStart, tryEnd, tryBlock);
+				var tryEnd = GetInstrIndex(exHandlers[0].TryEnd) - 1;
+				tryBlock.BaseBlocks = bbl.Replace(tryStart, tryEnd, tryBlock);
 
 				foreach (var exHandler in exHandlers) {
 					var tryHandlerBlock = new TryHandlerBlock(exHandler);
-					tryBlock.addTryHandler(tryHandlerBlock);
+					tryBlock.AddTryHandler(tryHandlerBlock);
 
 					int filterStart = -1, handlerStart = -1, handlerEnd = -1;
 
 					if (exHandler.FilterStart != null) {
 						filterStart = instrToIndex[exHandler.FilterStart];
 						var end = instrToIndex[exHandler.HandlerStart] - 1;
-						tryHandlerBlock.FilterHandlerBlock.BaseBlocks = bbl.replace(filterStart, end, tryHandlerBlock.FilterHandlerBlock);
+						tryHandlerBlock.FilterHandlerBlock.BaseBlocks = bbl.Replace(filterStart, end, tryHandlerBlock.FilterHandlerBlock);
 					}
 
 					handlerStart = instrToIndex[exHandler.HandlerStart];
-					handlerEnd = getInstrIndex(exHandler.HandlerEnd) - 1;
-					tryHandlerBlock.HandlerBlock.BaseBlocks = bbl.replace(handlerStart, handlerEnd, tryHandlerBlock.HandlerBlock);
+					handlerEnd = GetInstrIndex(exHandler.HandlerEnd) - 1;
+					tryHandlerBlock.HandlerBlock.BaseBlocks = bbl.Replace(handlerStart, handlerEnd, tryHandlerBlock.HandlerBlock);
 
-					tryHandlerBlock.BaseBlocks = bbl.replace(filterStart == -1 ? handlerStart : filterStart, handlerEnd, tryHandlerBlock);
+					tryHandlerBlock.BaseBlocks = bbl.Replace(filterStart == -1 ? handlerStart : filterStart, handlerEnd, tryHandlerBlock);
 				}
 			}
 
 			return bbl;
 		}
 
-		int getInstrIndex(Instruction instruction) {
+		int GetInstrIndex(Instruction instruction) {
 			if (instruction == null)
 				return instructions.Count;
 			return instrToIndex[instruction];
 		}
 
-		public MethodBlocks parse() {
+		public MethodBlocks Parse() {
 			var instrToBlock = new List<Block>(instructions.Count);
 			var allBlocks = new List<Block>();
-			findBlocks(instrToBlock, allBlocks);
-			fixBranchTargets(instrToBlock, allBlocks);
-			fixBlockSources(allBlocks);
-			var exSorted = getSortedExceptionInfos();
-			var bbl = createBaseBlockList(allBlocks, exSorted);
+			FindBlocks(instrToBlock, allBlocks);
+			FixBranchTargets(instrToBlock, allBlocks);
+			FixBlockSources(allBlocks);
+			var exSorted = GetSortedExceptionInfos();
+			var bbl = CreateBaseBlockList(allBlocks, exSorted);
 
 			foreach (var block in allBlocks)
-				block.removeLastBr();
+				block.RemoveLastBr();
 
 			var mb = new MethodBlocks();
-			mb.BaseBlocks = bbl.getBlocks(mb);
+			mb.BaseBlocks = bbl.GetBlocks(mb);
 			return mb;
 		}
 	}
diff --git a/blocks/MemberDefDict.cs b/blocks/MemberDefDict.cs
index 45af5e6a..ce02d4be 100644
--- a/blocks/MemberDefDict.cs
+++ b/blocks/MemberDefDict.cs
@@ -32,23 +32,23 @@ namespace de4dot.blocks {
 			get { return tokenToValue.Count; }
 		}
 
-		public IEnumerable<TypeDef> getKeys() {
+		public IEnumerable<TypeDef> GetKeys() {
 			return tokenToKey.Values;
 		}
 
-		public IEnumerable<TValue> getValues() {
+		public IEnumerable<TValue> GetValues() {
 			return tokenToValue.Values;
 		}
 
-		ScopeAndTokenKey getTokenKey(TypeDef typeDef) {
+		ScopeAndTokenKey GetTokenKey(TypeDef typeDef) {
 			return new ScopeAndTokenKey(typeDef);
 		}
 
-		public TValue find(IType typeRef) {
+		public TValue Find(IType typeRef) {
 			TValue value;
 			var typeDef = typeRef as TypeDef;
 			if (typeDef != null)
-				tokenToValue.TryGetValue(getTokenKey(typeDef), out value);
+				tokenToValue.TryGetValue(GetTokenKey(typeDef), out value);
 			else if (typeRef != null)
 				refToValue.TryGetValue(typeRef, out value);
 			else
@@ -56,23 +56,23 @@ namespace de4dot.blocks {
 			return value;
 		}
 
-		public TValue findAny(IType type) {
+		public TValue FindAny(IType type) {
 			TValue value;
 			var typeDef = type as TypeDef;
-			if (typeDef != null && tokenToValue.TryGetValue(getTokenKey(typeDef), out value))
+			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);
+		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])) {
+				GetAccessibilityOrder(typeDef) < GetAccessibilityOrder(refToKey[typeDef])) {
 				refToKey[typeDef] = typeDef;
 				refToValue[typeDef] = value;
 			}
@@ -89,11 +89,11 @@ namespace de4dot.blocks {
 			60,		// NestedFamANDAssem
 			30,		// NestedFamORAssem
 		};
-		static int getAccessibilityOrder(TypeDef typeDef) {
+		static int GetAccessibilityOrder(TypeDef typeDef) {
 			return accessibilityOrder[(int)typeDef.Attributes & 7];
 		}
 
-		public void onTypesRenamed() {
+		public void OnTypesRenamed() {
 			var newTypeRefToValue = new Dictionary<IType, TValue>(refToValue.Count);
 			foreach (var kvp in refToValue)
 				newTypeRefToValue[kvp.Key] = kvp.Value;
@@ -111,48 +111,48 @@ namespace de4dot.blocks {
 			get { return tokenToValue.Count; }
 		}
 
-		public IEnumerable<FieldDef> getKeys() {
+		public IEnumerable<FieldDef> GetKeys() {
 			return tokenToKey.Values;
 		}
 
-		public IEnumerable<TValue> getValues() {
+		public IEnumerable<TValue> GetValues() {
 			return tokenToValue.Values;
 		}
 
-		ScopeAndTokenKey getTokenKey(FieldDef fieldDef) {
+		ScopeAndTokenKey GetTokenKey(FieldDef fieldDef) {
 			return new ScopeAndTokenKey(fieldDef);
 		}
 
-		internal abstract IFieldRefKey getRefKey(IField fieldRef);
+		internal abstract IFieldRefKey GetRefKey(IField fieldRef);
 
-		public TValue find(IField fieldRef) {
+		public TValue Find(IField fieldRef) {
 			TValue value;
 			var fieldDef = fieldRef as FieldDef;
 			if (fieldDef != null)
-				tokenToValue.TryGetValue(getTokenKey(fieldDef), out value);
+				tokenToValue.TryGetValue(GetTokenKey(fieldDef), out value);
 			else
-				refToValue.TryGetValue(getRefKey(fieldRef), out value);
+				refToValue.TryGetValue(GetRefKey(fieldRef), out value);
 			return value;
 		}
 
-		public TValue findAny(IField fieldRef) {
+		public TValue FindAny(IField fieldRef) {
 			TValue value;
 			var fieldDef = fieldRef as FieldDef;
-			if (fieldDef != null && tokenToValue.TryGetValue(getTokenKey(fieldDef), out value))
+			if (fieldDef != null && tokenToValue.TryGetValue(GetTokenKey(fieldDef), out value))
 				return value;
 
-			refToValue.TryGetValue(getRefKey(fieldRef), out value);
+			refToValue.TryGetValue(GetRefKey(fieldRef), out value);
 			return value;
 		}
 
-		public void add(FieldDef fieldDef, TValue value) {
-			var tokenKey = getTokenKey(fieldDef);
+		public void Add(FieldDef fieldDef, TValue value) {
+			var tokenKey = GetTokenKey(fieldDef);
 			tokenToValue[tokenKey] = value;
 			tokenToKey[tokenKey] = fieldDef;
 
-			var refKey = getRefKey(fieldDef);
+			var refKey = GetRefKey(fieldDef);
 			if (!refToValue.ContainsKey(refKey) ||
-				getAccessibilityOrder(fieldDef) < getAccessibilityOrder(refToKey[refKey])) {
+				GetAccessibilityOrder(fieldDef) < GetAccessibilityOrder(refToKey[refKey])) {
 				refToKey[refKey] = fieldDef;
 				refToValue[refKey] = value;
 			}
@@ -169,26 +169,26 @@ namespace de4dot.blocks {
 			0,		// Public
 			70,		// <reserved>
 		};
-		static int getAccessibilityOrder(FieldDef fieldDef) {
+		static int GetAccessibilityOrder(FieldDef fieldDef) {
 			return accessibilityOrder[(int)fieldDef.Attributes & 7];
 		}
 
-		public void onTypesRenamed() {
+		public void OnTypesRenamed() {
 			var newFieldRefToDef = new Dictionary<IFieldRefKey, TValue>(refToValue.Count);
 			foreach (var kvp in refToValue)
-				newFieldRefToDef[getRefKey((FieldDef)kvp.Key.FieldRef)] = kvp.Value;
+				newFieldRefToDef[GetRefKey((FieldDef)kvp.Key.FieldRef)] = kvp.Value;
 			refToValue = newFieldRefToDef;
 		}
 	}
 
 	public class FieldDefDict<TValue> : FieldDefDictBase<TValue> {
-		internal override IFieldRefKey getRefKey(IField fieldRef) {
+		internal override IFieldRefKey GetRefKey(IField fieldRef) {
 			return new FieldRefKey(fieldRef);
 		}
 	}
 
 	public class FieldDefAndDeclaringTypeDict<TValue> : FieldDefDictBase<TValue> {
-		internal override IFieldRefKey getRefKey(IField fieldRef) {
+		internal override IFieldRefKey GetRefKey(IField fieldRef) {
 			return new FieldRefAndDeclaringTypeKey(fieldRef);
 		}
 	}
@@ -203,48 +203,48 @@ namespace de4dot.blocks {
 			get { return tokenToValue.Count; }
 		}
 
-		public IEnumerable<MethodDef> getKeys() {
+		public IEnumerable<MethodDef> GetKeys() {
 			return tokenToKey.Values;
 		}
 
-		public IEnumerable<TValue> getValues() {
+		public IEnumerable<TValue> GetValues() {
 			return tokenToValue.Values;
 		}
 
-		ScopeAndTokenKey getTokenKey(MethodDef methodDef) {
+		ScopeAndTokenKey GetTokenKey(MethodDef methodDef) {
 			return new ScopeAndTokenKey(methodDef);
 		}
 
-		internal abstract IMethodRefKey getRefKey(IMethod methodRef);
+		internal abstract IMethodRefKey GetRefKey(IMethod methodRef);
 
-		public TValue find(IMethod methodRef) {
+		public TValue Find(IMethod methodRef) {
 			TValue value;
 			var methodDef = methodRef as MethodDef;
 			if (methodDef != null)
-				tokenToValue.TryGetValue(getTokenKey(methodDef), out value);
+				tokenToValue.TryGetValue(GetTokenKey(methodDef), out value);
 			else
-				refToValue.TryGetValue(getRefKey(methodRef), out value);
+				refToValue.TryGetValue(GetRefKey(methodRef), out value);
 			return value;
 		}
 
-		public TValue findAny(IMethod methodRef) {
+		public TValue FindAny(IMethod methodRef) {
 			TValue value;
 			var methodDef = methodRef as MethodDef;
-			if (methodDef != null && tokenToValue.TryGetValue(getTokenKey(methodDef), out value))
+			if (methodDef != null && tokenToValue.TryGetValue(GetTokenKey(methodDef), out value))
 				return value;
 
-			refToValue.TryGetValue(getRefKey(methodRef), out value);
+			refToValue.TryGetValue(GetRefKey(methodRef), out value);
 			return value;
 		}
 
-		public void add(MethodDef methodDef, TValue value) {
-			var tokenKey = getTokenKey(methodDef);
+		public void Add(MethodDef methodDef, TValue value) {
+			var tokenKey = GetTokenKey(methodDef);
 			tokenToValue[tokenKey] = value;
 			tokenToKey[tokenKey] = methodDef;
 
-			var refKey = getRefKey(methodDef);
+			var refKey = GetRefKey(methodDef);
 			if (!refToValue.ContainsKey(refKey) ||
-				getAccessibilityOrder(methodDef) < getAccessibilityOrder(refToKey[refKey])) {
+				GetAccessibilityOrder(methodDef) < GetAccessibilityOrder(refToKey[refKey])) {
 				refToKey[refKey] = methodDef;
 				refToValue[refKey] = value;
 			}
@@ -261,26 +261,26 @@ namespace de4dot.blocks {
 			0,		// Public
 			70,		// <reserved>
 		};
-		static int getAccessibilityOrder(MethodDef methodDef) {
+		static int GetAccessibilityOrder(MethodDef methodDef) {
 			return accessibilityOrder[(int)methodDef.Attributes & 7];
 		}
 
-		public void onTypesRenamed() {
+		public void OnTypesRenamed() {
 			var newFieldRefToDef = new Dictionary<IMethodRefKey, TValue>(refToValue.Count);
 			foreach (var kvp in refToValue)
-				newFieldRefToDef[getRefKey((MethodDef)kvp.Key.MethodRef)] = kvp.Value;
+				newFieldRefToDef[GetRefKey((MethodDef)kvp.Key.MethodRef)] = kvp.Value;
 			refToValue = newFieldRefToDef;
 		}
 	}
 
 	public class MethodDefDict<TValue> : MethodDefDictBase<TValue> {
-		internal override IMethodRefKey getRefKey(IMethod methodRef) {
+		internal override IMethodRefKey GetRefKey(IMethod methodRef) {
 			return new MethodRefKey(methodRef);
 		}
 	}
 
 	public class MethodDefAndDeclaringTypeDict<TValue> : MethodDefDictBase<TValue> {
-		internal override IMethodRefKey getRefKey(IMethod methodRef) {
+		internal override IMethodRefKey GetRefKey(IMethod methodRef) {
 			return new MethodRefAndDeclaringTypeKey(methodRef);
 		}
 	}
@@ -294,59 +294,59 @@ namespace de4dot.blocks {
 			get { return tokenToValue.Count; }
 		}
 
-		public IEnumerable<EventDef> getKeys() {
+		public IEnumerable<EventDef> GetKeys() {
 			return tokenToKey.Values;
 		}
 
-		public IEnumerable<TValue> getValues() {
+		public IEnumerable<TValue> GetValues() {
 			return tokenToValue.Values;
 		}
 
-		ScopeAndTokenKey getTokenKey(EventDef eventRef) {
+		ScopeAndTokenKey GetTokenKey(EventDef eventRef) {
 			return new ScopeAndTokenKey(eventRef);
 		}
 
-		internal abstract IEventRefKey getRefKey(EventDef eventRef);
+		internal abstract IEventRefKey GetRefKey(EventDef eventRef);
 
-		public TValue find(EventDef eventRef) {
+		public TValue Find(EventDef eventRef) {
 			TValue value;
-			tokenToValue.TryGetValue(getTokenKey(eventRef), out value);
+			tokenToValue.TryGetValue(GetTokenKey(eventRef), out value);
 			return value;
 		}
 
-		public TValue findAny(EventDef eventRef) {
+		public TValue FindAny(EventDef eventRef) {
 			TValue value;
-			if (tokenToValue.TryGetValue(getTokenKey(eventRef), out value))
+			if (tokenToValue.TryGetValue(GetTokenKey(eventRef), out value))
 				return value;
 
-			refToValue.TryGetValue(getRefKey(eventRef), out value);
+			refToValue.TryGetValue(GetRefKey(eventRef), out value);
 			return value;
 		}
 
-		public void add(EventDef eventDef, TValue value) {
-			var tokenKey = getTokenKey(eventDef);
+		public void Add(EventDef eventDef, TValue value) {
+			var tokenKey = GetTokenKey(eventDef);
 			tokenToValue[tokenKey] = value;
 			tokenToKey[tokenKey] = eventDef;
 
-			refToValue[getRefKey(eventDef)] = value;
+			refToValue[GetRefKey(eventDef)] = value;
 		}
 
-		public void onTypesRenamed() {
+		public void OnTypesRenamed() {
 			var newFieldRefToDef = new Dictionary<IEventRefKey, TValue>(refToValue.Count);
 			foreach (var kvp in refToValue)
-				newFieldRefToDef[getRefKey((EventDef)kvp.Key.EventDef)] = kvp.Value;
+				newFieldRefToDef[GetRefKey((EventDef)kvp.Key.EventDef)] = kvp.Value;
 			refToValue = newFieldRefToDef;
 		}
 	}
 
 	public class EventDefDict<TValue> : EventDefDictBase<TValue> {
-		internal override IEventRefKey getRefKey(EventDef eventRef) {
+		internal override IEventRefKey GetRefKey(EventDef eventRef) {
 			return new EventRefKey(eventRef);
 		}
 	}
 
 	public class EventDefAndDeclaringTypeDict<TValue> : EventDefDictBase<TValue> {
-		internal override IEventRefKey getRefKey(EventDef eventRef) {
+		internal override IEventRefKey GetRefKey(EventDef eventRef) {
 			return new EventRefAndDeclaringTypeKey(eventRef);
 		}
 	}
@@ -360,59 +360,59 @@ namespace de4dot.blocks {
 			get { return tokenToValue.Count; }
 		}
 
-		public IEnumerable<PropertyDef> getKeys() {
+		public IEnumerable<PropertyDef> GetKeys() {
 			return tokenToKey.Values;
 		}
 
-		public IEnumerable<TValue> getValues() {
+		public IEnumerable<TValue> GetValues() {
 			return tokenToValue.Values;
 		}
 
-		ScopeAndTokenKey getTokenKey(PropertyDef propertyRef) {
+		ScopeAndTokenKey GetTokenKey(PropertyDef propertyRef) {
 			return new ScopeAndTokenKey(propertyRef);
 		}
 
-		internal abstract IPropertyRefKey getRefKey(PropertyDef propertyRef);
+		internal abstract IPropertyRefKey GetRefKey(PropertyDef propertyRef);
 
-		public TValue find(PropertyDef propRef) {
+		public TValue Find(PropertyDef propRef) {
 			TValue value;
-			tokenToValue.TryGetValue(getTokenKey(propRef), out value);
+			tokenToValue.TryGetValue(GetTokenKey(propRef), out value);
 			return value;
 		}
 
-		public TValue findAny(PropertyDef propRef) {
+		public TValue FindAny(PropertyDef propRef) {
 			TValue value;
-			if (tokenToValue.TryGetValue(getTokenKey(propRef), out value))
+			if (tokenToValue.TryGetValue(GetTokenKey(propRef), out value))
 				return value;
 
-			refToValue.TryGetValue(getRefKey(propRef), out value);
+			refToValue.TryGetValue(GetRefKey(propRef), out value);
 			return value;
 		}
 
-		public void add(PropertyDef propDef, TValue value) {
-			var tokenKey = getTokenKey(propDef);
+		public void Add(PropertyDef propDef, TValue value) {
+			var tokenKey = GetTokenKey(propDef);
 			tokenToValue[tokenKey] = value;
 			tokenToKey[tokenKey] = propDef;
 
-			refToValue[getRefKey(propDef)] = value;
+			refToValue[GetRefKey(propDef)] = value;
 		}
 
-		public void onTypesRenamed() {
+		public void OnTypesRenamed() {
 			var newFieldRefToDef = new Dictionary<IPropertyRefKey, TValue>(refToValue.Count);
 			foreach (var kvp in refToValue)
-				newFieldRefToDef[getRefKey((PropertyDef)kvp.Key.PropertyDef)] = kvp.Value;
+				newFieldRefToDef[GetRefKey((PropertyDef)kvp.Key.PropertyDef)] = kvp.Value;
 			refToValue = newFieldRefToDef;
 		}
 	}
 
 	public class PropertyDefDict<TValue> : PropertyDefDictBase<TValue> {
-		internal override IPropertyRefKey getRefKey(PropertyDef propRef) {
+		internal override IPropertyRefKey GetRefKey(PropertyDef propRef) {
 			return new PropertyRefKey(propRef);
 		}
 	}
 
 	public class PropertyDefAndDeclaringTypeDict<TValue> : PropertyDefDictBase<TValue> {
-		internal override IPropertyRefKey getRefKey(PropertyDef propRef) {
+		internal override IPropertyRefKey GetRefKey(PropertyDef propRef) {
 			return new PropertyRefAndDeclaringTypeKey(propRef);
 		}
 	}
@@ -467,16 +467,16 @@ namespace de4dot.blocks {
 				return true;
 			if (a == null || b == null)
 				return false;
-			return getCanonicalizedScopeName(a) == getCanonicalizedScopeName(b);
+			return GetCanonicalizedScopeName(a) == GetCanonicalizedScopeName(b);
 		}
 
 		static int GetHashCode(IScope a) {
 			if (a == null)
 				return 0;
-			return getCanonicalizedScopeName(a).GetHashCode();
+			return GetCanonicalizedScopeName(a).GetHashCode();
 		}
 
-		static string getAssemblyName(IScope a) {
+		static string GetAssemblyName(IScope a) {
 			switch (a.ScopeType) {
 			case ScopeType.AssemblyRef:
 				return ((AssemblyRef)a).Name.String;
@@ -489,10 +489,10 @@ namespace de4dot.blocks {
 			return null;
 		}
 
-		static string getCanonicalizedScopeName(IScope a) {
+		static string GetCanonicalizedScopeName(IScope a) {
 			if (a == null)
 				return string.Empty;
-			var asmName = getAssemblyName(a);
+			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.
diff --git a/blocks/ScopeBlock.cs b/blocks/ScopeBlock.cs
index 6817f822..952cc155 100644
--- a/blocks/ScopeBlock.cs
+++ b/blocks/ScopeBlock.cs
@@ -32,52 +32,52 @@ namespace de4dot.blocks {
 			set { baseBlocks = value; }
 		}
 
-		public IEnumerable<BaseBlock> getBaseBlocks() {
+		public IEnumerable<BaseBlock> GetBaseBlocks() {
 			if (baseBlocks != null) {
 				foreach (var bb in baseBlocks)
 					yield return bb;
 			}
 		}
 
-		public List<BaseBlock> getAllBaseBlocks() {
-			return getTheBlocks(new List<BaseBlock>());
+		public List<BaseBlock> GetAllBaseBlocks() {
+			return GetTheBlocks(new List<BaseBlock>());
 		}
 
-		public List<Block> getAllBlocks() {
-			return getTheBlocks(new List<Block>());
+		public List<Block> GetAllBlocks() {
+			return GetTheBlocks(new List<Block>());
 		}
 
-		public List<Block> getAllBlocks(List<Block> allBlocks) {
+		public List<Block> GetAllBlocks(List<Block> allBlocks) {
 			allBlocks.Clear();
-			return getTheBlocks(allBlocks);
+			return GetTheBlocks(allBlocks);
 		}
 
-		public List<ScopeBlock> getAllScopeBlocks() {
-			return getTheBlocks(new List<ScopeBlock>());
+		public List<ScopeBlock> GetAllScopeBlocks() {
+			return GetTheBlocks(new List<ScopeBlock>());
 		}
 
-		public List<T> getTheBlocks<T>(List<T> list) where T : BaseBlock {
-			addBlocks(list, this);
+		public List<T> GetTheBlocks<T>(List<T> list) where T : BaseBlock {
+			AddBlocks(list, this);
 			return list;
 		}
 
-		void addBlocks<T>(IList<T> list, ScopeBlock scopeBlock) where T : BaseBlock {
-			foreach (var bb in scopeBlock.getBaseBlocks()) {
+		void AddBlocks<T>(IList<T> list, ScopeBlock scopeBlock) where T : BaseBlock {
+			foreach (var bb in scopeBlock.GetBaseBlocks()) {
 				T t = bb as T;
 				if (t != null)
 					list.Add(t);
 				if (bb is ScopeBlock)
-					addBlocks(list, (ScopeBlock)bb);
+					AddBlocks(list, (ScopeBlock)bb);
 			}
 		}
 
-		List<Block> findBlocks() {
-			return findBlocks(null);
+		List<Block> FindBlocks() {
+			return FindBlocks(null);
 		}
 
-		List<Block> findBlocks(Func<Block, bool> blockChecker) {
+		List<Block> FindBlocks(Func<Block, bool> blockChecker) {
 			var blocks = new List<Block>();
-			foreach (var bb in getBaseBlocks()) {
+			foreach (var bb in GetBaseBlocks()) {
 				Block block = bb as Block;
 				if (block != null && (blockChecker == null || blockChecker(block)))
 					blocks.Add(block);
@@ -85,7 +85,7 @@ namespace de4dot.blocks {
 			return blocks;
 		}
 
-		internal bool getLdcValue(Instr instr, out int value) {
+		internal bool GetLdcValue(Instr instr, out int value) {
 			if (Code.Ldc_I4_0 <= instr.OpCode.Code && instr.OpCode.Code <= Code.Ldc_I4_8)
 				value = instr.OpCode.Code - Code.Ldc_I4_0;
 			else if (instr.OpCode.Code == Code.Ldc_I4)
@@ -103,18 +103,18 @@ namespace de4dot.blocks {
 
 		// Remove the block if it's a dead block. If it has refs to other dead blocks, those
 		// are also removed.
-		public void removeDeadBlock(Block block) {
-			removeDeadBlocks(new List<Block> { block });
+		public void RemoveDeadBlock(Block block) {
+			RemoveDeadBlocks(new List<Block> { block });
 		}
 
 		// Remove all dead blocks we can find
-		public void removeDeadBlocks() {
-			removeDeadBlocks(findBlocks());
+		public void RemoveDeadBlocks() {
+			RemoveDeadBlocks(FindBlocks());
 		}
 
 		// Remove the blocks if they're dead blocks. If they have refs to other dead blocks,
 		// those are also removed.
-		public void removeDeadBlocks(List<Block> blocks) {
+		public void RemoveDeadBlocks(List<Block> blocks) {
 			while (blocks.Count != 0) {
 				var block = blocks[blocks.Count - 1];
 				blocks.RemoveAt(blocks.Count - 1);
@@ -122,7 +122,7 @@ namespace de4dot.blocks {
 					continue;	// Not dead
 				if (block == baseBlocks[0])
 					continue;	// It's the start of this block fence so must be present
-				if (!isOurBaseBlock(block))
+				if (!IsOurBaseBlock(block))
 					continue;	// Some other ScopeBlock owns it, eg. first instr of an exception handler
 
 				// It's a dead block we can delete!
@@ -131,27 +131,27 @@ namespace de4dot.blocks {
 					blocks.Add(block.FallThrough);
 				if (block.Targets != null)
 					blocks.AddRange(block.Targets);
-				block.removeDeadBlock();
+				block.RemoveDeadBlock();
 				if (!baseBlocks.Remove(block))
 					throw new ApplicationException("Could not remove dead block from baseBlocks");
 			}
 		}
 
-		public bool isOurBaseBlock(BaseBlock bb) {
+		public bool IsOurBaseBlock(BaseBlock bb) {
 			return bb != null && bb.Parent == this;
 		}
 
 		// For each block, if it has only one target, and the target has only one source, then
 		// merge them into one block.
-		public int mergeBlocks() {
+		public int MergeBlocks() {
 			int mergedBlocks = 0;
-			var blocks = findBlocks();
+			var blocks = FindBlocks();
 			for (int i = 0; i < blocks.Count; i++) {
 				var block = blocks[i];
-				var target = block.getOnlyTarget();
-				if (!isOurBaseBlock(target))
+				var target = block.GetOnlyTarget();
+				if (!IsOurBaseBlock(target))
 					continue;	// Only merge blocks we own!
-				if (!block.canMerge(target))
+				if (!block.CanMerge(target))
 					continue;	// Can't merge them!
 				if (target == baseBlocks[0])
 					continue;	// The first one has an implicit source (eg. start of method or exception handler)
@@ -160,7 +160,7 @@ namespace de4dot.blocks {
 				if (targetIndex < 0)
 					throw new ApplicationException("Could not remove target block from blocks");
 				blocks.RemoveAt(targetIndex);
-				block.merge(target);
+				block.Merge(target);
 				if (!baseBlocks.Remove(target))
 					throw new ApplicationException("Could not remove merged block from baseBlocks");
 				if (targetIndex < i)
@@ -174,20 +174,20 @@ namespace de4dot.blocks {
 
 		// If bb is in baseBlocks (a direct child), return bb. If bb is a BaseBlock in a
 		// ScopeBlock that is a direct child, then return that ScopeBlock. Else return null.
-		public BaseBlock toChild(BaseBlock bb) {
-			if (isOurBaseBlock(bb))
+		public BaseBlock ToChild(BaseBlock bb) {
+			if (IsOurBaseBlock(bb))
 				return bb;
 
 			for (var sb = bb.Parent; sb != null; sb = sb.Parent) {
-				if (isOurBaseBlock(sb))
+				if (IsOurBaseBlock(sb))
 					return sb;
 			}
 
 			return null;
 		}
 
-		internal void repartitionBlocks() {
-			var newBaseBlocks = new BlocksSorter(this).sort();
+		internal void RepartitionBlocks() {
+			var newBaseBlocks = new BlocksSorter(this).Sort();
 
 			const bool insane = true;
 			if (insane) {
@@ -206,7 +206,7 @@ namespace de4dot.blocks {
 
 		// Removes the TryBlock and all its TryHandlerBlocks. The code inside the try block
 		// is not removed.
-		public void removeTryBlock(TryBlock tryBlock) {
+		public void RemoveTryBlock(TryBlock tryBlock) {
 			int tryBlockIndex = baseBlocks.IndexOf(tryBlock);
 			if (tryBlockIndex < 0)
 				throw new ApplicationException("Can't remove the TryBlock since it's not this ScopeBlock's TryBlock");
@@ -220,15 +220,15 @@ namespace de4dot.blocks {
 			// Get removed blocks and make sure they're not referenced by remaining code
 			var removedBlocks = new List<Block>();
 			foreach (var handler in tryBlock.TryHandlerBlocks)
-				handler.getTheBlocks(removedBlocks);
-			if (!verifyNoExternalRefs(removedBlocks))
+				handler.GetTheBlocks(removedBlocks);
+			if (!VerifyNoExternalRefs(removedBlocks))
 				throw new ApplicationException("Removed blocks are referenced by remaining code");
 
-			removeAllDeadBlocks(Utils.convert<TryHandlerBlock, BaseBlock>(tryBlock.TryHandlerBlocks));
+			RemoveAllDeadBlocks(Utils.Convert<TryHandlerBlock, BaseBlock>(tryBlock.TryHandlerBlocks));
 		}
 
 		// Returns true if no external blocks references the blocks
-		static bool verifyNoExternalRefs(IList<Block> removedBlocks) {
+		static bool VerifyNoExternalRefs(IList<Block> removedBlocks) {
 			var removedDict = new Dictionary<Block, bool>();
 			foreach (var removedBlock in removedBlocks)
 				removedDict[removedBlock] = true;
@@ -243,13 +243,13 @@ namespace de4dot.blocks {
 		}
 
 		// Remove all blocks in deadBlocks. They're guaranteed to be dead.
-		void removeAllDeadBlocks(IEnumerable<BaseBlock> deadBlocks) {
-			removeAllDeadBlocks(deadBlocks, null);
+		void RemoveAllDeadBlocks(IEnumerable<BaseBlock> deadBlocks) {
+			RemoveAllDeadBlocks(deadBlocks, null);
 		}
 
 		// Remove all blocks in deadBlocks. They're guaranteed to be dead. deadBlocksDict is
 		// a dictionary of all dead blocks (even those not in this ScopeBlock).
-		internal void removeAllDeadBlocks(IEnumerable<BaseBlock> deadBlocks, Dictionary<BaseBlock, bool> deadBlocksDict) {
+		internal void RemoveAllDeadBlocks(IEnumerable<BaseBlock> deadBlocks, Dictionary<BaseBlock, bool> deadBlocksDict) {
 
 			// Verify that all the blocks really are dead. If all their source blocks are
 			// dead, then they are dead.
@@ -260,7 +260,7 @@ namespace de4dot.blocks {
 					allDeadBlocks.Add(bb as Block);
 				else if (bb is ScopeBlock) {
 					var sb = (ScopeBlock)bb;
-					allDeadBlocks.AddRange(sb.getAllBlocks());
+					allDeadBlocks.AddRange(sb.GetAllBlocks());
 				}
 				else
 					throw new ApplicationException(string.Format("Unknown BaseBlock type {0}", bb.GetType()));
@@ -278,20 +278,20 @@ namespace de4dot.blocks {
 			}
 
 			foreach (var block in allDeadBlocks)
-				block.removeGuaranteedDeadBlock();
+				block.RemoveGuaranteedDeadBlock();
 			foreach (var bb in deadBlocks) {
 				if (!baseBlocks.Remove(bb))
 					throw new ApplicationException("Could not remove dead base block from baseBlocks");
 			}
 		}
 
-		public void removeGuaranteedDeadBlock(Block block) {
+		public void RemoveGuaranteedDeadBlock(Block block) {
 			if (!baseBlocks.Remove(block))
 				throw new ApplicationException("Could not remove dead block");
-			block.removeGuaranteedDeadBlock();
+			block.RemoveGuaranteedDeadBlock();
 		}
 
-		public void add(Block block) {
+		public void Add(Block block) {
 			if (block.Parent != null)
 				throw new ApplicationException("Block already has a parent");
 			baseBlocks.Add(block);
diff --git a/blocks/TryBlock.cs b/blocks/TryBlock.cs
index 4a664117..a1ac3246 100644
--- a/blocks/TryBlock.cs
+++ b/blocks/TryBlock.cs
@@ -31,7 +31,7 @@ namespace de4dot.blocks {
 			get { return handlerBlocks; }
 		}
 
-		public void addTryHandler(TryHandlerBlock tryHandlerBlock) {
+		public void AddTryHandler(TryHandlerBlock tryHandlerBlock) {
 			handlerBlocks.Add(tryHandlerBlock);
 		}
 	}
diff --git a/blocks/Utils.cs b/blocks/Utils.cs
index f0502326..80cb953d 100644
--- a/blocks/Utils.cs
+++ b/blocks/Utils.cs
@@ -47,21 +47,21 @@ namespace de4dot.blocks {
 	}
 
 	static class Utils {
-		public static IDictionary<T, int> createObjectToIndexDictionary<T>(IList<T> objs) {
+		public static IDictionary<T, int> CreateObjectToIndexDictionary<T>(IList<T> objs) {
 			var dict = new Dictionary<T, int>();
 			for (int i = 0; i < objs.Count; i++)
 				dict[objs[i]] = i;
 			return dict;
 		}
 
-		public static List<TOut> convert<TIn, TOut>(IEnumerable<TIn> list) where TIn : TOut {
+		public static List<TOut> Convert<TIn, TOut>(IEnumerable<TIn> list) where TIn : TOut {
 			var olist = new List<TOut>();
 			foreach (var l in list)
 				olist.Add(l);
 			return olist;
 		}
 
-		public static IEnumerable<T> unique<T>(IEnumerable<T> values) {
+		public static IEnumerable<T> Unique<T>(IEnumerable<T> values) {
 			// HashSet is only available in .NET 3.5 and later.
 			var dict = new Dictionary<T, bool>();
 			foreach (var val in values)
diff --git a/blocks/cflow/BlockCflowDeobfuscator.cs b/blocks/cflow/BlockCflowDeobfuscator.cs
index 2d4412fb..24975de0 100644
--- a/blocks/cflow/BlockCflowDeobfuscator.cs
+++ b/blocks/cflow/BlockCflowDeobfuscator.cs
@@ -31,11 +31,11 @@ namespace de4dot.blocks.cflow {
 			branchEmulator = new BranchEmulator(instructionEmulator, this);
 		}
 
-		protected override bool deobfuscate(Block block) {
+		protected override bool Deobfuscate(Block block) {
 			this.block = block;
-			if (!block.LastInstr.isConditionalBranch() && block.LastInstr.OpCode.Code != Code.Switch)
+			if (!block.LastInstr.IsConditionalBranch() && block.LastInstr.OpCode.Code != Code.Switch)
 				return false;
-			instructionEmulator.init(blocks);
+			instructionEmulator.Initialize(blocks);
 
 			var instructions = block.Instructions;
 			if (instructions.Count == 0)
@@ -43,7 +43,7 @@ namespace de4dot.blocks.cflow {
 			try {
 				for (int i = 0; i < instructions.Count - 1; i++) {
 					var instr = instructions[i].Instruction;
-					instructionEmulator.emulate(instr);
+					instructionEmulator.Emulate(instr);
 				}
 			}
 			catch (NullReferenceException) {
@@ -51,28 +51,28 @@ namespace de4dot.blocks.cflow {
 				return false;
 			}
 
-			return branchEmulator.emulate(block.LastInstr.Instruction);
+			return branchEmulator.Emulate(block.LastInstr.Instruction);
 		}
 
-		void popPushedArgs(int stackArgs) {
+		void PopPushedArgs(int stackArgs) {
 			// Pop the arguments to the bcc instruction. The dead code remover will get rid of the
 			// pop and any pushed arguments. Insert the pops just before the bcc instr.
 			for (int i = 0; i < stackArgs; i++)
-				block.insert(block.Instructions.Count - 1, OpCodes.Pop.ToInstruction());
+				block.Insert(block.Instructions.Count - 1, OpCodes.Pop.ToInstruction());
 		}
 
-		void IBranchHandler.handleNormal(int stackArgs, bool isTaken) {
-			popPushedArgs(stackArgs);
-			block.replaceBccWithBranch(isTaken);
+		void IBranchHandler.HandleNormal(int stackArgs, bool isTaken) {
+			PopPushedArgs(stackArgs);
+			block.ReplaceBccWithBranch(isTaken);
 		}
 
-		bool IBranchHandler.handleSwitch(Int32Value switchIndex) {
-			var target = CflowUtils.getSwitchTarget(block.Targets, block.FallThrough, switchIndex);
+		bool IBranchHandler.HandleSwitch(Int32Value switchIndex) {
+			var target = CflowUtils.GetSwitchTarget(block.Targets, block.FallThrough, switchIndex);
 			if (target == null)
 				return false;
 
-			popPushedArgs(1);
-			block.replaceSwitchWithBranch(target);
+			PopPushedArgs(1);
+			block.ReplaceSwitchWithBranch(target);
 			return true;
 		}
 	}
diff --git a/blocks/cflow/BlockDeobfuscator.cs b/blocks/cflow/BlockDeobfuscator.cs
index 473fa574..fabd9146 100644
--- a/blocks/cflow/BlockDeobfuscator.cs
+++ b/blocks/cflow/BlockDeobfuscator.cs
@@ -27,17 +27,17 @@ namespace de4dot.blocks.cflow {
 
 		public bool ExecuteOnNoChange { get; set; }
 
-		public virtual void deobfuscateBegin(Blocks blocks) {
+		public virtual void DeobfuscateBegin(Blocks blocks) {
 			this.blocks = blocks;
 		}
 
-		public bool deobfuscate(List<Block> allBlocks) {
-			init(allBlocks);
+		public bool Deobfuscate(List<Block> allBlocks) {
+			Initialize(allBlocks);
 
 			bool changed = false;
 			foreach (var block in allBlocks) {
 				try {
-					changed |= deobfuscate(block);
+					changed |= Deobfuscate(block);
 				}
 				catch (NullReferenceException) {
 					// Here if eg. invalid metadata token in a call instruction (operand is null)
@@ -46,10 +46,10 @@ namespace de4dot.blocks.cflow {
 			return changed;
 		}
 
-		protected virtual void init(List<Block> allBlocks) {
+		protected virtual void Initialize(List<Block> allBlocks) {
 			this.allBlocks = allBlocks;
 		}
 
-		protected abstract bool deobfuscate(Block block);
+		protected abstract bool Deobfuscate(Block block);
 	}
 }
diff --git a/blocks/cflow/BlocksCflowDeobfuscator.cs b/blocks/cflow/BlocksCflowDeobfuscator.cs
index a0b7df4e..af37f5a7 100644
--- a/blocks/cflow/BlocksCflowDeobfuscator.cs
+++ b/blocks/cflow/BlocksCflowDeobfuscator.cs
@@ -28,15 +28,15 @@ namespace de4dot.blocks.cflow {
 		List<IBlocksDeobfuscator> ourBlocksDeobfuscators = new List<IBlocksDeobfuscator>();
 
 		public BlocksCflowDeobfuscator() {
-			init();
+			Initialize();
 		}
 
 		public BlocksCflowDeobfuscator(IEnumerable<IBlocksDeobfuscator> blocksDeobfuscator) {
-			init();
-			add(blocksDeobfuscator);
+			Initialize();
+			Add(blocksDeobfuscator);
 		}
 
-		void init() {
+		void Initialize() {
 			ourBlocksDeobfuscators.Add(new BlockCflowDeobfuscator { ExecuteOnNoChange = false });
 			ourBlocksDeobfuscators.Add(new SwitchCflowDeobfuscator { ExecuteOnNoChange = false });
 			ourBlocksDeobfuscators.Add(new DeadStoreRemover { ExecuteOnNoChange = false });
@@ -46,73 +46,73 @@ namespace de4dot.blocks.cflow {
 			ourBlocksDeobfuscators.Add(new DupBlockCflowDeobfuscator { ExecuteOnNoChange = true });
 		}
 
-		public void add(IEnumerable<IBlocksDeobfuscator> blocksDeobfuscators) {
+		public void Add(IEnumerable<IBlocksDeobfuscator> blocksDeobfuscators) {
 			foreach (var bd in blocksDeobfuscators)
-				add(bd);
+				Add(bd);
 		}
 
-		public void add(IBlocksDeobfuscator blocksDeobfuscator) {
+		public void Add(IBlocksDeobfuscator blocksDeobfuscator) {
 			if (blocksDeobfuscator != null)
 				userBlocksDeobfuscators.Add(blocksDeobfuscator);
 		}
 
-		public void init(Blocks blocks) {
+		public void Initialize(Blocks blocks) {
 			this.blocks = blocks;
 		}
 
-		public void deobfuscate() {
+		public void Deobfuscate() {
 			bool changed;
 			int iterations = -1;
 
-			deobfuscateBegin(userBlocksDeobfuscators);
-			deobfuscateBegin(ourBlocksDeobfuscators);
+			DeobfuscateBegin(userBlocksDeobfuscators);
+			DeobfuscateBegin(ourBlocksDeobfuscators);
 
 			do {
 				iterations++;
 				changed = false;
-				removeDeadBlocks();
-				mergeBlocks();
+				RemoveDeadBlocks();
+				MergeBlocks();
 
-				blocks.MethodBlocks.getAllBlocks(allBlocks);
+				blocks.MethodBlocks.GetAllBlocks(allBlocks);
 
 				if (iterations == 0)
-					changed |= fixDotfuscatorLoop();
+					changed |= FixDotfuscatorLoop();
 
-				changed |= deobfuscate(userBlocksDeobfuscators, allBlocks);
-				changed |= deobfuscate(ourBlocksDeobfuscators, allBlocks);
-				changed |= deobfuscateNoChange(changed, userBlocksDeobfuscators, allBlocks);
-				changed |= deobfuscateNoChange(changed, ourBlocksDeobfuscators, allBlocks);
+				changed |= Deobfuscate(userBlocksDeobfuscators, allBlocks);
+				changed |= Deobfuscate(ourBlocksDeobfuscators, allBlocks);
+				changed |= DeobfuscateNoChange(changed, userBlocksDeobfuscators, allBlocks);
+				changed |= DeobfuscateNoChange(changed, ourBlocksDeobfuscators, allBlocks);
 			} while (changed);
 		}
 
-		void deobfuscateBegin(IEnumerable<IBlocksDeobfuscator> bds) {
+		void DeobfuscateBegin(IEnumerable<IBlocksDeobfuscator> bds) {
 			foreach (var bd in bds)
-				bd.deobfuscateBegin(blocks);
+				bd.DeobfuscateBegin(blocks);
 		}
 
-		bool deobfuscate(IEnumerable<IBlocksDeobfuscator> bds, List<Block> allBlocks) {
+		bool Deobfuscate(IEnumerable<IBlocksDeobfuscator> bds, List<Block> allBlocks) {
 			bool changed = false;
 			foreach (var bd in bds) {
 				if (bd.ExecuteOnNoChange)
 					continue;
-				changed |= bd.deobfuscate(allBlocks);
+				changed |= bd.Deobfuscate(allBlocks);
 			}
 			return changed;
 		}
 
-		bool deobfuscateNoChange(bool changed, IEnumerable<IBlocksDeobfuscator> bds, List<Block> allBlocks) {
+		bool DeobfuscateNoChange(bool changed, IEnumerable<IBlocksDeobfuscator> bds, List<Block> allBlocks) {
 			foreach (var bd in bds) {
 				if (changed)
 					break;
 				if (!bd.ExecuteOnNoChange)
 					continue;
-				changed |= bd.deobfuscate(allBlocks);
+				changed |= bd.Deobfuscate(allBlocks);
 			}
 			return changed;
 		}
 
 		// Hack for old Dotfuscator
-		bool fixDotfuscatorLoop() {
+		bool FixDotfuscatorLoop() {
 			/*
 			blk1:
 				...
@@ -136,7 +136,7 @@ namespace de4dot.blocks.cflow {
 					continue;
 				if (instructions[1].OpCode.Code != Code.Dup)
 					continue;
-				if (!instructions[2].isLdcI4())
+				if (!instructions[2].IsLdcI4())
 					continue;
 				if (instructions[3].OpCode.Code != Code.Sub && instructions[3].OpCode.Code != Code.Add)
 					continue;
@@ -148,32 +148,32 @@ namespace de4dot.blocks.cflow {
 				var prev = block.Sources[0];
 				if (prev == block)
 					prev = block.Sources[1];
-				if (prev == null || !prev.LastInstr.isLdcI4())
+				if (prev == null || !prev.LastInstr.IsLdcI4())
 					continue;
 				var next = block.FallThrough;
 				if (next.FirstInstr.OpCode.Code != Code.Pop)
 					continue;
-				block.replaceLastInstrsWithBranch(5, next);
+				block.ReplaceLastInstrsWithBranch(5, next);
 				changed = true;
 			}
 			return changed;
 		}
 
-		bool removeDeadBlocks() {
-			return new DeadBlocksRemover(blocks.MethodBlocks).remove() > 0;
+		bool RemoveDeadBlocks() {
+			return new DeadBlocksRemover(blocks.MethodBlocks).Remove() > 0;
 		}
 
-		bool mergeBlocks() {
+		bool MergeBlocks() {
 			bool changed = false;
-			foreach (var scopeBlock in getAllScopeBlocks(blocks.MethodBlocks))
-				changed |= scopeBlock.mergeBlocks() > 0;
+			foreach (var scopeBlock in GetAllScopeBlocks(blocks.MethodBlocks))
+				changed |= scopeBlock.MergeBlocks() > 0;
 			return changed;
 		}
 
-		IEnumerable<ScopeBlock> getAllScopeBlocks(ScopeBlock scopeBlock) {
+		IEnumerable<ScopeBlock> GetAllScopeBlocks(ScopeBlock scopeBlock) {
 			var list = new List<ScopeBlock>();
 			list.Add(scopeBlock);
-			list.AddRange(scopeBlock.getAllScopeBlocks());
+			list.AddRange(scopeBlock.GetAllScopeBlocks());
 			return list;
 		}
 	}
diff --git a/blocks/cflow/BranchEmulator.cs b/blocks/cflow/BranchEmulator.cs
index e9e755a9..f71e1d2d 100644
--- a/blocks/cflow/BranchEmulator.cs
+++ b/blocks/cflow/BranchEmulator.cs
@@ -22,10 +22,10 @@ using dnlib.DotNet.Emit;
 namespace de4dot.blocks.cflow {
 	public interface IBranchHandler {
 		// stackArgs is the number of args used by the branch instruction (1 or 2)
-		void handleNormal(int stackArgs, bool isTaken);
+		void HandleNormal(int stackArgs, bool isTaken);
 
 		// Returns true if the switch target was found (even if it was the fall-through)
-		bool handleSwitch(Int32Value switchIndex);
+		bool HandleSwitch(Int32Value switchIndex);
 	}
 
 	public class BranchEmulator {
@@ -37,216 +37,216 @@ namespace de4dot.blocks.cflow {
 			this.branchHandler = branchHandler;
 		}
 
-		public bool emulate(Instruction instr) {
+		public bool Emulate(Instruction instr) {
 			switch (instr.OpCode.Code) {
 			case Code.Br:
-			case Code.Br_S:		return emulate_Br();
+			case Code.Br_S:		return Emulate_Br();
 			case Code.Beq:
-			case Code.Beq_S:	return emulate_Beq();
+			case Code.Beq_S:	return Emulate_Beq();
 			case Code.Bge:
-			case Code.Bge_S:	return emulate_Bge();
+			case Code.Bge_S:	return Emulate_Bge();
 			case Code.Bge_Un:
-			case Code.Bge_Un_S:	return emulate_Bge_Un();
+			case Code.Bge_Un_S:	return Emulate_Bge_Un();
 			case Code.Bgt:
-			case Code.Bgt_S:	return emulate_Bgt();
+			case Code.Bgt_S:	return Emulate_Bgt();
 			case Code.Bgt_Un:
-			case Code.Bgt_Un_S:	return emulate_Bgt_Un();
+			case Code.Bgt_Un_S:	return Emulate_Bgt_Un();
 			case Code.Ble:
-			case Code.Ble_S:	return emulate_Ble();
+			case Code.Ble_S:	return Emulate_Ble();
 			case Code.Ble_Un:
-			case Code.Ble_Un_S:	return emulate_Ble_Un();
+			case Code.Ble_Un_S:	return Emulate_Ble_Un();
 			case Code.Blt:
-			case Code.Blt_S:	return emulate_Blt();
+			case Code.Blt_S:	return Emulate_Blt();
 			case Code.Blt_Un:
-			case Code.Blt_Un_S:	return emulate_Blt_Un();
+			case Code.Blt_Un_S:	return Emulate_Blt_Un();
 			case Code.Bne_Un:
-			case Code.Bne_Un_S:	return emulate_Bne_Un();
+			case Code.Bne_Un_S:	return Emulate_Bne_Un();
 			case Code.Brfalse:
-			case Code.Brfalse_S:return emulate_Brfalse();
+			case Code.Brfalse_S:return Emulate_Brfalse();
 			case Code.Brtrue:
-			case Code.Brtrue_S:	return emulate_Brtrue();
-			case Code.Switch:	return emulate_Switch();
+			case Code.Brtrue_S:	return Emulate_Brtrue();
+			case Code.Switch:	return Emulate_Switch();
 
 			default:
 				return false;
 			}
 		}
 
-		bool emulateBranch(int stackArgs, Bool3 cond) {
+		bool EmulateBranch(int stackArgs, Bool3 cond) {
 			if (cond == Bool3.Unknown)
 				return false;
-			return emulateBranch(stackArgs, cond == Bool3.True);
+			return EmulateBranch(stackArgs, cond == Bool3.True);
 		}
 
-		bool emulateBranch(int stackArgs, bool isTaken) {
-			branchHandler.handleNormal(stackArgs, isTaken);
+		bool EmulateBranch(int stackArgs, bool isTaken) {
+			branchHandler.HandleNormal(stackArgs, isTaken);
 			return true;
 		}
 
-		bool emulate_Br() {
-			return emulateBranch(0, true);
+		bool Emulate_Br() {
+			return EmulateBranch(0, true);
 		}
 
-		bool emulate_Beq() {
-			var val2 = instructionEmulator.pop();
-			var val1 = instructionEmulator.pop();
+		bool Emulate_Beq() {
+			var val2 = instructionEmulator.Pop();
+			var val1 = instructionEmulator.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				return emulateBranch(2, Int32Value.compareEq((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt64())
-				return emulateBranch(2, Int64Value.compareEq((Int64Value)val1, (Int64Value)val2));
-			else if (val1.isNull() && val2.isNull())
-				return emulateBranch(2, true);
+			if (val1.IsInt32() && val2.IsInt32())
+				return EmulateBranch(2, Int32Value.CompareEq((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt64())
+				return EmulateBranch(2, Int64Value.CompareEq((Int64Value)val1, (Int64Value)val2));
+			else if (val1.IsNull() && val2.IsNull())
+				return EmulateBranch(2, true);
 			else
 				return false;
 		}
 
-		bool emulate_Bne_Un() {
-			var val2 = instructionEmulator.pop();
-			var val1 = instructionEmulator.pop();
+		bool Emulate_Bne_Un() {
+			var val2 = instructionEmulator.Pop();
+			var val1 = instructionEmulator.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				return emulateBranch(2, Int32Value.compareNeq((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt64())
-				return emulateBranch(2, Int64Value.compareNeq((Int64Value)val1, (Int64Value)val2));
-			else if (val1.isNull() && val2.isNull())
-				return emulateBranch(2, false);
+			if (val1.IsInt32() && val2.IsInt32())
+				return EmulateBranch(2, Int32Value.CompareNeq((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt64())
+				return EmulateBranch(2, Int64Value.CompareNeq((Int64Value)val1, (Int64Value)val2));
+			else if (val1.IsNull() && val2.IsNull())
+				return EmulateBranch(2, false);
 			else
 				return false;
 		}
 
-		bool emulate_Bge() {
-			var val2 = instructionEmulator.pop();
-			var val1 = instructionEmulator.pop();
+		bool Emulate_Bge() {
+			var val2 = instructionEmulator.Pop();
+			var val1 = instructionEmulator.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				return emulateBranch(2, Int32Value.compareGe((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt64())
-				return emulateBranch(2, Int64Value.compareGe((Int64Value)val1, (Int64Value)val2));
+			if (val1.IsInt32() && val2.IsInt32())
+				return EmulateBranch(2, Int32Value.CompareGe((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt64())
+				return EmulateBranch(2, Int64Value.CompareGe((Int64Value)val1, (Int64Value)val2));
 			else
 				return false;
 		}
 
-		bool emulate_Bge_Un() {
-			var val2 = instructionEmulator.pop();
-			var val1 = instructionEmulator.pop();
+		bool Emulate_Bge_Un() {
+			var val2 = instructionEmulator.Pop();
+			var val1 = instructionEmulator.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				return emulateBranch(2, Int32Value.compareGe_Un((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt64())
-				return emulateBranch(2, Int64Value.compareGe_Un((Int64Value)val1, (Int64Value)val2));
+			if (val1.IsInt32() && val2.IsInt32())
+				return EmulateBranch(2, Int32Value.CompareGe_Un((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt64())
+				return EmulateBranch(2, Int64Value.CompareGe_Un((Int64Value)val1, (Int64Value)val2));
 			else
 				return false;
 		}
 
-		bool emulate_Bgt() {
-			var val2 = instructionEmulator.pop();
-			var val1 = instructionEmulator.pop();
+		bool Emulate_Bgt() {
+			var val2 = instructionEmulator.Pop();
+			var val1 = instructionEmulator.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				return emulateBranch(2, Int32Value.compareGt((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt64())
-				return emulateBranch(2, Int64Value.compareGt((Int64Value)val1, (Int64Value)val2));
+			if (val1.IsInt32() && val2.IsInt32())
+				return EmulateBranch(2, Int32Value.CompareGt((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt64())
+				return EmulateBranch(2, Int64Value.CompareGt((Int64Value)val1, (Int64Value)val2));
 			else
 				return false;
 		}
 
-		bool emulate_Bgt_Un() {
-			var val2 = instructionEmulator.pop();
-			var val1 = instructionEmulator.pop();
+		bool Emulate_Bgt_Un() {
+			var val2 = instructionEmulator.Pop();
+			var val1 = instructionEmulator.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				return emulateBranch(2, Int32Value.compareGt_Un((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt64())
-				return emulateBranch(2, Int64Value.compareGt_Un((Int64Value)val1, (Int64Value)val2));
+			if (val1.IsInt32() && val2.IsInt32())
+				return EmulateBranch(2, Int32Value.CompareGt_Un((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt64())
+				return EmulateBranch(2, Int64Value.CompareGt_Un((Int64Value)val1, (Int64Value)val2));
 			else
 				return false;
 		}
 
-		bool emulate_Ble() {
-			var val2 = instructionEmulator.pop();
-			var val1 = instructionEmulator.pop();
+		bool Emulate_Ble() {
+			var val2 = instructionEmulator.Pop();
+			var val1 = instructionEmulator.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				return emulateBranch(2, Int32Value.compareLe((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt64())
-				return emulateBranch(2, Int64Value.compareLe((Int64Value)val1, (Int64Value)val2));
+			if (val1.IsInt32() && val2.IsInt32())
+				return EmulateBranch(2, Int32Value.CompareLe((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt64())
+				return EmulateBranch(2, Int64Value.CompareLe((Int64Value)val1, (Int64Value)val2));
 			else
 				return false;
 		}
 
-		bool emulate_Ble_Un() {
-			var val2 = instructionEmulator.pop();
-			var val1 = instructionEmulator.pop();
+		bool Emulate_Ble_Un() {
+			var val2 = instructionEmulator.Pop();
+			var val1 = instructionEmulator.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				return emulateBranch(2, Int32Value.compareLe_Un((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt64())
-				return emulateBranch(2, Int64Value.compareLe_Un((Int64Value)val1, (Int64Value)val2));
+			if (val1.IsInt32() && val2.IsInt32())
+				return EmulateBranch(2, Int32Value.CompareLe_Un((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt64())
+				return EmulateBranch(2, Int64Value.CompareLe_Un((Int64Value)val1, (Int64Value)val2));
 			else
 				return false;
 		}
 
-		bool emulate_Blt() {
-			var val2 = instructionEmulator.pop();
-			var val1 = instructionEmulator.pop();
+		bool Emulate_Blt() {
+			var val2 = instructionEmulator.Pop();
+			var val1 = instructionEmulator.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				return emulateBranch(2, Int32Value.compareLt((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt64())
-				return emulateBranch(2, Int64Value.compareLt((Int64Value)val1, (Int64Value)val2));
+			if (val1.IsInt32() && val2.IsInt32())
+				return EmulateBranch(2, Int32Value.CompareLt((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt64())
+				return EmulateBranch(2, Int64Value.CompareLt((Int64Value)val1, (Int64Value)val2));
 			else
 				return false;
 		}
 
-		bool emulate_Blt_Un() {
-			var val2 = instructionEmulator.pop();
-			var val1 = instructionEmulator.pop();
+		bool Emulate_Blt_Un() {
+			var val2 = instructionEmulator.Pop();
+			var val1 = instructionEmulator.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				return emulateBranch(2, Int32Value.compareLt_Un((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt64())
-				return emulateBranch(2, Int64Value.compareLt_Un((Int64Value)val1, (Int64Value)val2));
+			if (val1.IsInt32() && val2.IsInt32())
+				return EmulateBranch(2, Int32Value.CompareLt_Un((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt64())
+				return EmulateBranch(2, Int64Value.CompareLt_Un((Int64Value)val1, (Int64Value)val2));
 			else
 				return false;
 		}
 
-		bool emulate_Brfalse() {
-			var val1 = instructionEmulator.pop();
+		bool Emulate_Brfalse() {
+			var val1 = instructionEmulator.Pop();
 
-			if (val1.isInt32())
-				return emulateBranch(1, Int32Value.compareFalse((Int32Value)val1));
-			else if (val1.isInt64())
-				return emulateBranch(1, Int64Value.compareFalse((Int64Value)val1));
-			else if (val1.isNull())
-				return emulateBranch(1, true);
-			else if (val1.isObject() || val1.isString())
-				return emulateBranch(1, false);
+			if (val1.IsInt32())
+				return EmulateBranch(1, Int32Value.CompareFalse((Int32Value)val1));
+			else if (val1.IsInt64())
+				return EmulateBranch(1, Int64Value.CompareFalse((Int64Value)val1));
+			else if (val1.IsNull())
+				return EmulateBranch(1, true);
+			else if (val1.IsObject() || val1.IsString())
+				return EmulateBranch(1, false);
 			else
 				return false;
 		}
 
-		bool emulate_Brtrue() {
-			var val1 = instructionEmulator.pop();
+		bool Emulate_Brtrue() {
+			var val1 = instructionEmulator.Pop();
 
-			if (val1.isInt32())
-				return emulateBranch(1, Int32Value.compareTrue((Int32Value)val1));
-			else if (val1.isInt64())
-				return emulateBranch(1, Int64Value.compareTrue((Int64Value)val1));
-			else if (val1.isNull())
-				return emulateBranch(1, false);
-			else if (val1.isObject() || val1.isString())
-				return emulateBranch(1, true);
+			if (val1.IsInt32())
+				return EmulateBranch(1, Int32Value.CompareTrue((Int32Value)val1));
+			else if (val1.IsInt64())
+				return EmulateBranch(1, Int64Value.CompareTrue((Int64Value)val1));
+			else if (val1.IsNull())
+				return EmulateBranch(1, false);
+			else if (val1.IsObject() || val1.IsString())
+				return EmulateBranch(1, true);
 			else
 				return false;
 		}
 
-		bool emulate_Switch() {
-			var val1 = instructionEmulator.pop();
+		bool Emulate_Switch() {
+			var val1 = instructionEmulator.Pop();
 
-			if (!val1.isInt32())
+			if (!val1.IsInt32())
 				return false;
-			return branchHandler.handleSwitch((Int32Value)val1);
+			return branchHandler.HandleSwitch((Int32Value)val1);
 		}
 	}
 }
diff --git a/blocks/cflow/CachedCflowDeobfuscator.cs b/blocks/cflow/CachedCflowDeobfuscator.cs
index 826d7f99..4cb373a2 100644
--- a/blocks/cflow/CachedCflowDeobfuscator.cs
+++ b/blocks/cflow/CachedCflowDeobfuscator.cs
@@ -31,19 +31,19 @@ namespace de4dot.blocks.cflow {
 		}
 
 		public CachedCflowDeobfuscator(IEnumerable<IBlocksDeobfuscator> blocksDeobfuscators) {
-			add(blocksDeobfuscators);
+			Add(blocksDeobfuscators);
 		}
 
-		public void add(IEnumerable<IBlocksDeobfuscator> blocksDeobfuscators) {
+		public void Add(IEnumerable<IBlocksDeobfuscator> blocksDeobfuscators) {
 			foreach (var bd in blocksDeobfuscators)
-				cflowDeobfuscator.add(bd);
+				cflowDeobfuscator.Add(bd);
 		}
 
-		public void add(IBlocksDeobfuscator blocksDeobfuscator) {
-			cflowDeobfuscator.add(blocksDeobfuscator);
+		public void Add(IBlocksDeobfuscator blocksDeobfuscator) {
+			cflowDeobfuscator.Add(blocksDeobfuscator);
 		}
 
-		public MethodDef deobfuscate(MethodDef method) {
+		public MethodDef Deobfuscate(MethodDef method) {
 			MethodDef deobfuscatedMethod;
 			if (deobfuscated.TryGetValue(method, out deobfuscatedMethod))
 				return deobfuscatedMethod;
@@ -53,22 +53,22 @@ namespace de4dot.blocks.cflow {
 				return method;
 			}
 
-			deobfuscatedMethod = DotNetUtils.clone(method);
+			deobfuscatedMethod = DotNetUtils.Clone(method);
 			deobfuscated[method] = deobfuscatedMethod;
 
 			var blocks = new Blocks(deobfuscatedMethod);
-			deobfuscate(blocks);
+			Deobfuscate(blocks);
 			IList<Instruction> allInstructions;
 			IList<ExceptionHandler> allExceptionHandlers;
-			blocks.getCode(out allInstructions, out allExceptionHandlers);
-			DotNetUtils.restoreBody(deobfuscatedMethod, allInstructions, allExceptionHandlers);
+			blocks.GetCode(out allInstructions, out allExceptionHandlers);
+			DotNetUtils.RestoreBody(deobfuscatedMethod, allInstructions, allExceptionHandlers);
 
 			return deobfuscatedMethod;
 		}
 
-		void deobfuscate(Blocks blocks) {
-			cflowDeobfuscator.init(blocks);
-			cflowDeobfuscator.deobfuscate();
+		void Deobfuscate(Blocks blocks) {
+			cflowDeobfuscator.Initialize(blocks);
+			cflowDeobfuscator.Deobfuscate();
 		}
 	}
 }
diff --git a/blocks/cflow/CflowDeobfuscator.cs b/blocks/cflow/CflowDeobfuscator.cs
index 098329c6..de24048a 100644
--- a/blocks/cflow/CflowDeobfuscator.cs
+++ b/blocks/cflow/CflowDeobfuscator.cs
@@ -29,30 +29,30 @@ namespace de4dot.blocks.cflow {
 		}
 
 		public CflowDeobfuscator(IBlocksDeobfuscator blocksDeobfuscator) {
-			cflowDeobfuscator.add(blocksDeobfuscator);
+			cflowDeobfuscator.Add(blocksDeobfuscator);
 		}
 
-		public void deobfuscate(MethodDef method) {
-			deobfuscate(method, (blocks) => {
-				cflowDeobfuscator.init(blocks);
-				cflowDeobfuscator.deobfuscate();
+		public void Deobfuscate(MethodDef method) {
+			Deobfuscate(method, (blocks) => {
+				cflowDeobfuscator.Initialize(blocks);
+				cflowDeobfuscator.Deobfuscate();
 			});
 		}
 
-		static bool hasNonEmptyBody(MethodDef method) {
+		static bool HasNonEmptyBody(MethodDef method) {
 			return method.Body != null && method.Body.Instructions.Count > 0;
 		}
 
-		void deobfuscate(MethodDef method, Action<Blocks> handler) {
-			if (hasNonEmptyBody(method)) {
+		void Deobfuscate(MethodDef method, Action<Blocks> handler) {
+			if (HasNonEmptyBody(method)) {
 				var blocks = new Blocks(method);
 
 				handler(blocks);
 
 				IList<Instruction> allInstructions;
 				IList<ExceptionHandler> allExceptionHandlers;
-				blocks.getCode(out allInstructions, out allExceptionHandlers);
-				DotNetUtils.restoreBody(method, allInstructions, allExceptionHandlers);
+				blocks.GetCode(out allInstructions, out allExceptionHandlers);
+				DotNetUtils.RestoreBody(method, allInstructions, allExceptionHandlers);
 			}
 		}
 	}
diff --git a/blocks/cflow/CflowUtils.cs b/blocks/cflow/CflowUtils.cs
index f8925a40..1f644bf1 100644
--- a/blocks/cflow/CflowUtils.cs
+++ b/blocks/cflow/CflowUtils.cs
@@ -21,8 +21,8 @@ using System.Collections.Generic;
 
 namespace de4dot.blocks.cflow {
 	static class CflowUtils {
-		public static Block getSwitchTarget(IList<Block> targets, Block fallThrough, Int32Value intValue) {
-			if (!intValue.allBitsValid())
+		public static Block GetSwitchTarget(IList<Block> targets, Block fallThrough, Int32Value intValue) {
+			if (!intValue.AllBitsValid())
 				return null;
 
 			int index = intValue.value;
diff --git a/blocks/cflow/ConstantsFolder.cs b/blocks/cflow/ConstantsFolder.cs
index 880ca759..aa4b0ba9 100644
--- a/blocks/cflow/ConstantsFolder.cs
+++ b/blocks/cflow/ConstantsFolder.cs
@@ -29,15 +29,15 @@ namespace de4dot.blocks.cflow {
 		InstructionEmulator instructionEmulator = new InstructionEmulator();
 		IList<Parameter> args;
 
-		protected override void init(List<Block> allBlocks) {
-			base.init(allBlocks);
+		protected override void Initialize(List<Block> allBlocks) {
+			base.Initialize(allBlocks);
 			args = blocks.Method.Parameters;
 		}
 
-		protected override bool deobfuscate(Block block) {
+		protected override bool Deobfuscate(Block block) {
 			bool changed = false;
 
-			instructionEmulator.init(blocks);
+			instructionEmulator.Initialize(blocks);
 			var instrs = block.Instructions;
 			for (int i = 0; i < instrs.Count; i++) {
 				var instr = instrs[i];
@@ -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(instr.Instruction.GetParameter(args)));
+					changed |= FixLoadInstruction(block, i, instructionEmulator.GetArg(instr.Instruction.GetParameter(args)));
 					break;
 
 				case Code.Ldloc:
@@ -58,22 +58,22 @@ namespace de4dot.blocks.cflow {
 				case Code.Ldloc_2:
 				case Code.Ldloc_3:
 				case Code.Ldloc_S:
-					changed |= fixLoadInstruction(block, i, instructionEmulator.getLocal(instr.Instruction.GetLocal(blocks.Locals)));
+					changed |= FixLoadInstruction(block, i, instructionEmulator.GetLocal(instr.Instruction.GetLocal(blocks.Locals)));
 					break;
 
 				case Code.Ldarga:
 				case Code.Ldarga_S:
-					instructionEmulator.makeArgUnknown((Parameter)instr.Operand);
+					instructionEmulator.MakeArgUnknown((Parameter)instr.Operand);
 					break;
 
 				case Code.Ldloca:
 				case Code.Ldloca_S:
-					instructionEmulator.makeLocalUnknown((Local)instr.Operand);
+					instructionEmulator.MakeLocalUnknown((Local)instr.Operand);
 					break;
 				}
 
 				try {
-					instructionEmulator.emulate(instr.Instruction);
+					instructionEmulator.Emulate(instr.Instruction);
 				}
 				catch (NullReferenceException) {
 					// Here if eg. invalid metadata token in a call instruction (operand is null)
@@ -84,17 +84,17 @@ namespace de4dot.blocks.cflow {
 			return changed;
 		}
 
-		bool fixLoadInstruction(Block block, int index, Value value) {
-			if (value.isInt32()) {
+		bool FixLoadInstruction(Block block, int index, Value value) {
+			if (value.IsInt32()) {
 				var intValue = (Int32Value)value;
-				if (!intValue.allBitsValid())
+				if (!intValue.AllBitsValid())
 					return false;
 				block.Instructions[index] = new Instr(Instruction.CreateLdcI4(intValue.value));
 				return true;
 			}
-			else if (value.isInt64()) {
+			else if (value.IsInt64()) {
 				var intValue = (Int64Value)value;
-				if (!intValue.allBitsValid())
+				if (!intValue.AllBitsValid())
 					return false;
 				block.Instructions[index] = new Instr(OpCodes.Ldc_I8.ToInstruction(intValue.value));
 				return true;
diff --git a/blocks/cflow/DeadCodeRemover.cs b/blocks/cflow/DeadCodeRemover.cs
index e4d806ed..0581f373 100644
--- a/blocks/cflow/DeadCodeRemover.cs
+++ b/blocks/cflow/DeadCodeRemover.cs
@@ -27,7 +27,7 @@ namespace de4dot.blocks.cflow {
 		List<int> allDeadInstructions = new List<int>();
 		InstructionExpressionFinder instructionExpressionFinder = new InstructionExpressionFinder();
 
-		protected override bool deobfuscate(Block block) {
+		protected override bool Deobfuscate(Block block) {
 			allDeadInstructions.Clear();
 
 			bool changed = false;
@@ -56,10 +56,10 @@ namespace de4dot.blocks.cflow {
 				case Code.Leave_S:
 				case Code.Endfinally:
 				case Code.Pop:
-					instructionExpressionFinder.init(block, false);
-					if (!instructionExpressionFinder.find(i))
+					instructionExpressionFinder.Initialize(block, false);
+					if (!instructionExpressionFinder.Find(i))
 						continue;
-					if (!okInstructions(block, instructionExpressionFinder.DeadInstructions))
+					if (!OkInstructions(block, instructionExpressionFinder.DeadInstructions))
 						continue;
 					allDeadInstructions.AddRange(instructionExpressionFinder.DeadInstructions);
 					break;
@@ -70,14 +70,14 @@ namespace de4dot.blocks.cflow {
 			}
 
 			if (allDeadInstructions.Count > 0) {
-				block.remove(allDeadInstructions);
+				block.Remove(allDeadInstructions);
 				changed = true;
 			}
 
 			return changed;
 		}
 
-		bool okInstructions(Block block, IEnumerable<int> indexes) {
+		bool OkInstructions(Block block, IEnumerable<int> indexes) {
 			foreach (var index in indexes) {
 				var instr = block.Instructions[index];
 				switch (instr.OpCode.Code) {
@@ -318,27 +318,27 @@ namespace de4dot.blocks.cflow {
 				get { return deadInstructions; }
 			}
 
-			public void init(Block block, bool methodHasReturnValue) {
+			public void Initialize(Block block, bool methodHasReturnValue) {
 				deadInstructions.Clear();
 				this.block = block;
 				this.methodHasReturnValue = methodHasReturnValue;
 			}
 
-			public bool find(int index) {
-				return find(ref index, true);
+			public bool Find(int index) {
+				return Find(ref index, true);
 			}
 
-			bool find(ref int index, bool addIt) {
+			bool Find(ref int index, bool addIt) {
 				if (index < 0)
 					return false;
 
 				var startInstr = block.Instructions[index];
 				int startInstrPushes, startInstrPops;
-				calculateStackUsage(startInstr.Instruction, false, out startInstrPushes, out startInstrPops);
+				CalculateStackUsage(startInstr.Instruction, false, out startInstrPushes, out startInstrPops);
 
 				// Don't add it if it clears the stack (eg. leave)
 				if (addIt && startInstrPops >= 0)
-					addIndex(index);
+					AddIndex(index);
 
 				if (startInstrPops == 0)
 					return true;
@@ -349,19 +349,19 @@ namespace de4dot.blocks.cflow {
 						break;
 
 					int pushes, pops;
-					calculateStackUsage(instr.Instruction, methodHasReturnValue, out pushes, out pops);
+					CalculateStackUsage(instr.Instruction, methodHasReturnValue, out pushes, out pops);
 					if (pops < 0)
 						break;	// eg. leave
 					index--;
 
 					if (pops > 0) {	// if instr uses any args
 						bool otherExpr = pops > 0 && pushes == 0;
-						if (!find(ref index, addIt && !otherExpr))
+						if (!Find(ref index, addIt && !otherExpr))
 							break;
 					}
 					else if (pushes != 0 || pops != 0) {
 						if (addIt)
-							addIndex(index);
+							AddIndex(index);
 					}
 					if (pushes > 0 && startInstrPops >= 0) {
 						if (pushes > startInstrPops)
@@ -373,12 +373,12 @@ namespace de4dot.blocks.cflow {
 				return startInstrPops <= 0;
 			}
 
-			void addIndex(int index) {
+			void AddIndex(int index) {
 				deadInstructions.Add(index);
 			}
 		}
 
-		static void calculateStackUsage(Instruction instr, bool methodHasReturnValue, out int pushes, out int pops) {
+		static void CalculateStackUsage(Instruction instr, bool methodHasReturnValue, out int pushes, out int pops) {
 			instr.CalculateStackUsage(false, out pushes, out pops);
 		}
 	}
diff --git a/blocks/cflow/DeadStoreRemover.cs b/blocks/cflow/DeadStoreRemover.cs
index caa46fab..0126e7a4 100644
--- a/blocks/cflow/DeadStoreRemover.cs
+++ b/blocks/cflow/DeadStoreRemover.cs
@@ -41,16 +41,16 @@ namespace de4dot.blocks.cflow {
 
 		public bool ExecuteOnNoChange { get; set; }
 
-		public void deobfuscateBegin(Blocks blocks) {
+		public void DeobfuscateBegin(Blocks blocks) {
 			this.blocks = blocks;
 		}
 
-		public bool deobfuscate(List<Block> allBlocks) {
+		public bool Deobfuscate(List<Block> allBlocks) {
 			this.allBlocks = allBlocks;
-			return remove();
+			return Remove();
 		}
 
-		bool remove() {
+		bool Remove() {
 			if (blocks.Locals.Count == 0)
 				return false;
 
@@ -61,7 +61,7 @@ namespace de4dot.blocks.cflow {
 				deadLocals.Add(false);
 			}
 
-			findLoadStores();
+			FindLoadStores();
 
 			bool deadStores = false;
 			for (int i = 0; i < blocks.Locals.Count; i++) {
@@ -74,10 +74,10 @@ namespace de4dot.blocks.cflow {
 			if (!deadStores)
 				return false;
 
-			return removeDeadStores();
+			return RemoveDeadStores();
 		}
 
-		void findLoadStores() {
+		void FindLoadStores() {
 			foreach (var block in allBlocks) {
 				foreach (var instr in block.Instructions) {
 					Local local;
@@ -89,7 +89,7 @@ namespace de4dot.blocks.cflow {
 					case Code.Ldloc_1:
 					case Code.Ldloc_2:
 					case Code.Ldloc_3:
-						local = Instr.getLocalVar(blocks.Locals, instr);
+						local = Instr.GetLocalVar(blocks.Locals, instr);
 						flags = AccessFlags.Read;
 						break;
 
@@ -99,7 +99,7 @@ namespace de4dot.blocks.cflow {
 					case Code.Stloc_1:
 					case Code.Stloc_2:
 					case Code.Stloc_3:
-						local = Instr.getLocalVar(blocks.Locals, instr);
+						local = Instr.GetLocalVar(blocks.Locals, instr);
 						flags = AccessFlags.Write;
 						break;
 
@@ -122,7 +122,7 @@ namespace de4dot.blocks.cflow {
 			}
 		}
 
-		bool removeDeadStores() {
+		bool RemoveDeadStores() {
 			bool changed = false;
 			foreach (var block in allBlocks) {
 				var instructions = block.Instructions;
@@ -136,7 +136,7 @@ namespace de4dot.blocks.cflow {
 					case Code.Stloc_1:
 					case Code.Stloc_2:
 					case Code.Stloc_3:
-						local = Instr.getLocalVar(blocks.Locals, instr);
+						local = Instr.GetLocalVar(blocks.Locals, instr);
 						break;
 
 					default:
diff --git a/blocks/cflow/DupBlockDeobfuscator.cs b/blocks/cflow/DupBlockDeobfuscator.cs
index 257c93ce..7060ea2e 100644
--- a/blocks/cflow/DupBlockDeobfuscator.cs
+++ b/blocks/cflow/DupBlockDeobfuscator.cs
@@ -25,22 +25,22 @@ namespace de4dot.blocks.cflow {
 	// If a block is just a dup followed by a bcc, try to append the block
 	// to all its sources. Will fix some SA assemblies.
 	class DupBlockCflowDeobfuscator : BlockDeobfuscator {
-		protected override bool deobfuscate(Block block) {
+		protected override bool Deobfuscate(Block block) {
 			if (block.Instructions.Count != 2)
 				return false;
 			if (block.Instructions[0].OpCode.Code != Code.Dup)
 				return false;
-			if (!block.LastInstr.isConditionalBranch() && block.LastInstr.OpCode.Code != Code.Switch)
+			if (!block.LastInstr.IsConditionalBranch() && block.LastInstr.OpCode.Code != Code.Switch)
 				return false;
 
 			bool modified = false;
 			foreach (var source in new List<Block>(block.Sources)) {
-				if (source.getOnlyTarget() != block)
+				if (source.GetOnlyTarget() != block)
 					continue;
-				if (!source.canAppend(block))
+				if (!source.CanAppend(block))
 					continue;
 
-				source.append(block);
+				source.Append(block);
 				modified = true;
 			}
 			return modified;
diff --git a/blocks/cflow/IBlocksDeobfuscator.cs b/blocks/cflow/IBlocksDeobfuscator.cs
index 1d96d9d6..d979637d 100644
--- a/blocks/cflow/IBlocksDeobfuscator.cs
+++ b/blocks/cflow/IBlocksDeobfuscator.cs
@@ -23,9 +23,9 @@ namespace de4dot.blocks.cflow {
 	public interface IBlocksDeobfuscator {
 		bool ExecuteOnNoChange { get; }
 
-		void deobfuscateBegin(Blocks blocks);
+		void DeobfuscateBegin(Blocks blocks);
 
 		// Returns true if something was updated
-		bool deobfuscate(List<Block> allBlocks);
+		bool Deobfuscate(List<Block> allBlocks);
 	}
 }
diff --git a/blocks/cflow/ICflowDeobfuscator.cs b/blocks/cflow/ICflowDeobfuscator.cs
index f1a3c354..9f2358de 100644
--- a/blocks/cflow/ICflowDeobfuscator.cs
+++ b/blocks/cflow/ICflowDeobfuscator.cs
@@ -21,6 +21,6 @@ using dnlib.DotNet;
 
 namespace de4dot.blocks.cflow {
 	public interface ICflowDeobfuscator {
-		void deobfuscate(MethodDef method);
+		void Deobfuscate(MethodDef method);
 	}
 }
diff --git a/blocks/cflow/InstructionEmulator.cs b/blocks/cflow/InstructionEmulator.cs
index 13667f95..3345cf64 100644
--- a/blocks/cflow/InstructionEmulator.cs
+++ b/blocks/cflow/InstructionEmulator.cs
@@ -39,17 +39,17 @@ namespace de4dot.blocks.cflow {
 		}
 
 		public InstructionEmulator(MethodDef method) {
-			init(method);
+			Initialize(method);
 		}
 
-		public void init(Blocks blocks) {
-			init(blocks.Method);
+		public void Initialize(Blocks blocks) {
+			Initialize(blocks.Method);
 		}
 
-		public void init(MethodDef method) {
+		public void Initialize(MethodDef method) {
 			this.parameterDefs = method.Parameters;
 			this.localDefs = method.Body.Variables;
-			valueStack.init();
+			valueStack.Initialize();
 			protectedStackValues.Clear();
 
 			if (method != prev_method) {
@@ -57,11 +57,11 @@ namespace de4dot.blocks.cflow {
 
 				cached_args.Clear();
 				for (int i = 0; i < parameterDefs.Count; i++)
-					cached_args.Add(getUnknownValue(parameterDefs[i].Type));
+					cached_args.Add(GetUnknownValue(parameterDefs[i].Type));
 
 				cached_locals.Clear();
 				for (int i = 0; i < localDefs.Count; i++)
-					cached_locals.Add(getUnknownValue(localDefs[i].Type));
+					cached_locals.Add(GetUnknownValue(localDefs[i].Type));
 			}
 
 			args.Clear();
@@ -70,32 +70,32 @@ namespace de4dot.blocks.cflow {
 			locals.AddRange(cached_locals);
 		}
 
-		public void setProtected(Value value) {
+		public void SetProtected(Value value) {
 			protectedStackValues[value] = true;
 		}
 
-		static Value getUnknownValue(ITypeDefOrRef type) {
-			return getUnknownValue(type.ToTypeSig(false));
+		static Value GetUnknownValue(ITypeDefOrRef type) {
+			return GetUnknownValue(type.ToTypeSig(false));
 		}
 
-		static Value getUnknownValue(TypeSig type) {
+		static Value GetUnknownValue(TypeSig type) {
 			if (type == null)
 				return new UnknownValue();
 			switch (type.ElementType) {
-			case ElementType.Boolean: return Int32Value.createUnknownBool();
-			case ElementType.I1: return Int32Value.createUnknown();
-			case ElementType.U1: return Int32Value.createUnknownUInt8();
-			case ElementType.I2: return Int32Value.createUnknown();
-			case ElementType.U2: return Int32Value.createUnknownUInt16();
-			case ElementType.I4: return Int32Value.createUnknown();
-			case ElementType.U4: return Int32Value.createUnknown();
-			case ElementType.I8: return Int64Value.createUnknown();
-			case ElementType.U8: return Int64Value.createUnknown();
+			case ElementType.Boolean: return Int32Value.CreateUnknownBool();
+			case ElementType.I1: return Int32Value.CreateUnknown();
+			case ElementType.U1: return Int32Value.CreateUnknownUInt8();
+			case ElementType.I2: return Int32Value.CreateUnknown();
+			case ElementType.U2: return Int32Value.CreateUnknownUInt16();
+			case ElementType.I4: return Int32Value.CreateUnknown();
+			case ElementType.U4: return Int32Value.CreateUnknown();
+			case ElementType.I8: return Int64Value.CreateUnknown();
+			case ElementType.U8: return Int64Value.CreateUnknown();
 			}
 			return new UnknownValue();
 		}
 
-		Value truncateValue(Value value, TypeSig type) {
+		Value TruncateValue(Value value, TypeSig type) {
 			if (type == null)
 				return value;
 			if (protectedStackValues.ContainsKey(value))
@@ -103,302 +103,302 @@ namespace de4dot.blocks.cflow {
 
 			switch (type.ElementType) {
 			case ElementType.Boolean:
-				if (value.isInt32())
-					return ((Int32Value)value).toBoolean();
-				return Int32Value.createUnknownBool();
+				if (value.IsInt32())
+					return ((Int32Value)value).ToBoolean();
+				return Int32Value.CreateUnknownBool();
 
 			case ElementType.I1:
-				if (value.isInt32())
-					return ((Int32Value)value).toInt8();
-				return Int32Value.createUnknown();
+				if (value.IsInt32())
+					return ((Int32Value)value).ToInt8();
+				return Int32Value.CreateUnknown();
 
 			case ElementType.U1:
-				if (value.isInt32())
-					return ((Int32Value)value).toUInt8();
-				return Int32Value.createUnknownUInt8();
+				if (value.IsInt32())
+					return ((Int32Value)value).ToUInt8();
+				return Int32Value.CreateUnknownUInt8();
 
 			case ElementType.I2:
-				if (value.isInt32())
-					return ((Int32Value)value).toInt16();
-				return Int32Value.createUnknown();
+				if (value.IsInt32())
+					return ((Int32Value)value).ToInt16();
+				return Int32Value.CreateUnknown();
 
 			case ElementType.U2:
-				if (value.isInt32())
-					return ((Int32Value)value).toUInt16();
-				return Int32Value.createUnknownUInt16();
+				if (value.IsInt32())
+					return ((Int32Value)value).ToUInt16();
+				return Int32Value.CreateUnknownUInt16();
 
 			case ElementType.I4:
 			case ElementType.U4:
-				if (value.isInt32())
+				if (value.IsInt32())
 					return value;
-				return Int32Value.createUnknown();
+				return Int32Value.CreateUnknown();
 
 			case ElementType.I8:
 			case ElementType.U8:
-				if (value.isInt64())
+				if (value.IsInt64())
 					return value;
-				return Int64Value.createUnknown();
+				return Int64Value.CreateUnknown();
 
 			case ElementType.R4:
-				if (value.isReal8())
+				if (value.IsReal8())
 					return new Real8Value((float)((Real8Value)value).value);
 				return new UnknownValue();
 
 			case ElementType.R8:
-				if (value.isReal8())
+				if (value.IsReal8())
 					return value;
 				return new UnknownValue();
 			}
 			return value;
 		}
 
-		static Value getValue(List<Value> list, int i) {
+		static Value GetValue(List<Value> list, int i) {
 			if (0 <= i && i < list.Count)
 				return list[i];
 			return new UnknownValue();
 		}
 
-		public Value getArg(int i) {
-			return getValue(args, i);
+		public Value GetArg(int i) {
+			return GetValue(args, i);
 		}
 
-		public Value getArg(Parameter arg) {
+		public Value GetArg(Parameter arg) {
 			if (arg == null)
 				return new UnknownValue();
-			return getArg(arg.Index);
+			return GetArg(arg.Index);
 		}
 
-		TypeSig getArgType(int index) {
+		TypeSig GetArgType(int index) {
 			if (0 <= index && index < parameterDefs.Count)
 				return parameterDefs[index].Type;
 			return null;
 		}
 
-		public void setArg(Parameter arg, Value value) {
+		public void SetArg(Parameter arg, Value value) {
 			if (arg != null)
-				setArg(arg.Index, value);
+				SetArg(arg.Index, value);
 		}
 
-		public void makeArgUnknown(Parameter arg) {
+		public void MakeArgUnknown(Parameter arg) {
 			if (arg != null)
-				setArg(arg, getUnknownArg(arg.Index));
+				SetArg(arg, GetUnknownArg(arg.Index));
 		}
 
-		void setArg(int index, Value value) {
+		void SetArg(int index, Value value) {
 			if (0 <= index && index < args.Count)
-				args[index] = truncateValue(value, getArgType(index));
+				args[index] = TruncateValue(value, GetArgType(index));
 		}
 
-		Value getUnknownArg(int index) {
-			return getUnknownValue(getArgType(index));
+		Value GetUnknownArg(int index) {
+			return GetUnknownValue(GetArgType(index));
 		}
 
-		public Value getLocal(int i) {
-			return getValue(locals, i);
+		public Value GetLocal(int i) {
+			return GetValue(locals, i);
 		}
 
-		public Value getLocal(Local local) {
+		public Value GetLocal(Local local) {
 			if (local == null)
 				return new UnknownValue();
-			return getLocal(local.Index);
+			return GetLocal(local.Index);
 		}
 
-		public void setLocal(Local local, Value value) {
+		public void SetLocal(Local local, Value value) {
 			if (local != null)
-				setLocal(local.Index, value);
+				SetLocal(local.Index, value);
 		}
 
-		public void makeLocalUnknown(Local local) {
+		public void MakeLocalUnknown(Local local) {
 			if (local != null)
-				setLocal(local.Index, getUnknownLocal(local.Index));
+				SetLocal(local.Index, GetUnknownLocal(local.Index));
 		}
 
-		void setLocal(int index, Value value) {
+		void SetLocal(int index, Value value) {
 			if (0 <= index && index < locals.Count)
-				locals[index] = truncateValue(value, localDefs[index].Type);
+				locals[index] = TruncateValue(value, localDefs[index].Type);
 		}
 
-		Value getUnknownLocal(int index) {
+		Value GetUnknownLocal(int index) {
 			if (0 <= index && index < localDefs.Count)
-				return getUnknownValue(localDefs[index].Type);
+				return GetUnknownValue(localDefs[index].Type);
 			return new UnknownValue();
 		}
 
-		public int stackSize() {
+		public int StackSize() {
 			return valueStack.Size;
 		}
 
-		public void push(Value value) {
-			valueStack.push(value);
+		public void Push(Value value) {
+			valueStack.Push(value);
 		}
 
-		public void clearStack() {
-			valueStack.clear();
+		public void ClearStack() {
+			valueStack.Clear();
 		}
 
-		public void pop(int num) {
+		public void Pop(int num) {
 			if (num < 0)
-				valueStack.clear();
+				valueStack.Clear();
 			else
-				valueStack.pop(num);
+				valueStack.Pop(num);
 		}
 
-		public Value pop() {
-			return valueStack.pop();
+		public Value Pop() {
+			return valueStack.Pop();
 		}
 
-		public Value peek() {
-			return valueStack.peek();
+		public Value Peek() {
+			return valueStack.Peek();
 		}
 
-		public void emulate(IEnumerable<Instr> instructions) {
+		public void Emulate(IEnumerable<Instr> instructions) {
 			foreach (var instr in instructions)
-				emulate(instr.Instruction);
+				Emulate(instr.Instruction);
 		}
 
-		public void emulate(IList<Instr> instructions, int start, int end) {
+		public void Emulate(IList<Instr> instructions, int start, int end) {
 			for (int i = start; i < end; i++)
-				emulate(instructions[i].Instruction);
+				Emulate(instructions[i].Instruction);
 		}
 
-		public void emulate(Instruction instr) {
+		public void Emulate(Instruction instr) {
 			switch (instr.OpCode.Code) {
 			case Code.Starg:
-			case Code.Starg_S:	emulate_Starg((Parameter)instr.Operand); break;
+			case Code.Starg_S:	Emulate_Starg((Parameter)instr.Operand); break;
 			case Code.Stloc:
-			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.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((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.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((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.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((Parameter)instr.Operand); break;
+			case Code.Ldarga_S:	Emulate_Ldarga((Parameter)instr.Operand); break;
 			case Code.Ldloca:
-			case Code.Ldloca_S:	emulate_Ldloca((Local)instr.Operand); break;
+			case Code.Ldloca_S:	Emulate_Ldloca((Local)instr.Operand); break;
 
-			case Code.Dup:		valueStack.copyTop(); break;
+			case Code.Dup:		valueStack.CopyTop(); break;
 
-			case Code.Ldc_I4:	valueStack.push(new Int32Value((int)instr.Operand)); break;
-			case Code.Ldc_I4_S:	valueStack.push(new Int32Value((sbyte)instr.Operand)); break;
-			case Code.Ldc_I8:	valueStack.push(new Int64Value((long)instr.Operand)); break;
-			case Code.Ldc_R4:	valueStack.push(new Real8Value((float)instr.Operand)); break;
-			case Code.Ldc_R8:	valueStack.push(new Real8Value((double)instr.Operand)); break;
-			case Code.Ldc_I4_0:	valueStack.push(Int32Value.zero); break;
-			case Code.Ldc_I4_1:	valueStack.push(Int32Value.one); break;
-			case Code.Ldc_I4_2:	valueStack.push(new Int32Value(2)); break;
-			case Code.Ldc_I4_3:	valueStack.push(new Int32Value(3)); break;
-			case Code.Ldc_I4_4:	valueStack.push(new Int32Value(4)); break;
-			case Code.Ldc_I4_5:	valueStack.push(new Int32Value(5)); break;
-			case Code.Ldc_I4_6:	valueStack.push(new Int32Value(6)); break;
-			case Code.Ldc_I4_7:	valueStack.push(new Int32Value(7)); break;
-			case Code.Ldc_I4_8:	valueStack.push(new Int32Value(8)); break;
-			case Code.Ldc_I4_M1:valueStack.push(new Int32Value(-1)); break;
-			case Code.Ldnull:	valueStack.push(NullValue.Instance); break;
-			case Code.Ldstr:	valueStack.push(new StringValue((string)instr.Operand)); break;
-			case Code.Box:		valueStack.push(new BoxedValue(valueStack.pop())); break;
+			case Code.Ldc_I4:	valueStack.Push(new Int32Value((int)instr.Operand)); break;
+			case Code.Ldc_I4_S:	valueStack.Push(new Int32Value((sbyte)instr.Operand)); break;
+			case Code.Ldc_I8:	valueStack.Push(new Int64Value((long)instr.Operand)); break;
+			case Code.Ldc_R4:	valueStack.Push(new Real8Value((float)instr.Operand)); break;
+			case Code.Ldc_R8:	valueStack.Push(new Real8Value((double)instr.Operand)); break;
+			case Code.Ldc_I4_0:	valueStack.Push(Int32Value.zero); break;
+			case Code.Ldc_I4_1:	valueStack.Push(Int32Value.one); break;
+			case Code.Ldc_I4_2:	valueStack.Push(new Int32Value(2)); break;
+			case Code.Ldc_I4_3:	valueStack.Push(new Int32Value(3)); break;
+			case Code.Ldc_I4_4:	valueStack.Push(new Int32Value(4)); break;
+			case Code.Ldc_I4_5:	valueStack.Push(new Int32Value(5)); break;
+			case Code.Ldc_I4_6:	valueStack.Push(new Int32Value(6)); break;
+			case Code.Ldc_I4_7:	valueStack.Push(new Int32Value(7)); break;
+			case Code.Ldc_I4_8:	valueStack.Push(new Int32Value(8)); break;
+			case Code.Ldc_I4_M1:valueStack.Push(new Int32Value(-1)); break;
+			case Code.Ldnull:	valueStack.Push(NullValue.Instance); break;
+			case Code.Ldstr:	valueStack.Push(new StringValue((string)instr.Operand)); break;
+			case Code.Box:		valueStack.Push(new BoxedValue(valueStack.Pop())); break;
 
-			case Code.Conv_U1:	emulate_Conv_U1(instr); break;
-			case Code.Conv_U2:	emulate_Conv_U2(instr); break;
-			case Code.Conv_U4:	emulate_Conv_U4(instr); break;
-			case Code.Conv_U8:	emulate_Conv_U8(instr); break;
-			case Code.Conv_I1:	emulate_Conv_I1(instr); break;
-			case Code.Conv_I2:	emulate_Conv_I2(instr); break;
-			case Code.Conv_I4:	emulate_Conv_I4(instr); break;
-			case Code.Conv_I8:	emulate_Conv_I8(instr); break;
-			case Code.Add:		emulate_Add(instr); break;
-			case Code.Sub:		emulate_Sub(instr); break;
-			case Code.Mul:		emulate_Mul(instr); break;
-			case Code.Div:		emulate_Div(instr); break;
-			case Code.Div_Un:	emulate_Div_Un(instr); break;
-			case Code.Rem:		emulate_Rem(instr); break;
-			case Code.Rem_Un:	emulate_Rem_Un(instr); break;
-			case Code.Neg:		emulate_Neg(instr); break;
-			case Code.And:		emulate_And(instr); break;
-			case Code.Or:		emulate_Or(instr); break;
-			case Code.Xor:		emulate_Xor(instr); break;
-			case Code.Not:		emulate_Not(instr); break;
-			case Code.Shl:		emulate_Shl(instr); break;
-			case Code.Shr:		emulate_Shr(instr); break;
-			case Code.Shr_Un:	emulate_Shr_Un(instr); break;
-			case Code.Ceq:		emulate_Ceq(instr); break;
-			case Code.Cgt:		emulate_Cgt(instr); break;
-			case Code.Cgt_Un:	emulate_Cgt_Un(instr); break;
-			case Code.Clt:		emulate_Clt(instr); break;
-			case Code.Clt_Un:	emulate_Clt_Un(instr); break;
-			case Code.Unbox_Any:emulate_Unbox_Any(instr); break;
+			case Code.Conv_U1:	Emulate_Conv_U1(instr); break;
+			case Code.Conv_U2:	Emulate_Conv_U2(instr); break;
+			case Code.Conv_U4:	Emulate_Conv_U4(instr); break;
+			case Code.Conv_U8:	Emulate_Conv_U8(instr); break;
+			case Code.Conv_I1:	Emulate_Conv_I1(instr); break;
+			case Code.Conv_I2:	Emulate_Conv_I2(instr); break;
+			case Code.Conv_I4:	Emulate_Conv_I4(instr); break;
+			case Code.Conv_I8:	Emulate_Conv_I8(instr); break;
+			case Code.Add:		Emulate_Add(instr); break;
+			case Code.Sub:		Emulate_Sub(instr); break;
+			case Code.Mul:		Emulate_Mul(instr); break;
+			case Code.Div:		Emulate_Div(instr); break;
+			case Code.Div_Un:	Emulate_Div_Un(instr); break;
+			case Code.Rem:		Emulate_Rem(instr); break;
+			case Code.Rem_Un:	Emulate_Rem_Un(instr); break;
+			case Code.Neg:		Emulate_Neg(instr); break;
+			case Code.And:		Emulate_And(instr); break;
+			case Code.Or:		Emulate_Or(instr); break;
+			case Code.Xor:		Emulate_Xor(instr); break;
+			case Code.Not:		Emulate_Not(instr); break;
+			case Code.Shl:		Emulate_Shl(instr); break;
+			case Code.Shr:		Emulate_Shr(instr); break;
+			case Code.Shr_Un:	Emulate_Shr_Un(instr); break;
+			case Code.Ceq:		Emulate_Ceq(instr); break;
+			case Code.Cgt:		Emulate_Cgt(instr); break;
+			case Code.Cgt_Un:	Emulate_Cgt_Un(instr); break;
+			case Code.Clt:		Emulate_Clt(instr); break;
+			case Code.Clt_Un:	Emulate_Clt_Un(instr); break;
+			case Code.Unbox_Any:Emulate_Unbox_Any(instr); break;
 
-			case Code.Call:		emulate_Call(instr); break;
-			case Code.Callvirt:	emulate_Callvirt(instr); break;
+			case Code.Call:		Emulate_Call(instr); break;
+			case Code.Callvirt:	Emulate_Callvirt(instr); break;
 
-			case Code.Castclass: emulate_Castclass(instr); break;
-			case Code.Isinst:	emulate_Isinst(instr); break;
+			case Code.Castclass: Emulate_Castclass(instr); break;
+			case Code.Isinst:	Emulate_Isinst(instr); break;
 
-			case Code.Add_Ovf:	emulateIntOps2(); break;
-			case Code.Add_Ovf_Un: emulateIntOps2(); break;
-			case Code.Sub_Ovf:	emulateIntOps2(); break;
-			case Code.Sub_Ovf_Un: emulateIntOps2(); break;
-			case Code.Mul_Ovf:	emulateIntOps2(); break;
-			case Code.Mul_Ovf_Un: emulateIntOps2(); break;
+			case Code.Add_Ovf:	EmulateIntOps2(); break;
+			case Code.Add_Ovf_Un: EmulateIntOps2(); break;
+			case Code.Sub_Ovf:	EmulateIntOps2(); break;
+			case Code.Sub_Ovf_Un: EmulateIntOps2(); break;
+			case Code.Mul_Ovf:	EmulateIntOps2(); break;
+			case Code.Mul_Ovf_Un: EmulateIntOps2(); break;
 
 			case Code.Conv_Ovf_I1:
-			case Code.Conv_Ovf_I1_Un: valueStack.pop(); valueStack.push(Int32Value.createUnknown()); break;
+			case Code.Conv_Ovf_I1_Un: valueStack.Pop(); valueStack.Push(Int32Value.CreateUnknown()); break;
 			case Code.Conv_Ovf_I2:
-			case Code.Conv_Ovf_I2_Un: valueStack.pop(); valueStack.push(Int32Value.createUnknown()); break;
+			case Code.Conv_Ovf_I2_Un: valueStack.Pop(); valueStack.Push(Int32Value.CreateUnknown()); break;
 			case Code.Conv_Ovf_I4:
-			case Code.Conv_Ovf_I4_Un: valueStack.pop(); valueStack.push(Int32Value.createUnknown()); break;
+			case Code.Conv_Ovf_I4_Un: valueStack.Pop(); valueStack.Push(Int32Value.CreateUnknown()); break;
 			case Code.Conv_Ovf_I8:
-			case Code.Conv_Ovf_I8_Un: valueStack.pop(); valueStack.push(Int64Value.createUnknown()); break;
+			case Code.Conv_Ovf_I8_Un: valueStack.Pop(); valueStack.Push(Int64Value.CreateUnknown()); break;
 			case Code.Conv_Ovf_U1:
-			case Code.Conv_Ovf_U1_Un: valueStack.pop(); valueStack.push(Int32Value.createUnknownUInt8()); break;
+			case Code.Conv_Ovf_U1_Un: valueStack.Pop(); valueStack.Push(Int32Value.CreateUnknownUInt8()); break;
 			case Code.Conv_Ovf_U2:
-			case Code.Conv_Ovf_U2_Un: valueStack.pop(); valueStack.push(Int32Value.createUnknownUInt16()); break;
+			case Code.Conv_Ovf_U2_Un: valueStack.Pop(); valueStack.Push(Int32Value.CreateUnknownUInt16()); break;
 			case Code.Conv_Ovf_U4:
-			case Code.Conv_Ovf_U4_Un: valueStack.pop(); valueStack.push(Int32Value.createUnknown()); break;
+			case Code.Conv_Ovf_U4_Un: valueStack.Pop(); valueStack.Push(Int32Value.CreateUnknown()); break;
 			case Code.Conv_Ovf_U8:
-			case Code.Conv_Ovf_U8_Un: valueStack.pop(); valueStack.push(Int64Value.createUnknown()); break;
+			case Code.Conv_Ovf_U8_Un: valueStack.Pop(); valueStack.Push(Int64Value.CreateUnknown()); break;
 
-			case Code.Ldelem_I1: valueStack.pop(2); valueStack.push(Int32Value.createUnknown()); break;
-			case Code.Ldelem_I2: valueStack.pop(2); valueStack.push(Int32Value.createUnknown()); break;
-			case Code.Ldelem_I4: valueStack.pop(2); valueStack.push(Int32Value.createUnknown()); break;
-			case Code.Ldelem_I8: valueStack.pop(2); valueStack.push(Int64Value.createUnknown()); break;
-			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:	 valueStack.pop(2); valueStack.push(getUnknownValue(instr.Operand as ITypeDefOrRef)); break;
+			case Code.Ldelem_I1: valueStack.Pop(2); valueStack.Push(Int32Value.CreateUnknown()); break;
+			case Code.Ldelem_I2: valueStack.Pop(2); valueStack.Push(Int32Value.CreateUnknown()); break;
+			case Code.Ldelem_I4: valueStack.Pop(2); valueStack.Push(Int32Value.CreateUnknown()); break;
+			case Code.Ldelem_I8: valueStack.Pop(2); valueStack.Push(Int64Value.CreateUnknown()); break;
+			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:	 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;
-			case Code.Ldind_I4:	valueStack.pop(); valueStack.push(Int32Value.createUnknown()); break;
-			case Code.Ldind_I8:	valueStack.pop(); valueStack.push(Int64Value.createUnknown()); break;
-			case Code.Ldind_U1:	valueStack.pop(); valueStack.push(Int32Value.createUnknownUInt8()); break;
-			case Code.Ldind_U2:	valueStack.pop(); valueStack.push(Int32Value.createUnknownUInt16()); break;
-			case Code.Ldind_U4:	valueStack.pop(); valueStack.push(Int32Value.createUnknown()); break;
+			case Code.Ldind_I1:	valueStack.Pop(); valueStack.Push(Int32Value.CreateUnknown()); break;
+			case Code.Ldind_I2:	valueStack.Pop(); valueStack.Push(Int32Value.CreateUnknown()); break;
+			case Code.Ldind_I4:	valueStack.Pop(); valueStack.Push(Int32Value.CreateUnknown()); break;
+			case Code.Ldind_I8:	valueStack.Pop(); valueStack.Push(Int64Value.CreateUnknown()); break;
+			case Code.Ldind_U1:	valueStack.Pop(); valueStack.Push(Int32Value.CreateUnknownUInt8()); break;
+			case Code.Ldind_U2:	valueStack.Pop(); valueStack.Push(Int32Value.CreateUnknownUInt16()); break;
+			case Code.Ldind_U4:	valueStack.Pop(); valueStack.Push(Int32Value.CreateUnknown()); break;
 
-			case Code.Ldlen:	valueStack.pop(); valueStack.push(Int32Value.createUnknown()); break;
-			case Code.Sizeof:	valueStack.push(Int32Value.createUnknown()); break;
+			case Code.Ldlen:	valueStack.Pop(); valueStack.Push(Int32Value.CreateUnknown()); break;
+			case Code.Sizeof:	valueStack.Push(Int32Value.CreateUnknown()); break;
 
-			case Code.Ldfld:	emulate_Ldfld(instr); break;
-			case Code.Ldsfld:	emulate_Ldsfld(instr); break;
+			case Code.Ldfld:	Emulate_Ldfld(instr); break;
+			case Code.Ldsfld:	Emulate_Ldsfld(instr); break;
 
-			case Code.Ldftn:	valueStack.push(new ObjectValue(instr.Operand)); break;
-			case Code.Ldsflda:	valueStack.push(new ObjectValue(instr.Operand)); break;
-			case Code.Ldtoken:	valueStack.push(new ObjectValue(instr.Operand)); break;
-			case Code.Ldvirtftn:valueStack.pop(); valueStack.push(new ObjectValue()); break;
-			case Code.Ldflda:	valueStack.pop(); valueStack.push(new ObjectValue()); break;
+			case Code.Ldftn:	valueStack.Push(new ObjectValue(instr.Operand)); break;
+			case Code.Ldsflda:	valueStack.Push(new ObjectValue(instr.Operand)); break;
+			case Code.Ldtoken:	valueStack.Push(new ObjectValue(instr.Operand)); break;
+			case Code.Ldvirtftn:valueStack.Pop(); valueStack.Push(new ObjectValue()); break;
+			case Code.Ldflda:	valueStack.Pop(); valueStack.Push(new ObjectValue()); break;
 
 			case Code.Unbox:
 
@@ -499,449 +499,449 @@ namespace de4dot.blocks.cflow {
 			case Code.Unaligned:
 			case Code.Volatile:
 			default:
-				updateStack(instr);
+				UpdateStack(instr);
 				break;
 			}
 		}
 
-		void updateStack(Instruction instr) {
+		void UpdateStack(Instruction instr) {
 			int pushes, pops;
 			instr.CalculateStackUsage(out pushes, out pops);
 			if (pops == -1)
-				valueStack.clear();
+				valueStack.Clear();
 			else {
-				valueStack.pop(pops);
-				valueStack.push(pushes);
+				valueStack.Pop(pops);
+				valueStack.Push(pushes);
 			}
 		}
 
-		void emulate_Conv_U1(Instruction instr) {
-			var val1 = valueStack.pop();
+		void Emulate_Conv_U1(Instruction instr) {
+			var val1 = valueStack.Pop();
 			switch (val1.valueType) {
-			case ValueType.Int32:	valueStack.push(Int32Value.Conv_U1((Int32Value)val1)); break;
-			case ValueType.Int64:	valueStack.push(Int32Value.Conv_U1((Int64Value)val1)); break;
-			case ValueType.Real8:	valueStack.push(Int32Value.Conv_U1((Real8Value)val1)); break;
-			default:				valueStack.push(Int32Value.createUnknownUInt8()); break;
+			case ValueType.Int32:	valueStack.Push(Int32Value.Conv_U1((Int32Value)val1)); break;
+			case ValueType.Int64:	valueStack.Push(Int32Value.Conv_U1((Int64Value)val1)); break;
+			case ValueType.Real8:	valueStack.Push(Int32Value.Conv_U1((Real8Value)val1)); break;
+			default:				valueStack.Push(Int32Value.CreateUnknownUInt8()); break;
 			}
 		}
 
-		void emulate_Conv_I1(Instruction instr) {
-			var val1 = valueStack.pop();
+		void Emulate_Conv_I1(Instruction instr) {
+			var val1 = valueStack.Pop();
 			switch (val1.valueType) {
-			case ValueType.Int32:	valueStack.push(Int32Value.Conv_I1((Int32Value)val1)); break;
-			case ValueType.Int64:	valueStack.push(Int32Value.Conv_I1((Int64Value)val1)); break;
-			case ValueType.Real8:	valueStack.push(Int32Value.Conv_I1((Real8Value)val1)); break;
-			default:				valueStack.push(Int32Value.createUnknown()); break;
+			case ValueType.Int32:	valueStack.Push(Int32Value.Conv_I1((Int32Value)val1)); break;
+			case ValueType.Int64:	valueStack.Push(Int32Value.Conv_I1((Int64Value)val1)); break;
+			case ValueType.Real8:	valueStack.Push(Int32Value.Conv_I1((Real8Value)val1)); break;
+			default:				valueStack.Push(Int32Value.CreateUnknown()); break;
 			}
 		}
 
-		void emulate_Conv_U2(Instruction instr) {
-			var val1 = valueStack.pop();
+		void Emulate_Conv_U2(Instruction instr) {
+			var val1 = valueStack.Pop();
 			switch (val1.valueType) {
-			case ValueType.Int32:	valueStack.push(Int32Value.Conv_U2((Int32Value)val1)); break;
-			case ValueType.Int64:	valueStack.push(Int32Value.Conv_U2((Int64Value)val1)); break;
-			case ValueType.Real8:	valueStack.push(Int32Value.Conv_U2((Real8Value)val1)); break;
-			default:				valueStack.push(Int32Value.createUnknownUInt16()); break;
+			case ValueType.Int32:	valueStack.Push(Int32Value.Conv_U2((Int32Value)val1)); break;
+			case ValueType.Int64:	valueStack.Push(Int32Value.Conv_U2((Int64Value)val1)); break;
+			case ValueType.Real8:	valueStack.Push(Int32Value.Conv_U2((Real8Value)val1)); break;
+			default:				valueStack.Push(Int32Value.CreateUnknownUInt16()); break;
 			}
 		}
 
-		void emulate_Conv_I2(Instruction instr) {
-			var val1 = valueStack.pop();
+		void Emulate_Conv_I2(Instruction instr) {
+			var val1 = valueStack.Pop();
 			switch (val1.valueType) {
-			case ValueType.Int32:	valueStack.push(Int32Value.Conv_I2((Int32Value)val1)); break;
-			case ValueType.Int64:	valueStack.push(Int32Value.Conv_I2((Int64Value)val1)); break;
-			case ValueType.Real8:	valueStack.push(Int32Value.Conv_I2((Real8Value)val1)); break;
-			default:				valueStack.push(Int32Value.createUnknown()); break;
+			case ValueType.Int32:	valueStack.Push(Int32Value.Conv_I2((Int32Value)val1)); break;
+			case ValueType.Int64:	valueStack.Push(Int32Value.Conv_I2((Int64Value)val1)); break;
+			case ValueType.Real8:	valueStack.Push(Int32Value.Conv_I2((Real8Value)val1)); break;
+			default:				valueStack.Push(Int32Value.CreateUnknown()); break;
 			}
 		}
 
-		void emulate_Conv_U4(Instruction instr) {
-			var val1 = valueStack.pop();
+		void Emulate_Conv_U4(Instruction instr) {
+			var val1 = valueStack.Pop();
 			switch (val1.valueType) {
-			case ValueType.Int32:	valueStack.push(Int32Value.Conv_U4((Int32Value)val1)); break;
-			case ValueType.Int64:	valueStack.push(Int32Value.Conv_U4((Int64Value)val1)); break;
-			case ValueType.Real8:	valueStack.push(Int32Value.Conv_U4((Real8Value)val1)); break;
-			default:				valueStack.push(Int32Value.createUnknown()); break;
+			case ValueType.Int32:	valueStack.Push(Int32Value.Conv_U4((Int32Value)val1)); break;
+			case ValueType.Int64:	valueStack.Push(Int32Value.Conv_U4((Int64Value)val1)); break;
+			case ValueType.Real8:	valueStack.Push(Int32Value.Conv_U4((Real8Value)val1)); break;
+			default:				valueStack.Push(Int32Value.CreateUnknown()); break;
 			}
 		}
 
-		void emulate_Conv_I4(Instruction instr) {
-			var val1 = valueStack.pop();
+		void Emulate_Conv_I4(Instruction instr) {
+			var val1 = valueStack.Pop();
 			switch (val1.valueType) {
-			case ValueType.Int32:	valueStack.push(Int32Value.Conv_I4((Int32Value)val1)); break;
-			case ValueType.Int64:	valueStack.push(Int32Value.Conv_I4((Int64Value)val1)); break;
-			case ValueType.Real8:	valueStack.push(Int32Value.Conv_I4((Real8Value)val1)); break;
-			default:				valueStack.push(Int32Value.createUnknown()); break;
+			case ValueType.Int32:	valueStack.Push(Int32Value.Conv_I4((Int32Value)val1)); break;
+			case ValueType.Int64:	valueStack.Push(Int32Value.Conv_I4((Int64Value)val1)); break;
+			case ValueType.Real8:	valueStack.Push(Int32Value.Conv_I4((Real8Value)val1)); break;
+			default:				valueStack.Push(Int32Value.CreateUnknown()); break;
 			}
 		}
 
-		void emulate_Conv_U8(Instruction instr) {
-			var val1 = valueStack.pop();
+		void Emulate_Conv_U8(Instruction instr) {
+			var val1 = valueStack.Pop();
 			switch (val1.valueType) {
-			case ValueType.Int32:	valueStack.push(Int64Value.Conv_U8((Int32Value)val1)); break;
-			case ValueType.Int64:	valueStack.push(Int64Value.Conv_U8((Int64Value)val1)); break;
-			case ValueType.Real8:	valueStack.push(Int64Value.Conv_U8((Real8Value)val1)); break;
-			default:				valueStack.push(Int64Value.createUnknown()); break;
+			case ValueType.Int32:	valueStack.Push(Int64Value.Conv_U8((Int32Value)val1)); break;
+			case ValueType.Int64:	valueStack.Push(Int64Value.Conv_U8((Int64Value)val1)); break;
+			case ValueType.Real8:	valueStack.Push(Int64Value.Conv_U8((Real8Value)val1)); break;
+			default:				valueStack.Push(Int64Value.CreateUnknown()); break;
 			}
 		}
 
-		void emulate_Conv_I8(Instruction instr) {
-			var val1 = valueStack.pop();
+		void Emulate_Conv_I8(Instruction instr) {
+			var val1 = valueStack.Pop();
 			switch (val1.valueType) {
-			case ValueType.Int32:	valueStack.push(Int64Value.Conv_I8((Int32Value)val1)); break;
-			case ValueType.Int64:	valueStack.push(Int64Value.Conv_I8((Int64Value)val1)); break;
-			case ValueType.Real8:	valueStack.push(Int64Value.Conv_I8((Real8Value)val1)); break;
-			default:				valueStack.push(Int64Value.createUnknown()); break;
+			case ValueType.Int32:	valueStack.Push(Int64Value.Conv_I8((Int32Value)val1)); break;
+			case ValueType.Int64:	valueStack.Push(Int64Value.Conv_I8((Int64Value)val1)); break;
+			case ValueType.Real8:	valueStack.Push(Int64Value.Conv_I8((Real8Value)val1)); break;
+			default:				valueStack.Push(Int64Value.CreateUnknown()); break;
 			}
 		}
 
-		void emulate_Add(Instruction instr) {
-			var val2 = valueStack.pop();
-			var val1 = valueStack.pop();
+		void Emulate_Add(Instruction instr) {
+			var val2 = valueStack.Pop();
+			var val1 = valueStack.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				valueStack.push(Int32Value.Add((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt64())
-				valueStack.push(Int64Value.Add((Int64Value)val1, (Int64Value)val2));
-			else if (val1.isReal8() && val2.isReal8())
-				valueStack.push(Real8Value.Add((Real8Value)val1, (Real8Value)val2));
+			if (val1.IsInt32() && val2.IsInt32())
+				valueStack.Push(Int32Value.Add((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt64())
+				valueStack.Push(Int64Value.Add((Int64Value)val1, (Int64Value)val2));
+			else if (val1.IsReal8() && val2.IsReal8())
+				valueStack.Push(Real8Value.Add((Real8Value)val1, (Real8Value)val2));
 			else
-				valueStack.pushUnknown();
+				valueStack.PushUnknown();
 		}
 
-		void emulate_Sub(Instruction instr) {
-			var val2 = valueStack.pop();
-			var val1 = valueStack.pop();
+		void Emulate_Sub(Instruction instr) {
+			var val2 = valueStack.Pop();
+			var val1 = valueStack.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				valueStack.push(Int32Value.Sub((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt64())
-				valueStack.push(Int64Value.Sub((Int64Value)val1, (Int64Value)val2));
-			else if (val1.isReal8() && val2.isReal8())
-				valueStack.push(Real8Value.Sub((Real8Value)val1, (Real8Value)val2));
+			if (val1.IsInt32() && val2.IsInt32())
+				valueStack.Push(Int32Value.Sub((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt64())
+				valueStack.Push(Int64Value.Sub((Int64Value)val1, (Int64Value)val2));
+			else if (val1.IsReal8() && val2.IsReal8())
+				valueStack.Push(Real8Value.Sub((Real8Value)val1, (Real8Value)val2));
 			else
-				valueStack.pushUnknown();
+				valueStack.PushUnknown();
 		}
 
-		void emulate_Mul(Instruction instr) {
-			var val2 = valueStack.pop();
-			var val1 = valueStack.pop();
+		void Emulate_Mul(Instruction instr) {
+			var val2 = valueStack.Pop();
+			var val1 = valueStack.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				valueStack.push(Int32Value.Mul((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt64())
-				valueStack.push(Int64Value.Mul((Int64Value)val1, (Int64Value)val2));
-			else if (val1.isReal8() && val2.isReal8())
-				valueStack.push(Real8Value.Mul((Real8Value)val1, (Real8Value)val2));
+			if (val1.IsInt32() && val2.IsInt32())
+				valueStack.Push(Int32Value.Mul((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt64())
+				valueStack.Push(Int64Value.Mul((Int64Value)val1, (Int64Value)val2));
+			else if (val1.IsReal8() && val2.IsReal8())
+				valueStack.Push(Real8Value.Mul((Real8Value)val1, (Real8Value)val2));
 			else
-				valueStack.pushUnknown();
+				valueStack.PushUnknown();
 		}
 
-		void emulate_Div(Instruction instr) {
-			var val2 = valueStack.pop();
-			var val1 = valueStack.pop();
+		void Emulate_Div(Instruction instr) {
+			var val2 = valueStack.Pop();
+			var val1 = valueStack.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				valueStack.push(Int32Value.Div((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt64())
-				valueStack.push(Int64Value.Div((Int64Value)val1, (Int64Value)val2));
-			else if (val1.isReal8() && val2.isReal8())
-				valueStack.push(Real8Value.Div((Real8Value)val1, (Real8Value)val2));
+			if (val1.IsInt32() && val2.IsInt32())
+				valueStack.Push(Int32Value.Div((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt64())
+				valueStack.Push(Int64Value.Div((Int64Value)val1, (Int64Value)val2));
+			else if (val1.IsReal8() && val2.IsReal8())
+				valueStack.Push(Real8Value.Div((Real8Value)val1, (Real8Value)val2));
 			else
-				valueStack.pushUnknown();
+				valueStack.PushUnknown();
 		}
 
-		void emulate_Div_Un(Instruction instr) {
-			var val2 = valueStack.pop();
-			var val1 = valueStack.pop();
+		void Emulate_Div_Un(Instruction instr) {
+			var val2 = valueStack.Pop();
+			var val1 = valueStack.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				valueStack.push(Int32Value.Div_Un((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt64())
-				valueStack.push(Int64Value.Div_Un((Int64Value)val1, (Int64Value)val2));
+			if (val1.IsInt32() && val2.IsInt32())
+				valueStack.Push(Int32Value.Div_Un((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt64())
+				valueStack.Push(Int64Value.Div_Un((Int64Value)val1, (Int64Value)val2));
 			else
-				valueStack.pushUnknown();
+				valueStack.PushUnknown();
 		}
 
-		void emulate_Rem(Instruction instr) {
-			var val2 = valueStack.pop();
-			var val1 = valueStack.pop();
+		void Emulate_Rem(Instruction instr) {
+			var val2 = valueStack.Pop();
+			var val1 = valueStack.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				valueStack.push(Int32Value.Rem((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt64())
-				valueStack.push(Int64Value.Rem((Int64Value)val1, (Int64Value)val2));
-			else if (val1.isReal8() && val2.isReal8())
-				valueStack.push(Real8Value.Rem((Real8Value)val1, (Real8Value)val2));
+			if (val1.IsInt32() && val2.IsInt32())
+				valueStack.Push(Int32Value.Rem((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt64())
+				valueStack.Push(Int64Value.Rem((Int64Value)val1, (Int64Value)val2));
+			else if (val1.IsReal8() && val2.IsReal8())
+				valueStack.Push(Real8Value.Rem((Real8Value)val1, (Real8Value)val2));
 			else
-				valueStack.pushUnknown();
+				valueStack.PushUnknown();
 		}
 
-		void emulate_Rem_Un(Instruction instr) {
-			var val2 = valueStack.pop();
-			var val1 = valueStack.pop();
+		void Emulate_Rem_Un(Instruction instr) {
+			var val2 = valueStack.Pop();
+			var val1 = valueStack.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				valueStack.push(Int32Value.Rem_Un((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt64())
-				valueStack.push(Int64Value.Rem_Un((Int64Value)val1, (Int64Value)val2));
+			if (val1.IsInt32() && val2.IsInt32())
+				valueStack.Push(Int32Value.Rem_Un((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt64())
+				valueStack.Push(Int64Value.Rem_Un((Int64Value)val1, (Int64Value)val2));
 			else
-				valueStack.pushUnknown();
+				valueStack.PushUnknown();
 		}
 
-		void emulate_Neg(Instruction instr) {
-			var val1 = valueStack.pop();
+		void Emulate_Neg(Instruction instr) {
+			var val1 = valueStack.Pop();
 
-			if (val1.isInt32())
-				valueStack.push(Int32Value.Neg((Int32Value)val1));
-			else if (val1.isInt64())
-				valueStack.push(Int64Value.Neg((Int64Value)val1));
-			else if (val1.isReal8())
-				valueStack.push(Real8Value.Neg((Real8Value)val1));
+			if (val1.IsInt32())
+				valueStack.Push(Int32Value.Neg((Int32Value)val1));
+			else if (val1.IsInt64())
+				valueStack.Push(Int64Value.Neg((Int64Value)val1));
+			else if (val1.IsReal8())
+				valueStack.Push(Real8Value.Neg((Real8Value)val1));
 			else
-				valueStack.pushUnknown();
+				valueStack.PushUnknown();
 		}
 
-		void emulate_And(Instruction instr) {
-			var val2 = valueStack.pop();
-			var val1 = valueStack.pop();
+		void Emulate_And(Instruction instr) {
+			var val2 = valueStack.Pop();
+			var val1 = valueStack.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				valueStack.push(Int32Value.And((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt64())
-				valueStack.push(Int64Value.And((Int64Value)val1, (Int64Value)val2));
+			if (val1.IsInt32() && val2.IsInt32())
+				valueStack.Push(Int32Value.And((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt64())
+				valueStack.Push(Int64Value.And((Int64Value)val1, (Int64Value)val2));
 			else
-				valueStack.pushUnknown();
+				valueStack.PushUnknown();
 		}
 
-		void emulate_Or(Instruction instr) {
-			var val2 = valueStack.pop();
-			var val1 = valueStack.pop();
+		void Emulate_Or(Instruction instr) {
+			var val2 = valueStack.Pop();
+			var val1 = valueStack.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				valueStack.push(Int32Value.Or((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt64())
-				valueStack.push(Int64Value.Or((Int64Value)val1, (Int64Value)val2));
+			if (val1.IsInt32() && val2.IsInt32())
+				valueStack.Push(Int32Value.Or((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt64())
+				valueStack.Push(Int64Value.Or((Int64Value)val1, (Int64Value)val2));
 			else
-				valueStack.pushUnknown();
+				valueStack.PushUnknown();
 		}
 
-		void emulate_Xor(Instruction instr) {
-			var val2 = valueStack.pop();
-			var val1 = valueStack.pop();
+		void Emulate_Xor(Instruction instr) {
+			var val2 = valueStack.Pop();
+			var val1 = valueStack.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				valueStack.push(Int32Value.Xor((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt64())
-				valueStack.push(Int64Value.Xor((Int64Value)val1, (Int64Value)val2));
+			if (val1.IsInt32() && val2.IsInt32())
+				valueStack.Push(Int32Value.Xor((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt64())
+				valueStack.Push(Int64Value.Xor((Int64Value)val1, (Int64Value)val2));
 			else
-				valueStack.pushUnknown();
+				valueStack.PushUnknown();
 		}
 
-		void emulate_Not(Instruction instr) {
-			var val1 = valueStack.pop();
+		void Emulate_Not(Instruction instr) {
+			var val1 = valueStack.Pop();
 
-			if (val1.isInt32())
-				valueStack.push(Int32Value.Not((Int32Value)val1));
-			else if (val1.isInt64())
-				valueStack.push(Int64Value.Not((Int64Value)val1));
+			if (val1.IsInt32())
+				valueStack.Push(Int32Value.Not((Int32Value)val1));
+			else if (val1.IsInt64())
+				valueStack.Push(Int64Value.Not((Int64Value)val1));
 			else
-				valueStack.pushUnknown();
+				valueStack.PushUnknown();
 		}
 
-		void emulate_Shl(Instruction instr) {
-			var val2 = valueStack.pop();
-			var val1 = valueStack.pop();
+		void Emulate_Shl(Instruction instr) {
+			var val2 = valueStack.Pop();
+			var val1 = valueStack.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				valueStack.push(Int32Value.Shl((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt32())
-				valueStack.push(Int64Value.Shl((Int64Value)val1, (Int32Value)val2));
+			if (val1.IsInt32() && val2.IsInt32())
+				valueStack.Push(Int32Value.Shl((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt32())
+				valueStack.Push(Int64Value.Shl((Int64Value)val1, (Int32Value)val2));
 			else
-				valueStack.pushUnknown();
+				valueStack.PushUnknown();
 		}
 
-		void emulate_Shr(Instruction instr) {
-			var val2 = valueStack.pop();
-			var val1 = valueStack.pop();
+		void Emulate_Shr(Instruction instr) {
+			var val2 = valueStack.Pop();
+			var val1 = valueStack.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				valueStack.push(Int32Value.Shr((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt32())
-				valueStack.push(Int64Value.Shr((Int64Value)val1, (Int32Value)val2));
+			if (val1.IsInt32() && val2.IsInt32())
+				valueStack.Push(Int32Value.Shr((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt32())
+				valueStack.Push(Int64Value.Shr((Int64Value)val1, (Int32Value)val2));
 			else
-				valueStack.pushUnknown();
+				valueStack.PushUnknown();
 		}
 
-		void emulate_Shr_Un(Instruction instr) {
-			var val2 = valueStack.pop();
-			var val1 = valueStack.pop();
+		void Emulate_Shr_Un(Instruction instr) {
+			var val2 = valueStack.Pop();
+			var val1 = valueStack.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				valueStack.push(Int32Value.Shr_Un((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt32())
-				valueStack.push(Int64Value.Shr_Un((Int64Value)val1, (Int32Value)val2));
+			if (val1.IsInt32() && val2.IsInt32())
+				valueStack.Push(Int32Value.Shr_Un((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt32())
+				valueStack.Push(Int64Value.Shr_Un((Int64Value)val1, (Int32Value)val2));
 			else
-				valueStack.pushUnknown();
+				valueStack.PushUnknown();
 		}
 
-		void emulate_Ceq(Instruction instr) {
-			var val2 = valueStack.pop();
-			var val1 = valueStack.pop();
+		void Emulate_Ceq(Instruction instr) {
+			var val2 = valueStack.Pop();
+			var val1 = valueStack.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				valueStack.push(Int32Value.Ceq((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt64())
-				valueStack.push(Int64Value.Ceq((Int64Value)val1, (Int64Value)val2));
-			else if (val1.isNull() && val2.isNull())
-				valueStack.push(Int32Value.one);
+			if (val1.IsInt32() && val2.IsInt32())
+				valueStack.Push(Int32Value.Ceq((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt64())
+				valueStack.Push(Int64Value.Ceq((Int64Value)val1, (Int64Value)val2));
+			else if (val1.IsNull() && val2.IsNull())
+				valueStack.Push(Int32Value.one);
 			else
-				valueStack.push(Int32Value.createUnknownBool());
+				valueStack.Push(Int32Value.CreateUnknownBool());
 		}
 
-		void emulate_Cgt(Instruction instr) {
-			var val2 = valueStack.pop();
-			var val1 = valueStack.pop();
+		void Emulate_Cgt(Instruction instr) {
+			var val2 = valueStack.Pop();
+			var val1 = valueStack.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				valueStack.push(Int32Value.Cgt((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt64())
-				valueStack.push(Int64Value.Cgt((Int64Value)val1, (Int64Value)val2));
+			if (val1.IsInt32() && val2.IsInt32())
+				valueStack.Push(Int32Value.Cgt((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt64())
+				valueStack.Push(Int64Value.Cgt((Int64Value)val1, (Int64Value)val2));
 			else
-				valueStack.push(Int32Value.createUnknownBool());
+				valueStack.Push(Int32Value.CreateUnknownBool());
 		}
 
-		void emulate_Cgt_Un(Instruction instr) {
-			var val2 = valueStack.pop();
-			var val1 = valueStack.pop();
+		void Emulate_Cgt_Un(Instruction instr) {
+			var val2 = valueStack.Pop();
+			var val1 = valueStack.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				valueStack.push(Int32Value.Cgt_Un((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt64())
-				valueStack.push(Int64Value.Cgt_Un((Int64Value)val1, (Int64Value)val2));
+			if (val1.IsInt32() && val2.IsInt32())
+				valueStack.Push(Int32Value.Cgt_Un((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt64())
+				valueStack.Push(Int64Value.Cgt_Un((Int64Value)val1, (Int64Value)val2));
 			else
-				valueStack.push(Int32Value.createUnknownBool());
+				valueStack.Push(Int32Value.CreateUnknownBool());
 		}
 
-		void emulate_Clt(Instruction instr) {
-			var val2 = valueStack.pop();
-			var val1 = valueStack.pop();
+		void Emulate_Clt(Instruction instr) {
+			var val2 = valueStack.Pop();
+			var val1 = valueStack.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				valueStack.push(Int32Value.Clt((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt64())
-				valueStack.push(Int64Value.Clt((Int64Value)val1, (Int64Value)val2));
+			if (val1.IsInt32() && val2.IsInt32())
+				valueStack.Push(Int32Value.Clt((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt64())
+				valueStack.Push(Int64Value.Clt((Int64Value)val1, (Int64Value)val2));
 			else
-				valueStack.push(Int32Value.createUnknownBool());
+				valueStack.Push(Int32Value.CreateUnknownBool());
 		}
 
-		void emulate_Clt_Un(Instruction instr) {
-			var val2 = valueStack.pop();
-			var val1 = valueStack.pop();
+		void Emulate_Clt_Un(Instruction instr) {
+			var val2 = valueStack.Pop();
+			var val1 = valueStack.Pop();
 
-			if (val1.isInt32() && val2.isInt32())
-				valueStack.push(Int32Value.Clt_Un((Int32Value)val1, (Int32Value)val2));
-			else if (val1.isInt64() && val2.isInt64())
-				valueStack.push(Int64Value.Clt_Un((Int64Value)val1, (Int64Value)val2));
+			if (val1.IsInt32() && val2.IsInt32())
+				valueStack.Push(Int32Value.Clt_Un((Int32Value)val1, (Int32Value)val2));
+			else if (val1.IsInt64() && val2.IsInt64())
+				valueStack.Push(Int64Value.Clt_Un((Int64Value)val1, (Int64Value)val2));
 			else
-				valueStack.push(Int32Value.createUnknownBool());
+				valueStack.Push(Int32Value.CreateUnknownBool());
 		}
 
-		void emulate_Unbox_Any(Instruction instr) {
-			var val1 = valueStack.pop();
-			if (val1.isBoxed())
-				valueStack.push(((BoxedValue)val1).value);
+		void Emulate_Unbox_Any(Instruction instr) {
+			var val1 = valueStack.Pop();
+			if (val1.IsBoxed())
+				valueStack.Push(((BoxedValue)val1).value);
 			else
-				valueStack.pushUnknown();
+				valueStack.PushUnknown();
 		}
 
-		void emulate_Starg(Parameter arg) {
-			setArg(arg == null ? -1 : arg.Index, 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(Local local) {
+			Emulate_Stloc(local == null ? -1 : local.Index);
 		}
 
-		void emulate_Stloc(int index) {
-			setLocal(index, valueStack.pop());
+		void Emulate_Stloc(int index) {
+			SetLocal(index, valueStack.Pop());
 		}
 
-		void emulate_Ldarga(Parameter arg) {
-			valueStack.pushUnknown();
-			makeArgUnknown(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(Local local) {
+			Emulate_Ldloca(local == null ? -1 : local.Index);
 		}
 
-		void emulate_Ldloca(int index) {
-			valueStack.pushUnknown();
-			setLocal(index, getUnknownLocal(index));
+		void Emulate_Ldloca(int index) {
+			valueStack.PushUnknown();
+			SetLocal(index, GetUnknownLocal(index));
 		}
 
-		void emulate_Call(Instruction instr) {
-			emulate_Call(instr, (IMethod)instr.Operand);
+		void Emulate_Call(Instruction instr) {
+			Emulate_Call(instr, (IMethod)instr.Operand);
 		}
 
-		void emulate_Callvirt(Instruction instr) {
-			emulate_Call(instr, (IMethod)instr.Operand);
+		void Emulate_Callvirt(Instruction instr) {
+			Emulate_Call(instr, (IMethod)instr.Operand);
 		}
 
-		void emulate_Call(Instruction instr, IMethod method) {
+		void Emulate_Call(Instruction instr, IMethod method) {
 			int pushes, pops;
 			instr.CalculateStackUsage(out pushes, out pops);
-			valueStack.pop(pops);
+			valueStack.Pop(pops);
 			if (pushes == 1)
-				valueStack.push(getUnknownValue(method.MethodSig.GetRetType()));
+				valueStack.Push(GetUnknownValue(method.MethodSig.GetRetType()));
 			else
-				valueStack.push(pushes);
+				valueStack.Push(pushes);
 		}
 
-		void emulate_Castclass(Instruction instr) {
-			var val1 = valueStack.pop();
+		void Emulate_Castclass(Instruction instr) {
+			var val1 = valueStack.Pop();
 
-			if (val1.isNull())
-				valueStack.push(val1);
+			if (val1.IsNull())
+				valueStack.Push(val1);
 			else
-				valueStack.pushUnknown();
+				valueStack.PushUnknown();
 		}
 
-		void emulate_Isinst(Instruction instr) {
-			var val1 = valueStack.pop();
+		void Emulate_Isinst(Instruction instr) {
+			var val1 = valueStack.Pop();
 
-			if (val1.isNull())
-				valueStack.push(val1);
+			if (val1.IsNull())
+				valueStack.Push(val1);
 			else
-				valueStack.pushUnknown();
+				valueStack.PushUnknown();
 		}
 
-		void emulate_Ldfld(Instruction instr) {
-			var val1 = valueStack.pop();
-			emulateLoadField(instr.Operand as IField);
+		void Emulate_Ldfld(Instruction instr) {
+			var val1 = valueStack.Pop();
+			EmulateLoadField(instr.Operand as IField);
 		}
 
-		void emulate_Ldsfld(Instruction instr) {
-			emulateLoadField(instr.Operand as IField);
+		void Emulate_Ldsfld(Instruction instr) {
+			EmulateLoadField(instr.Operand as IField);
 		}
 
-		void emulateLoadField(IField field) {
+		void EmulateLoadField(IField field) {
 			if (field != null)
-				valueStack.push(getUnknownValue(field.FieldSig.GetFieldType()));
+				valueStack.Push(GetUnknownValue(field.FieldSig.GetFieldType()));
 			else
-				valueStack.pushUnknown();
+				valueStack.PushUnknown();
 		}
 
-		void emulateIntOps2() {
-			var val2 = valueStack.pop();
-			var val1 = valueStack.pop();
-			if (val1.isInt32() && val2.isInt32())
-				valueStack.push(Int32Value.createUnknown());
-			else if (val1.isInt64() && val2.isInt64())
-				valueStack.push(Int64Value.createUnknown());
+		void EmulateIntOps2() {
+			var val2 = valueStack.Pop();
+			var val1 = valueStack.Pop();
+			if (val1.IsInt32() && val2.IsInt32())
+				valueStack.Push(Int32Value.CreateUnknown());
+			else if (val1.IsInt64() && val2.IsInt64())
+				valueStack.Push(Int64Value.CreateUnknown());
 			else
-				valueStack.pushUnknown();
+				valueStack.PushUnknown();
 		}
 	}
 }
diff --git a/blocks/cflow/Int32Value.cs b/blocks/cflow/Int32Value.cs
index d81bb626..f885bf6a 100644
--- a/blocks/cflow/Int32Value.cs
+++ b/blocks/cflow/Int32Value.cs
@@ -40,75 +40,75 @@ namespace de4dot.blocks.cflow {
 			this.validMask = validMask;
 		}
 
-		public bool hasUnknownBits() {
+		public bool HasUnknownBits() {
 			return validMask != NO_UNKNOWN_BITS;
 		}
 
-		public bool allBitsValid() {
-			return !hasUnknownBits();
+		public bool AllBitsValid() {
+			return !HasUnknownBits();
 		}
 
-		bool isBitValid(int n) {
-			return isBitValid(validMask, n);
+		bool IsBitValid(int n) {
+			return IsBitValid(validMask, n);
 		}
 
-		static bool isBitValid(uint validMask, int n) {
+		static bool IsBitValid(uint validMask, int n) {
 			return (validMask & (1U << n)) != 0;
 		}
 
-		public static Int32Value createUnknownBool() {
+		public static Int32Value CreateUnknownBool() {
 			return new Int32Value(0, NO_UNKNOWN_BITS << 1);
 		}
 
-		public static Int32Value createUnknownUInt8() {
+		public static Int32Value CreateUnknownUInt8() {
 			return new Int32Value(0, NO_UNKNOWN_BITS << 8);
 		}
 
-		public static Int32Value createUnknownUInt16() {
+		public static Int32Value CreateUnknownUInt16() {
 			return new Int32Value(0, NO_UNKNOWN_BITS << 16);
 		}
 
-		public static Int32Value createUnknown() {
+		public static Int32Value CreateUnknown() {
 			return new Int32Value(0, 0U);
 		}
 
-		public bool isZero() {
-			return hasValue(0);
+		public bool IsZero() {
+			return HasValue(0);
 		}
 
-		public bool isNonZero() {
+		public bool IsNonZero() {
 			return (value & validMask) != 0;
 		}
 
-		public bool hasValue(int value) {
-			return allBitsValid() && this.value == value;
+		public bool HasValue(int value) {
+			return AllBitsValid() && this.value == value;
 		}
 
-		public bool hasValue(uint value) {
-			return hasValue((int)value);
+		public bool HasValue(uint value) {
+			return HasValue((int)value);
 		}
 
-		public Int32Value toBoolean() {
-			if (isNonZero())
+		public Int32Value ToBoolean() {
+			if (IsNonZero())
 				return new Int32Value(1, NO_UNKNOWN_BITS);
-			if (isZero())
+			if (IsZero())
 				return this;
-			return createUnknownBool();
+			return CreateUnknownBool();
 		}
 
-		public Int32Value toInt8() {
+		public Int32Value ToInt8() {
 			return Conv_I1(this);
 		}
 
-		public Int32Value toUInt8() {
+		public Int32Value ToUInt8() {
 			return Conv_U1(this);
 		}
 
-		public Int32Value toInt16() {
+		public Int32Value ToInt16() {
 			return Conv_I2(this);
 		}
 
-		public Int32Value toUInt16() {
+		public Int32Value ToUInt16() {
 			return Conv_U2(this);
 		}
 
@@ -140,7 +140,7 @@ namespace de4dot.blocks.cflow {
 
 		public static Int32Value Conv_I1(int value, uint validMask) {
 			value = (int)(sbyte)value;
-			if (isBitValid(validMask, 7))
+			if (IsBitValid(validMask, 7))
 				validMask |= NO_UNKNOWN_BITS << 8;
 			else
 				validMask &= ~(NO_UNKNOWN_BITS << 8);
@@ -179,7 +179,7 @@ namespace de4dot.blocks.cflow {
 
 		public static Int32Value Conv_I2(int value, uint validMask) {
 			value = (int)(short)value;
-			if (isBitValid(validMask, 15))
+			if (IsBitValid(validMask, 15))
 				validMask |= NO_UNKNOWN_BITS << 16;
 			else
 				validMask &= ~(NO_UNKNOWN_BITS << 16);
@@ -215,97 +215,97 @@ namespace de4dot.blocks.cflow {
 		}
 
 		public static Int32Value Add(Int32Value a, Int32Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return new Int32Value(a.value + b.value);
 			if (ReferenceEquals(a, b))
 				return new Int32Value(a.value << 1, (a.validMask << 1) | 1);
-			return createUnknown();
+			return CreateUnknown();
 		}
 
 		public static Int32Value Sub(Int32Value a, Int32Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return new Int32Value(a.value - b.value);
 			if (ReferenceEquals(a, b))
 				return zero;
-			return createUnknown();
+			return CreateUnknown();
 		}
 
 		public static Int32Value Mul(Int32Value a, Int32Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return new Int32Value(a.value * b.value);
-			if (a.isZero() || b.isZero())
+			if (a.IsZero() || b.IsZero())
 				return zero;
-			if (a.hasValue(1))
+			if (a.HasValue(1))
 				return b;
-			if (b.hasValue(1))
+			if (b.HasValue(1))
 				return a;
-			return createUnknown();
+			return CreateUnknown();
 		}
 
 		public static Int32Value Div(Int32Value a, Int32Value b) {
-			if (a.allBitsValid() && b.allBitsValid()) {
+			if (a.AllBitsValid() && b.AllBitsValid()) {
 				try {
 					return new Int32Value(a.value / b.value);
 				}
 				catch (ArithmeticException) {
-					return createUnknown();
+					return CreateUnknown();
 				}
 			}
-			if (ReferenceEquals(a, b) && a.isNonZero())
+			if (ReferenceEquals(a, b) && a.IsNonZero())
 				return one;
-			if (b.hasValue(1))
+			if (b.HasValue(1))
 				return a;
-			return createUnknown();
+			return CreateUnknown();
 		}
 
 		public static Int32Value Div_Un(Int32Value a, Int32Value b) {
-			if (a.allBitsValid() && b.allBitsValid()) {
+			if (a.AllBitsValid() && b.AllBitsValid()) {
 				try {
 					return new Int32Value((int)((uint)a.value / (uint)b.value));
 				}
 				catch (ArithmeticException) {
-					return createUnknown();
+					return CreateUnknown();
 				}
 			}
-			if (ReferenceEquals(a, b) && a.isNonZero())
+			if (ReferenceEquals(a, b) && a.IsNonZero())
 				return one;
-			if (b.hasValue(1))
+			if (b.HasValue(1))
 				return a;
-			return createUnknown();
+			return CreateUnknown();
 		}
 
 		public static Int32Value Rem(Int32Value a, Int32Value b) {
-			if (a.allBitsValid() && b.allBitsValid()) {
+			if (a.AllBitsValid() && b.AllBitsValid()) {
 				try {
 					return new Int32Value(a.value % b.value);
 				}
 				catch (ArithmeticException) {
-					return createUnknown();
+					return CreateUnknown();
 				}
 			}
-			if ((ReferenceEquals(a, b) && a.isNonZero()) || b.hasValue(1))
+			if ((ReferenceEquals(a, b) && a.IsNonZero()) || b.HasValue(1))
 				return zero;
-			return createUnknown();
+			return CreateUnknown();
 		}
 
 		public static Int32Value Rem_Un(Int32Value a, Int32Value b) {
-			if (a.allBitsValid() && b.allBitsValid()) {
+			if (a.AllBitsValid() && b.AllBitsValid()) {
 				try {
 					return new Int32Value((int)((uint)a.value % (uint)b.value));
 				}
 				catch (ArithmeticException) {
-					return createUnknown();
+					return CreateUnknown();
 				}
 			}
-			if ((ReferenceEquals(a, b) && a.isNonZero()) || b.hasValue(1))
+			if ((ReferenceEquals(a, b) && a.IsNonZero()) || b.HasValue(1))
 				return zero;
-			return createUnknown();
+			return CreateUnknown();
 		}
 
 		public static Int32Value Neg(Int32Value a) {
-			if (a.allBitsValid())
+			if (a.AllBitsValid())
 				return new Int32Value(-a.value);
-			return createUnknown();
+			return CreateUnknown();
 		}
 
 		public static Int32Value And(Int32Value a, Int32Value b) {
@@ -333,38 +333,38 @@ namespace de4dot.blocks.cflow {
 		}
 
 		public static Int32Value Shl(Int32Value a, Int32Value b) {
-			if (b.hasUnknownBits())
-				return createUnknown();
+			if (b.HasUnknownBits())
+				return CreateUnknown();
 			if (b.value == 0)
 				return a;
 			if (b.value < 0 || b.value >= sizeof(int) * 8)
-				return createUnknown();
+				return CreateUnknown();
 			int shift = b.value;
 			uint validMask = (a.validMask << shift) | (uint.MaxValue >> (sizeof(int) * 8 - shift));
 			return new Int32Value(a.value << shift, validMask);
 		}
 
 		public static Int32Value Shr(Int32Value a, Int32Value b) {
-			if (b.hasUnknownBits())
-				return createUnknown();
+			if (b.HasUnknownBits())
+				return CreateUnknown();
 			if (b.value == 0)
 				return a;
 			if (b.value < 0 || b.value >= sizeof(int) * 8)
-				return createUnknown();
+				return CreateUnknown();
 			int shift = b.value;
 			uint validMask = a.validMask >> shift;
-			if (a.isBitValid(sizeof(int) * 8 - 1))
+			if (a.IsBitValid(sizeof(int) * 8 - 1))
 				validMask |= (uint.MaxValue << (sizeof(int) * 8 - shift));
 			return new Int32Value(a.value >> shift, validMask);
 		}
 
 		public static Int32Value Shr_Un(Int32Value a, Int32Value b) {
-			if (b.hasUnknownBits())
-				return createUnknown();
+			if (b.HasUnknownBits())
+				return CreateUnknown();
 			if (b.value == 0)
 				return a;
 			if (b.value < 0 || b.value >= sizeof(int) * 8)
-				return createUnknown();
+				return CreateUnknown();
 			int shift = b.value;
 			uint validMask = (a.validMask >> shift) | (uint.MaxValue << (sizeof(int) * 8 - shift));
 			return new Int32Value((int)((uint)a.value >> shift), validMask);
@@ -374,32 +374,32 @@ namespace de4dot.blocks.cflow {
 			switch (b) {
 			case Bool3.False:	return zero;
 			case Bool3.True:	return one;
-			default:			return createUnknownBool();
+			default:			return CreateUnknownBool();
 			}
 		}
 
 		public static Int32Value Ceq(Int32Value a, Int32Value b) {
-			return create(compareEq(a, b));
+			return create(CompareEq(a, b));
 		}
 
 		public static Int32Value Cgt(Int32Value a, Int32Value b) {
-			return create(compareGt(a, b));
+			return create(CompareGt(a, b));
 		}
 
 		public static Int32Value Cgt_Un(Int32Value a, Int32Value b) {
-			return create(compareGt_Un(a, b));
+			return create(CompareGt_Un(a, b));
 		}
 
 		public static Int32Value Clt(Int32Value a, Int32Value b) {
-			return create(compareLt(a, b));
+			return create(CompareLt(a, b));
 		}
 
 		public static Int32Value Clt_Un(Int32Value a, Int32Value b) {
-			return create(compareLt_Un(a, b));
+			return create(CompareLt_Un(a, b));
 		}
 
-		public static Bool3 compareEq(Int32Value a, Int32Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+		public static Bool3 CompareEq(Int32Value a, Int32Value b) {
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return a.value == b.value ? Bool3.True : Bool3.False;
 			if (ReferenceEquals(a, b))
 				return Bool3.True;
@@ -408,8 +408,8 @@ namespace de4dot.blocks.cflow {
 			return Bool3.Unknown;
 		}
 
-		public static Bool3 compareNeq(Int32Value a, Int32Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+		public static Bool3 CompareNeq(Int32Value a, Int32Value b) {
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return a.value != b.value ? Bool3.True : Bool3.False;
 			if (ReferenceEquals(a, b))
 				return Bool3.False;
@@ -418,96 +418,96 @@ namespace de4dot.blocks.cflow {
 			return Bool3.Unknown;
 		}
 
-		public static Bool3 compareGt(Int32Value a, Int32Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+		public static Bool3 CompareGt(Int32Value a, Int32Value b) {
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return a.value > b.value ? Bool3.True : Bool3.False;
-			if (a.hasValue(int.MinValue))
+			if (a.HasValue(int.MinValue))
 				return Bool3.False;	// min > x => false
-			if (b.hasValue(int.MaxValue))
+			if (b.HasValue(int.MaxValue))
 				return Bool3.False;	// x > max => false
 			return Bool3.Unknown;
 		}
 
-		public static Bool3 compareGt_Un(Int32Value a, Int32Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+		public static Bool3 CompareGt_Un(Int32Value a, Int32Value b) {
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return (uint)a.value > (uint)b.value ? Bool3.True : Bool3.False;
-			if (a.hasValue(uint.MinValue))
+			if (a.HasValue(uint.MinValue))
 				return Bool3.False;	// min > x => false
-			if (b.hasValue(uint.MaxValue))
+			if (b.HasValue(uint.MaxValue))
 				return Bool3.False;	// x > max => false
 			return Bool3.Unknown;
 		}
 
-		public static Bool3 compareGe(Int32Value a, Int32Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+		public static Bool3 CompareGe(Int32Value a, Int32Value b) {
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return a.value >= b.value ? Bool3.True : Bool3.False;
-			if (a.hasValue(int.MaxValue))
+			if (a.HasValue(int.MaxValue))
 				return Bool3.True;	// max >= x => true
-			if (b.hasValue(int.MinValue))
+			if (b.HasValue(int.MinValue))
 				return Bool3.True;	// x >= min => true
 			return Bool3.Unknown;
 		}
 
-		public static Bool3 compareGe_Un(Int32Value a, Int32Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+		public static Bool3 CompareGe_Un(Int32Value a, Int32Value b) {
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return (uint)a.value >= (uint)b.value ? Bool3.True : Bool3.False;
-			if (a.hasValue(uint.MaxValue))
+			if (a.HasValue(uint.MaxValue))
 				return Bool3.True;	// max >= x => true
-			if (b.hasValue(uint.MinValue))
+			if (b.HasValue(uint.MinValue))
 				return Bool3.True;	// x >= min => true
 			return Bool3.Unknown;
 		}
 
-		public static Bool3 compareLe(Int32Value a, Int32Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+		public static Bool3 CompareLe(Int32Value a, Int32Value b) {
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return a.value <= b.value ? Bool3.True : Bool3.False;
-			if (a.hasValue(int.MinValue))
+			if (a.HasValue(int.MinValue))
 				return Bool3.True;	// min <= x => true
-			if (b.hasValue(int.MaxValue))
+			if (b.HasValue(int.MaxValue))
 				return Bool3.True;	// x <= max => true
 			return Bool3.Unknown;
 		}
 
-		public static Bool3 compareLe_Un(Int32Value a, Int32Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+		public static Bool3 CompareLe_Un(Int32Value a, Int32Value b) {
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return (uint)a.value <= (uint)b.value ? Bool3.True : Bool3.False;
-			if (a.hasValue(uint.MinValue))
+			if (a.HasValue(uint.MinValue))
 				return Bool3.True;	// min <= x => true
-			if (b.hasValue(uint.MaxValue))
+			if (b.HasValue(uint.MaxValue))
 				return Bool3.True;	// x <= max => true
 			return Bool3.Unknown;
 		}
 
-		public static Bool3 compareLt(Int32Value a, Int32Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+		public static Bool3 CompareLt(Int32Value a, Int32Value b) {
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return a.value < b.value ? Bool3.True : Bool3.False;
-			if (a.hasValue(int.MaxValue))
+			if (a.HasValue(int.MaxValue))
 				return Bool3.False;	// max < x => false
-			if (b.hasValue(int.MinValue))
+			if (b.HasValue(int.MinValue))
 				return Bool3.False;	// x < min => false
 			return Bool3.Unknown;
 		}
 
-		public static Bool3 compareLt_Un(Int32Value a, Int32Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+		public static Bool3 CompareLt_Un(Int32Value a, Int32Value b) {
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return (uint)a.value < (uint)b.value ? Bool3.True : Bool3.False;
-			if (a.hasValue(uint.MaxValue))
+			if (a.HasValue(uint.MaxValue))
 				return Bool3.False;	// max < x => false
-			if (b.hasValue(uint.MinValue))
+			if (b.HasValue(uint.MinValue))
 				return Bool3.False;	// x < min => false
 			return Bool3.Unknown;
 		}
 
-		public static Bool3 compareTrue(Int32Value a) {
-			if (a.allBitsValid())
+		public static Bool3 CompareTrue(Int32Value a) {
+			if (a.AllBitsValid())
 				return a.value != 0 ? Bool3.True : Bool3.False;
 			if ((a.value & a.validMask) != 0)
 				return Bool3.True;
 			return Bool3.Unknown;
 		}
 
-		public static Bool3 compareFalse(Int32Value a) {
-			if (a.allBitsValid())
+		public static Bool3 CompareFalse(Int32Value a) {
+			if (a.AllBitsValid())
 				return a.value == 0 ? Bool3.True : Bool3.False;
 			if ((a.value & a.validMask) != 0)
 				return Bool3.False;
@@ -515,7 +515,7 @@ namespace de4dot.blocks.cflow {
 		}
 
 		public override string ToString() {
-			if (allBitsValid())
+			if (AllBitsValid())
 				return value.ToString();
 			return string.Format("0x{0:X8}({1:X8})", value, validMask);
 		}
diff --git a/blocks/cflow/Int64Value.cs b/blocks/cflow/Int64Value.cs
index 447de554..9ec2ff41 100644
--- a/blocks/cflow/Int64Value.cs
+++ b/blocks/cflow/Int64Value.cs
@@ -40,40 +40,40 @@ namespace de4dot.blocks.cflow {
 			this.validMask = validMask;
 		}
 
-		bool hasUnknownBits() {
+		bool HasUnknownBits() {
 			return validMask != NO_UNKNOWN_BITS;
 		}
 
-		public bool allBitsValid() {
-			return !hasUnknownBits();
+		public bool AllBitsValid() {
+			return !HasUnknownBits();
 		}
 
-		bool isBitValid(int n) {
-			return isBitValid(validMask, n);
+		bool IsBitValid(int n) {
+			return IsBitValid(validMask, n);
 		}
 
-		static bool isBitValid(ulong validMask, int n) {
+		static bool IsBitValid(ulong validMask, int n) {
 			return (validMask & (1UL << n)) != 0;
 		}
 
-		public static Int64Value createUnknown() {
+		public static Int64Value CreateUnknown() {
 			return new Int64Value(0, 0UL);
 		}
 
-		public bool isZero() {
-			return hasValue(0);
+		public bool IsZero() {
+			return HasValue(0);
 		}
 
-		public bool isNonZero() {
+		public bool IsNonZero() {
 			return ((ulong)value & validMask) != 0;
 		}
 
-		public bool hasValue(long value) {
-			return allBitsValid() && this.value == value;
+		public bool HasValue(long value) {
+			return AllBitsValid() && this.value == value;
 		}
 
-		public bool hasValue(ulong value) {
-			return hasValue((long)value);
+		public bool HasValue(ulong value) {
+			return HasValue((long)value);
 		}
 
 		public static Int64Value Conv_U8(Int32Value a) {
@@ -93,7 +93,7 @@ namespace de4dot.blocks.cflow {
 		public static Int64Value Conv_I8(Int32Value a) {
 			long value = a.value;
 			ulong validMask = a.validMask;
-			if (isBitValid(validMask, 31))
+			if (IsBitValid(validMask, 31))
 				validMask |= NO_UNKNOWN_BITS << 32;
 			else
 				validMask &= ~(NO_UNKNOWN_BITS << 32);
@@ -109,97 +109,97 @@ namespace de4dot.blocks.cflow {
 		}
 
 		public static Int64Value Add(Int64Value a, Int64Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return new Int64Value(a.value + b.value);
 			if (ReferenceEquals(a, b))
 				return new Int64Value(a.value << 1, (a.validMask << 1) | 1);
-			return createUnknown();
+			return CreateUnknown();
 		}
 
 		public static Int64Value Sub(Int64Value a, Int64Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return new Int64Value(a.value - b.value);
 			if (ReferenceEquals(a, b))
 				return zero;
-			return createUnknown();
+			return CreateUnknown();
 		}
 
 		public static Int64Value Mul(Int64Value a, Int64Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return new Int64Value(a.value * b.value);
-			if (a.isZero() || b.isZero())
+			if (a.IsZero() || b.IsZero())
 				return zero;
-			if (a.hasValue(1))
+			if (a.HasValue(1))
 				return b;
-			if (b.hasValue(1))
+			if (b.HasValue(1))
 				return a;
-			return createUnknown();
+			return CreateUnknown();
 		}
 
 		public static Int64Value Div(Int64Value a, Int64Value b) {
-			if (a.allBitsValid() && b.allBitsValid()) {
+			if (a.AllBitsValid() && b.AllBitsValid()) {
 				try {
 					return new Int64Value(a.value / b.value);
 				}
 				catch (ArithmeticException) {
-					return createUnknown();
+					return CreateUnknown();
 				}
 			}
-			if (ReferenceEquals(a, b) && a.isNonZero())
+			if (ReferenceEquals(a, b) && a.IsNonZero())
 				return one;
-			if (b.hasValue(1))
+			if (b.HasValue(1))
 				return a;
-			return createUnknown();
+			return CreateUnknown();
 		}
 
 		public static Int64Value Div_Un(Int64Value a, Int64Value b) {
-			if (a.allBitsValid() && b.allBitsValid()) {
+			if (a.AllBitsValid() && b.AllBitsValid()) {
 				try {
 					return new Int64Value((long)((ulong)a.value / (ulong)b.value));
 				}
 				catch (ArithmeticException) {
-					return createUnknown();
+					return CreateUnknown();
 				}
 			}
-			if (ReferenceEquals(a, b) && a.isNonZero())
+			if (ReferenceEquals(a, b) && a.IsNonZero())
 				return one;
-			if (b.hasValue(1))
+			if (b.HasValue(1))
 				return a;
-			return createUnknown();
+			return CreateUnknown();
 		}
 
 		public static Int64Value Rem(Int64Value a, Int64Value b) {
-			if (a.allBitsValid() && b.allBitsValid()) {
+			if (a.AllBitsValid() && b.AllBitsValid()) {
 				try {
 					return new Int64Value(a.value % b.value);
 				}
 				catch (ArithmeticException) {
-					return createUnknown();
+					return CreateUnknown();
 				}
 			}
-			if ((ReferenceEquals(a, b) && a.isNonZero()) || b.hasValue(1))
+			if ((ReferenceEquals(a, b) && a.IsNonZero()) || b.HasValue(1))
 				return zero;
-			return createUnknown();
+			return CreateUnknown();
 		}
 
 		public static Int64Value Rem_Un(Int64Value a, Int64Value b) {
-			if (a.allBitsValid() && b.allBitsValid()) {
+			if (a.AllBitsValid() && b.AllBitsValid()) {
 				try {
 					return new Int64Value((long)((ulong)a.value % (ulong)b.value));
 				}
 				catch (ArithmeticException) {
-					return createUnknown();
+					return CreateUnknown();
 				}
 			}
-			if ((ReferenceEquals(a, b) && a.isNonZero()) || b.hasValue(1))
+			if ((ReferenceEquals(a, b) && a.IsNonZero()) || b.HasValue(1))
 				return zero;
-			return createUnknown();
+			return CreateUnknown();
 		}
 
 		public static Int64Value Neg(Int64Value a) {
-			if (a.allBitsValid())
+			if (a.AllBitsValid())
 				return new Int64Value(-a.value);
-			return createUnknown();
+			return CreateUnknown();
 		}
 
 		public static Int64Value And(Int64Value a, Int64Value b) {
@@ -227,73 +227,73 @@ namespace de4dot.blocks.cflow {
 		}
 
 		public static Int64Value Shl(Int64Value a, Int32Value b) {
-			if (b.hasUnknownBits())
-				return createUnknown();
+			if (b.HasUnknownBits())
+				return CreateUnknown();
 			if (b.value == 0)
 				return a;
 			if (b.value < 0 || b.value >= sizeof(long) * 8)
-				return createUnknown();
+				return CreateUnknown();
 			int shift = b.value;
 			ulong validMask = (a.validMask << shift) | (ulong.MaxValue >> (sizeof(long) * 8 - shift));
 			return new Int64Value(a.value << shift, validMask);
 		}
 
 		public static Int64Value Shr(Int64Value a, Int32Value b) {
-			if (b.hasUnknownBits())
-				return createUnknown();
+			if (b.HasUnknownBits())
+				return CreateUnknown();
 			if (b.value == 0)
 				return a;
 			if (b.value < 0 || b.value >= sizeof(long) * 8)
-				return createUnknown();
+				return CreateUnknown();
 			int shift = b.value;
 			ulong validMask = a.validMask >> shift;
-			if (a.isBitValid(sizeof(long) * 8 - 1))
+			if (a.IsBitValid(sizeof(long) * 8 - 1))
 				validMask |= (ulong.MaxValue << (sizeof(long) * 8 - shift));
 			return new Int64Value(a.value >> shift, validMask);
 		}
 
 		public static Int64Value Shr_Un(Int64Value a, Int32Value b) {
-			if (b.hasUnknownBits())
-				return createUnknown();
+			if (b.HasUnknownBits())
+				return CreateUnknown();
 			if (b.value == 0)
 				return a;
 			if (b.value < 0 || b.value >= sizeof(long) * 8)
-				return createUnknown();
+				return CreateUnknown();
 			int shift = b.value;
 			ulong validMask = (a.validMask >> shift) | (ulong.MaxValue << (sizeof(long) * 8 - shift));
 			return new Int64Value((long)((ulong)a.value >> shift), validMask);
 		}
 
-		static Int32Value create(Bool3 b) {
+		static Int32Value Create(Bool3 b) {
 			switch (b) {
 			case Bool3.False:	return Int32Value.zero;
 			case Bool3.True:	return Int32Value.one;
-			default:			return Int32Value.createUnknownBool();
+			default:			return Int32Value.CreateUnknownBool();
 			}
 		}
 
 		public static Int32Value Ceq(Int64Value a, Int64Value b) {
-			return create(compareEq(a, b));
+			return Create(CompareEq(a, b));
 		}
 
 		public static Int32Value Cgt(Int64Value a, Int64Value b) {
-			return create(compareGt(a, b));
+			return Create(CompareGt(a, b));
 		}
 
 		public static Int32Value Cgt_Un(Int64Value a, Int64Value b) {
-			return create(compareGt_Un(a, b));
+			return Create(CompareGt_Un(a, b));
 		}
 
 		public static Int32Value Clt(Int64Value a, Int64Value b) {
-			return create(compareLt(a, b));
+			return Create(CompareLt(a, b));
 		}
 
 		public static Int32Value Clt_Un(Int64Value a, Int64Value b) {
-			return create(compareLt_Un(a, b));
+			return Create(CompareLt_Un(a, b));
 		}
 
-		public static Bool3 compareEq(Int64Value a, Int64Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+		public static Bool3 CompareEq(Int64Value a, Int64Value b) {
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return a.value == b.value ? Bool3.True : Bool3.False;
 			if (ReferenceEquals(a, b))
 				return Bool3.True;
@@ -302,8 +302,8 @@ namespace de4dot.blocks.cflow {
 			return Bool3.Unknown;
 		}
 
-		public static Bool3 compareNeq(Int64Value a, Int64Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+		public static Bool3 CompareNeq(Int64Value a, Int64Value b) {
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return a.value != b.value ? Bool3.True : Bool3.False;
 			if (ReferenceEquals(a, b))
 				return Bool3.False;
@@ -312,96 +312,96 @@ namespace de4dot.blocks.cflow {
 			return Bool3.Unknown;
 		}
 
-		public static Bool3 compareGt(Int64Value a, Int64Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+		public static Bool3 CompareGt(Int64Value a, Int64Value b) {
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return a.value > b.value ? Bool3.True : Bool3.False;
-			if (a.hasValue(long.MinValue))
+			if (a.HasValue(long.MinValue))
 				return Bool3.False;	// min > x => false
-			if (b.hasValue(long.MaxValue))
+			if (b.HasValue(long.MaxValue))
 				return Bool3.False;	// x > max => false
 			return Bool3.Unknown;
 		}
 
-		public static Bool3 compareGt_Un(Int64Value a, Int64Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+		public static Bool3 CompareGt_Un(Int64Value a, Int64Value b) {
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return (ulong)a.value > (ulong)b.value ? Bool3.True : Bool3.False;
-			if (a.hasValue(ulong.MinValue))
+			if (a.HasValue(ulong.MinValue))
 				return Bool3.False;	// min > x => false
-			if (b.hasValue(ulong.MaxValue))
+			if (b.HasValue(ulong.MaxValue))
 				return Bool3.False;	// x > max => false
 			return Bool3.Unknown;
 		}
 
-		public static Bool3 compareGe(Int64Value a, Int64Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+		public static Bool3 CompareGe(Int64Value a, Int64Value b) {
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return a.value >= b.value ? Bool3.True : Bool3.False;
-			if (a.hasValue(long.MaxValue))
+			if (a.HasValue(long.MaxValue))
 				return Bool3.True;	// max >= x => true
-			if (b.hasValue(long.MinValue))
+			if (b.HasValue(long.MinValue))
 				return Bool3.True;	// x >= min => true
 			return Bool3.Unknown;
 		}
 
-		public static Bool3 compareGe_Un(Int64Value a, Int64Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+		public static Bool3 CompareGe_Un(Int64Value a, Int64Value b) {
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return (ulong)a.value >= (ulong)b.value ? Bool3.True : Bool3.False;
-			if (a.hasValue(ulong.MaxValue))
+			if (a.HasValue(ulong.MaxValue))
 				return Bool3.True;	// max >= x => true
-			if (b.hasValue(ulong.MinValue))
+			if (b.HasValue(ulong.MinValue))
 				return Bool3.True;	// x >= min => true
 			return Bool3.Unknown;
 		}
 
-		public static Bool3 compareLe(Int64Value a, Int64Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+		public static Bool3 CompareLe(Int64Value a, Int64Value b) {
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return a.value <= b.value ? Bool3.True : Bool3.False;
-			if (a.hasValue(long.MinValue))
+			if (a.HasValue(long.MinValue))
 				return Bool3.True;	// min <= x => true
-			if (b.hasValue(long.MaxValue))
+			if (b.HasValue(long.MaxValue))
 				return Bool3.True;	// x <= max => true
 			return Bool3.Unknown;
 		}
 
-		public static Bool3 compareLe_Un(Int64Value a, Int64Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+		public static Bool3 CompareLe_Un(Int64Value a, Int64Value b) {
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return (ulong)a.value <= (ulong)b.value ? Bool3.True : Bool3.False;
-			if (a.hasValue(ulong.MinValue))
+			if (a.HasValue(ulong.MinValue))
 				return Bool3.True;	// min <= x => true
-			if (b.hasValue(ulong.MaxValue))
+			if (b.HasValue(ulong.MaxValue))
 				return Bool3.True;	// x <= max => true
 			return Bool3.Unknown;
 		}
 
-		public static Bool3 compareLt(Int64Value a, Int64Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+		public static Bool3 CompareLt(Int64Value a, Int64Value b) {
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return a.value < b.value ? Bool3.True : Bool3.False;
-			if (a.hasValue(long.MaxValue))
+			if (a.HasValue(long.MaxValue))
 				return Bool3.False;	// max < x => false
-			if (b.hasValue(long.MinValue))
+			if (b.HasValue(long.MinValue))
 				return Bool3.False;	// x < min => false
 			return Bool3.Unknown;
 		}
 
-		public static Bool3 compareLt_Un(Int64Value a, Int64Value b) {
-			if (a.allBitsValid() && b.allBitsValid())
+		public static Bool3 CompareLt_Un(Int64Value a, Int64Value b) {
+			if (a.AllBitsValid() && b.AllBitsValid())
 				return (ulong)a.value < (ulong)b.value ? Bool3.True : Bool3.False;
-			if (a.hasValue(ulong.MaxValue))
+			if (a.HasValue(ulong.MaxValue))
 				return Bool3.False;	// max < x => false
-			if (b.hasValue(ulong.MinValue))
+			if (b.HasValue(ulong.MinValue))
 				return Bool3.False;	// x < min => false
 			return Bool3.Unknown;
 		}
 
-		public static Bool3 compareTrue(Int64Value a) {
-			if (a.allBitsValid())
+		public static Bool3 CompareTrue(Int64Value a) {
+			if (a.AllBitsValid())
 				return a.value != 0 ? Bool3.True : Bool3.False;
 			if (((ulong)a.value & a.validMask) != 0)
 				return Bool3.True;
 			return Bool3.Unknown;
 		}
 
-		public static Bool3 compareFalse(Int64Value a) {
-			if (a.allBitsValid())
+		public static Bool3 CompareFalse(Int64Value a) {
+			if (a.AllBitsValid())
 				return a.value == 0 ? Bool3.True : Bool3.False;
 			if (((ulong)a.value & a.validMask) != 0)
 				return Bool3.False;
@@ -409,7 +409,7 @@ namespace de4dot.blocks.cflow {
 		}
 
 		public override string ToString() {
-			if (allBitsValid())
+			if (AllBitsValid())
 				return value.ToString();
 			return string.Format("0x{0:X8}L({1:X8})", value, validMask);
 		}
diff --git a/blocks/cflow/MethodCallInliner.cs b/blocks/cflow/MethodCallInliner.cs
index cb279cf1..3ed807cd 100644
--- a/blocks/cflow/MethodCallInliner.cs
+++ b/blocks/cflow/MethodCallInliner.cs
@@ -29,18 +29,18 @@ namespace de4dot.blocks.cflow {
 			this.inlineInstanceMethods = inlineInstanceMethods;
 		}
 
-		protected override bool deobfuscateInternal() {
+		protected override bool DeobfuscateInternal() {
 			bool changed = false;
 			var instructions = block.Instructions;
 			for (int i = 0; i < instructions.Count; i++) {
 				var instr = instructions[i].Instruction;
 				if (instr.OpCode.Code == Code.Call)
-					changed |= inlineMethod(instr, i);
+					changed |= InlineMethod(instr, i);
 			}
 			return changed;
 		}
 
-		protected virtual bool canInline(MethodDef method) {
+		protected virtual bool CanInline(MethodDef method) {
 			if (method.GenericParameters.Count > 0)
 				return false;
 			if (method == blocks.Method)
@@ -55,19 +55,19 @@ namespace de4dot.blocks.cflow {
 			return inlineInstanceMethods;
 		}
 
-		bool inlineMethod(Instruction callInstr, int instrIndex) {
+		bool InlineMethod(Instruction callInstr, int instrIndex) {
 			var methodToInline = callInstr.Operand as MethodDef;
 			if (methodToInline == null)
 				return false;
 
-			if (!canInline(methodToInline))
+			if (!CanInline(methodToInline))
 				return false;
 			var body = methodToInline.Body;
 			if (body == null)
 				return false;
 
 			int index = 0;
-			var instr = DotNetUtils.getInstruction(body.Instructions, ref index);
+			var instr = DotNetUtils.GetInstruction(body.Instructions, ref index);
 			if (instr == null)
 				return false;
 
@@ -83,7 +83,7 @@ namespace de4dot.blocks.cflow {
 			case Code.Call:
 			case Code.Callvirt:
 			case Code.Newobj:
-				return inlineOtherMethod(instrIndex, methodToInline, instr, index);
+				return InlineOtherMethod(instrIndex, methodToInline, instr, index);
 
 			case Code.Ldc_I4:
 			case Code.Ldc_I4_0:
@@ -106,17 +106,17 @@ namespace de4dot.blocks.cflow {
 			case Code.Ldtoken:
 			case Code.Ldsfld:
 			case Code.Ldsflda:
-				return inlineLoadMethod(instrIndex, methodToInline, instr, index);
+				return InlineLoadMethod(instrIndex, methodToInline, instr, index);
 
 			default:
 				return false;
 			}
 		}
 
-		protected override bool isCompatibleType(int paramIndex, IType origType, IType newType) {
+		protected override bool IsCompatibleType(int paramIndex, IType origType, IType newType) {
 			if (new SigComparer(SigComparerOptions.IgnoreModifiers).Equals(origType, newType))
 				return true;
-			if (isValueType(newType) || isValueType(origType))
+			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 455623f5..4b46febc 100644
--- a/blocks/cflow/MethodCallInlinerBase.cs
+++ b/blocks/cflow/MethodCallInlinerBase.cs
@@ -33,24 +33,24 @@ namespace de4dot.blocks.cflow {
 
 		public bool ExecuteOnNoChange { get; set; }
 
-		public void deobfuscateBegin(Blocks blocks) {
+		public void DeobfuscateBegin(Blocks blocks) {
 			this.blocks = blocks;
 			iteration = 0;
 		}
 
-		public bool deobfuscate(List<Block> allBlocks) {
+		public bool Deobfuscate(List<Block> allBlocks) {
 			if (iteration++ >= MAX_ITERATIONS)
 				return false;
 
 			bool changed = false;
 			foreach (var block in allBlocks) {
 				this.block = block;
-				changed |= deobfuscateInternal();
+				changed |= DeobfuscateInternal();
 			}
 			return changed;
 		}
 
-		protected abstract bool deobfuscateInternal();
+		protected abstract bool DeobfuscateInternal();
 
 		protected class InstructionPatcher {
 			readonly int patchIndex;
@@ -64,53 +64,53 @@ namespace de4dot.blocks.cflow {
 				this.clonedInstr = new Instr(lastInstr.Clone());
 			}
 
-			public void patch(Block block) {
+			public void Patch(Block block) {
 				block.Instructions[patchIndex] = clonedInstr;
 			}
 		}
 
-		protected bool inlineLoadMethod(int patchIndex, MethodDef methodToInline, Instruction loadInstr, int instrIndex) {
-			if (!isReturn(methodToInline, instrIndex))
+		protected bool InlineLoadMethod(int patchIndex, MethodDef methodToInline, Instruction loadInstr, int instrIndex) {
+			if (!IsReturn(methodToInline, instrIndex))
 				return false;
 
-			int methodArgsCount = DotNetUtils.getArgsCount(methodToInline);
+			int methodArgsCount = DotNetUtils.GetArgsCount(methodToInline);
 			for (int i = 0; i < methodArgsCount; i++)
-				block.insert(patchIndex++, OpCodes.Pop.ToInstruction());
+				block.Insert(patchIndex++, OpCodes.Pop.ToInstruction());
 
 			block.Instructions[patchIndex] = new Instr(loadInstr.Clone());
 			return true;
 		}
 
-		protected bool inlineOtherMethod(int patchIndex, MethodDef methodToInline, Instruction instr, int instrIndex) {
-			return inlineOtherMethod(patchIndex, methodToInline, instr, instrIndex, 0);
+		protected bool InlineOtherMethod(int patchIndex, MethodDef methodToInline, Instruction instr, int instrIndex) {
+			return InlineOtherMethod(patchIndex, methodToInline, instr, instrIndex, 0);
 		}
 
-		protected bool inlineOtherMethod(int patchIndex, MethodDef methodToInline, Instruction instr, int instrIndex, int popLastArgs) {
-			return patchMethod(methodToInline, tryInlineOtherMethod(patchIndex, methodToInline, instr, instrIndex, 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(MethodDef methodToInline, InstructionPatcher patcher) {
+		protected bool PatchMethod(MethodDef methodToInline, InstructionPatcher patcher) {
 			if (patcher == null)
 				return false;
 
-			if (!isReturn(methodToInline, patcher.afterIndex))
+			if (!IsReturn(methodToInline, patcher.afterIndex))
 				return false;
 
-			patcher.patch(block);
+			patcher.Patch(block);
 			return true;
 		}
 
-		protected InstructionPatcher tryInlineOtherMethod(int patchIndex, MethodDef methodToInline, Instruction instr, int instrIndex) {
-			return tryInlineOtherMethod(patchIndex, methodToInline, instr, instrIndex, 0);
+		protected InstructionPatcher TryInlineOtherMethod(int patchIndex, MethodDef methodToInline, Instruction instr, int instrIndex) {
+			return TryInlineOtherMethod(patchIndex, methodToInline, instr, instrIndex, 0);
 		}
 
-		protected virtual Instruction onAfterLoadArg(MethodDef methodToInline, Instruction instr, ref int instrIndex) {
+		protected virtual Instruction OnAfterLoadArg(MethodDef methodToInline, Instruction instr, ref int instrIndex) {
 			return instr;
 		}
 
-		protected InstructionPatcher tryInlineOtherMethod(int patchIndex, MethodDef 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);
+			int methodArgsCount = DotNetUtils.GetArgsCount(methodToInline);
 			bool foundLdarga = false;
 			while (instr != null && loadIndex < methodArgsCount) {
 				bool isLdarg = true;
@@ -136,8 +136,8 @@ namespace de4dot.blocks.cflow {
 				if (instr.GetParameterIndex() != loadIndex)
 					return null;
 				loadIndex++;
-				instr = DotNetUtils.getInstruction(methodToInline.Body.Instructions, ref instrIndex);
-				instr = onAfterLoadArg(methodToInline, instr, ref instrIndex);
+				instr = DotNetUtils.GetInstruction(methodToInline.Body.Instructions, ref instrIndex);
+				instr = OnAfterLoadArg(methodToInline, instr, ref instrIndex);
 			}
 			if (instr == null || loadIndex != methodArgsCount - popLastArgs)
 				return null;
@@ -150,13 +150,13 @@ namespace de4dot.blocks.cflow {
 				if (calledMethod == null)
 					return null;
 
-				if (!isCompatibleType(-1, calledMethod.MethodSig.RetType, methodToInline.MethodSig.RetType))
+				if (!IsCompatibleType(-1, calledMethod.MethodSig.RetType, methodToInline.MethodSig.RetType))
 					return null;
 
-				if (!checkSameMethods(calledMethod, methodToInline, popLastArgs))
+				if (!CheckSameMethods(calledMethod, methodToInline, popLastArgs))
 					return null;
 
-				if (!hasAccessTo(instr.Operand))
+				if (!HasAccessTo(instr.Operand))
 					return null;
 
 				return new InstructionPatcher(patchIndex, instrIndex, callInstr);
@@ -169,19 +169,19 @@ namespace de4dot.blocks.cflow {
 				if (ctor == null)
 					return null;
 
-				if (!isCompatibleType(-1, ctor.DeclaringType, methodToInline.MethodSig.RetType))
+				if (!IsCompatibleType(-1, ctor.DeclaringType, methodToInline.MethodSig.RetType))
 					return null;
 
 				var methodArgs = methodToInline.Parameters;
-				var calledMethodArgs = DotNetUtils.getArgs(ctor);
+				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].Type))
+					if (!IsCompatibleType(i, calledMethodArgs[i], methodArgs[i - 1].Type))
 						return null;
 				}
 
-				if (!hasAccessTo(instr.Operand))
+				if (!HasAccessTo(instr.Operand))
 					return null;
 
 				return new InstructionPatcher(patchIndex, instrIndex, newobjInstr);
@@ -192,7 +192,7 @@ namespace de4dot.blocks.cflow {
 				if (methodArgsCount != 1)
 					return null;
 
-				if (!hasAccessTo(instr.Operand))
+				if (!HasAccessTo(instr.Operand))
 					return null;
 
 				return new InstructionPatcher(patchIndex, instrIndex, ldInstr);
@@ -201,36 +201,36 @@ namespace de4dot.blocks.cflow {
 			return null;
 		}
 
-		bool hasAccessTo(object operand) {
+		bool HasAccessTo(object operand) {
 			if (operand == null)
 				return false;
 			accessChecker.UserType = blocks.Method.DeclaringType;
-			return accessChecker.CanAccess(operand) ?? getDefaultAccessResult();
+			return accessChecker.CanAccess(operand) ?? GetDefaultAccessResult();
 		}
 
-		protected virtual bool getDefaultAccessResult() {
+		protected virtual bool GetDefaultAccessResult() {
 			return true;
 		}
 
-		protected virtual bool isReturn(MethodDef methodToInline, int instrIndex) {
-			var instr = DotNetUtils.getInstruction(methodToInline.Body.Instructions, ref instrIndex);
+		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(IMethod method, MethodDef methodToInline) {
-			return checkSameMethods(method, methodToInline, 0);
+		protected bool CheckSameMethods(IMethod method, MethodDef methodToInline) {
+			return CheckSameMethods(method, methodToInline, 0);
 		}
 
-		protected bool checkSameMethods(IMethod method, MethodDef methodToInline, int ignoreLastMethodToInlineArgs) {
+		protected bool CheckSameMethods(IMethod method, MethodDef methodToInline, int ignoreLastMethodToInlineArgs) {
 			var methodToInlineArgs = methodToInline.Parameters;
-			var methodArgs = DotNetUtils.getArgs(method);
+			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 = getArgType(methodToInline, methodToInlineArgs[i].Type);
-				if (!isCompatibleType(i, methodArg, methodToInlineArg)) {
+				var methodToInlineArg = GetArgType(methodToInline, methodToInlineArgs[i].Type);
+				if (!IsCompatibleType(i, methodArg, methodToInlineArg)) {
 					if (i != 0 || !hasImplicitThis)
 						return false;
 					if (!isCompatibleValueThisPtr(methodArg, methodToInlineArg))
@@ -241,7 +241,7 @@ namespace de4dot.blocks.cflow {
 			return true;
 		}
 
-		static TypeSig getArgType(MethodDef method, TypeSig arg) {
+		static TypeSig GetArgType(MethodDef method, TypeSig arg) {
 			if (arg.GetElementType() != ElementType.MVar)
 				return arg;
 			var mvar = (GenericMVar)arg;
@@ -254,7 +254,7 @@ namespace de4dot.blocks.cflow {
 			return arg;
 		}
 
-		protected virtual bool isCompatibleType(int paramIndex, IType origType, IType newType) {
+		protected virtual bool IsCompatibleType(int paramIndex, IType origType, IType newType) {
 			return new SigComparer().Equals(origType, newType);
 		}
 
@@ -262,12 +262,12 @@ namespace de4dot.blocks.cflow {
 			var newByRef = newType as ByRefSig;
 			if (newByRef == null)
 				return false;
-			if (!isValueType(newByRef.Next) || !isValueType(origType))
+			if (!IsValueType(newByRef.Next) || !IsValueType(origType))
 				return false;
 			return new SigComparer().Equals(origType, newByRef.Next);
 		}
 
-		protected static bool isValueType(IType type) {
+		protected static bool IsValueType(IType type) {
 			if (type == null)
 				return false;
 			var ts = type as TypeSig;
diff --git a/blocks/cflow/StLdlocFixer.cs b/blocks/cflow/StLdlocFixer.cs
index 16982f92..aa576f82 100644
--- a/blocks/cflow/StLdlocFixer.cs
+++ b/blocks/cflow/StLdlocFixer.cs
@@ -26,12 +26,12 @@ namespace de4dot.blocks.cflow {
 	class StLdlocFixer : BlockDeobfuscator {
 		IList<Local> locals;
 
-		protected override void init(List<Block> allBlocks) {
-			base.init(allBlocks);
+		protected override void Initialize(List<Block> allBlocks) {
+			base.Initialize(allBlocks);
 			locals = blocks.Locals;
 		}
 
-		protected override bool deobfuscate(Block block) {
+		protected override bool Deobfuscate(Block block) {
 			bool changed = false;
 			var instructions = block.Instructions;
 			for (int i = 0; i < instructions.Count; i++) {
@@ -47,12 +47,12 @@ namespace de4dot.blocks.cflow {
 				case Code.Stloc_3:
 					if (i + 1 >= instructions.Count)
 						break;
-					if (!instructions[i + 1].isLdloc())
+					if (!instructions[i + 1].IsLdloc())
 						break;
-					var local = Instr.getLocalVar(locals, instr);
+					var local = Instr.GetLocalVar(locals, instr);
 					if (local.Type.ElementType != ElementType.Boolean)
 						continue;
-					if (local != Instr.getLocalVar(locals, instructions[i + 1]))
+					if (local != Instr.GetLocalVar(locals, instructions[i + 1]))
 						break;
 					instructions[i] = new Instr(OpCodes.Dup.ToInstruction());
 					instructions[i + 1] = instr;
diff --git a/blocks/cflow/SwitchCflowDeobfuscator.cs b/blocks/cflow/SwitchCflowDeobfuscator.cs
index 961c183b..9cadad5b 100644
--- a/blocks/cflow/SwitchCflowDeobfuscator.cs
+++ b/blocks/cflow/SwitchCflowDeobfuscator.cs
@@ -26,50 +26,50 @@ namespace de4dot.blocks.cflow {
 	class SwitchCflowDeobfuscator : BlockDeobfuscator {
 		InstructionEmulator instructionEmulator = new InstructionEmulator();
 
-		protected override bool deobfuscate(Block switchBlock) {
+		protected override bool Deobfuscate(Block switchBlock) {
 			if (switchBlock.LastInstr.OpCode.Code != Code.Switch)
 				return false;
 
-			if (isSwitchTopOfStack(switchBlock) && deobfuscateTos(switchBlock))
+			if (IsSwitchTopOfStack(switchBlock) && DeobfuscateTOS(switchBlock))
 				return true;
 
-			if (isLdlocBranch(switchBlock, true) && deobfuscateLdloc(switchBlock))
+			if (IsLdlocBranch(switchBlock, true) && DeobfuscateLdloc(switchBlock))
 				return true;
 
-			if (isStLdlocBranch(switchBlock, true) && deobfuscateStLdloc(switchBlock))
+			if (IsStLdlocBranch(switchBlock, true) && DeobfuscateStLdloc(switchBlock))
 				return true;
 
-			if (isSwitchType1(switchBlock) && deobfuscateType1(switchBlock))
+			if (IsSwitchType1(switchBlock) && DeobfuscateType1(switchBlock))
 				return true;
 
-			if (isSwitchType2(switchBlock) && deobfuscateType2(switchBlock))
+			if (IsSwitchType2(switchBlock) && DeobfuscateType2(switchBlock))
 				return true;
 
-			if (switchBlock.FirstInstr.isLdloc() && fixSwitchBranch(switchBlock))
+			if (switchBlock.FirstInstr.IsLdloc() && FixSwitchBranch(switchBlock))
 				return true;
 
 			return false;
 		}
 
-		static bool isSwitchTopOfStack(Block switchBlock) {
+		static bool IsSwitchTopOfStack(Block switchBlock) {
 			return switchBlock.Instructions.Count == 1;
 		}
 
-		static bool isLdlocBranch(Block switchBlock, bool isSwitch) {
+		static bool IsLdlocBranch(Block switchBlock, bool isSwitch) {
 			int numInstrs = 1 + (isSwitch ? 1 : 0);
-			return switchBlock.Instructions.Count == numInstrs && switchBlock.Instructions[0].isLdloc();
+			return switchBlock.Instructions.Count == numInstrs && switchBlock.Instructions[0].IsLdloc();
 		}
 
-		static bool isSwitchType1(Block switchBlock) {
-			return switchBlock.FirstInstr.isLdloc();
+		static bool IsSwitchType1(Block switchBlock) {
+			return switchBlock.FirstInstr.IsLdloc();
 		}
 
-		bool isSwitchType2(Block switchBlock) {
+		bool IsSwitchType2(Block switchBlock) {
 			Local local = null;
 			foreach (var instr in switchBlock.Instructions) {
-				if (!instr.isLdloc())
+				if (!instr.IsLdloc())
 					continue;
-				local = Instr.getLocalVar(blocks.Locals, instr);
+				local = Instr.GetLocalVar(blocks.Locals, instr);
 				break;
 			}
 			if (local == null)
@@ -79,12 +79,12 @@ namespace de4dot.blocks.cflow {
 				var instrs = source.Instructions;
 				for (int i = 1; i < instrs.Count; i++) {
 					var ldci4 = instrs[i - 1];
-					if (!ldci4.isLdcI4())
+					if (!ldci4.IsLdcI4())
 						continue;
 					var stloc = instrs[i];
-					if (!stloc.isStloc())
+					if (!stloc.IsStloc())
 						continue;
-					if (Instr.getLocalVar(blocks.Locals, stloc) != local)
+					if (Instr.GetLocalVar(blocks.Locals, stloc) != local)
 						continue;
 
 					return true;
@@ -94,29 +94,29 @@ namespace de4dot.blocks.cflow {
 			return false;
 		}
 
-		bool isStLdlocBranch(Block switchBlock, bool isSwitch) {
+		bool IsStLdlocBranch(Block switchBlock, bool isSwitch) {
 			int numInstrs = 2 + (isSwitch ? 1 : 0);
 			return switchBlock.Instructions.Count == numInstrs &&
-				switchBlock.Instructions[0].isStloc() &&
-				switchBlock.Instructions[1].isLdloc() &&
-				Instr.getLocalVar(blocks.Locals, switchBlock.Instructions[0]) == Instr.getLocalVar(blocks.Locals, switchBlock.Instructions[1]);
+				switchBlock.Instructions[0].IsStloc() &&
+				switchBlock.Instructions[1].IsLdloc() &&
+				Instr.GetLocalVar(blocks.Locals, switchBlock.Instructions[0]) == Instr.GetLocalVar(blocks.Locals, switchBlock.Instructions[1]);
 		}
 
-		bool deobfuscateTos(Block switchBlock) {
+		bool DeobfuscateTOS(Block switchBlock) {
 			bool changed = false;
 			if (switchBlock.Targets == null)
 				return changed;
 			var targets = new List<Block>(switchBlock.Targets);
 
-			changed |= deobfuscateTos(targets, switchBlock.FallThrough, switchBlock);
+			changed |= DeobfuscateTOS(targets, switchBlock.FallThrough, switchBlock);
 
 			return changed;
 		}
 
-		bool deobfuscateLdloc(Block switchBlock) {
+		bool DeobfuscateLdloc(Block switchBlock) {
 			bool changed = false;
 
-			var switchVariable = Instr.getLocalVar(blocks.Locals, switchBlock.Instructions[0]);
+			var switchVariable = Instr.GetLocalVar(blocks.Locals, switchBlock.Instructions[0]);
 			if (switchVariable == null)
 				return changed;
 
@@ -124,15 +124,15 @@ namespace de4dot.blocks.cflow {
 				return changed;
 			var targets = new List<Block>(switchBlock.Targets);
 
-			changed |= deobfuscateLdloc(targets, switchBlock.FallThrough, switchBlock, switchVariable);
+			changed |= DeobfuscateLdloc(targets, switchBlock.FallThrough, switchBlock, switchVariable);
 
 			return changed;
 		}
 
-		bool deobfuscateStLdloc(Block switchBlock) {
+		bool DeobfuscateStLdloc(Block switchBlock) {
 			bool changed = false;
 
-			var switchVariable = Instr.getLocalVar(blocks.Locals, switchBlock.Instructions[0]);
+			var switchVariable = Instr.GetLocalVar(blocks.Locals, switchBlock.Instructions[0]);
 			if (switchVariable == null)
 				return changed;
 
@@ -140,7 +140,7 @@ namespace de4dot.blocks.cflow {
 				return changed;
 			var targets = new List<Block>(switchBlock.Targets);
 
-			changed |= deobfuscateStLdloc(targets, switchBlock.FallThrough, switchBlock);
+			changed |= DeobfuscateStLdloc(targets, switchBlock.FallThrough, switchBlock);
 
 			return changed;
 		}
@@ -153,19 +153,19 @@ namespace de4dot.blocks.cflow {
 		//		stloc N
 		//		ldloc N
 		//		switch (......)
-		bool deobfuscateStLdloc(IList<Block> switchTargets, Block switchFallThrough, Block block) {
+		bool DeobfuscateStLdloc(IList<Block> switchTargets, Block switchFallThrough, Block block) {
 			bool changed = false;
 			foreach (var source in new List<Block>(block.Sources)) {
 				if (!isBranchBlock(source))
 					continue;
-				instructionEmulator.init(blocks);
-				instructionEmulator.emulate(source.Instructions);
+				instructionEmulator.Initialize(blocks);
+				instructionEmulator.Emulate(source.Instructions);
 
-				var target = getSwitchTarget(switchTargets, switchFallThrough, instructionEmulator.pop());
+				var target = GetSwitchTarget(switchTargets, switchFallThrough, instructionEmulator.Pop());
 				if (target == null)
 					continue;
-				source.replaceLastNonBranchWithBranch(0, target);
-				source.add(new Instr(OpCodes.Pop.ToInstruction()));
+				source.ReplaceLastNonBranchWithBranch(0, target);
+				source.Add(new Instr(OpCodes.Pop.ToInstruction()));
 				changed = true;
 			}
 			return changed;
@@ -179,32 +179,32 @@ namespace de4dot.blocks.cflow {
 		//	swblk:
 		//		ldloc N
 		//		switch (......)
-		bool deobfuscateLdloc(IList<Block> switchTargets, Block switchFallThrough, Block block, Local 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)) {
-					instructionEmulator.init(blocks);
-					instructionEmulator.emulate(source.Instructions);
+					instructionEmulator.Initialize(blocks);
+					instructionEmulator.Emulate(source.Instructions);
 
-					var target = getSwitchTarget(switchTargets, switchFallThrough, instructionEmulator.getLocal(switchVariable));
+					var target = GetSwitchTarget(switchTargets, switchFallThrough, instructionEmulator.GetLocal(switchVariable));
 					if (target == null)
 						continue;
-					source.replaceLastNonBranchWithBranch(0, target);
+					source.ReplaceLastNonBranchWithBranch(0, target);
 					changed = true;
 				}
-				else if (isBccBlock(source)) {
-					instructionEmulator.init(blocks);
-					instructionEmulator.emulate(source.Instructions);
+				else if (IsBccBlock(source)) {
+					instructionEmulator.Initialize(blocks);
+					instructionEmulator.Emulate(source.Instructions);
 
-					var target = getSwitchTarget(switchTargets, switchFallThrough, instructionEmulator.getLocal(switchVariable));
+					var target = GetSwitchTarget(switchTargets, switchFallThrough, instructionEmulator.GetLocal(switchVariable));
 					if (target == null)
 						continue;
 					if (source.Targets[0] == block) {
-						source.setNewTarget(0, target);
+						source.SetNewTarget(0, target);
 						changed = true;
 					}
 					if (source.FallThrough == block) {
-						source.setNewFallThrough(target);
+						source.SetNewFallThrough(target);
 						changed = true;
 					}
 				}
@@ -218,21 +218,21 @@ namespace de4dot.blocks.cflow {
 		//		br swblk
 		//	swblk:
 		//		switch (......)
-		bool deobfuscateTos(IList<Block> switchTargets, Block switchFallThrough, Block block) {
+		bool DeobfuscateTOS(IList<Block> switchTargets, Block switchFallThrough, Block block) {
 			bool changed = false;
 			foreach (var source in new List<Block>(block.Sources)) {
 				if (!isBranchBlock(source))
 					continue;
-				instructionEmulator.init(blocks);
-				instructionEmulator.emulate(source.Instructions);
+				instructionEmulator.Initialize(blocks);
+				instructionEmulator.Emulate(source.Instructions);
 
-				var target = getSwitchTarget(switchTargets, switchFallThrough, instructionEmulator.pop());
+				var target = GetSwitchTarget(switchTargets, switchFallThrough, instructionEmulator.Pop());
 				if (target == null) {
-					changed |= deobfuscateTos_Ldloc(switchTargets, switchFallThrough, source);
+					changed |= DeobfuscateTos_Ldloc(switchTargets, switchFallThrough, source);
 				}
 				else {
-					source.replaceLastNonBranchWithBranch(0, target);
-					source.add(new Instr(OpCodes.Pop.ToInstruction()));
+					source.ReplaceLastNonBranchWithBranch(0, target);
+					source.Add(new Instr(OpCodes.Pop.ToInstruction()));
 					changed = true;
 				}
 			}
@@ -245,15 +245,15 @@ namespace de4dot.blocks.cflow {
 		//		stloc N
 		//		ldloc N
 		//		br swblk
-		bool deobfuscateTos_Ldloc(IList<Block> switchTargets, Block switchFallThrough, Block block) {
-			if (isLdlocBranch(block, false)) {
-				var switchVariable = Instr.getLocalVar(blocks.Locals, block.Instructions[0]);
+		bool DeobfuscateTos_Ldloc(IList<Block> switchTargets, Block switchFallThrough, Block block) {
+			if (IsLdlocBranch(block, false)) {
+				var switchVariable = Instr.GetLocalVar(blocks.Locals, block.Instructions[0]);
 				if (switchVariable == null)
 					return false;
-				return deobfuscateLdloc(switchTargets, switchFallThrough, block, switchVariable);
+				return DeobfuscateLdloc(switchTargets, switchFallThrough, block, switchVariable);
 			}
-			else if (isStLdlocBranch(block, false))
-				return deobfuscateStLdloc(switchTargets, switchFallThrough, block);
+			else if (IsStLdlocBranch(block, false))
+				return DeobfuscateStLdloc(switchTargets, switchFallThrough, block);
 
 			return false;
 		}
@@ -273,7 +273,7 @@ namespace de4dot.blocks.cflow {
 			}
 		}
 
-		static bool isBccBlock(Block block) {
+		static bool IsBccBlock(Block block) {
 			if (block.Targets == null || block.Targets.Count != 1)
 				return false;
 			if (block.FallThrough == null)
@@ -309,91 +309,91 @@ namespace de4dot.blocks.cflow {
 			}
 		}
 
-		bool deobfuscateType1(Block switchBlock) {
+		bool DeobfuscateType1(Block switchBlock) {
 			Block target;
-			if (!emulateGetTarget(switchBlock, out target) || target != null)
+			if (!EmulateGetTarget(switchBlock, out target) || target != null)
 				return false;
 
 			bool changed = false;
 
 			foreach (var source in new List<Block>(switchBlock.Sources)) {
-				if (!source.canAppend(switchBlock))
+				if (!source.CanAppend(switchBlock))
 					continue;
-				if (!willHaveKnownTarget(switchBlock, source))
+				if (!WillHaveKnownTarget(switchBlock, source))
 					continue;
 
-				source.append(switchBlock);
+				source.Append(switchBlock);
 				changed = true;
 			}
 
 			return changed;
 		}
 
-		bool deobfuscateType2(Block switchBlock) {
+		bool DeobfuscateType2(Block switchBlock) {
 			bool changed = false;
 
 			var bccSources = new List<Block>();
 			foreach (var source in new List<Block>(switchBlock.Sources)) {
-				if (source.LastInstr.isConditionalBranch()) {
+				if (source.LastInstr.IsConditionalBranch()) {
 					bccSources.Add(source);
 					continue;
 				}
-				if (!source.canAppend(switchBlock))
+				if (!source.CanAppend(switchBlock))
 					continue;
-				if (!willHaveKnownTarget(switchBlock, source))
+				if (!WillHaveKnownTarget(switchBlock, source))
 					continue;
 
-				source.append(switchBlock);
+				source.Append(switchBlock);
 				changed = true;
 			}
 
 			foreach (var bccSource in bccSources) {
-				if (!willHaveKnownTarget(switchBlock, bccSource))
+				if (!WillHaveKnownTarget(switchBlock, bccSource))
 					continue;
-				var consts = getBccLocalConstants(bccSource);
+				var consts = GetBccLocalConstants(bccSource);
 				if (consts.Count == 0)
 					continue;
-				var newFallThrough = createBlock(consts, bccSource.FallThrough);
-				var newTarget = createBlock(consts, bccSource.Targets[0]);
+				var newFallThrough = CreateBlock(consts, bccSource.FallThrough);
+				var newTarget = CreateBlock(consts, bccSource.Targets[0]);
 				var oldFallThrough = bccSource.FallThrough;
 				var oldTarget = bccSource.Targets[0];
-				bccSource.setNewFallThrough(newFallThrough);
-				bccSource.setNewTarget(0, newTarget);
-				newFallThrough.setNewFallThrough(oldFallThrough);
-				newTarget.setNewFallThrough(oldTarget);
+				bccSource.SetNewFallThrough(newFallThrough);
+				bccSource.SetNewTarget(0, newTarget);
+				newFallThrough.SetNewFallThrough(oldFallThrough);
+				newTarget.SetNewFallThrough(oldTarget);
 				changed = true;
 			}
 
 			return changed;
 		}
 
-		static Block createBlock(Dictionary<Local, 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(Instruction.CreateLdcI4(kv.Value)));
 				block.Instructions.Add(new Instr(OpCodes.Stloc.ToInstruction(kv.Key)));
 			}
-			fallThrough.Parent.add(block);
+			fallThrough.Parent.Add(block);
 			return block;
 		}
 
-		Dictionary<Local, int> getBccLocalConstants(Block block) {
+		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];
-				if (instr.isStloc()) {
-					var local = Instr.getLocalVar(blocks.Locals, instr);
+				if (instr.IsStloc()) {
+					var local = Instr.GetLocalVar(blocks.Locals, instr);
 					if (local == null)
 						continue;
 					var ldci4 = i == 0 ? null : instrs[i - 1];
-					if (ldci4 == null || !ldci4.isLdcI4())
+					if (ldci4 == null || !ldci4.IsLdcI4())
 						dict.Remove(local);
 					else
-						dict[local] = ldci4.getLdcI4Value();
+						dict[local] = ldci4.GetLdcI4Value();
 				}
-				else if (instr.isLdloc()) {
-					var local = Instr.getLocalVar(blocks.Locals, instr);
+				else if (instr.IsLdloc()) {
+					var local = Instr.GetLocalVar(blocks.Locals, instr);
 					if (local != null)
 						dict.Remove(local);
 				}
@@ -406,47 +406,47 @@ namespace de4dot.blocks.cflow {
 			return dict;
 		}
 
-		bool emulateGetTarget(Block switchBlock, out Block target) {
-			instructionEmulator.init(blocks);
+		bool EmulateGetTarget(Block switchBlock, out Block target) {
+			instructionEmulator.Initialize(blocks);
 			try {
-				instructionEmulator.emulate(switchBlock.Instructions, 0, switchBlock.Instructions.Count - 1);
+				instructionEmulator.Emulate(switchBlock.Instructions, 0, switchBlock.Instructions.Count - 1);
 			}
 			catch (NullReferenceException) {
 				// Here if eg. invalid metadata token in a call instruction (operand is null)
 				target = null;
 				return false;
 			}
-			target = getTarget(switchBlock);
+			target = GetTarget(switchBlock);
 			return true;
 		}
 
-		bool willHaveKnownTarget(Block switchBlock, Block source) {
-			instructionEmulator.init(blocks);
+		bool WillHaveKnownTarget(Block switchBlock, Block source) {
+			instructionEmulator.Initialize(blocks);
 			try {
-				instructionEmulator.emulate(source.Instructions);
-				instructionEmulator.emulate(switchBlock.Instructions, 0, switchBlock.Instructions.Count - 1);
+				instructionEmulator.Emulate(source.Instructions);
+				instructionEmulator.Emulate(switchBlock.Instructions, 0, switchBlock.Instructions.Count - 1);
 			}
 			catch (NullReferenceException) {
 				// Here if eg. invalid metadata token in a call instruction (operand is null)
 				return false;
 			}
-			return getTarget(switchBlock) != null;
+			return GetTarget(switchBlock) != null;
 		}
 
-		Block getTarget(Block switchBlock) {
-			var val1 = instructionEmulator.pop();
-			if (!val1.isInt32())
+		Block GetTarget(Block switchBlock) {
+			var val1 = instructionEmulator.Pop();
+			if (!val1.IsInt32())
 				return null;
-			return CflowUtils.getSwitchTarget(switchBlock.Targets, switchBlock.FallThrough, (Int32Value)val1);
+			return CflowUtils.GetSwitchTarget(switchBlock.Targets, switchBlock.FallThrough, (Int32Value)val1);
 		}
 
-		static Block getSwitchTarget(IList<Block> targets, Block fallThrough, Value value) {
-			if (!value.isInt32())
+		static Block GetSwitchTarget(IList<Block> targets, Block fallThrough, Value value) {
+			if (!value.IsInt32())
 				return null;
-			return CflowUtils.getSwitchTarget(targets, fallThrough, (Int32Value)value);
+			return CflowUtils.GetSwitchTarget(targets, fallThrough, (Int32Value)value);
 		}
 
-		static bool fixSwitchBranch(Block switchBlock) {
+		static bool FixSwitchBranch(Block switchBlock) {
 			// Code:
 			//	blk1:
 			//		ldc.i4 XXX
@@ -467,11 +467,11 @@ namespace de4dot.blocks.cflow {
 			foreach (var commonSource in new List<Block>(switchBlock.Sources)) {
 				if (commonSource.Instructions.Count != 1)
 					continue;
-				if (!commonSource.FirstInstr.isStloc())
+				if (!commonSource.FirstInstr.IsStloc())
 					continue;
 				foreach (var blk in new List<Block>(commonSource.Sources)) {
-					if (blk.canAppend(commonSource)) {
-						blk.append(commonSource);
+					if (blk.CanAppend(commonSource)) {
+						blk.Append(commonSource);
 						changed = true;
 					}
 				}
diff --git a/blocks/cflow/Value.cs b/blocks/cflow/Value.cs
index 99cb7b25..bbb54a8c 100644
--- a/blocks/cflow/Value.cs
+++ b/blocks/cflow/Value.cs
@@ -38,35 +38,35 @@ namespace de4dot.blocks.cflow {
 	public abstract class Value {
 		public readonly ValueType valueType;
 
-		public bool isUnknown() {
+		public bool IsUnknown() {
 			return valueType == ValueType.Unknown;
 		}
 
-		public bool isNull() {
+		public bool IsNull() {
 			return valueType == ValueType.Null;
 		}
 
-		public bool isObject() {
+		public bool IsObject() {
 			return valueType == ValueType.Object;
 		}
 
-		public bool isBoxed() {
+		public bool IsBoxed() {
 			return valueType == ValueType.Boxed;
 		}
 
-		public bool isInt32() {
+		public bool IsInt32() {
 			return valueType == ValueType.Int32;
 		}
 
-		public bool isInt64() {
+		public bool IsInt64() {
 			return valueType == ValueType.Int64;
 		}
 
-		public bool isReal8() {
+		public bool IsReal8() {
 			return valueType == ValueType.Real8;
 		}
 
-		public bool isString() {
+		public bool IsString() {
 			return valueType == ValueType.String;
 		}
 
diff --git a/blocks/cflow/ValueStack.cs b/blocks/cflow/ValueStack.cs
index 9c81f1e6..d301d043 100644
--- a/blocks/cflow/ValueStack.cs
+++ b/blocks/cflow/ValueStack.cs
@@ -29,43 +29,43 @@ namespace de4dot.blocks.cflow {
 			get { return stack.Count; }
 		}
 
-		public void init() {
+		public void Initialize() {
 			stack.Clear();
 		}
 
-		public void clear() {
+		public void Clear() {
 			stack.Clear();
 		}
 
-		public void push(Value value) {
+		public void Push(Value value) {
 			stack.Add(value);
 		}
 
-		public Value peek() {
+		public Value Peek() {
 			if (stack.Count == 0)
 				return new UnknownValue();
 			return stack[stack.Count - 1];
 		}
 
-		public Value pop() {
-			Value value = peek();
+		public Value Pop() {
+			Value value = Peek();
 			if (stack.Count != 0)
 				stack.RemoveAt(stack.Count - 1);
 			return value;
 		}
 
-		public void push(int count) {
+		public void Push(int count) {
 			if (count < 0)
 				throw new ArgumentOutOfRangeException("count");
 			for (int i = 0; i < count; i++)
-				pushUnknown();
+				PushUnknown();
 		}
 
-		public void pushUnknown() {
-			push(new UnknownValue());
+		public void PushUnknown() {
+			Push(new UnknownValue());
 		}
 
-		public void pop(int count) {
+		public void Pop(int count) {
 			if (count < 0)
 				throw new ArgumentOutOfRangeException("count");
 			if (count >= stack.Count)
@@ -74,8 +74,8 @@ namespace de4dot.blocks.cflow {
 				stack.RemoveRange(stack.Count - count, count);
 		}
 
-		public void copyTop() {
-			push(peek());
+		public void CopyTop() {
+			Push(Peek());
 		}
 
 		public override string ToString() {
diff --git a/de4dot-x64/Program.cs b/de4dot-x64/Program.cs
index 307df192..d470a2b5 100644
--- a/de4dot-x64/Program.cs
+++ b/de4dot-x64/Program.cs
@@ -20,7 +20,7 @@
 namespace de4dot_x64 {
 	class Program {
 		static int Main(string[] args) {
-			return de4dot.cui.Program.main(args);
+			return de4dot.cui.Program.Main2(args);
 		}
 	}
 }
diff --git a/de4dot.code/AssemblyClient/AssemblyClient.cs b/de4dot.code/AssemblyClient/AssemblyClient.cs
index 7da997e6..68bca68e 100644
--- a/de4dot.code/AssemblyClient/AssemblyClient.cs
+++ b/de4dot.code/AssemblyClient/AssemblyClient.cs
@@ -43,13 +43,13 @@ namespace de4dot.code.AssemblyClient {
 			this.loader = loader;
 		}
 
-		public void connect() {
-			loader.loadServer();
-			service = loader.createService();
+		public void Connect() {
+			loader.LoadServer();
+			service = loader.CreateService();
 			serverLoadedTime = DateTime.UtcNow;
 		}
 
-		public void waitConnected() {
+		public void WaitConnected() {
 			// If we don't wait here, we'll sometimes get stuck in doNothing(). Make sure the
 			// server has had time to start... This only seems to be needed when starting a
 			// server in a different process, though.
@@ -61,7 +61,7 @@ namespace de4dot.code.AssemblyClient {
 			var startTime = DateTime.UtcNow;
 			while (true) {
 				try {
-					service.doNothing();
+					service.DoNothing();
 					break;
 				}
 				catch (RemotingException) {
@@ -77,7 +77,7 @@ namespace de4dot.code.AssemblyClient {
 		public void Dispose() {
 			if (service != null) {
 				try {
-					service.exit();
+					service.Exit();
 				}
 				catch (RemotingException) {
 					// Couldn't connect
diff --git a/de4dot.code/AssemblyClient/AssemblyClientFactory.cs b/de4dot.code/AssemblyClient/AssemblyClientFactory.cs
index a6120d3b..fdcd9a59 100644
--- a/de4dot.code/AssemblyClient/AssemblyClientFactory.cs
+++ b/de4dot.code/AssemblyClient/AssemblyClientFactory.cs
@@ -21,17 +21,17 @@ using dnlib.DotNet;
 
 namespace de4dot.code.AssemblyClient {
 	public interface IAssemblyClientFactory {
-		IAssemblyClient create();
+		IAssemblyClient Create();
 	}
 
 	public class SameAppDomainAssemblyClientFactory : IAssemblyClientFactory {
-		public IAssemblyClient create() {
+		public IAssemblyClient Create() {
 			return new AssemblyClient(new SameAppDomainAssemblyServerLoader());
 		}
 	}
 
 	public class NewAppDomainAssemblyClientFactory : IAssemblyClientFactory {
-		public IAssemblyClient create() {
+		public IAssemblyClient Create() {
 			return new AssemblyClient(new NewAppDomainAssemblyServerLoader());
 		}
 	}
@@ -47,15 +47,15 @@ namespace de4dot.code.AssemblyClient {
 			this.serverVersion = serverVersion;
 		}
 
-		public IAssemblyClient create(ModuleDef module) {
-			return new AssemblyClient(new NewProcessAssemblyServerLoader(getServerClrVersion(module)));
+		public IAssemblyClient Create(ModuleDef module) {
+			return new AssemblyClient(new NewProcessAssemblyServerLoader(GetServerClrVersion(module)));
 		}
 
-		public IAssemblyClient create() {
+		public IAssemblyClient Create() {
 			return new AssemblyClient(new NewProcessAssemblyServerLoader(serverVersion));
 		}
 
-		internal static ServerClrVersion getServerClrVersion(ModuleDef module) {
+		internal static ServerClrVersion GetServerClrVersion(ModuleDef module) {
 			switch (module.GetPointerSize()) {
 			default:
 			case 4:
diff --git a/de4dot.code/AssemblyClient/IAssemblyClient.cs b/de4dot.code/AssemblyClient/IAssemblyClient.cs
index 68a1b008..0449796b 100644
--- a/de4dot.code/AssemblyClient/IAssemblyClient.cs
+++ b/de4dot.code/AssemblyClient/IAssemblyClient.cs
@@ -23,7 +23,7 @@ using AssemblyData;
 namespace de4dot.code.AssemblyClient {
 	public interface IAssemblyClient : IDisposable {
 		IAssemblyService Service { get; }
-		void connect();
-		void waitConnected();
+		void Connect();
+		void WaitConnected();
 	}
 }
diff --git a/de4dot.code/AssemblyClient/IAssemblyServerLoader.cs b/de4dot.code/AssemblyClient/IAssemblyServerLoader.cs
index 2a110e11..958c8f1e 100644
--- a/de4dot.code/AssemblyClient/IAssemblyServerLoader.cs
+++ b/de4dot.code/AssemblyClient/IAssemblyServerLoader.cs
@@ -22,7 +22,7 @@ using AssemblyData;
 
 namespace de4dot.code.AssemblyClient {
 	interface IAssemblyServerLoader : IDisposable {
-		void loadServer();
-		IAssemblyService createService();
+		void LoadServer();
+		IAssemblyService CreateService();
 	}
 }
diff --git a/de4dot.code/AssemblyClient/IpcAssemblyServerLoader.cs b/de4dot.code/AssemblyClient/IpcAssemblyServerLoader.cs
index e79c3a02..423f4eb7 100644
--- a/de4dot.code/AssemblyClient/IpcAssemblyServerLoader.cs
+++ b/de4dot.code/AssemblyClient/IpcAssemblyServerLoader.cs
@@ -42,13 +42,13 @@ namespace de4dot.code.AssemblyClient {
 		}
 
 		protected IpcAssemblyServerLoader(ServerClrVersion serverVersion) {
-			assemblyServerFilename = getServerName(serverVersion);
-			ipcName = Utils.randomName(15, 20);
-			ipcUri = Utils.randomName(15, 20);
+			assemblyServerFilename = GetServerName(serverVersion);
+			ipcName = Utils.RandomName(15, 20);
+			ipcUri = Utils.RandomName(15, 20);
 			url = string.Format("ipc://{0}/{1}", ipcName, ipcUri);
 		}
 
-		static string getServerName(ServerClrVersion serverVersion) {
+		static string GetServerName(ServerClrVersion serverVersion) {
 			if (serverVersion == ServerClrVersion.CLR_ANY_ANYCPU)
 				serverVersion = IntPtr.Size == 4 ? ServerClrVersion.CLR_ANY_x86 : ServerClrVersion.CLR_ANY_x64;
 			switch (serverVersion) {
@@ -62,13 +62,13 @@ namespace de4dot.code.AssemblyClient {
 			}
 		}
 
-		public void loadServer() {
-			loadServer(Utils.getPathOfOurFile(assemblyServerFilename));
+		public void LoadServer() {
+			LoadServer(Utils.GetPathOfOurFile(assemblyServerFilename));
 		}
 
-		public abstract void loadServer(string filename);
+		public abstract void LoadServer(string filename);
 
-		public IAssemblyService createService() {
+		public IAssemblyService CreateService() {
 			return (IAssemblyService)Activator.GetObject(typeof(AssemblyService), url);
 		}
 
diff --git a/de4dot.code/AssemblyClient/NewAppDomainAssemblyServerLoader.cs b/de4dot.code/AssemblyClient/NewAppDomainAssemblyServerLoader.cs
index 9ba76b25..16b274ce 100644
--- a/de4dot.code/AssemblyClient/NewAppDomainAssemblyServerLoader.cs
+++ b/de4dot.code/AssemblyClient/NewAppDomainAssemblyServerLoader.cs
@@ -26,11 +26,11 @@ namespace de4dot.code.AssemblyClient {
 		AppDomain appDomain;
 		Thread thread;
 
-		public override void loadServer(string filename) {
+		public override void LoadServer(string filename) {
 			if (appDomain != null)
 				throw new ApplicationException("Server is already loaded");
 
-			appDomain = AppDomain.CreateDomain(Utils.randomName(15, 20));
+			appDomain = AppDomain.CreateDomain(Utils.RandomName(15, 20));
 			thread = new Thread(new ThreadStart(() => {
 				try {
 					appDomain.ExecuteAssembly(filename, null, new string[] { ipcName, ipcUri });
@@ -41,14 +41,14 @@ namespace de4dot.code.AssemblyClient {
 				catch (AppDomainUnloadedException) {
 					// Here if it was unloaded by Dispose()
 				}
-				unloadAppDomain(appDomain);
+				UnloadAppDomain(appDomain);
 				appDomain = null;
 			}));
 			thread.Start();
 		}
 
 		public override void Dispose() {
-			unloadAppDomain(appDomain);
+			UnloadAppDomain(appDomain);
 			if (thread != null) {
 				try {
 					if (!thread.Join(100))
@@ -60,11 +60,11 @@ namespace de4dot.code.AssemblyClient {
 				thread = null;
 			}
 			// It could still be loaded if the thread was aborted so do it again
-			unloadAppDomain(appDomain);
+			UnloadAppDomain(appDomain);
 			appDomain = null;
 		}
 
-		static void unloadAppDomain(AppDomain appDomain) {
+		static void UnloadAppDomain(AppDomain appDomain) {
 			if (appDomain != null) {
 				try {
 					AppDomain.Unload(appDomain);
diff --git a/de4dot.code/AssemblyClient/NewProcessAssemblyServerLoader.cs b/de4dot.code/AssemblyClient/NewProcessAssemblyServerLoader.cs
index 98291639..379ed0ce 100644
--- a/de4dot.code/AssemblyClient/NewProcessAssemblyServerLoader.cs
+++ b/de4dot.code/AssemblyClient/NewProcessAssemblyServerLoader.cs
@@ -32,18 +32,18 @@ namespace de4dot.code.AssemblyClient {
 			: base(version) {
 		}
 
-		public override void loadServer(string filename) {
+		public override void LoadServer(string filename) {
 			if (process != null)
 				throw new ApplicationException("Server is already loaded");
 
 			var psi = new ProcessStartInfo {
-				Arguments = string.Format("{0} {1}", Utils.shellEscape(ipcName), Utils.shellEscape(ipcUri)),
+				Arguments = string.Format("{0} {1}", Utils.ShellEscape(ipcName), Utils.ShellEscape(ipcUri)),
 				CreateNoWindow = true,
 				ErrorDialog = false,
 				FileName = filename,
 				LoadUserProfile = false,
 				UseShellExecute = false,
-				WorkingDirectory = Utils.getOurBaseDir(),
+				WorkingDirectory = Utils.GetOurBaseDir(),
 			};
 			process = Process.Start(psi);
 			if (process == null)
diff --git a/de4dot.code/AssemblyClient/SameAppDomainAssemblyServerLoader.cs b/de4dot.code/AssemblyClient/SameAppDomainAssemblyServerLoader.cs
index 685758ec..978a205c 100644
--- a/de4dot.code/AssemblyClient/SameAppDomainAssemblyServerLoader.cs
+++ b/de4dot.code/AssemblyClient/SameAppDomainAssemblyServerLoader.cs
@@ -25,13 +25,13 @@ namespace de4dot.code.AssemblyClient {
 	class SameAppDomainAssemblyServerLoader : IAssemblyServerLoader {
 		IAssemblyService service;
 
-		public void loadServer() {
+		public void LoadServer() {
 			if (service != null)
 				throw new ApplicationException("Server already loaded");
 			service = new AssemblyService();
 		}
 
-		public IAssemblyService createService() {
+		public IAssemblyService CreateService() {
 			return service;
 		}
 
diff --git a/de4dot.code/AssemblyModule.cs b/de4dot.code/AssemblyModule.cs
index 3deb192c..e303a0c7 100644
--- a/de4dot.code/AssemblyModule.cs
+++ b/de4dot.code/AssemblyModule.cs
@@ -31,27 +31,27 @@ namespace de4dot.code {
 		ModuleContext moduleContext;
 
 		public AssemblyModule(string filename, ModuleContext moduleContext) {
-			this.filename = Utils.getFullPath(filename);
+			this.filename = Utils.GetFullPath(filename);
 			this.moduleContext = moduleContext;
 		}
 
-		public ModuleDefMD load() {
-			return setModule(ModuleDefMD.Load(filename, moduleContext));
+		public ModuleDefMD Load() {
+			return SetModule(ModuleDefMD.Load(filename, moduleContext));
 		}
 
-		public ModuleDefMD load(byte[] fileData) {
-			return setModule(ModuleDefMD.Load(fileData, moduleContext));
+		public ModuleDefMD Load(byte[] fileData) {
+			return SetModule(ModuleDefMD.Load(fileData, moduleContext));
 		}
 
-		ModuleDefMD setModule(ModuleDefMD newModule) {
+		ModuleDefMD SetModule(ModuleDefMD newModule) {
 			module = newModule;
-			TheAssemblyResolver.Instance.addModule(module);
+			TheAssemblyResolver.Instance.AddModule(module);
 			module.EnableTypeDefFindCache = true;
 			module.Location = filename;
 			return module;
 		}
 
-		public void save(string newFilename, MetaDataFlags mdFlags, IModuleWriterListener writerListener) {
+		public void Save(string newFilename, MetaDataFlags mdFlags, IModuleWriterListener writerListener) {
 			if (module.IsILOnly) {
 				var writerOptions = new ModuleWriterOptions(module, writerListener);
 				writerOptions.MetaDataOptions.Flags |= mdFlags;
@@ -68,7 +68,7 @@ namespace de4dot.code {
 			}
 		}
 
-		public ModuleDefMD reload(byte[] newModuleData, DumpedMethodsRestorer dumpedMethodsRestorer, IStringDecrypter stringDecrypter) {
+		public ModuleDefMD Reload(byte[] newModuleData, DumpedMethodsRestorer dumpedMethodsRestorer, IStringDecrypter stringDecrypter) {
 			TheAssemblyResolver.Instance.Remove(module);
 			var mod = ModuleDefMD.Load(newModuleData, moduleContext);
 			if (dumpedMethodsRestorer != null)
@@ -77,7 +77,7 @@ namespace de4dot.code {
 			mod.MethodDecrypter = dumpedMethodsRestorer;
 			mod.TablesStream.ColumnReader = dumpedMethodsRestorer;
 			mod.TablesStream.MethodRowReader = dumpedMethodsRestorer;
-			return setModule(mod);
+			return SetModule(mod);
 		}
 
 		public override string ToString() {
diff --git a/de4dot.code/AssemblyResolver.cs b/de4dot.code/AssemblyResolver.cs
index 17051c7a..717f6601 100644
--- a/de4dot.code/AssemblyResolver.cs
+++ b/de4dot.code/AssemblyResolver.cs
@@ -27,16 +27,16 @@ namespace de4dot.code {
 			EnableTypeDefCache = true;
 		}
 
-		public void addSearchDirectory(string dir) {
+		public void AddSearchDirectory(string dir) {
 			if (!PostSearchPaths.Contains(dir))
 				PostSearchPaths.Add(dir);
 		}
 
-		public void addModule(ModuleDef module) {
+		public void AddModule(ModuleDef module) {
 			AddToCache(module.Assembly);
 		}
 
-		public void removeModule(ModuleDef module) {
+		public void RemoveModule(ModuleDef module) {
 			var assembly = module.Assembly;
 			if (assembly == null)
 				return;
@@ -44,7 +44,7 @@ namespace de4dot.code {
 			Remove(module.Assembly);
 		}
 
-		public void clearAll() {
+		public void ClearAll() {
 			//TODO: cache.Clear();
 			//TODO: resetSearchPaths();
 		}
diff --git a/de4dot.code/DeobfuscatorContext.cs b/de4dot.code/DeobfuscatorContext.cs
index bb9d739e..2d7e85a2 100644
--- a/de4dot.code/DeobfuscatorContext.cs
+++ b/de4dot.code/DeobfuscatorContext.cs
@@ -28,25 +28,25 @@ namespace de4dot.code {
 	public class DeobfuscatorContext : IDeobfuscatorContext {
 		Dictionary<string, object> dataDict = new Dictionary<string, object>(StringComparer.Ordinal);
 
-		public void clear() {
+		public void Clear() {
 			dataDict.Clear();
 		}
 
-		public void setData(string name, object data) {
+		public void SetData(string name, object data) {
 			dataDict[name] = data;
 		}
 
-		public object getData(string name) {
+		public object GetData(string name) {
 			object value;
 			dataDict.TryGetValue(name, out value);
 			return value;
 		}
 
-		public void clearData(string name) {
+		public void ClearData(string name) {
 			dataDict.Remove(name);
 		}
 
-		static ITypeDefOrRef getNonGenericTypeRef(ITypeDefOrRef typeRef) {
+		static ITypeDefOrRef GetNonGenericTypeRef(ITypeDefOrRef typeRef) {
 			var ts = typeRef as TypeSpec;
 			if (ts == null)
 				return typeRef;
@@ -56,10 +56,10 @@ namespace de4dot.code {
 			return gis.GenericType.TypeDefOrRef;
 		}
 
-		public TypeDef resolveType(ITypeDefOrRef type) {
+		public TypeDef ResolveType(ITypeDefOrRef type) {
 			if (type == null)
 				return null;
-			type = getNonGenericTypeRef(type);
+			type = GetNonGenericTypeRef(type);
 
 			var typeDef = type as TypeDef;
 			if (typeDef != null)
@@ -72,7 +72,7 @@ namespace de4dot.code {
 			return null;
 		}
 
-		public MethodDef resolveMethod(IMethod method) {
+		public MethodDef ResolveMethod(IMethod method) {
 			if (method == null)
 				return null;
 
@@ -84,14 +84,14 @@ namespace de4dot.code {
 			if (mr == null || !mr.IsMethodRef)
 				return null;
 
-			var type = resolveType(mr.DeclaringType);
+			var type = ResolveType(mr.DeclaringType);
 			if (type == null)
 				return null;
 
 			return type.Resolve(mr) as MethodDef;
 		}
 
-		public FieldDef resolveField(IField field) {
+		public FieldDef ResolveField(IField field) {
 			if (field == null)
 				return null;
 
@@ -103,7 +103,7 @@ namespace de4dot.code {
 			if (mr == null || !mr.IsFieldRef)
 				return null;
 
-			var type = resolveType(mr.DeclaringType);
+			var type = ResolveType(mr.DeclaringType);
 			if (type == null)
 				return null;
 
diff --git a/de4dot.code/DumpedMethodsRestorer.cs b/de4dot.code/DumpedMethodsRestorer.cs
index fb252639..104ab04e 100644
--- a/de4dot.code/DumpedMethodsRestorer.cs
+++ b/de4dot.code/DumpedMethodsRestorer.cs
@@ -37,12 +37,12 @@ namespace de4dot.code {
 			this.dumpedMethods = dumpedMethods;
 		}
 
-		DumpedMethod getDumpedMethod(uint rid) {
-			return dumpedMethods.get(0x06000000 | rid);
+		DumpedMethod GetDumpedMethod(uint rid) {
+			return dumpedMethods.Get(0x06000000 | rid);
 		}
 
 		public RawMethodRow ReadRow(uint rid) {
-			var dm = getDumpedMethod(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);
@@ -62,11 +62,11 @@ namespace de4dot.code {
 		}
 
 		public bool HasMethodBody(uint rid) {
-			return getDumpedMethod(rid) != null;
+			return GetDumpedMethod(rid) != null;
 		}
 
 		public MethodBody GetMethodBody(uint rid, RVA rva, IList<Parameter> parameters) {
-			var dm = getDumpedMethod(rid);
+			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/IDeobfuscatorContext.cs b/de4dot.code/IDeobfuscatorContext.cs
index fdfb96f5..ceb4d96b 100644
--- a/de4dot.code/IDeobfuscatorContext.cs
+++ b/de4dot.code/IDeobfuscatorContext.cs
@@ -21,12 +21,12 @@ using dnlib.DotNet;
 
 namespace de4dot.code {
 	public interface IDeobfuscatorContext {
-		void clear();
-		void setData(string name, object data);
-		object getData(string name);
-		void clearData(string name);
-		TypeDef resolveType(ITypeDefOrRef type);
-		MethodDef resolveMethod(IMethod method);
-		FieldDef resolveField(IField field);
+		void Clear();
+		void SetData(string name, object data);
+		object GetData(string name);
+		void ClearData(string name);
+		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 c3820c95..5d070dc7 100644
--- a/de4dot.code/IObfuscatedFile.cs
+++ b/de4dot.code/IObfuscatedFile.cs
@@ -35,12 +35,12 @@ namespace de4dot.code {
 		bool RemoveNamespaceWithOneType { get; }
 		bool RenameResourceKeys { get; }
 
-		void deobfuscateBegin();
-		void deobfuscate();
-		void deobfuscateEnd();
-		void deobfuscateCleanUp();
+		void DeobfuscateBegin();
+		void Deobfuscate();
+		void DeobfuscateEnd();
+		void DeobfuscateCleanUp();
 
-		void load(IList<IDeobfuscator> deobfuscators);
-		void save();
+		void Load(IList<IDeobfuscator> deobfuscators);
+		void Save();
 	}
 }
diff --git a/de4dot.code/Logger.cs b/de4dot.code/Logger.cs
index 704994e2..d6260709 100644
--- a/de4dot.code/Logger.cs
+++ b/de4dot.code/Logger.cs
@@ -39,7 +39,7 @@ namespace de4dot.code {
 				if (indentLevel == value)
 					return;
 				indentLevel = value;
-				initIndentString();
+				InitIndentString();
 			}
 		}
 
@@ -66,20 +66,20 @@ namespace de4dot.code {
 			this.canIgnoreMessages = canIgnoreMessages;
 		}
 
-		void initIndentString() {
+		void InitIndentString() {
 			if (indentLevel < 0)
 				indentLevel = 0;
 			indentString = new string(' ', indentLevel * indentSize);
 		}
 
-		public void indent() {
+		public void Indent() {
 			indentLevel++;
-			initIndentString();
+			InitIndentString();
 		}
 
-		public void deIndent() {
+		public void DeIndent() {
 			indentLevel--;
-			initIndentString();
+			InitIndentString();
 		}
 
 		public void Log(object sender, LoggerEvent loggerEvent, string format, params object[] args) {
@@ -93,7 +93,7 @@ namespace de4dot.code {
 		public void Log(bool canIgnore, object sender, LoggerEvent loggerEvent, string format, params object[] args) {
 			if (IgnoresEvent(loggerEvent))
 				return;
-			if (canIgnore && ignoreMessage(loggerEvent, format, args))
+			if (canIgnore && IgnoreMessage(loggerEvent, format, args))
 				return;
 
 			switch (loggerEvent) {
@@ -114,7 +114,7 @@ namespace de4dot.code {
 			}
 		}
 
-		bool ignoreMessage(LoggerEvent loggerEvent, string format, object[] args) {
+		bool IgnoreMessage(LoggerEvent loggerEvent, string format, object[] args) {
 			if (loggerEvent != LoggerEvent.Error && loggerEvent != LoggerEvent.Warning)
 				return false;
 			if (!canIgnoreMessages)
@@ -138,7 +138,7 @@ namespace de4dot.code {
 			return loggerEvent > maxLoggerEvent;
 		}
 
-		public static void log(LoggerEvent loggerEvent, string format, params object[] args) {
+		public static void Log(LoggerEvent loggerEvent, string format, params object[] args) {
 			Instance.Log(null, loggerEvent, format, args);
 		}
 
diff --git a/de4dot.code/MethodPrinter.cs b/de4dot.code/MethodPrinter.cs
index 59642053..98b54777 100644
--- a/de4dot.code/MethodPrinter.cs
+++ b/de4dot.code/MethodPrinter.cs
@@ -41,13 +41,13 @@ namespace de4dot.code {
 		Dictionary<Instruction, ExInfo> exInfos = new Dictionary<Instruction, ExInfo>();
 		ExInfo lastExInfo;
 
-		public void print(LoggerEvent loggerEvent, IList<Instruction> allInstructions, IList<ExceptionHandler> allExceptionHandlers) {
+		public void Print(LoggerEvent loggerEvent, IList<Instruction> allInstructions, IList<ExceptionHandler> allExceptionHandlers) {
 			try {
 				this.loggerEvent = loggerEvent;
 				this.allInstructions = allInstructions;
 				this.allExceptionHandlers = allExceptionHandlers;
 				lastExInfo = new ExInfo();
-				print();
+				Print();
 			}
 			finally {
 				this.allInstructions = null;
@@ -59,27 +59,27 @@ namespace de4dot.code {
 			}
 		}
 
-		void initTargets() {
+		void InitTargets() {
 			foreach (var instr in allInstructions) {
 				switch (instr.OpCode.OperandType) {
 				case OperandType.ShortInlineBrTarget:
 				case OperandType.InlineBrTarget:
-					setTarget(instr.Operand as Instruction);
+					SetTarget(instr.Operand as Instruction);
 					break;
 
 				case OperandType.InlineSwitch:
 					foreach (var targetInstr in (Instruction[])instr.Operand)
-						setTarget(targetInstr);
+						SetTarget(targetInstr);
 					break;
 				}
 			}
 
 			foreach (var ex in allExceptionHandlers) {
-				setTarget(ex.TryStart);
-				setTarget(ex.TryEnd);
-				setTarget(ex.FilterStart);
-				setTarget(ex.HandlerStart);
-				setTarget(ex.HandlerEnd);
+				SetTarget(ex.TryStart);
+				SetTarget(ex.TryEnd);
+				SetTarget(ex.FilterStart);
+				SetTarget(ex.HandlerStart);
+				SetTarget(ex.HandlerEnd);
 			}
 
 			var sortedTargets = new List<Instruction>(targets.Keys);
@@ -88,27 +88,27 @@ namespace de4dot.code {
 				labels[sortedTargets[i]] = string.Format("label_{0}", i);
 		}
 
-		void setTarget(Instruction instr) {
+		void SetTarget(Instruction instr) {
 			if (instr != null)
 				targets[instr] = true;
 		}
 
-		void initExHandlers() {
+		void InitExHandlers() {
 			foreach (var ex in allExceptionHandlers) {
 				if (ex.TryStart != null) {
-					getExInfo(ex.TryStart).tryStarts.Add(ex);
-					getExInfo(ex.TryEnd).tryEnds.Add(ex);
+					GetExInfo(ex.TryStart).tryStarts.Add(ex);
+					GetExInfo(ex.TryEnd).tryEnds.Add(ex);
 				}
 				if (ex.FilterStart != null)
-					getExInfo(ex.FilterStart).filterStarts.Add(ex);
+					GetExInfo(ex.FilterStart).filterStarts.Add(ex);
 				if (ex.HandlerStart != null) {
-					getExInfo(ex.HandlerStart).handlerStarts.Add(ex);
-					getExInfo(ex.HandlerEnd).handlerEnds.Add(ex);
+					GetExInfo(ex.HandlerStart).handlerStarts.Add(ex);
+					GetExInfo(ex.HandlerEnd).handlerEnds.Add(ex);
 				}
 			}
 		}
 
-		ExInfo getExInfo(Instruction instruction) {
+		ExInfo GetExInfo(Instruction instruction) {
 			if (instruction == null)
 				return lastExInfo;
 			ExInfo exInfo;
@@ -117,49 +117,49 @@ namespace de4dot.code {
 			return exInfo;
 		}
 
-		void print() {
-			initTargets();
-			initExHandlers();
+		void Print() {
+			InitTargets();
+			InitExHandlers();
 
-			Logger.Instance.indent();
+			Logger.Instance.Indent();
 			foreach (var instr in allInstructions) {
 				if (targets.ContainsKey(instr)) {
-					Logger.Instance.deIndent();
-					Logger.log(loggerEvent, "{0}:", getLabel(instr));
-					Logger.Instance.indent();
+					Logger.Instance.DeIndent();
+					Logger.Log(loggerEvent, "{0}:", GetLabel(instr));
+					Logger.Instance.Indent();
 				}
 				ExInfo exInfo;
 				if (exInfos.TryGetValue(instr, out exInfo))
-					printExInfo(exInfo);
+					PrintExInfo(exInfo);
 				var instrString = instr.OpCode.Name;
-				var operandString = getOperandString(instr);
+				var operandString = GetOperandString(instr);
 				var memberRef = instr.Operand as ITokenOperand;
 				if (operandString == "")
-					Logger.log(loggerEvent, "{0}", instrString);
+					Logger.Log(loggerEvent, "{0}", instrString);
 				else if (memberRef != null)
-					Logger.log(loggerEvent, "{0,-9} {1} // {2:X8}", instrString, Utils.removeNewlines(operandString), memberRef.MDToken.ToUInt32());
+					Logger.Log(loggerEvent, "{0,-9} {1} // {2:X8}", instrString, Utils.RemoveNewlines(operandString), memberRef.MDToken.ToUInt32());
 				else
-					Logger.log(loggerEvent, "{0,-9} {1}", instrString, Utils.removeNewlines(operandString));
+					Logger.Log(loggerEvent, "{0,-9} {1}", instrString, Utils.RemoveNewlines(operandString));
 			}
-			printExInfo(lastExInfo);
-			Logger.Instance.deIndent();
+			PrintExInfo(lastExInfo);
+			Logger.Instance.DeIndent();
 		}
 
-		string getOperandString(Instruction instr) {
+		string GetOperandString(Instruction instr) {
 			if (instr.Operand is Instruction)
-				return getLabel((Instruction)instr.Operand);
+				return GetLabel((Instruction)instr.Operand);
 			else if (instr.Operand is Instruction[]) {
 				var sb = new StringBuilder();
 				var targets = (Instruction[])instr.Operand;
 				for (int i = 0; i < targets.Length; i++) {
 					if (i > 0)
 						sb.Append(',');
-					sb.Append(getLabel(targets[i]));
+					sb.Append(GetLabel(targets[i]));
 				}
 				return sb.ToString();
 			}
 			else if (instr.Operand is string)
-				return Utils.toCsharpString((string)instr.Operand);
+				return Utils.ToCsharpString((string)instr.Operand);
 			else if (instr.Operand is Parameter) {
 				var arg = (Parameter)instr.Operand;
 				var s = InstructionPrinter.GetOperandString(instr);
@@ -171,36 +171,36 @@ namespace de4dot.code {
 				return InstructionPrinter.GetOperandString(instr);
 		}
 
-		void printExInfo(ExInfo exInfo) {
-			Logger.Instance.deIndent();
+		void PrintExInfo(ExInfo exInfo) {
+			Logger.Instance.DeIndent();
 			foreach (var ex in exInfo.tryStarts)
-				Logger.log(loggerEvent, "// try start: {0}", getExceptionString(ex));
+				Logger.Log(loggerEvent, "// try start: {0}", GetExceptionString(ex));
 			foreach (var ex in exInfo.tryEnds)
-				Logger.log(loggerEvent, "// try end: {0}", getExceptionString(ex));
+				Logger.Log(loggerEvent, "// try end: {0}", GetExceptionString(ex));
 			foreach (var ex in exInfo.filterStarts)
-				Logger.log(loggerEvent, "// filter start: {0}", getExceptionString(ex));
+				Logger.Log(loggerEvent, "// filter start: {0}", GetExceptionString(ex));
 			foreach (var ex in exInfo.handlerStarts)
-				Logger.log(loggerEvent, "// handler start: {0}", getExceptionString(ex));
+				Logger.Log(loggerEvent, "// handler start: {0}", GetExceptionString(ex));
 			foreach (var ex in exInfo.handlerEnds)
-				Logger.log(loggerEvent, "// handler end: {0}", getExceptionString(ex));
-			Logger.Instance.indent();
+				Logger.Log(loggerEvent, "// handler end: {0}", GetExceptionString(ex));
+			Logger.Instance.Indent();
 		}
 
-		string getExceptionString(ExceptionHandler ex) {
+		string GetExceptionString(ExceptionHandler ex) {
 			var sb = new StringBuilder();
 			if (ex.TryStart != null)
-				sb.Append(string.Format("TRY: {0}-{1}", getLabel(ex.TryStart), getLabel(ex.TryEnd)));
+				sb.Append(string.Format("TRY: {0}-{1}", GetLabel(ex.TryStart), GetLabel(ex.TryEnd)));
 			if (ex.FilterStart != null)
-				sb.Append(string.Format(", FILTER: {0}", getLabel(ex.FilterStart)));
+				sb.Append(string.Format(", FILTER: {0}", GetLabel(ex.FilterStart)));
 			if (ex.HandlerStart != null)
-				sb.Append(string.Format(", HANDLER: {0}-{1}", getLabel(ex.HandlerStart), getLabel(ex.HandlerEnd)));
+				sb.Append(string.Format(", HANDLER: {0}-{1}", GetLabel(ex.HandlerStart), GetLabel(ex.HandlerEnd)));
 			sb.Append(string.Format(", TYPE: {0}", ex.HandlerType));
 			if (ex.CatchType != null)
 				sb.Append(string.Format(", CATCH: {0}", ex.CatchType));
 			return sb.ToString();
 		}
 
-		string getLabel(Instruction instr) {
+		string GetLabel(Instruction instr) {
 			if (instr == null)
 				return "<end>";
 			return labels[instr];
diff --git a/de4dot.code/MethodReturnValueInliner.cs b/de4dot.code/MethodReturnValueInliner.cs
index 7a42d8b0..20b2079d 100644
--- a/de4dot.code/MethodReturnValueInliner.cs
+++ b/de4dot.code/MethodReturnValueInliner.cs
@@ -35,24 +35,24 @@ namespace de4dot.code {
 			object value;
 			bool unknownValue = false;
 
-			public bool isValid() {
+			public bool IsValid() {
 				return !unknownValue && writes == 1;
 			}
 
 			public object Value {
 				get {
-					if (!isValid())
+					if (!IsValid())
 						throw new ApplicationException("Unknown variable value");
 					return value;
 				}
 				set { this.value = value; }
 			}
 
-			public void addWrite() {
+			public void AddWrite() {
 				writes++;
 			}
 
-			public void setUnknown() {
+			public void SetUnknown() {
 				unknownValue = true;
 			}
 		}
@@ -60,10 +60,10 @@ namespace de4dot.code {
 		public VariableValues(IList<Local> locals, IList<Block> allBlocks) {
 			this.locals = locals;
 			this.allBlocks = allBlocks;
-			init();
+			Initialize();
 		}
 
-		void init() {
+		void Initialize() {
 			foreach (var variable in locals)
 				variableToValue[variable] = new Variable();
 
@@ -78,12 +78,12 @@ namespace de4dot.code {
 					case Code.Stloc_1:
 					case Code.Stloc_2:
 					case Code.Stloc_3:
-						var variable = Instr.getLocalVar(locals, instr);
+						var variable = Instr.GetLocalVar(locals, instr);
 						var val = variableToValue[variable];
-						val.addWrite();
+						val.AddWrite();
 						object obj;
-						if (!getValue(block, i, out obj))
-							val.setUnknown();
+						if (!GetValue(block, i, out obj))
+							val.SetUnknown();
 						val.Value = obj;
 						break;
 
@@ -94,7 +94,7 @@ namespace de4dot.code {
 			}
 		}
 
-		bool getValue(Block block, int index, out object obj) {
+		bool GetValue(Block block, int index, out object obj) {
 			while (true) {
 				if (index <= 0) {
 					obj = null;
@@ -135,7 +135,7 @@ namespace de4dot.code {
 			}
 		}
 
-		public Variable getValue(Local variable) {
+		public Variable GetValue(Local variable) {
 			return variableToValue[variable];
 		}
 	}
@@ -165,7 +165,7 @@ namespace de4dot.code {
 				this.callEndIndex = callEndIndex;
 			}
 
-			public IMethod getMethodRef() {
+			public IMethod GetMethodRef() {
 				return (IMethod)block.Instructions[callEndIndex].Operand;
 			}
 		}
@@ -180,18 +180,18 @@ namespace de4dot.code {
 			get { return theMethod; }
 		}
 
-		protected abstract void inlineAllCalls();
+		protected abstract void InlineAllCalls();
 
 		// Returns null if method is not a method we should inline
-		protected abstract CallResult createCallResult(IMethod method, MethodSpec gim, Block block, int callInstrIndex);
+		protected abstract CallResult CreateCallResult(IMethod method, MethodSpec gim, Block block, int callInstrIndex);
 
-		public int decrypt(Blocks blocks) {
+		public int Decrypt(Blocks blocks) {
 			if (!HasHandlers)
 				return 0;
-			return decrypt(blocks.Method, blocks.MethodBlocks.getAllBlocks());
+			return Decrypt(blocks.Method, blocks.MethodBlocks.GetAllBlocks());
 		}
 
-		public int decrypt(MethodDef method, List<Block> allBlocks) {
+		public int Decrypt(MethodDef method, List<Block> allBlocks) {
 			if (!HasHandlers)
 				return 0;
 			try {
@@ -199,9 +199,9 @@ namespace de4dot.code {
 				callResults = new List<CallResult>();
 				this.allBlocks = allBlocks;
 
-				findAllCallResults();
-				inlineAllCalls();
-				inlineReturnValues();
+				FindAllCallResults();
+				InlineAllCalls();
+				InlineReturnValues();
 				return callResults.Count;
 			}
 			catch {
@@ -216,11 +216,11 @@ namespace de4dot.code {
 			}
 		}
 
-		bool getLocalVariableValue(Local variable, out object value) {
+		bool GetLocalVariableValue(Local variable, out object value) {
 			if (variableValues == null)
 				variableValues = new VariableValues(theMethod.Body.Variables, allBlocks);
-			var val = variableValues.getValue(variable);
-			if (!val.isValid()) {
+			var val = variableValues.GetValue(variable);
+			if (!val.IsValid()) {
 				value = null;
 				return false;
 			}
@@ -228,12 +228,12 @@ namespace de4dot.code {
 			return true;
 		}
 
-		void findAllCallResults() {
+		void FindAllCallResults() {
 			foreach (var block in allBlocks)
-				findCallResults(block);
+				FindCallResults(block);
 		}
 
-		void findCallResults(Block block) {
+		void FindCallResults(Block block) {
 			for (int i = 0; i < block.Instructions.Count; i++) {
 				var instr = block.Instructions[i];
 				if (instr.OpCode != OpCodes.Call)
@@ -246,31 +246,31 @@ namespace de4dot.code {
 				var gim = method as MethodSpec;
 				if (gim != null)
 					elementMethod = gim.Method;
-				var callResult = createCallResult(elementMethod, gim, block, i);
+				var callResult = CreateCallResult(elementMethod, gim, block, i);
 				if (callResult == null)
 					continue;
 
-				if (findArgs(callResult))
+				if (FindArgs(callResult))
 					callResults.Add(callResult);
 			}
 		}
 
-		bool findArgs(CallResult callResult) {
+		bool FindArgs(CallResult callResult) {
 			var block = callResult.block;
-			var method = callResult.getMethodRef();
-			var methodArgs = DotNetUtils.getArgs(method);
+			var method = callResult.GetMethodRef();
+			var methodArgs = DotNetUtils.GetArgs(method);
 			int numArgs = methodArgs.Count;
 			var args = new object[numArgs];
 
 			int instrIndex = callResult.callEndIndex - 1;
 			for (int i = numArgs - 1; i >= 0; i--) {
 				object arg = null;
-				if (!getArg(method, block, ref arg, ref instrIndex))
+				if (!GetArg(method, block, ref arg, ref instrIndex))
 					return false;
 				if (arg is int)
-					arg = fixIntArg(methodArgs[i], (int)arg);
+					arg = FixIntArg(methodArgs[i], (int)arg);
 				else if (arg is long)
-					arg = fixIntArg(methodArgs[i], (long)arg);
+					arg = FixIntArg(methodArgs[i], (long)arg);
 				args[i] = arg;
 			}
 
@@ -279,7 +279,7 @@ namespace de4dot.code {
 			return true;
 		}
 
-		object fixIntArg(TypeSig type, long value) {
+		object FixIntArg(TypeSig type, long value) {
 			switch (type.ElementType) {
 			case ElementType.Boolean: return value != 0;
 			case ElementType.Char: return (char)value;
@@ -295,14 +295,14 @@ namespace de4dot.code {
 			throw new ApplicationException(string.Format("Wrong type {0}", type));
 		}
 
-		bool getArg(IMethod 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).
 					Logger.w("Could not find all arguments to method {0} ({1:X8})",
-								Utils.removeNewlines(method),
+								Utils.RemoveNewlines(method),
 								method.MDToken.ToInt32());
 					errors++;
 					return false;
@@ -342,7 +342,7 @@ namespace de4dot.code {
 				case Code.Ldloc_1:
 				case Code.Ldloc_2:
 				case Code.Ldloc_3:
-					getLocalVariableValue(instr.Instruction.GetLocal(theMethod.Body.Variables), out arg);
+					GetLocalVariableValue(instr.Instruction.GetLocal(theMethod.Body.Variables), out arg);
 					break;
 
 				case Code.Ldfld:
@@ -355,7 +355,7 @@ namespace de4dot.code {
 					instr.Instruction.CalculateStackUsage(false, out pushes, out pops);
 					if (!useUnknownArgs || pushes != 1) {
 						Logger.w("Could not find all arguments to method {0} ({1:X8}), instr: {2}",
-									Utils.removeNewlines(method),
+									Utils.RemoveNewlines(method),
 									method.MDToken.ToInt32(),
 									instr);
 						errors++;
@@ -363,7 +363,7 @@ namespace de4dot.code {
 					}
 
 					for (int i = 0; i < pops; i++) {
-						if (!getArg(method, block, ref arg, ref instrIndex))
+						if (!GetArg(method, block, ref arg, ref instrIndex))
 							return false;
 					}
 					arg = null;
@@ -375,8 +375,8 @@ namespace de4dot.code {
 			return true;
 		}
 
-		void inlineReturnValues() {
-			callResults = removeNulls(callResults);
+		void InlineReturnValues() {
+			callResults = RemoveNulls(callResults);
 			callResults.Sort((a, b) => {
 				int i1 = allBlocks.FindIndex((x) => a.block == x);
 				int i2 = allBlocks.FindIndex((x) => b.block == x);
@@ -386,10 +386,10 @@ namespace de4dot.code {
 				return a.callStartIndex.CompareTo(b.callStartIndex);
 			});
 			callResults.Reverse();
-			inlineReturnValues(callResults);
+			InlineReturnValues(callResults);
 		}
 
-		static List<CallResult> removeNulls(List<CallResult> inList) {
+		static List<CallResult> RemoveNulls(List<CallResult> inList) {
 			var outList = new List<CallResult>(inList.Count);
 			foreach (var callResult in inList) {
 				if (callResult.returnValue != null)
@@ -398,6 +398,6 @@ namespace de4dot.code {
 			return outList;
 		}
 
-		protected abstract void inlineReturnValues(IList<CallResult> callResults);
+		protected abstract void InlineReturnValues(IList<CallResult> callResults);
 	}
 }
diff --git a/de4dot.code/NameRegexes.cs b/de4dot.code/NameRegexes.cs
index a3c04c37..5f1a411b 100644
--- a/de4dot.code/NameRegexes.cs
+++ b/de4dot.code/NameRegexes.cs
@@ -39,7 +39,7 @@ namespace de4dot.code {
 		}
 
 		// Returns true if the regex matches. Use MatchValue to get result.
-		public bool isMatch(string s) {
+		public bool IsMatch(string s) {
 			return regex.IsMatch(s);
 		}
 
@@ -60,10 +60,10 @@ namespace de4dot.code {
 		}
 
 		public NameRegexes(string regex) {
-			set(regex);
+			Set(regex);
 		}
 
-		public void set(string regexesString) {
+		public void Set(string regexesString) {
 			regexes = new List<NameRegex>();
 			if (regexesString != "") {
 				foreach (var regex in regexesString.Split(new char[] { regexSeparatorChar }))
@@ -71,9 +71,9 @@ namespace de4dot.code {
 			}
 		}
 
-		public bool isMatch(string s) {
+		public bool IsMatch(string s) {
 			foreach (var regex in regexes) {
-				if (regex.isMatch(s))
+				if (regex.IsMatch(s))
 					return regex.MatchValue;
 			}
 
diff --git a/de4dot.code/ObfuscatedFile.cs b/de4dot.code/ObfuscatedFile.cs
index 242e86c9..c4cfa2bf 100644
--- a/de4dot.code/ObfuscatedFile.cs
+++ b/de4dot.code/ObfuscatedFile.cs
@@ -55,27 +55,27 @@ namespace de4dot.code {
 
 				public SavedMethodBody(MethodDef method) {
 					this.method = method;
-					DotNetUtils.copyBody(method, out instructions, out exceptionHandlers);
+					DotNetUtils.CopyBody(method, out instructions, out exceptionHandlers);
 				}
 
-				public void restore() {
-					DotNetUtils.restoreBody(method, instructions, exceptionHandlers);
+				public void Restore() {
+					DotNetUtils.RestoreBody(method, instructions, exceptionHandlers);
 				}
 			}
 
-			public void save(MethodDef method) {
-				if (isSaved(method))
+			public void Save(MethodDef method) {
+				if (IsSaved(method))
 					return;
 				savedMethodBodies[method] = new SavedMethodBody(method);
 			}
 
-			public void restoreAll() {
+			public void RestoreAll() {
 				foreach (var smb in savedMethodBodies.Values)
-					smb.restore();
+					smb.Restore();
 				savedMethodBodies.Clear();
 			}
 
-			public bool isSaved(MethodDef method) {
+			public bool IsSaved(MethodDef method) {
 				return savedMethodBodies.ContainsKey(method);
 			}
 		}
@@ -139,17 +139,17 @@ namespace de4dot.code {
 			this.assemblyClientFactory = assemblyClientFactory;
 			this.options = options;
 			userStringDecrypterMethods = options.StringDecrypterMethods.Count > 0;
-			options.Filename = Utils.getFullPath(options.Filename);
+			options.Filename = Utils.GetFullPath(options.Filename);
 			assemblyModule = new AssemblyModule(options.Filename, moduleContext);
 
 			if (options.NewFilename == null)
-				options.NewFilename = getDefaultNewFilename();
+				options.NewFilename = GetDefaultNewFilename();
 
 			if (string.Equals(options.Filename, options.NewFilename, StringComparison.OrdinalIgnoreCase))
 				throw new UserException(string.Format("filename is same as new filename! ({0})", options.Filename));
 		}
 
-		string getDefaultNewFilename() {
+		string GetDefaultNewFilename() {
 			int dotIndex = options.Filename.LastIndexOf('.');
 			string noExt, ext;
 			if (dotIndex != -1) {
@@ -163,15 +163,15 @@ namespace de4dot.code {
 			return noExt + "-cleaned" + ext;
 		}
 
-		public void load(IList<IDeobfuscator> deobfuscators) {
+		public void Load(IList<IDeobfuscator> deobfuscators) {
 			try {
-				loadModule(deobfuscators);
-				TheAssemblyResolver.Instance.addSearchDirectory(Utils.getDirName(Filename));
-				TheAssemblyResolver.Instance.addSearchDirectory(Utils.getDirName(NewFilename));
-				detectObfuscator(deobfuscators);
+				LoadModule(deobfuscators);
+				TheAssemblyResolver.Instance.AddSearchDirectory(Utils.GetDirName(Filename));
+				TheAssemblyResolver.Instance.AddSearchDirectory(Utils.GetDirName(NewFilename));
+				DetectObfuscator(deobfuscators);
 				if (deob == null)
 					throw new ApplicationException("Could not detect obfuscator!");
-				initializeDeobfuscator();
+				InitializeDeobfuscator();
 			}
 			finally {
 				foreach (var d in deobfuscators) {
@@ -181,13 +181,13 @@ namespace de4dot.code {
 			}
 		}
 
-		void loadModule(IEnumerable<IDeobfuscator> deobfuscators) {
+		void LoadModule(IEnumerable<IDeobfuscator> deobfuscators) {
 			ModuleDefMD oldModule = module;
 			try {
-				module = assemblyModule.load();
+				module = assemblyModule.Load();
 			}
 			catch (BadImageFormatException) {
-				if (!unpackNativeImage(deobfuscators))
+				if (!UnpackNativeImage(deobfuscators))
 					throw new BadImageFormatException();
 				Logger.v("Unpacked native file");
 			}
@@ -197,12 +197,12 @@ namespace de4dot.code {
 			}
 		}
 
-		bool unpackNativeImage(IEnumerable<IDeobfuscator> deobfuscators) {
+		bool UnpackNativeImage(IEnumerable<IDeobfuscator> deobfuscators) {
 			using (var peImage = new PEImage(Filename)) {
 				foreach (var deob in deobfuscators) {
 					byte[] unpackedData = null;
 					try {
-						unpackedData = deob.unpackNativeFile(peImage);
+						unpackedData = deob.UnpackNativeFile(peImage);
 					}
 					catch {
 					}
@@ -211,7 +211,7 @@ namespace de4dot.code {
 
 					var oldModule = module;
 					try {
-						module = assemblyModule.load(unpackedData);
+						module = assemblyModule.Load(unpackedData);
 					}
 					catch {
 						Logger.w("Could not load unpacked data. File: {0}, deobfuscator: {0}", peImage.FileName ?? "(unknown filename)", deob.TypeLong);
@@ -229,16 +229,16 @@ namespace de4dot.code {
 			return false;
 		}
 
-		void initializeDeobfuscator() {
+		void InitializeDeobfuscator() {
 			if (options.StringDecrypterType == DecrypterType.Default)
 				options.StringDecrypterType = deob.DefaultDecrypterType;
 			if (options.StringDecrypterType == DecrypterType.Default)
 				options.StringDecrypterType = DecrypterType.Static;
 
-			deob.Operations = createOperations();
+			deob.Operations = CreateOperations();
 		}
 
-		IOperations createOperations() {
+		IOperations CreateOperations() {
 			var op = new Operations();
 
 			switch (options.StringDecrypterType) {
@@ -260,7 +260,7 @@ namespace de4dot.code {
 			return op;
 		}
 
-		void detectObfuscator(IEnumerable<IDeobfuscator> deobfuscators) {
+		void DetectObfuscator(IEnumerable<IDeobfuscator> deobfuscators) {
 
 			// The deobfuscators may call methods to deobfuscate control flow and decrypt
 			// strings (statically) in order to detect the obfuscator.
@@ -269,14 +269,14 @@ namespace de4dot.code {
 
 			// It's not null if it unpacked a native file
 			if (this.deob != null) {
-				deob.init(module);
+				deob.Initialize(module);
 				deob.DeobfuscatedFile = this;
-				deob.detect();
+				deob.Detect();
 				return;
 			}
 
 			foreach (var deob in deobfuscators) {
-				deob.init(module);
+				deob.Initialize(module);
 				deob.DeobfuscatedFile = this;
 			}
 
@@ -284,16 +284,16 @@ namespace de4dot.code {
 				foreach (var deob in deobfuscators) {
 					if (string.Equals(options.ForcedObfuscatorType, deob.Type, StringComparison.OrdinalIgnoreCase)) {
 						this.deob = deob;
-						deob.detect();
+						deob.Detect();
 						return;
 					}
 				}
 			}
 			else
-				this.deob = detectObfuscator2(deobfuscators);
+				this.deob = DetectObfuscator2(deobfuscators);
 		}
 
-		IDeobfuscator detectObfuscator2(IEnumerable<IDeobfuscator> deobfuscators) {
+		IDeobfuscator DetectObfuscator2(IEnumerable<IDeobfuscator> deobfuscators) {
 			var allDetected = new List<IDeobfuscator>();
 			IDeobfuscator detected = null;
 			int detectVal = 0;
@@ -301,7 +301,7 @@ namespace de4dot.code {
 				this.deob = deob;	// So we can call deob.CanInlineMethods in deobfuscate()
 				int val;
 				try {
-					val = deob.detect();
+					val = deob.Detect();
 				}
 				catch {
 					val = deob.Type == "un" ? 1 : 0;
@@ -318,16 +318,16 @@ namespace de4dot.code {
 
 			if (allDetected.Count > 1) {
 				Logger.n("More than one obfuscator detected:");
-				Logger.Instance.indent();
+				Logger.Instance.Indent();
 				foreach (var deob in allDetected)
 					Logger.n("{0} (use: -p {1})", deob.Name, deob.Type);
-				Logger.Instance.deIndent();
+				Logger.Instance.DeIndent();
 			}
 
 			return detected;
 		}
 
-		MetaDataFlags getMetaDataFlags() {
+		MetaDataFlags GetMetaDataFlags() {
 			var mdFlags = options.MetaDataFlags | deob.MetaDataFlags;
 
 			// Always preserve tokens if it's an unknown obfuscator
@@ -341,15 +341,15 @@ namespace de4dot.code {
 			return mdFlags;
 		}
 
-		public void save() {
+		public void Save() {
 			Logger.n("Saving {0}", options.NewFilename);
-			var mdFlags = getMetaDataFlags();
+			var mdFlags = GetMetaDataFlags();
 			if (!options.ControlFlowDeobfuscation)
 				mdFlags |= MetaDataFlags.KeepOldMaxStack;
-			assemblyModule.save(options.NewFilename, mdFlags, deob as IModuleWriterListener);
+			assemblyModule.Save(options.NewFilename, mdFlags, deob as IModuleWriterListener);
 		}
 
-		IList<MethodDef> getAllMethods() {
+		IList<MethodDef> GetAllMethods() {
 			var list = new List<MethodDef>();
 
 			foreach (var type in module.GetTypes()) {
@@ -360,25 +360,25 @@ namespace de4dot.code {
 			return list;
 		}
 
-		public void deobfuscateBegin() {
+		public void DeobfuscateBegin() {
 			switch (options.StringDecrypterType) {
 			case DecrypterType.None:
-				checkSupportedStringDecrypter(StringFeatures.AllowNoDecryption);
+				CheckSupportedStringDecrypter(StringFeatures.AllowNoDecryption);
 				break;
 
 			case DecrypterType.Static:
-				checkSupportedStringDecrypter(StringFeatures.AllowStaticDecryption);
+				CheckSupportedStringDecrypter(StringFeatures.AllowStaticDecryption);
 				break;
 
 			case DecrypterType.Delegate:
 			case DecrypterType.Emulate:
-				checkSupportedStringDecrypter(StringFeatures.AllowDynamicDecryption);
+				CheckSupportedStringDecrypter(StringFeatures.AllowDynamicDecryption);
 				var newProcFactory = assemblyClientFactory as NewProcessAssemblyClientFactory;
 				if (newProcFactory != null)
-					assemblyClient = newProcFactory.create(module);
+					assemblyClient = newProcFactory.Create(module);
 				else
-					assemblyClient = assemblyClientFactory.create();
-				assemblyClient.connect();
+					assemblyClient = assemblyClientFactory.Create();
+				assemblyClient.Connect();
 				break;
 
 			default:
@@ -386,73 +386,73 @@ namespace de4dot.code {
 			}
 		}
 
-		public void checkSupportedStringDecrypter(StringFeatures feature) {
+		public void CheckSupportedStringDecrypter(StringFeatures feature) {
 			if ((deob.StringFeatures & feature) == feature)
 				return;
 			throw new UserException(string.Format("Deobfuscator {0} does not support this string decryption type", deob.TypeLong));
 		}
 
-		public void deobfuscate() {
+		public void Deobfuscate() {
 			Logger.n("Cleaning {0}", options.Filename);
-			initAssemblyClient();
+			InitAssemblyClient();
 
 			for (int i = 0; ; i++) {
 				byte[] fileData = null;
 				DumpedMethods dumpedMethods = null;
-				if (!deob.getDecryptedModule(i, ref fileData, ref dumpedMethods))
+				if (!deob.GetDecryptedModule(i, ref fileData, ref dumpedMethods))
 					break;
-				reloadModule(fileData, dumpedMethods);
+				ReloadModule(fileData, dumpedMethods);
 			}
 
-			deob.deobfuscateBegin();
-			deobfuscateMethods();
-			deob.deobfuscateEnd();
+			deob.DeobfuscateBegin();
+			DeobfuscateMethods();
+			deob.DeobfuscateEnd();
 		}
 
-		void reloadModule(byte[] newModuleData, DumpedMethods dumpedMethods) {
+		void ReloadModule(byte[] newModuleData, DumpedMethods dumpedMethods) {
 			Logger.v("Reloading decrypted assembly (original filename: {0})", Filename);
 			simpleDeobfuscatorFlags.Clear();
 			using (var oldModule = module) {
-				module = assemblyModule.reload(newModuleData, createDumpedMethodsRestorer(dumpedMethods), deob as IStringDecrypter);
-				deob = deob.moduleReloaded(module);
+				module = assemblyModule.Reload(newModuleData, CreateDumpedMethodsRestorer(dumpedMethods), deob as IStringDecrypter);
+				deob = deob.ModuleReloaded(module);
 			}
-			initializeDeobfuscator();
+			InitializeDeobfuscator();
 			deob.DeobfuscatedFile = this;
-			updateDynamicStringInliner();
+			UpdateDynamicStringInliner();
 		}
 
-		DumpedMethodsRestorer createDumpedMethodsRestorer(DumpedMethods dumpedMethods) {
+		DumpedMethodsRestorer CreateDumpedMethodsRestorer(DumpedMethods dumpedMethods) {
 			if (dumpedMethods == null || dumpedMethods.Count == 0)
 				return null;
 			return new DumpedMethodsRestorer(dumpedMethods);
 		}
 
-		void initAssemblyClient() {
+		void InitAssemblyClient() {
 			if (assemblyClient == null)
 				return;
 
-			assemblyClient.waitConnected();
-			assemblyClient.Service.loadAssembly(options.Filename);
+			assemblyClient.WaitConnected();
+			assemblyClient.Service.LoadAssembly(options.Filename);
 
 			if (options.StringDecrypterType == DecrypterType.Delegate)
-				assemblyClient.Service.setStringDecrypterType(AssemblyData.StringDecrypterType.Delegate);
+				assemblyClient.Service.SetStringDecrypterType(AssemblyData.StringDecrypterType.Delegate);
 			else if (options.StringDecrypterType == DecrypterType.Emulate)
-				assemblyClient.Service.setStringDecrypterType(AssemblyData.StringDecrypterType.Emulate);
+				assemblyClient.Service.SetStringDecrypterType(AssemblyData.StringDecrypterType.Emulate);
 			else
 				throw new ApplicationException(string.Format("Invalid string decrypter type '{0}'", options.StringDecrypterType));
 
 			dynamicStringInliner = new DynamicStringInliner(assemblyClient);
-			updateDynamicStringInliner();
+			UpdateDynamicStringInliner();
 		}
 
-		void updateDynamicStringInliner() {
+		void UpdateDynamicStringInliner() {
 			if (dynamicStringInliner != null)
-				dynamicStringInliner.init(getMethodTokens());
+				dynamicStringInliner.Initialize(GetMethodTokens());
 		}
 
-		IEnumerable<int> getMethodTokens() {
+		IEnumerable<int> GetMethodTokens() {
 			if (!userStringDecrypterMethods)
-				return deob.getStringDecrypterMethods();
+				return deob.GetStringDecrypterMethods();
 
 			var tokens = new List<int>();
 
@@ -464,18 +464,18 @@ namespace de4dot.code {
 				if (int.TryParse(tokenStr, NumberStyles.HexNumber, null, out methodToken))
 					tokens.Add(methodToken);
 				else
-					tokens.AddRange(findMethodTokens(val));
+					tokens.AddRange(FindMethodTokens(val));
 			}
 
 			return tokens;
 		}
 
-		IEnumerable<int> findMethodTokens(string methodDesc) {
+		IEnumerable<int> FindMethodTokens(string methodDesc) {
 			var tokens = new List<int>();
 
 			string typeString, methodName;
 			string[] argsStrings;
-			splitMethodDesc(methodDesc, out typeString, out methodName, out argsStrings);
+			SplitMethodDesc(methodDesc, out typeString, out methodName, out argsStrings);
 
 			foreach (var type in module.GetTypes()) {
 				if (typeString != null && typeString != type.FullName)
@@ -502,7 +502,7 @@ namespace de4dot.code {
 						}
 					}
 
-					Logger.v("Adding string decrypter; token: {0:X8}, method: {1}", method.MDToken.ToInt32(), Utils.removeNewlines(method.FullName));
+					Logger.v("Adding string decrypter; token: {0:X8}, method: {1}", method.MDToken.ToInt32(), Utils.RemoveNewlines(method.FullName));
 					tokens.Add(method.MDToken.ToInt32());
 				}
 			}
@@ -510,7 +510,7 @@ namespace de4dot.code {
 			return tokens;
 		}
 
-		static void splitMethodDesc(string methodDesc, out string type, out string name, out string[] args) {
+		static void SplitMethodDesc(string methodDesc, out string type, out string name, out string[] args) {
 			string stringArgs = null;
 			args = null;
 			type = null;
@@ -555,20 +555,20 @@ namespace de4dot.code {
 				name = null;
 		}
 
-		public void deobfuscateEnd() {
-			deobfuscateCleanUp();
+		public void DeobfuscateEnd() {
+			DeobfuscateCleanUp();
 		}
 
-		public void deobfuscateCleanUp() {
+		public void DeobfuscateCleanUp() {
 			if (assemblyClient != null) {
 				assemblyClient.Dispose();
 				assemblyClient = null;
 			}
 		}
 
-		void deobfuscateMethods() {
+		void DeobfuscateMethods() {
 			if (savedMethodBodies != null) {
-				savedMethodBodies.restoreAll();
+				savedMethodBodies.RestoreAll();
 				savedMethodBodies = null;
 			}
 			deob.DeobfuscatedFile = null;
@@ -584,21 +584,21 @@ namespace de4dot.code {
 				Logger.v("Deobfuscating methods");
 			var methodPrinter = new MethodPrinter();
 			var cflowDeobfuscator = new BlocksCflowDeobfuscator(deob.BlocksDeobfuscators);
-			foreach (var method in getAllMethods()) {
+			foreach (var method in GetAllMethods()) {
 				if (isVerbose) {
-					Logger.v("Deobfuscating {0} ({1:X8})", Utils.removeNewlines(method), method.MDToken.ToUInt32());
-					Logger.Instance.indent();
+					Logger.v("Deobfuscating {0} ({1:X8})", Utils.RemoveNewlines(method), method.MDToken.ToUInt32());
+					Logger.Instance.Indent();
 				}
 
 				int oldIndentLevel = Logger.Instance.IndentLevel;
 				try {
-					deobfuscate(method, cflowDeobfuscator, methodPrinter, isVerbose, isVV);
+					Deobfuscate(method, cflowDeobfuscator, methodPrinter, isVerbose, isVV);
 				}
 				catch (ApplicationException) {
 					throw;
 				}
 				catch (Exception ex) {
-					if (!canLoadMethodBody(method)) {
+					if (!CanLoadMethodBody(method)) {
 						if (isVerbose)
 							Logger.v("Invalid method body. {0:X8}", method.MDToken.ToInt32());
 						method.Body = new CilBody();
@@ -612,14 +612,14 @@ namespace de4dot.code {
 				finally {
 					Logger.Instance.IndentLevel = oldIndentLevel;
 				}
-				removeNoInliningAttribute(method);
+				RemoveNoInliningAttribute(method);
 
 				if (isVerbose)
-					Logger.Instance.deIndent();
+					Logger.Instance.DeIndent();
 			}
 		}
 
-		static bool canLoadMethodBody(MethodDef method) {
+		static bool CanLoadMethodBody(MethodDef method) {
 			try {
 				var body = method.Body;
 				return true;
@@ -631,39 +631,39 @@ namespace de4dot.code {
 
 		bool CanOptimizeLocals() {
 			// Don't remove any locals if we must preserve StandAloneSig table
-			return (getMetaDataFlags() & MetaDataFlags.PreserveStandAloneSigRids) == 0;
+			return (GetMetaDataFlags() & MetaDataFlags.PreserveStandAloneSigRids) == 0;
 		}
 
-		void deobfuscate(MethodDef method, BlocksCflowDeobfuscator cflowDeobfuscator, MethodPrinter methodPrinter, bool isVerbose, bool isVV) {
-			if (!hasNonEmptyBody(method))
+		void Deobfuscate(MethodDef method, BlocksCflowDeobfuscator cflowDeobfuscator, MethodPrinter methodPrinter, bool isVerbose, bool isVV) {
+			if (!HasNonEmptyBody(method))
 				return;
 
 			var blocks = new Blocks(method);
 			int numRemovedLocals = 0;
 			int oldNumInstructions = method.Body.Instructions.Count;
 
-			deob.deobfuscateMethodBegin(blocks);
+			deob.DeobfuscateMethodBegin(blocks);
 			if (options.ControlFlowDeobfuscation) {
-				cflowDeobfuscator.init(blocks);
-				cflowDeobfuscator.deobfuscate();
+				cflowDeobfuscator.Initialize(blocks);
+				cflowDeobfuscator.Deobfuscate();
 			}
 
-			if (deob.deobfuscateOther(blocks) && options.ControlFlowDeobfuscation)
-				cflowDeobfuscator.deobfuscate();
+			if (deob.DeobfuscateOther(blocks) && options.ControlFlowDeobfuscation)
+				cflowDeobfuscator.Deobfuscate();
 
 			if (options.ControlFlowDeobfuscation) {
 				if (CanOptimizeLocals())
-					numRemovedLocals = blocks.optimizeLocals();
-				blocks.repartitionBlocks();
+					numRemovedLocals = blocks.OptimizeLocals();
+				blocks.RepartitionBlocks();
 			}
 
-			deobfuscateStrings(blocks);
-			deob.deobfuscateMethodEnd(blocks);
+			DeobfuscateStrings(blocks);
+			deob.DeobfuscateMethodEnd(blocks);
 
 			IList<Instruction> allInstructions;
 			IList<ExceptionHandler> allExceptionHandlers;
-			blocks.getCode(out allInstructions, out allExceptionHandlers);
-			DotNetUtils.restoreBody(method, allInstructions, allExceptionHandlers);
+			blocks.GetCode(out allInstructions, out allExceptionHandlers);
+			DotNetUtils.RestoreBody(method, allInstructions, allExceptionHandlers);
 
 			if (isVerbose && numRemovedLocals > 0)
 				Logger.v("Removed {0} unused local(s)", numRemovedLocals);
@@ -672,29 +672,29 @@ namespace de4dot.code {
 				Logger.v("Removed {0} dead instruction(s)", numRemovedInstructions);
 
 			if (isVV) {
-				Logger.log(LoggerEvent.VeryVerbose, "Deobfuscated code:");
-				Logger.Instance.indent();
-				methodPrinter.print(LoggerEvent.VeryVerbose, allInstructions, allExceptionHandlers);
-				Logger.Instance.deIndent();
+				Logger.Log(LoggerEvent.VeryVerbose, "Deobfuscated code:");
+				Logger.Instance.Indent();
+				methodPrinter.Print(LoggerEvent.VeryVerbose, allInstructions, allExceptionHandlers);
+				Logger.Instance.DeIndent();
 			}
 		}
 
-		bool hasNonEmptyBody(MethodDef method) {
+		bool HasNonEmptyBody(MethodDef method) {
 			return method.HasBody && method.Body.Instructions.Count > 0;
 		}
 
-		void deobfuscateStrings(Blocks blocks) {
+		void DeobfuscateStrings(Blocks blocks) {
 			switch (options.StringDecrypterType) {
 			case DecrypterType.None:
 				break;
 
 			case DecrypterType.Static:
-				deob.deobfuscateStrings(blocks);
+				deob.DeobfuscateStrings(blocks);
 				break;
 
 			case DecrypterType.Delegate:
 			case DecrypterType.Emulate:
-				dynamicStringInliner.decrypt(blocks);
+				dynamicStringInliner.Decrypt(blocks);
 				break;
 
 			default:
@@ -702,14 +702,14 @@ namespace de4dot.code {
 			}
 		}
 
-		void removeNoInliningAttribute(MethodDef method) {
+		void RemoveNoInliningAttribute(MethodDef method) {
 			method.IsNoInlining = false;
 			for (int i = 0; i < method.CustomAttributes.Count; i++) {
 				var cattr = method.CustomAttributes[i];
 				if (cattr.TypeFullName != "System.Runtime.CompilerServices.MethodImplAttribute")
 					continue;
 				int options = 0;
-				if (!getMethodImplOptions(cattr, ref options))
+				if (!GetMethodImplOptions(cattr, ref options))
 					continue;
 				if (options != 0 && options != (int)MethodImplAttributes.NoInlining)
 					continue;
@@ -718,7 +718,7 @@ namespace de4dot.code {
 			}
 		}
 
-		static bool getMethodImplOptions(CustomAttribute cattr, ref int value) {
+		static bool GetMethodImplOptions(CustomAttribute cattr, ref int value) {
 			if (cattr.IsRawBlob)
 				return false;
 			if (cattr.ConstructorArguments.Count != 1)
@@ -751,21 +751,21 @@ namespace de4dot.code {
 			HasDeobfuscated = 0x1,
 		}
 		Dictionary<MethodDef, SimpleDeobFlags> simpleDeobfuscatorFlags = new Dictionary<MethodDef, SimpleDeobFlags>();
-		bool check(MethodDef method, SimpleDeobFlags flag) {
+		bool Check(MethodDef method, SimpleDeobFlags flag) {
 			SimpleDeobFlags oldFlags;
 			simpleDeobfuscatorFlags.TryGetValue(method, out oldFlags);
 			simpleDeobfuscatorFlags[method] = oldFlags | flag;
 			return (oldFlags & flag) == flag;
 		}
 
-		void deobfuscate(MethodDef method, string msg, Action<Blocks> handler) {
+		void Deobfuscate(MethodDef method, string msg, Action<Blocks> handler) {
 			if (savedMethodBodies != null)
-				savedMethodBodies.save(method);
+				savedMethodBodies.Save(method);
 
-			Logger.v("{0}: {1} ({2:X8})", msg, Utils.removeNewlines(method), method.MDToken.ToUInt32());
-			Logger.Instance.indent();
+			Logger.v("{0}: {1} ({2:X8})", msg, Utils.RemoveNewlines(method), method.MDToken.ToUInt32());
+			Logger.Instance.Indent();
 
-			if (hasNonEmptyBody(method)) {
+			if (HasNonEmptyBody(method)) {
 				try {
 					var blocks = new Blocks(method);
 
@@ -773,55 +773,55 @@ namespace de4dot.code {
 
 					IList<Instruction> allInstructions;
 					IList<ExceptionHandler> allExceptionHandlers;
-					blocks.getCode(out allInstructions, out allExceptionHandlers);
-					DotNetUtils.restoreBody(method, allInstructions, allExceptionHandlers);
+					blocks.GetCode(out allInstructions, out allExceptionHandlers);
+					DotNetUtils.RestoreBody(method, allInstructions, allExceptionHandlers);
 				}
 				catch {
 					Logger.v("Could not deobfuscate {0:X8}", method.MDToken.ToInt32());
 				}
 			}
 
-			Logger.Instance.deIndent();
+			Logger.Instance.DeIndent();
 		}
 
-		void ISimpleDeobfuscator.deobfuscate(MethodDef method) {
-			((ISimpleDeobfuscator)this).deobfuscate(method, false);
+		void ISimpleDeobfuscator.Deobfuscate(MethodDef method) {
+			((ISimpleDeobfuscator)this).Deobfuscate(method, false);
 		}
 
-		void ISimpleDeobfuscator.deobfuscate(MethodDef method, bool force) {
-			if (!force && check(method, SimpleDeobFlags.HasDeobfuscated))
+		void ISimpleDeobfuscator.Deobfuscate(MethodDef method, bool force) {
+			if (!force && Check(method, SimpleDeobFlags.HasDeobfuscated))
 				return;
 
-			deobfuscate(method, "Deobfuscating control flow", (blocks) => {
+			Deobfuscate(method, "Deobfuscating control flow", (blocks) => {
 				var cflowDeobfuscator = new BlocksCflowDeobfuscator(deob.BlocksDeobfuscators);
-				cflowDeobfuscator.init(blocks);
-				cflowDeobfuscator.deobfuscate();
+				cflowDeobfuscator.Initialize(blocks);
+				cflowDeobfuscator.Deobfuscate();
 			});
 		}
 
-		void ISimpleDeobfuscator.decryptStrings(MethodDef method, IDeobfuscator theDeob) {
-			deobfuscate(method, "Static string decryption", (blocks) => theDeob.deobfuscateStrings(blocks));
+		void ISimpleDeobfuscator.DecryptStrings(MethodDef method, IDeobfuscator theDeob) {
+			Deobfuscate(method, "Static string decryption", (blocks) => theDeob.DeobfuscateStrings(blocks));
 		}
 
-		void IDeobfuscatedFile.createAssemblyFile(byte[] data, string assemblyName, string extension) {
+		void IDeobfuscatedFile.CreateAssemblyFile(byte[] data, string assemblyName, string extension) {
 			if (extension == null)
 				extension = ".dll";
-			var baseDir = Utils.getDirName(options.NewFilename);
+			var baseDir = Utils.GetDirName(options.NewFilename);
 			var newName = Path.Combine(baseDir, assemblyName + extension);
 			Logger.n("Creating file {0}", newName);
 			File.WriteAllBytes(newName, data);
 		}
 
-		void IDeobfuscatedFile.stringDecryptersAdded() {
-			updateDynamicStringInliner();
+		void IDeobfuscatedFile.StringDecryptersAdded() {
+			UpdateDynamicStringInliner();
 		}
 
-		void IDeobfuscatedFile.setDeobfuscator(IDeobfuscator deob) {
+		void IDeobfuscatedFile.SetDeobfuscator(IDeobfuscator deob) {
 			this.deob = deob;
 		}
 
 		public void Dispose() {
-			deobfuscateCleanUp();
+			DeobfuscateCleanUp();
 			if (module != null)
 				module.Dispose();
 			if (deob != null)
diff --git a/de4dot.code/Option.cs b/de4dot.code/Option.cs
index 8ec7b6d6..ff0039f4 100644
--- a/de4dot.code/Option.cs
+++ b/de4dot.code/Option.cs
@@ -57,7 +57,7 @@ namespace de4dot.code {
 		}
 
 		// Returns true if the new value is set, or false on error. error string is also updated.
-		public abstract bool set(string val, out string error);
+		public abstract bool Set(string val, out string error);
 
 		public Option(string shortName, string longName, string description) {
 			if (shortName != null)
@@ -79,7 +79,7 @@ namespace de4dot.code {
 			get { return "bool"; }
 		}
 
-		public override bool set(string newVal, out string error) {
+		public override bool Set(string newVal, out string error) {
 			if (string.Equals(newVal, "false", StringComparison.OrdinalIgnoreCase) ||
 				string.Equals(newVal, "off", StringComparison.OrdinalIgnoreCase) ||
 				string.Equals(newVal, "0", StringComparison.OrdinalIgnoreCase)) {
@@ -107,7 +107,7 @@ namespace de4dot.code {
 			get { return "int"; }
 		}
 
-		public override bool set(string newVal, out string error) {
+		public override bool Set(string newVal, out string error) {
 			int newInt;
 			if (!int.TryParse(newVal, out newInt)) {
 				error = string.Format("Not an integer: '{0}'", newVal);
@@ -135,7 +135,7 @@ namespace de4dot.code {
 			Default = this.val = val;
 		}
 
-		public override bool set(string newVal, out string error) {
+		public override bool Set(string newVal, out string error) {
 			val = newVal;
 			error = "";
 			return true;
@@ -158,10 +158,10 @@ namespace de4dot.code {
 			Default = this.val = new NameRegexes(val);
 		}
 
-		public override bool set(string newVal, out string error) {
+		public override bool Set(string newVal, out string error) {
 			try {
 				var regexes = new NameRegexes();
-				regexes.set(newVal);
+				regexes.Set(newVal);
 				val = regexes;
 			}
 			catch (ArgumentException) {
@@ -189,7 +189,7 @@ namespace de4dot.code {
 			Default = this.val = new Regex(val);
 		}
 
-		public override bool set(string newVal, out string error) {
+		public override bool Set(string newVal, out string error) {
 			try {
 				val = new Regex(newVal);
 			}
@@ -223,7 +223,7 @@ namespace de4dot.code {
 			this.action = action;
 		}
 
-		public override bool set(string val, out string error) {
+		public override bool Set(string val, out string error) {
 			triggered = true;
 			if (action != null)
 				action();
@@ -251,7 +251,7 @@ namespace de4dot.code {
 			Default = null;
 		}
 
-		public override bool set(string val, out string error) {
+		public override bool Set(string val, out string error) {
 			action(val);
 			error = "";
 			return true;
diff --git a/de4dot.code/StringInliner.cs b/de4dot.code/StringInliner.cs
index 51f243c5..afbd29ee 100644
--- a/de4dot.code/StringInliner.cs
+++ b/de4dot.code/StringInliner.cs
@@ -26,7 +26,7 @@ using de4dot.blocks;
 
 namespace de4dot.code {
 	abstract class StringInlinerBase : MethodReturnValueInliner {
-		protected override void inlineReturnValues(IList<CallResult> callResults) {
+		protected override void InlineReturnValues(IList<CallResult> callResults) {
 			foreach (var callResult in callResults) {
 				var block = callResult.block;
 				int num = callResult.callEndIndex - callResult.callStartIndex + 1;
@@ -36,13 +36,13 @@ namespace de4dot.code {
 					continue;
 
 				int ldstrIndex = callResult.callStartIndex;
-				block.replace(ldstrIndex, num, OpCodes.Ldstr.ToInstruction(decryptedString));
+				block.Replace(ldstrIndex, num, OpCodes.Ldstr.ToInstruction(decryptedString));
 
 				// If it's followed by castclass string, remove it
 				if (ldstrIndex + 1 < block.Instructions.Count) {
 					var instr = block.Instructions[ldstrIndex + 1];
 					if (instr.OpCode.Code == Code.Castclass && instr.Operand.ToString() == "System.String")
-						block.remove(ldstrIndex + 1, 1);
+						block.Remove(ldstrIndex + 1, 1);
 				}
 
 				// If it's followed by String.Intern(), then nop out that call
@@ -52,12 +52,12 @@ namespace de4dot.code {
 						var calledMethod = instr.Operand as IMethod;
 						if (calledMethod != null &&
 							calledMethod.FullName == "System.String System.String::Intern(System.String)") {
-							block.remove(ldstrIndex + 1, 1);
+							block.Remove(ldstrIndex + 1, 1);
 						}
 					}
 				}
 
-				Logger.v("Decrypted string: {0}", Utils.toCsharpString(decryptedString));
+				Logger.v("Decrypted string: {0}", Utils.ToCsharpString(decryptedString));
 			}
 		}
 	}
@@ -84,23 +84,23 @@ namespace de4dot.code {
 			this.assemblyClient = assemblyClient;
 		}
 
-		public void init(IEnumerable<int> methodTokens) {
+		public void Initialize(IEnumerable<int> methodTokens) {
 			methodTokenToId.Clear();
 			foreach (var methodToken in methodTokens) {
 				if (methodTokenToId.ContainsKey(methodToken))
 					continue;
-				methodTokenToId[methodToken] = assemblyClient.Service.defineStringDecrypter(methodToken);
+				methodTokenToId[methodToken] = assemblyClient.Service.DefineStringDecrypter(methodToken);
 			}
 		}
 
-		protected override CallResult createCallResult(IMethod method, MethodSpec gim, Block block, int callInstrIndex) {
+		protected override CallResult CreateCallResult(IMethod method, MethodSpec gim, Block block, int callInstrIndex) {
 			int methodId;
 			if (!methodTokenToId.TryGetValue(method.MDToken.ToInt32(), out methodId))
 				return null;
 			return new MyCallResult(block, callInstrIndex, methodId, gim);
 		}
 
-		protected override void inlineAllCalls() {
+		protected override void InlineAllCalls() {
 			var sortedCalls = new Dictionary<int, List<MyCallResult>>();
 			foreach (var tmp in callResults) {
 				var callResult = (MyCallResult)tmp;
@@ -114,13 +114,13 @@ namespace de4dot.code {
 				var list = sortedCalls[methodId];
 				var args = new object[list.Count];
 				for (int i = 0; i < list.Count; i++) {
-					AssemblyData.SimpleData.pack(list[i].args);
+					AssemblyData.SimpleData.Pack(list[i].args);
 					args[i] = list[i].args;
 				}
-				var decryptedStrings = assemblyClient.Service.decryptStrings(methodId, args, Method.MDToken.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);
+				AssemblyData.SimpleData.Unpack(decryptedStrings);
 				for (int i = 0; i < list.Count; i++)
 					list[i].returnValue = (string)decryptedStrings[i];
 			}
@@ -135,7 +135,7 @@ namespace de4dot.code {
 		}
 
 		public IEnumerable<MethodDef> Methods {
-			get { return stringDecrypters.getKeys(); }
+			get { return stringDecrypters.GetKeys(); }
 		}
 
 		class MyCallResult : CallResult {
@@ -148,21 +148,21 @@ namespace de4dot.code {
 			}
 		}
 
-		public void add(MethodDef method, Func<MethodDef, MethodSpec, object[], string> handler) {
+		public void Add(MethodDef method, Func<MethodDef, MethodSpec, object[], string> handler) {
 			if (method != null)
-				stringDecrypters.add(method, handler);
+				stringDecrypters.Add(method, handler);
 		}
 
-		protected override void inlineAllCalls() {
+		protected override void InlineAllCalls() {
 			foreach (var tmp in callResults) {
 				var callResult = (MyCallResult)tmp;
-				var handler = stringDecrypters.find(callResult.IMethod);
+				var handler = stringDecrypters.Find(callResult.IMethod);
 				callResult.returnValue = handler((MethodDef)callResult.IMethod, callResult.gim, callResult.args);
 			}
 		}
 
-		protected override CallResult createCallResult(IMethod method, MethodSpec gim, Block block, int callInstrIndex) {
-			if (stringDecrypters.find(method) == null)
+		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 c1dac662..d0a44dbe 100644
--- a/de4dot.code/Utils.cs
+++ b/de4dot.code/Utils.cs
@@ -55,7 +55,7 @@ namespace de4dot.code {
 	public static class Utils {
 		static Random random = new Random();
 
-		public static IEnumerable<T> unique<T>(IEnumerable<T> values) {
+		public static IEnumerable<T> Unique<T>(IEnumerable<T> values) {
 			// HashSet is only available in .NET 3.5 and later.
 			var dict = new Dictionary<T, bool>();
 			foreach (var val in values)
@@ -63,30 +63,30 @@ namespace de4dot.code {
 			return dict.Keys;
 		}
 
-		public static string toCsharpString(UTF8String s) {
-			return toCsharpString(UTF8String.ToSystemStringOrEmpty(s));
+		public static string ToCsharpString(UTF8String s) {
+			return ToCsharpString(UTF8String.ToSystemStringOrEmpty(s));
 		}
 
-		public static string toCsharpString(string s) {
+		public static string ToCsharpString(string s) {
 			var sb = new StringBuilder(s.Length + 2);
 			sb.Append('"');
 			foreach (var c in s) {
 				if ((int)c < 0x20) {
 					switch (c) {
-					case '\a': appendEscape(sb, 'a'); break;
-					case '\b': appendEscape(sb, 'b'); break;
-					case '\f': appendEscape(sb, 'f'); break;
-					case '\n': appendEscape(sb, 'n'); break;
-					case '\r': appendEscape(sb, 'r'); break;
-					case '\t': appendEscape(sb, 't'); break;
-					case '\v': appendEscape(sb, 'v'); break;
+					case '\a': AppendEscape(sb, 'a'); break;
+					case '\b': AppendEscape(sb, 'b'); break;
+					case '\f': AppendEscape(sb, 'f'); break;
+					case '\n': AppendEscape(sb, 'n'); break;
+					case '\r': AppendEscape(sb, 'r'); break;
+					case '\t': AppendEscape(sb, 't'); break;
+					case '\v': AppendEscape(sb, 'v'); break;
 					default:
 						sb.Append(string.Format(@"\u{0:X4}", (int)c));
 						break;
 					}
 				}
 				else if (c == '\\' || c == '"') {
-					appendEscape(sb, c);
+					AppendEscape(sb, c);
 				}
 				else
 					sb.Append(c);
@@ -95,12 +95,12 @@ namespace de4dot.code {
 			return sb.ToString();
 		}
 
-		public static string shellEscape(string s) {
+		public static string ShellEscape(string s) {
 			var sb = new StringBuilder(s.Length + 2);
 			sb.Append('"');
 			foreach (var c in s) {
 				if (c == '"')
-					appendEscape(sb, c);
+					AppendEscape(sb, c);
 				else
 					sb.Append(c);
 			}
@@ -108,20 +108,20 @@ namespace de4dot.code {
 			return sb.ToString();
 		}
 
-		static void appendEscape(StringBuilder sb, char c) {
+		static void AppendEscape(StringBuilder sb, char c) {
 			sb.Append('\\');
 			sb.Append(c);
 		}
 
-		public static string removeNewlines(object o) {
-			return removeNewlines(o.ToString());
+		public static string RemoveNewlines(object o) {
+			return RemoveNewlines(o.ToString());
 		}
 
-		public static string removeNewlines(string s) {
+		public static string RemoveNewlines(string s) {
 			return s.Replace('\n', ' ').Replace('\r', ' ');
 		}
 
-		public static string getFullPath(string path) {
+		public static string GetFullPath(string path) {
 			try {
 				return Path.GetFullPath(path);
 			}
@@ -130,7 +130,7 @@ namespace de4dot.code {
 			}
 		}
 
-		public static string randomName(int min, int max) {
+		public static string RandomName(int min, int max) {
 			int numChars = random.Next(min, max + 1);
 			var sb = new StringBuilder(numChars);
 			int numLower = 0;
@@ -150,26 +150,26 @@ namespace de4dot.code {
 			return sb.ToString();
 		}
 
-		public static string getBaseName(string name) {
+		public static string GetBaseName(string name) {
 			int index = name.LastIndexOf(Path.DirectorySeparatorChar);
 			if (index < 0)
 				return name;
 			return name.Substring(index + 1);
 		}
 
-		public static string getDirName(string name) {
+		public static string GetDirName(string name) {
 			return Path.GetDirectoryName(name);
 		}
 
 		static string ourBaseDir = null;
-		public static string getOurBaseDir() {
+		public static string GetOurBaseDir() {
 			if (ourBaseDir != null)
 				return ourBaseDir;
-			return ourBaseDir = getDirName(typeof(Utils).Assembly.Location);
+			return ourBaseDir = GetDirName(typeof(Utils).Assembly.Location);
 		}
 
-		public static string getPathOfOurFile(string filename) {
-			return Path.Combine(getOurBaseDir(), filename);
+		public static string GetPathOfOurFile(string filename) {
+			return Path.Combine(GetOurBaseDir(), filename);
 		}
 
 		// This fixes a mono (tested 2.10.5) String.StartsWith() bug. NB: stringComparison must be
@@ -180,14 +180,14 @@ namespace de4dot.code {
 			return left.Substring(0, right.Length).Equals(right, stringComparison);
 		}
 
-		public static string getAssemblySimpleName(string name) {
+		public static string GetAssemblySimpleName(string name) {
 			int i = name.IndexOf(',');
 			if (i < 0)
 				return name;
 			return name.Substring(0, i);
 		}
 
-		public static bool pathExists(string path) {
+		public static bool PathExists(string path) {
 			try {
 				return new DirectoryInfo(path).Exists;
 			}
@@ -196,7 +196,7 @@ namespace de4dot.code {
 			}
 		}
 
-		public static bool fileExists(string path) {
+		public static bool FileExists(string path) {
 			try {
 				return new FileInfo(path).Exists;
 			}
@@ -205,7 +205,7 @@ namespace de4dot.code {
 			}
 		}
 
-		public static bool compare(byte[] a, byte[] b) {
+		public static bool Compare(byte[] a, byte[] b) {
 			if (a.Length != b.Length)
 				return false;
 			for (int i = 0; i < a.Length; i++) {
@@ -215,7 +215,7 @@ namespace de4dot.code {
 			return true;
 		}
 
-		public static byte[] readFile(string filename) {
+		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.
 			const int MAX_BYTES_READ = 0x200000;
diff --git a/de4dot.code/deobfuscators/Agile_NET/CliSecureRtType.cs b/de4dot.code/deobfuscators/Agile_NET/CliSecureRtType.cs
index 1948eb80..6f6f233e 100644
--- a/de4dot.code/deobfuscators/Agile_NET/CliSecureRtType.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/CliSecureRtType.cs
@@ -63,26 +63,26 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 
 		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");
-			initializeMethod = lookup(oldOne.initializeMethod, "Could not find initializeMethod method");
-			stringDecrypterMethod = lookup(oldOne.stringDecrypterMethod, "Could not find stringDecrypterMethod method");
-			loadMethod = lookup(oldOne.loadMethod, "Could not find loadMethod method");
+			cliSecureRtType = Lookup(oldOne.cliSecureRtType, "Could not find CliSecureRt type");
+			postInitializeMethod = Lookup(oldOne.postInitializeMethod, "Could not find postInitializeMethod method");
+			initializeMethod = Lookup(oldOne.initializeMethod, "Could not find initializeMethod method");
+			stringDecrypterMethod = Lookup(oldOne.stringDecrypterMethod, "Could not find stringDecrypterMethod method");
+			loadMethod = Lookup(oldOne.loadMethod, "Could not find loadMethod method");
 			foundSig = oldOne.foundSig;
 		}
 
-		T lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
-			return DeobUtils.lookup(module, def, errorMessage);
+		T Lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
+			return DeobUtils.Lookup(module, def, errorMessage);
 		}
 
-		public void find(byte[] moduleBytes) {
+		public void Find(byte[] moduleBytes) {
 			if (cliSecureRtType != null)
 				return;
-			if (find2())
+			if (Find2())
 				return;
-			if (find3())
+			if (Find3())
 				return;
-			findNativeCode(moduleBytes);
+			FindNativeCode(moduleBytes);
 		}
 
 		static readonly string[] requiredFields1 = new string[] {
@@ -101,23 +101,23 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			"System.Reflection.Assembly",
 			"System.Byte[]",
 		};
-		bool find2() {
-			foreach (var cctor in DeobUtils.getInitCctors(module, 3)) {
-				foreach (var calledMethod in DotNetUtils.getCalledMethods(module, cctor)) {
+		bool Find2() {
+			foreach (var cctor in DeobUtils.GetInitCctors(module, 3)) {
+				foreach (var calledMethod in DotNetUtils.GetCalledMethods(module, cctor)) {
 					var type = calledMethod.DeclaringType;
 					if (type.IsPublic)
 						continue;
 					var fieldTypes = new FieldTypes(type);
-					if (!fieldTypes.exactly(requiredFields1) && !fieldTypes.exactly(requiredFields2) &&
-						!fieldTypes.exactly(requiredFields3) && !fieldTypes.exactly(requiredFields4))
+					if (!fieldTypes.Exactly(requiredFields1) && !fieldTypes.Exactly(requiredFields2) &&
+						!fieldTypes.Exactly(requiredFields3) && !fieldTypes.Exactly(requiredFields4))
 						continue;
-					if (!hasInitializeMethod(type, "_Initialize") && !hasInitializeMethod(type, "_Initialize64"))
+					if (!HasInitializeMethod(type, "_Initialize") && !HasInitializeMethod(type, "_Initialize64"))
 						continue;
 
-					stringDecrypterMethod = findStringDecrypterMethod(type);
+					stringDecrypterMethod = FindStringDecrypterMethod(type);
 					initializeMethod = calledMethod;
-					postInitializeMethod = findMethod(type, "System.Void", "PostInitialize", "()");
-					loadMethod = findMethod(type, "System.IntPtr", "Load", "()");
+					postInitializeMethod = FindMethod(type, "System.Void", "PostInitialize", "()");
+					loadMethod = FindMethod(type, "System.IntPtr", "Load", "()");
 					cliSecureRtType = type;
 					return true;
 				}
@@ -126,7 +126,7 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			return false;
 		}
 
-		bool find3() {
+		bool Find3() {
 			foreach (var type in module.Types) {
 				if (type.Fields.Count != 1)
 					continue;
@@ -148,11 +148,11 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			return false;
 		}
 
-		static MethodDef findStringDecrypterMethod(TypeDef type) {
+		static MethodDef FindStringDecrypterMethod(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (method.Body == null || !method.IsStatic)
 					continue;
-				if (!DotNetUtils.isMethod(method, "System.String", "(System.String)"))
+				if (!DotNetUtils.IsMethod(method, "System.String", "(System.String)"))
 					continue;
 
 				return method;
@@ -161,7 +161,7 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			return null;
 		}
 
-		static MethodDef findMethod(TypeDef 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)
@@ -175,8 +175,8 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			return null;
 		}
 
-		static bool hasInitializeMethod(TypeDef type, string name) {
-			var method = DotNetUtils.getPInvokeMethod(type, name);
+		static bool HasInitializeMethod(TypeDef type, string name) {
+			var method = DotNetUtils.GetPInvokeMethod(type, name);
 			if (method == null)
 				return false;
 			var sig = method.MethodSig;
@@ -190,17 +190,17 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			return true;
 		}
 
-		bool findNativeCode(byte[] moduleBytes) {
-			var bytes = moduleBytes != null ? moduleBytes : DeobUtils.readModule(module);
+		bool FindNativeCode(byte[] moduleBytes) {
+			var bytes = moduleBytes != null ? moduleBytes : DeobUtils.ReadModule(module);
 			using (var peImage = new MyPEImage(bytes))
-				return foundSig = MethodsDecrypter.detect(peImage);
+				return foundSig = MethodsDecrypter.Detect(peImage);
 		}
 
-		public bool isAtLeastVersion50() {
-			return DotNetUtils.hasPinvokeMethod(cliSecureRtType, "LoadLibraryA");
+		public bool IsAtLeastVersion50() {
+			return DotNetUtils.HasPinvokeMethod(cliSecureRtType, "LoadLibraryA");
 		}
 
-		public void findStringDecrypterMethod() {
+		public void FindStringDecrypterMethod() {
 			if (cliSecureRtType != null)
 				return;
 
@@ -210,7 +210,7 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 				if (type.Methods.Count != 1)
 					continue;
 				var cs = type.Methods[0];
-				if (!isOldStringDecrypterMethod(cs))
+				if (!IsOldStringDecrypterMethod(cs))
 					continue;
 
 				cliSecureRtType = type;
@@ -219,12 +219,12 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			}
 		}
 
-		static bool isOldStringDecrypterMethod(MethodDef method) {
+		static bool IsOldStringDecrypterMethod(MethodDef method) {
 			if (method == null || method.Body == null || !method.IsStatic)
 				return false;
-			if (!DotNetUtils.isMethod(method, "System.String", "(System.String)"))
+			if (!DotNetUtils.IsMethod(method, "System.String", "(System.String)"))
 				return false;
-			if (!DeobUtils.hasInteger(method, 0xFF))
+			if (!DeobUtils.HasInteger(method, 0xFF))
 				return false;
 
 			return true;
diff --git a/de4dot.code/deobfuscators/Agile_NET/CsBlowfish.cs b/de4dot.code/deobfuscators/Agile_NET/CsBlowfish.cs
index 028d7a4f..e44cf195 100644
--- a/de4dot.code/deobfuscators/Agile_NET/CsBlowfish.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/CsBlowfish.cs
@@ -26,7 +26,7 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			: base(key) {
 		}
 
-		protected override void encrypt(ref uint rxl, ref uint rxr) {
+		protected override void Encrypt(ref uint rxl, ref uint rxr) {
 			uint xl = rxl, xr = rxr;
 			for (int i = 0; i < 16; i++) {
 				xl ^= P[i];
@@ -38,7 +38,7 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			rxl = xr ^ P[17];
 		}
 
-		protected override void decrypt(ref uint rxl, ref uint rxr) {
+		protected override void Decrypt(ref uint rxl, ref uint rxr) {
 			uint xl = rxl, xr = rxr;
 			for (int i = 17; i >= 2; i--) {
 				xl ^= P[i];
diff --git a/de4dot.code/deobfuscators/Agile_NET/Deobfuscator.cs b/de4dot.code/deobfuscators/Agile_NET/Deobfuscator.cs
index f451c01b..4caf59ad 100644
--- a/de4dot.code/deobfuscators/Agile_NET/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/Deobfuscator.cs
@@ -37,11 +37,11 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 
 		public DeobfuscatorInfo()
 			: base(DEFAULT_REGEX) {
-			decryptMethods = new BoolOption(null, makeArgName("methods"), "Decrypt methods", true);
-			decryptResources = new BoolOption(null, makeArgName("rsrc"), "Decrypt resources", true);
-			removeStackFrameHelper = new BoolOption(null, makeArgName("stack"), "Remove all StackFrameHelper code", true);
-			restoreVmCode = new BoolOption(null, makeArgName("vm"), "Restore VM code", true);
-			setInitLocals = new BoolOption(null, makeArgName("initlocals"), "Set initlocals in method header", true);
+			decryptMethods = new BoolOption(null, MakeArgName("methods"), "Decrypt methods", true);
+			decryptResources = new BoolOption(null, MakeArgName("rsrc"), "Decrypt resources", true);
+			removeStackFrameHelper = new BoolOption(null, MakeArgName("stack"), "Remove all StackFrameHelper code", true);
+			restoreVmCode = new BoolOption(null, MakeArgName("vm"), "Restore VM code", true);
+			setInitLocals = new BoolOption(null, MakeArgName("initlocals"), "Set initlocals in method header", true);
 		}
 
 		public override string Name {
@@ -52,7 +52,7 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			get { return THE_TYPE; }
 		}
 
-		public override IDeobfuscator createDeobfuscator() {
+		public override IDeobfuscator CreateDeobfuscator() {
 			return new Deobfuscator(new Deobfuscator.Options {
 				ValidNameRegex = validNameRegex.get(),
 				DecryptMethods = decryptMethods.get(),
@@ -63,7 +63,7 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			});
 		}
 
-		protected override IEnumerable<Option> getOptionsInternal() {
+		protected override IEnumerable<Option> GetOptionsInternal() {
 			return new List<Option>() {
 				decryptMethods,
 				decryptResources,
@@ -112,16 +112,16 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			this.options = options;
 		}
 
-		public override void init(ModuleDefMD module) {
-			base.init(module);
+		public override void Initialize(ModuleDefMD module) {
+			base.Initialize(module);
 		}
 
-		public override byte[] unpackNativeFile(IPEImage peImage) {
-			return unpackNativeFile1(peImage) ?? unpackNativeFile2(peImage);
+		public override byte[] UnpackNativeFile(IPEImage peImage) {
+			return UnpackNativeFile1(peImage) ?? UnpackNativeFile2(peImage);
 		}
 
 		// Old CS versions
-		byte[] unpackNativeFile1(IPEImage peImage) {
+		byte[] UnpackNativeFile1(IPEImage peImage) {
 			const int dataDirNum = 6;	// debug dir
 			const int dotNetDirNum = 14;
 
@@ -135,16 +135,16 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			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);
-			writeUInt32(fileData, dataDir + 4, 0);
+			WriteUInt32(fileData, dotNetDir, BitConverter.ToUInt32(fileData, dataDir));
+			WriteUInt32(fileData, dotNetDir + 4, BitConverter.ToUInt32(fileData, dataDir + 4));
+			WriteUInt32(fileData, dataDir, 0);
+			WriteUInt32(fileData, dataDir + 4, 0);
 			ModuleBytes = fileData;
 			return fileData;
 		}
 
 		// CS 1.x
-		byte[] unpackNativeFile2(IPEImage peImage) {
+		byte[] UnpackNativeFile2(IPEImage peImage) {
 			var data = peImage.FindWin32ResourceData("ASSEMBLY", 101, 0);
 			if (data == null)
 				return null;
@@ -152,21 +152,21 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			return ModuleBytes = data.Data.ReadAllBytes();
 		}
 
-		static void writeUInt32(byte[] data, int offset, uint value) {
+		static void WriteUInt32(byte[] data, int offset, uint value) {
 			data[offset] = (byte)value;
 			data[offset + 1] = (byte)(value >> 8);
 			data[offset + 2] = (byte)(value >> 16);
 			data[offset + 3] = (byte)(value >> 24);
 		}
 
-		protected override int detectInternal() {
+		protected override int DetectInternal() {
 			int val = 0;
 
-			int sum = toInt32(cliSecureRtType.Detected) +
-					toInt32(stringDecrypter.Detected) +
-					toInt32(proxyCallFixer.Detected) +
-					toInt32(resourceDecrypter.Detected) +
-					toInt32(csvm.Detected);
+			int sum = ToInt32(cliSecureRtType.Detected) +
+					ToInt32(stringDecrypter.Detected) +
+					ToInt32(proxyCallFixer.Detected) +
+					ToInt32(resourceDecrypter.Detected) +
+					ToInt32(csvm.Detected);
 			if (sum > 0)
 				val += 100 + 10 * (sum - 1);
 			if (cliSecureAttributes.Count != 0)
@@ -175,21 +175,21 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			return val;
 		}
 
-		protected override void scanForObfuscator() {
-			findCliSecureAttribute();
+		protected override void ScanForObfuscator() {
+			FindCliSecureAttribute();
 			cliSecureRtType = new CliSecureRtType(module);
-			cliSecureRtType.find(ModuleBytes);
+			cliSecureRtType.Find(ModuleBytes);
 			stringDecrypter = new StringDecrypter(module, cliSecureRtType.StringDecrypterMethod);
-			stringDecrypter.find();
+			stringDecrypter.Find();
 			resourceDecrypter = new ResourceDecrypter(module);
-			resourceDecrypter.find();
+			resourceDecrypter.Find();
 			proxyCallFixer = new ProxyCallFixer(module);
-			proxyCallFixer.findDelegateCreator();
+			proxyCallFixer.FindDelegateCreator();
 			csvm = new vm.Csvm(DeobfuscatedFile.DeobfuscatorContext, module);
-			csvm.find();
+			csvm.Find();
 		}
 
-		void findCliSecureAttribute() {
+		void FindCliSecureAttribute() {
 			obfuscatorName = "CliSecure";
 			foreach (var type in module.Types) {
 				if (Utils.StartsWith(type.FullName, "SecureTeam.Attributes.ObfuscatedByCliSecureAttribute", StringComparison.Ordinal)) {
@@ -203,13 +203,13 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			}
 		}
 
-		public override bool getDecryptedModule(int count, ref byte[] newFileData, ref DumpedMethods dumpedMethods) {
+		public override bool GetDecryptedModule(int count, ref byte[] newFileData, ref DumpedMethods dumpedMethods) {
 			if (count != 0 || !options.DecryptMethods)
 				return false;
 
-			byte[] fileData = ModuleBytes ?? DeobUtils.readModule(module);
+			byte[] fileData = ModuleBytes ?? DeobUtils.ReadModule(module);
 			using (var peImage = new MyPEImage(fileData)) {
-				if (!new MethodsDecrypter().decrypt(peImage, module, cliSecureRtType, ref dumpedMethods)) {
+				if (!new MethodsDecrypter().Decrypt(peImage, module, cliSecureRtType, ref dumpedMethods)) {
 					Logger.v("Methods aren't encrypted or invalid signature");
 					return false;
 				}
@@ -219,10 +219,10 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			return true;
 		}
 
-		public override IDeobfuscator moduleReloaded(ModuleDefMD 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");
+			newOne.SetModule(module);
+			newOne.cliSecureAttributes = Lookup(module, cliSecureAttributes, "Could not find CliSecure attribute");
 			newOne.cliSecureRtType = new CliSecureRtType(module, cliSecureRtType);
 			newOne.stringDecrypter = new StringDecrypter(module, stringDecrypter);
 			newOne.resourceDecrypter = new ResourceDecrypter(module, resourceDecrypter);
@@ -231,105 +231,105 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			return newOne;
 		}
 
-		static List<TypeDef> lookup(ModuleDefMD module, List<TypeDef> types, string errorMsg) {
+		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));
+				list.Add(DeobUtils.Lookup(module, type, errorMsg));
 			return list;
 		}
 
-		public override void deobfuscateBegin() {
-			base.deobfuscateBegin();
+		public override void DeobfuscateBegin() {
+			base.DeobfuscateBegin();
 
-			cliSecureRtType.findStringDecrypterMethod();
+			cliSecureRtType.FindStringDecrypterMethod();
 			stringDecrypter.Method = cliSecureRtType.StringDecrypterMethod;
 
-			addAttributesToBeRemoved(cliSecureAttributes, "Obfuscator attribute");
+			AddAttributesToBeRemoved(cliSecureAttributes, "Obfuscator attribute");
 
 			if (options.DecryptResources) {
-				decryptResources(resourceDecrypter);
-				addCctorInitCallToBeRemoved(resourceDecrypter.RsrcRrrMethod);
+				DecryptResources(resourceDecrypter);
+				AddCctorInitCallToBeRemoved(resourceDecrypter.RsrcRrrMethod);
 			}
 
 			stackFrameHelper = new StackFrameHelper(module);
-			stackFrameHelper.find();
+			stackFrameHelper.Find();
 
 			foreach (var type in module.Types) {
-				if (type.FullName == "InitializeDelegate" && DotNetUtils.derivesFromDelegate(type))
-					this.addTypeToBeRemoved(type, "Obfuscator type");
+				if (type.FullName == "InitializeDelegate" && DotNetUtils.DerivesFromDelegate(type))
+					this.AddTypeToBeRemoved(type, "Obfuscator type");
 			}
 
-			proxyCallFixer.find();
+			proxyCallFixer.Find();
 
-			staticStringInliner.add(stringDecrypter.Method, (method, gim, args) => stringDecrypter.decrypt((string)args[0]));
-			DeobfuscatedFile.stringDecryptersAdded();
+			staticStringInliner.Add(stringDecrypter.Method, (method, gim, args) => stringDecrypter.Decrypt((string)args[0]));
+			DeobfuscatedFile.StringDecryptersAdded();
 
 			if (options.DecryptMethods) {
-				addCctorInitCallToBeRemoved(cliSecureRtType.InitializeMethod);
-				addCctorInitCallToBeRemoved(cliSecureRtType.PostInitializeMethod);
-				findPossibleNamesToRemove(cliSecureRtType.LoadMethod);
+				AddCctorInitCallToBeRemoved(cliSecureRtType.InitializeMethod);
+				AddCctorInitCallToBeRemoved(cliSecureRtType.PostInitializeMethod);
+				FindPossibleNamesToRemove(cliSecureRtType.LoadMethod);
 			}
 
 			if (options.RestoreVmCode) {
-				if (csvm.restore())
-					addResourceToBeRemoved(csvm.Resource, "CSVM data resource");
+				if (csvm.Restore())
+					AddResourceToBeRemoved(csvm.Resource, "CSVM data resource");
 				else {
 					Logger.e("Couldn't restore VM methods. Use --dont-rename or it will not run");
-					preserveTokensAndTypes();
+					PreserveTokensAndTypes();
 				}
 			}
 		}
 
-		void decryptResources(ResourceDecrypter resourceDecrypter) {
-			var rsrc = resourceDecrypter.mergeResources();
+		void DecryptResources(ResourceDecrypter resourceDecrypter) {
+			var rsrc = resourceDecrypter.MergeResources();
 			if (rsrc == null)
 				return;
-			addResourceToBeRemoved(rsrc, "Encrypted resources");
-			addTypeToBeRemoved(resourceDecrypter.Type, "Resource decrypter type");
+			AddResourceToBeRemoved(rsrc, "Encrypted resources");
+			AddTypeToBeRemoved(resourceDecrypter.Type, "Resource decrypter type");
 		}
 
-		public override void deobfuscateMethodEnd(Blocks blocks) {
-			proxyCallFixer.deobfuscate(blocks);
-			removeStackFrameHelperCode(blocks);
-			base.deobfuscateMethodEnd(blocks);
+		public override void DeobfuscateMethodEnd(Blocks blocks) {
+			proxyCallFixer.Deobfuscate(blocks);
+			RemoveStackFrameHelperCode(blocks);
+			base.DeobfuscateMethodEnd(blocks);
 		}
 
-		public override void deobfuscateEnd() {
+		public override void DeobfuscateEnd() {
 			if (options.SetInitLocals)
-				setInitLocals();
-			removeProxyDelegates(proxyCallFixer);
+				SetInitLocals();
+			RemoveProxyDelegates(proxyCallFixer);
 			if (options.RemoveStackFrameHelper) {
 				if (stackFrameHelper.ExceptionLoggerRemover.NumRemovedExceptionLoggers > 0)
-					addTypeToBeRemoved(stackFrameHelper.Type, "StackFrameHelper type");
+					AddTypeToBeRemoved(stackFrameHelper.Type, "StackFrameHelper type");
 			}
 			if (CanRemoveStringDecrypterType) {
-				addTypeToBeRemoved(stringDecrypter.Type, "String decrypter type");
+				AddTypeToBeRemoved(stringDecrypter.Type, "String decrypter type");
 				if (options.DecryptMethods)
-					addTypeToBeRemoved(cliSecureRtType.Type, "Obfuscator type");
+					AddTypeToBeRemoved(cliSecureRtType.Type, "Obfuscator type");
 			}
 			if (options.DecryptMethods) {
-				addResources("Obfuscator protection files");
+				AddResources("Obfuscator protection files");
 			}
 
-			base.deobfuscateEnd();
+			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())
+			if (!module.IsILOnly && !HasNativeMethods())
 				module.IsILOnly = true;
 		}
 
-		public override IEnumerable<int> getStringDecrypterMethods() {
+		public override IEnumerable<int> GetStringDecrypterMethods() {
 			var list = new List<int>();
 			if (stringDecrypter.Method != null)
 				list.Add(stringDecrypter.Method.MDToken.ToInt32());
 			return list;
 		}
 
-		void removeStackFrameHelperCode(Blocks blocks) {
+		void RemoveStackFrameHelperCode(Blocks blocks) {
 			if (!options.RemoveStackFrameHelper)
 				return;
-			if (stackFrameHelper.ExceptionLoggerRemover.remove(blocks))
+			if (stackFrameHelper.ExceptionLoggerRemover.Remove(blocks))
 				Logger.v("Removed StackFrameHelper code");
 		}
 	}
diff --git a/de4dot.code/deobfuscators/Agile_NET/MethodsDecrypter.cs b/de4dot.code/deobfuscators/Agile_NET/MethodsDecrypter.cs
index 0fd55e44..b431aeff 100644
--- a/de4dot.code/deobfuscators/Agile_NET/MethodsDecrypter.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/MethodsDecrypter.cs
@@ -72,7 +72,7 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 		SigType sigType;
 
 		interface IDecrypter {
-			MethodBodyHeader decrypt(MethodInfo methodInfo, out byte[] code, out byte[] extraSections);
+			MethodBodyHeader Decrypt(MethodInfo methodInfo, out byte[] code, out byte[] extraSections);
 		}
 
 		abstract class DecrypterBase : IDecrypter {
@@ -84,13 +84,13 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 				this.peImage = peImage;
 				this.codeHeader = codeHeader;
 				var mdDir = peImage.Cor20Header.MetaData;
-				endOfMetadata = peImage.rvaToOffset((uint)mdDir.VirtualAddress + mdDir.Size);
+				endOfMetadata = peImage.RvaToOffset((uint)mdDir.VirtualAddress + mdDir.Size);
 			}
 
-			public abstract MethodBodyHeader decrypt(MethodInfo methodInfo, out byte[] code, out byte[] extraSections);
+			public abstract MethodBodyHeader Decrypt(MethodInfo methodInfo, out byte[] code, out byte[] extraSections);
 
-			protected MethodBodyHeader getCodeBytes(byte[] methodBody, out byte[] code, out byte[] extraSections) {
-				return MethodBodyParser.parseMethodBody(MemoryImageStream.Create(methodBody), out code, out extraSections);
+			protected MethodBodyHeader GetCodeBytes(byte[] methodBody, out byte[] code, out byte[] extraSections) {
+				return MethodBodyParser.ParseMethodBody(MemoryImageStream.Create(methodBody), out code, out extraSections);
 			}
 		}
 
@@ -104,10 +104,10 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 				this.blowfish = new CsBlowfish(key);
 			}
 
-			public MethodBodyHeader decrypt(uint bodyOffset, out byte[] code, out byte[] extraSections) {
+			public MethodBodyHeader Decrypt(uint bodyOffset, out byte[] code, out byte[] extraSections) {
 				peImage.Reader.Position = bodyOffset;
-				var mbHeader = MethodBodyParser.parseMethodBody(peImage.Reader, out code, out extraSections);
-				blowfish.decrypt(code);
+				var mbHeader = MethodBodyParser.ParseMethodBody(peImage.Reader, out code, out extraSections);
+				blowfish.Decrypt(code);
 				return mbHeader;
 			}
 		}
@@ -118,9 +118,9 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 				: base(peImage, codeHeader) {
 			}
 
-			public override MethodBodyHeader decrypt(MethodInfo methodInfo, out byte[] code, out byte[] extraSections) {
-				peImage.Reader.Position = peImage.rvaToOffset(methodInfo.codeOffs);
-				return MethodBodyParser.parseMethodBody(peImage.Reader, out code, out extraSections);
+			public override MethodBodyHeader Decrypt(MethodInfo methodInfo, out byte[] code, out byte[] extraSections) {
+				peImage.Reader.Position = peImage.RvaToOffset(methodInfo.codeOffs);
+				return MethodBodyParser.ParseMethodBody(peImage.Reader, out code, out extraSections);
 			}
 		}
 
@@ -130,9 +130,9 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 				: base(peImage, codeHeader) {
 			}
 
-			public override MethodBodyHeader decrypt(MethodInfo methodInfo, out byte[] code, out byte[] extraSections) {
+			public override MethodBodyHeader Decrypt(MethodInfo methodInfo, out byte[] code, out byte[] extraSections) {
 				peImage.Reader.Position = endOfMetadata + methodInfo.codeOffs;
-				return MethodBodyParser.parseMethodBody(peImage.Reader, out code, out extraSections);
+				return MethodBodyParser.ParseMethodBody(peImage.Reader, out code, out extraSections);
 			}
 		}
 
@@ -142,14 +142,14 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 				: base(peImage, codeHeader) {
 			}
 
-			public override MethodBodyHeader decrypt(MethodInfo methodInfo, out byte[] code, out byte[] extraSections) {
-				var data = peImage.offsetReadBytes(endOfMetadata + methodInfo.codeOffs, (int)methodInfo.codeSize);
+			public override MethodBodyHeader Decrypt(MethodInfo methodInfo, out byte[] code, out byte[] extraSections) {
+				var data = peImage.OffsetReadBytes(endOfMetadata + methodInfo.codeOffs, (int)methodInfo.codeSize);
 				for (int i = 0; i < data.Length; i++) {
 					byte b = data[i];
 					b ^= codeHeader.decryptionKey[(methodInfo.codeOffs - 0x28 + i) % 16];
 					data[i] = b;
 				}
-				return getCodeBytes(data, out code, out extraSections);
+				return GetCodeBytes(data, out code, out extraSections);
 			}
 		}
 
@@ -162,15 +162,15 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 				this.codeHeaderSize = codeHeaderSize;
 			}
 
-			public override MethodBodyHeader decrypt(MethodInfo methodInfo, out byte[] code, out byte[] extraSections) {
-				byte[] data = peImage.offsetReadBytes(endOfMetadata + methodInfo.codeOffs, (int)methodInfo.codeSize);
+			public override MethodBodyHeader Decrypt(MethodInfo methodInfo, out byte[] code, out byte[] extraSections) {
+				byte[] data = peImage.OffsetReadBytes(endOfMetadata + methodInfo.codeOffs, (int)methodInfo.codeSize);
 				for (int i = 0; i < data.Length; i++) {
 					byte b = data[i];
 					b ^= codeHeader.decryptionKey[(methodInfo.codeOffs - codeHeaderSize + i) % 16];
 					b ^= codeHeader.decryptionKey[(methodInfo.codeOffs - codeHeaderSize + i + 7) % 16];
 					data[i] = b;
 				}
-				return getCodeBytes(data, out code, out extraSections);
+				return GetCodeBytes(data, out code, out extraSections);
 			}
 		}
 
@@ -181,17 +181,17 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			public ProDecrypter(MyPEImage peImage, CodeHeader codeHeader)
 				: base(peImage, codeHeader) {
 				for (int i = 0; i < 4; i++)
-					key[i] = be_readUInt32(codeHeader.decryptionKey, i * 4);
+					key[i] = ReadUInt32_be(codeHeader.decryptionKey, i * 4);
 			}
 
-			public override MethodBodyHeader decrypt(MethodInfo methodInfo, out byte[] code, out byte[] extraSections) {
-				byte[] data = peImage.offsetReadBytes(endOfMetadata + methodInfo.codeOffs, (int)methodInfo.codeSize);
+			public override MethodBodyHeader Decrypt(MethodInfo methodInfo, out byte[] code, out byte[] extraSections) {
+				byte[] data = peImage.OffsetReadBytes(endOfMetadata + methodInfo.codeOffs, (int)methodInfo.codeSize);
 
 				int numQwords = (int)(methodInfo.codeSize / 8);
 				for (int i = 0; i < numQwords; i++) {
 					int offset = i * 8;
-					uint q0 = be_readUInt32(data, offset);
-					uint q1 = be_readUInt32(data, offset + 4);
+					uint q0 = ReadUInt32_be(data, offset);
+					uint q1 = ReadUInt32_be(data, offset + 4);
 
 					const uint magic = 0x9E3779B8;
 					uint val = 0xC6EF3700;	// magic * 0x20
@@ -201,21 +201,21 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 						val -= magic;
 					}
 
-					be_writeUInt32(data, offset, q0);
-					be_writeUInt32(data, offset + 4, q1);
+					WriteUInt32_be(data, offset, q0);
+					WriteUInt32_be(data, offset + 4, q1);
 				}
 
-				return getCodeBytes(data, out code, out extraSections);
+				return GetCodeBytes(data, out code, out extraSections);
 			}
 
-			static uint be_readUInt32(byte[] data, int offset) {
+			static uint ReadUInt32_be(byte[] data, int offset) {
 				return (uint)((data[offset] << 24) +
 						(data[offset + 1] << 16) +
 						(data[offset + 2] << 8) +
 						data[offset + 3]);
 			}
 
-			static void be_writeUInt32(byte[] data, int offset, uint value) {
+			static void WriteUInt32_be(byte[] data, int offset, uint value) {
 				data[offset] = (byte)(value >> 24);
 				data[offset + 1] = (byte)(value >> 16);
 				data[offset + 2] = (byte)(value >> 8);
@@ -224,9 +224,9 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 		}
 
 		interface ICsHeader {
-			IDecrypter createDecrypter();
-			List<MethodInfo> getMethodInfos(uint codeHeaderOffset);
-			void patchMethodTable(MDTable methodDefTable, IList<MethodInfo> methodInfos);
+			IDecrypter CreateDecrypter();
+			List<MethodInfo> GetMethodInfos(uint codeHeaderOffset);
+			void PatchMethodTable(MDTable methodDefTable, IList<MethodInfo> methodInfos);
 		}
 
 		abstract class CsHeaderBase : ICsHeader {
@@ -238,42 +238,42 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 				this.codeHeaderSize = codeHeaderSize;
 			}
 
-			public abstract IDecrypter createDecrypter();
+			public abstract IDecrypter CreateDecrypter();
 
-			public virtual void patchMethodTable(MDTable methodDefTable, IList<MethodInfo> methodInfos) {
+			public virtual void PatchMethodTable(MDTable methodDefTable, IList<MethodInfo> methodInfos) {
 			}
 
-			public abstract List<MethodInfo> getMethodInfos(uint codeHeaderOffset);
+			public abstract List<MethodInfo> GetMethodInfos(uint codeHeaderOffset);
 
-			protected List<MethodInfo> getMethodInfos1(uint codeHeaderOffset) {
+			protected List<MethodInfo> GetMethodInfos1(uint codeHeaderOffset) {
 				uint offset = codeHeaderOffset + methodsDecrypter.codeHeader.totalCodeSize + codeHeaderSize;
 				var methodInfos = new List<MethodInfo>((int)methodsDecrypter.codeHeader.numMethods);
 				for (int i = 0; i < (int)methodsDecrypter.codeHeader.numMethods; i++, offset += 4) {
-					uint codeOffs = methodsDecrypter.peImage.offsetReadUInt32(offset);
+					uint codeOffs = methodsDecrypter.peImage.OffsetReadUInt32(offset);
 					methodInfos.Add(new MethodInfo(codeOffs, 0, 0, 0));
 				}
 				return methodInfos;
 			}
 
-			protected List<MethodInfo> getMethodInfos2(uint codeHeaderOffset) {
+			protected List<MethodInfo> GetMethodInfos2(uint codeHeaderOffset) {
 				uint offset = codeHeaderOffset + methodsDecrypter.codeHeader.totalCodeSize + codeHeaderSize;
 				var methodInfos = new List<MethodInfo>((int)methodsDecrypter.codeHeader.numMethods);
 				for (int i = 0; i < (int)methodsDecrypter.codeHeader.numMethods; i++, offset += 8) {
-					uint codeOffs = methodsDecrypter.peImage.offsetReadUInt32(offset);
-					uint codeSize = methodsDecrypter.peImage.offsetReadUInt32(offset + 4);
+					uint codeOffs = methodsDecrypter.peImage.OffsetReadUInt32(offset);
+					uint codeSize = methodsDecrypter.peImage.OffsetReadUInt32(offset + 4);
 					methodInfos.Add(new MethodInfo(codeOffs, codeSize, 0, 0));
 				}
 				return methodInfos;
 			}
 
-			protected List<MethodInfo> getMethodInfos4(uint codeHeaderOffset) {
+			protected List<MethodInfo> GetMethodInfos4(uint codeHeaderOffset) {
 				uint offset = codeHeaderOffset + methodsDecrypter.codeHeader.totalCodeSize + codeHeaderSize;
 				var methodInfos = new List<MethodInfo>((int)methodsDecrypter.codeHeader.numMethods);
 				for (int i = 0; i < (int)methodsDecrypter.codeHeader.numMethods; i++, offset += 16) {
-					uint codeOffs = methodsDecrypter.peImage.offsetReadUInt32(offset);
-					uint codeSize = methodsDecrypter.peImage.offsetReadUInt32(offset + 4);
-					uint flags = methodsDecrypter.peImage.offsetReadUInt32(offset + 8);
-					uint localVarSigTok = methodsDecrypter.peImage.offsetReadUInt32(offset + 12);
+					uint codeOffs = methodsDecrypter.peImage.OffsetReadUInt32(offset);
+					uint codeSize = methodsDecrypter.peImage.OffsetReadUInt32(offset + 4);
+					uint flags = methodsDecrypter.peImage.OffsetReadUInt32(offset + 8);
+					uint localVarSigTok = methodsDecrypter.peImage.OffsetReadUInt32(offset + 12);
 					methodInfos.Add(new MethodInfo(codeOffs, codeSize, flags, localVarSigTok));
 				}
 				return methodInfos;
@@ -286,12 +286,12 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 				: base(methodsDecrypter, 0x28) {
 			}
 
-			public override IDecrypter createDecrypter() {
+			public override IDecrypter CreateDecrypter() {
 				return new Decrypter30(methodsDecrypter.peImage, methodsDecrypter.codeHeader);
 			}
 
-			public override List<MethodInfo> getMethodInfos(uint codeHeaderOffset) {
-				return getMethodInfos1(codeHeaderOffset);
+			public override List<MethodInfo> GetMethodInfos(uint codeHeaderOffset) {
+				return GetMethodInfos1(codeHeaderOffset);
 			}
 		}
 
@@ -301,12 +301,12 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 				: base(methodsDecrypter, 0x28) {
 			}
 
-			public override IDecrypter createDecrypter() {
+			public override IDecrypter CreateDecrypter() {
 				return new Decrypter40(methodsDecrypter.peImage, methodsDecrypter.codeHeader);
 			}
 
-			public override List<MethodInfo> getMethodInfos(uint codeHeaderOffset) {
-				return getMethodInfos1(codeHeaderOffset);
+			public override List<MethodInfo> GetMethodInfos(uint codeHeaderOffset) {
+				return GetMethodInfos1(codeHeaderOffset);
 			}
 		}
 
@@ -316,12 +316,12 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 				: base(methodsDecrypter, 0x28) {
 			}
 
-			public override IDecrypter createDecrypter() {
+			public override IDecrypter CreateDecrypter() {
 				return new Decrypter45(methodsDecrypter.peImage, methodsDecrypter.codeHeader);
 			}
 
-			public override List<MethodInfo> getMethodInfos(uint codeHeaderOffset) {
-				return getMethodInfos2(codeHeaderOffset);
+			public override List<MethodInfo> GetMethodInfos(uint codeHeaderOffset) {
+				return GetMethodInfos2(codeHeaderOffset);
 			}
 		}
 
@@ -331,8 +331,8 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 				: base(methodsDecrypter, codeHeaderSize) {
 			}
 
-			public override IDecrypter createDecrypter() {
-				switch (getSigType(methodsDecrypter.codeHeader.signature)) {
+			public override IDecrypter CreateDecrypter() {
+				switch (GetSigType(methodsDecrypter.codeHeader.signature)) {
 				case SigType.Normal:
 					return new Decrypter5(methodsDecrypter.peImage, methodsDecrypter.codeHeader, codeHeaderSize);
 
@@ -345,21 +345,21 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 				}
 			}
 
-			public override List<MethodInfo> getMethodInfos(uint codeHeaderOffset) {
+			public override List<MethodInfo> GetMethodInfos(uint codeHeaderOffset) {
 				if (codeHeaderSize == 0x28)
-					return getMethodInfos2(codeHeaderOffset);
-				return getMethodInfos4(codeHeaderOffset);
+					return GetMethodInfos2(codeHeaderOffset);
+				return GetMethodInfos4(codeHeaderOffset);
 			}
 
-			public override void patchMethodTable(MDTable methodDefTable, IList<MethodInfo> methodInfos) {
+			public override void PatchMethodTable(MDTable methodDefTable, IList<MethodInfo> methodInfos) {
 				uint offset = (uint)methodDefTable.StartOffset - methodDefTable.RowSize;
 				foreach (var methodInfo in methodInfos) {
 					offset += methodDefTable.RowSize;
 					if (methodInfo.flags == 0 || methodInfo.codeOffs == 0)
 						continue;
-					uint rva = methodsDecrypter.peImage.offsetReadUInt32(offset);
-					methodsDecrypter.peImage.writeUInt16(rva, (ushort)methodInfo.flags);
-					methodsDecrypter.peImage.writeUInt32(rva + 8, methodInfo.localVarSigTok);
+					uint rva = methodsDecrypter.peImage.OffsetReadUInt32(offset);
+					methodsDecrypter.peImage.WriteUInt16(rva, (ushort)methodInfo.flags);
+					methodsDecrypter.peImage.WriteUInt32(rva + 8, methodInfo.localVarSigTok);
 				}
 			}
 		}
@@ -374,14 +374,14 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			V52,	// 5.2+ (or maybe 5.1+)
 		}
 
-		List<CsHeaderVersion> getCsHeaderVersions(uint codeHeaderOffset, MDTable methodDefTable) {
+		List<CsHeaderVersion> GetCsHeaderVersions(uint codeHeaderOffset, MDTable methodDefTable) {
 			if (sigType == SigType.Old)
 				return new List<CsHeaderVersion> { CsHeaderVersion.V10 };
-			if (!isOldHeader(methodDefTable))
+			if (!IsOldHeader(methodDefTable))
 				return new List<CsHeaderVersion> { CsHeaderVersion.V52 };
-			if (csRtType.isAtLeastVersion50())
+			if (csRtType.IsAtLeastVersion50())
 				return new List<CsHeaderVersion> { CsHeaderVersion.V50 };
-			if (isCsHeader40(codeHeaderOffset)) {
+			if (IsCsHeader40(codeHeaderOffset)) {
 				return new List<CsHeaderVersion> {
 					CsHeaderVersion.V40,
 					CsHeaderVersion.V30,
@@ -393,12 +393,12 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			};
 		}
 
-		bool isCsHeader40(uint codeHeaderOffset) {
+		bool IsCsHeader40(uint codeHeaderOffset) {
 			try {
 				uint offset = codeHeaderOffset + codeHeader.totalCodeSize + 0x28;
 				uint prevCodeOffs = 0;
 				for (int i = 0; i < (int)codeHeader.numMethods; i++, offset += 4) {
-					uint codeOffs = peImage.offsetReadUInt32(offset);
+					uint codeOffs = peImage.OffsetReadUInt32(offset);
 					if (prevCodeOffs != 0 && codeOffs != 0 && codeOffs < prevCodeOffs)
 						return false;
 					if (codeOffs != 0)
@@ -412,16 +412,16 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			}
 		}
 
-		bool isOldHeader(MDTable methodDefTable) {
+		bool IsOldHeader(MDTable methodDefTable) {
 			if (methodDefTable.RowSize != codeHeader.methodDefElemSize)
 				return true;
-			if ((uint)methodDefTable.StartOffset - peImage.rvaToOffset((uint)peImage.Cor20Header.MetaData.VirtualAddress) != codeHeader.methodDefTableOffset)
+			if ((uint)methodDefTable.StartOffset - peImage.RvaToOffset((uint)peImage.Cor20Header.MetaData.VirtualAddress) != codeHeader.methodDefTableOffset)
 				return true;
 
 			return false;
 		}
 
-		ICsHeader createCsHeader(CsHeaderVersion version) {
+		ICsHeader CreateCsHeader(CsHeaderVersion version) {
 			switch (version) {
 			case CsHeaderVersion.V30: return new CsHeader30(this);
 			case CsHeaderVersion.V40: return new CsHeader40(this);
@@ -438,19 +438,19 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			Error,
 		}
 
-		public bool decrypt(MyPEImage peImage, ModuleDefMD module, CliSecureRtType csRtType, ref DumpedMethods dumpedMethods) {
+		public bool Decrypt(MyPEImage peImage, ModuleDefMD module, CliSecureRtType csRtType, ref DumpedMethods dumpedMethods) {
 			this.peImage = peImage;
 			this.csRtType = csRtType;
 			this.module = module;
 
-			switch (decrypt2(ref dumpedMethods)) {
+			switch (Decrypt2(ref dumpedMethods)) {
 			case DecryptResult.Decrypted: return true;
 			case DecryptResult.NotEncrypted: return false;
 
 			case DecryptResult.Error:
 				Logger.n("Using dynamic method decryption");
-				byte[] moduleCctorBytes = getModuleCctorBytes(csRtType);
-				dumpedMethods = de4dot.code.deobfuscators.MethodsDecrypter.decrypt(module, moduleCctorBytes);
+				byte[] moduleCctorBytes = GetModuleCctorBytes(csRtType);
+				dumpedMethods = de4dot.code.deobfuscators.MethodsDecrypter.Decrypt(module, moduleCctorBytes);
 				return true;
 
 			default:
@@ -458,7 +458,7 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			}
 		}
 
-		static byte[] getModuleCctorBytes(CliSecureRtType csRtType) {
+		static byte[] GetModuleCctorBytes(CliSecureRtType csRtType) {
 			var initMethod = csRtType.InitializeMethod;
 			if (initMethod == null)
 				return null;
@@ -473,24 +473,24 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			return moduleCctorBytes;
 		}
 
-		static uint getCodeHeaderOffset(MyPEImage peImage) {
-			return peImage.rvaToOffset((uint)peImage.Cor20Header.MetaData.VirtualAddress + peImage.Cor20Header.MetaData.Size);
+		static uint GetCodeHeaderOffset(MyPEImage peImage) {
+			return peImage.RvaToOffset((uint)peImage.Cor20Header.MetaData.VirtualAddress + peImage.Cor20Header.MetaData.Size);
 		}
 
 		static string[] sections = new string[] {
 			".text", ".rsrc", ".data", ".rdata",
 		};
-		static uint getOldCodeHeaderOffset(MyPEImage peImage) {
-			var sect = getLastOf(peImage, sections);
+		static uint GetOldCodeHeaderOffset(MyPEImage peImage) {
+			var sect = GetLastOf(peImage, sections);
 			if (sect == null || sect.VirtualSize < 0x100)
 				return 0;
-			return peImage.rvaToOffset((uint)sect.VirtualAddress + sect.VirtualSize - 0x100);
+			return peImage.RvaToOffset((uint)sect.VirtualAddress + sect.VirtualSize - 0x100);
 		}
 
-		static ImageSectionHeader getLastOf(MyPEImage peImage, string[] sections) {
+		static ImageSectionHeader GetLastOf(MyPEImage peImage, string[] sections) {
 			ImageSectionHeader sect = null;
 			foreach (var name in sections) {
-				var sect2 = peImage.findSection(name);
+				var sect2 = peImage.FindSection(name);
 				if (sect2 == null)
 					continue;
 				if (sect == null || sect2.VirtualAddress > sect.VirtualAddress)
@@ -499,19 +499,19 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			return sect;
 		}
 
-		DecryptResult decrypt2(ref DumpedMethods dumpedMethods) {
-			uint codeHeaderOffset = initializeCodeHeader();
+		DecryptResult Decrypt2(ref DumpedMethods dumpedMethods) {
+			uint codeHeaderOffset = InitializeCodeHeader();
 			if (sigType == SigType.Unknown)
 				return DecryptResult.NotEncrypted;
 
 			var methodDefTable = peImage.DotNetFile.MetaData.TablesStream.MethodTable;
 
-			foreach (var version in getCsHeaderVersions(codeHeaderOffset, methodDefTable)) {
+			foreach (var version in GetCsHeaderVersions(codeHeaderOffset, methodDefTable)) {
 				try {
 					if (version == CsHeaderVersion.V10)
-						decryptMethodsOld(methodDefTable, ref dumpedMethods);
+						DecryptMethodsOld(methodDefTable, ref dumpedMethods);
 					else
-						decryptMethods(codeHeaderOffset, methodDefTable, createCsHeader(version), ref dumpedMethods);
+						DecryptMethods(codeHeaderOffset, methodDefTable, CreateCsHeader(version), ref dumpedMethods);
 					return DecryptResult.Decrypted;
 				}
 				catch {
@@ -521,23 +521,23 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			return DecryptResult.Error;
 		}
 
-		uint initializeCodeHeader() {
-			uint codeHeaderOffset = getCodeHeaderOffset(peImage);
-			readCodeHeader(codeHeaderOffset);
-			sigType = getSigType(codeHeader.signature);
+		uint InitializeCodeHeader() {
+			uint codeHeaderOffset = GetCodeHeaderOffset(peImage);
+			ReadCodeHeader(codeHeaderOffset);
+			sigType = GetSigType(codeHeader.signature);
 
 			if (sigType == SigType.Unknown) {
-				codeHeaderOffset = getOldCodeHeaderOffset(peImage);
+				codeHeaderOffset = GetOldCodeHeaderOffset(peImage);
 				if (codeHeaderOffset != 0) {
-					readCodeHeader(codeHeaderOffset);
-					sigType = getSigType(codeHeader.signature);
+					ReadCodeHeader(codeHeaderOffset);
+					sigType = GetSigType(codeHeader.signature);
 				}
 			}
 
 			return codeHeaderOffset;
 		}
 
-		void decryptMethodsOld(MDTable methodDefTable, ref DumpedMethods dumpedMethods) {
+		void DecryptMethodsOld(MDTable methodDefTable, ref DumpedMethods dumpedMethods) {
 			dumpedMethods = new DumpedMethods();
 			var decrypter = new Decrypter10(peImage, codeHeader.decryptionKey);
 			for (uint rid = 1; rid <= methodDefTable.Rows; rid++) {
@@ -547,74 +547,74 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 				if (method == null || method.DeclaringType == module.GlobalType)
 					continue;
 
-				peImage.readMethodTableRowTo(dm, rid);
+				peImage.ReadMethodTableRowTo(dm, rid);
 				if (dm.mdRVA == 0)
 					continue;
-				uint bodyOffset = peImage.rvaToOffset(dm.mdRVA);
+				uint bodyOffset = peImage.RvaToOffset(dm.mdRVA);
 
-				var mbHeader = decrypter.decrypt(bodyOffset, out dm.code, out dm.extraSections);
-				peImage.updateMethodHeaderInfo(dm, mbHeader);
+				var mbHeader = decrypter.Decrypt(bodyOffset, out dm.code, out dm.extraSections);
+				peImage.UpdateMethodHeaderInfo(dm, mbHeader);
 
-				dumpedMethods.add(dm);
+				dumpedMethods.Add(dm);
 			}
 		}
 
-		void decryptMethods(uint codeHeaderOffset, MDTable methodDefTable, ICsHeader csHeader, ref DumpedMethods dumpedMethods) {
-			var methodInfos = csHeader.getMethodInfos(codeHeaderOffset);
-			csHeader.patchMethodTable(methodDefTable, methodInfos);
+		void DecryptMethods(uint codeHeaderOffset, MDTable methodDefTable, ICsHeader csHeader, ref DumpedMethods dumpedMethods) {
+			var methodInfos = csHeader.GetMethodInfos(codeHeaderOffset);
+			csHeader.PatchMethodTable(methodDefTable, methodInfos);
 
 			dumpedMethods = new DumpedMethods();
-			decrypter = csHeader.createDecrypter();
+			decrypter = csHeader.CreateDecrypter();
 			for (uint rid = 1; rid <= (uint)methodInfos.Count; rid++) {
 				var methodInfo = methodInfos[(int)rid - 1];
 				if (methodInfo.codeOffs == 0)
 					continue;
 
 				var dm = new DumpedMethod();
-				peImage.readMethodTableRowTo(dm, rid);
+				peImage.ReadMethodTableRowTo(dm, rid);
 
-				var mbHeader = decrypter.decrypt(methodInfo, out dm.code, out dm.extraSections);
-				peImage.updateMethodHeaderInfo(dm, mbHeader);
+				var mbHeader = decrypter.Decrypt(methodInfo, out dm.code, out dm.extraSections);
+				peImage.UpdateMethodHeaderInfo(dm, mbHeader);
 
-				dumpedMethods.add(dm);
+				dumpedMethods.Add(dm);
 			}
 		}
 
-		void readCodeHeader(uint offset) {
-			codeHeader.signature = peImage.offsetReadBytes(offset, 16);
-			codeHeader.decryptionKey = peImage.offsetReadBytes(offset + 0x10, 16);
-			codeHeader.totalCodeSize = peImage.offsetReadUInt32(offset + 0x20);
-			codeHeader.numMethods = peImage.offsetReadUInt32(offset + 0x24);
-			codeHeader.methodDefTableOffset = peImage.offsetReadUInt32(offset + 0x28);
-			codeHeader.methodDefElemSize = peImage.offsetReadUInt32(offset + 0x2C);
+		void ReadCodeHeader(uint offset) {
+			codeHeader.signature = peImage.OffsetReadBytes(offset, 16);
+			codeHeader.decryptionKey = peImage.OffsetReadBytes(offset + 0x10, 16);
+			codeHeader.totalCodeSize = peImage.OffsetReadUInt32(offset + 0x20);
+			codeHeader.numMethods = peImage.OffsetReadUInt32(offset + 0x24);
+			codeHeader.methodDefTableOffset = peImage.OffsetReadUInt32(offset + 0x28);
+			codeHeader.methodDefElemSize = peImage.OffsetReadUInt32(offset + 0x2C);
 		}
 
-		static SigType getSigType(byte[] sig) {
-			if (Utils.compare(sig, normalSignature))
+		static SigType GetSigType(byte[] sig) {
+			if (Utils.Compare(sig, normalSignature))
 				return SigType.Normal;
-			else if (Utils.compare(sig, proSignature))
+			else if (Utils.Compare(sig, proSignature))
 				return SigType.Pro;
-			else if (Utils.compare(sig, oldSignature))
+			else if (Utils.Compare(sig, oldSignature))
 				return SigType.Old;
 			return SigType.Unknown;
 		}
 
-		static bool isValidSignature(byte[] signature) {
-			return getSigType(signature) != SigType.Unknown;
+		static bool IsValidSignature(byte[] signature) {
+			return GetSigType(signature) != SigType.Unknown;
 		}
 
-		public static bool detect(MyPEImage peImage) {
+		public static bool Detect(MyPEImage peImage) {
 			try {
-				uint codeHeaderOffset = getCodeHeaderOffset(peImage);
-				if (isValidSignature(peImage.offsetReadBytes(codeHeaderOffset, 16)))
+				uint codeHeaderOffset = GetCodeHeaderOffset(peImage);
+				if (IsValidSignature(peImage.OffsetReadBytes(codeHeaderOffset, 16)))
 					return true;
 			}
 			catch {
 			}
 
 			try {
-				uint codeHeaderOffset = getOldCodeHeaderOffset(peImage);
-				if (codeHeaderOffset != 0 && isValidSignature(peImage.offsetReadBytes(codeHeaderOffset, 16)))
+				uint codeHeaderOffset = GetOldCodeHeaderOffset(peImage);
+				if (codeHeaderOffset != 0 && IsValidSignature(peImage.OffsetReadBytes(codeHeaderOffset, 16)))
 					return true;
 			}
 			catch {
diff --git a/de4dot.code/deobfuscators/Agile_NET/ProxyCallFixer.cs b/de4dot.code/deobfuscators/Agile_NET/ProxyCallFixer.cs
index 5975f92a..d3de46d9 100644
--- a/de4dot.code/deobfuscators/Agile_NET/ProxyCallFixer.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/ProxyCallFixer.cs
@@ -32,28 +32,28 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 		public ProxyCallFixer(ModuleDefMD module, ProxyCallFixer oldOne)
 			: base(module) {
 			foreach (var method in oldOne.delegateCreatorMethods)
-				setDelegateCreatorMethod(lookup(method, "Could not find delegate creator method"));
+				SetDelegateCreatorMethod(Lookup(method, "Could not find delegate creator method"));
 		}
 
-		public void findDelegateCreator() {
+		public void FindDelegateCreator() {
 			foreach (var type in module.Types) {
 				var methodName = "System.Void " + type.FullName + "::icgd(System.Int32)";
 				foreach (var method in type.Methods) {
 					if (method.FullName == methodName) {
-						setDelegateCreatorMethod(method);
+						SetDelegateCreatorMethod(method);
 						return;
 					}
 				}
 			}
 		}
 
-		protected override object checkCctor(ref TypeDef type, MethodDef cctor) {
+		protected override object CheckCctor(ref TypeDef type, MethodDef cctor) {
 			var instrs = cctor.Body.Instructions;
 			if (instrs.Count != 3)
 				return null;
 			if (!instrs[0].IsLdcI4())
 				return null;
-			if (instrs[1].OpCode != OpCodes.Call || !isDelegateCreatorMethod(instrs[1].Operand as MethodDef))
+			if (instrs[1].OpCode != OpCodes.Call || !IsDelegateCreatorMethod(instrs[1].Operand as MethodDef))
 				return null;
 			if (instrs[2].OpCode != OpCodes.Ret)
 				return null;
@@ -67,7 +67,7 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			return new object();
 		}
 
-		protected override void getCallInfo(object context, FieldDef field, out IMethod calledMethod, out OpCode callOpcode) {
+		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)) {
diff --git a/de4dot.code/deobfuscators/Agile_NET/ResourceDecrypter.cs b/de4dot.code/deobfuscators/Agile_NET/ResourceDecrypter.cs
index fca3a1c8..53f5a9b2 100644
--- a/de4dot.code/deobfuscators/Agile_NET/ResourceDecrypter.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/ResourceDecrypter.cs
@@ -49,39 +49,39 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 
 		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");
+			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 : class, ICodedToken {
-			return DeobUtils.lookup(module, def, errorMessage);
+		T Lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
+			return DeobUtils.Lookup(module, def, errorMessage);
 		}
 
-		public void find() {
-			findResourceType();
+		public void Find() {
+			FindResourceType();
 		}
 
 		static readonly string[] requiredFields = new string[] {
 			"System.Reflection.Assembly",
 			"System.String[]",
 		};
-		void findResourceType() {
-			var cctor = DotNetUtils.getModuleTypeCctor(module);
+		void FindResourceType() {
+			var cctor = DotNetUtils.GetModuleTypeCctor(module);
 			if (cctor == null)
 				return;
 
-			foreach (var calledMethod in DotNetUtils.getCalledMethods(module, cctor)) {
+			foreach (var calledMethod in DotNetUtils.GetCalledMethods(module, cctor)) {
 				if (!calledMethod.IsStatic || calledMethod.Body == null)
 					continue;
-				if (!DotNetUtils.isMethod(calledMethod, "System.Void", "()"))
+				if (!DotNetUtils.IsMethod(calledMethod, "System.Void", "()"))
 					continue;
 				var type = calledMethod.DeclaringType;
-				if (!new FieldTypes(type).exactly(requiredFields))
+				if (!new FieldTypes(type).Exactly(requiredFields))
 					continue;
 
-				var resolveHandler = DotNetUtils.getMethod(type, "System.Reflection.Assembly", "(System.Object,System.ResolveEventArgs)");
-				var decryptMethod = DotNetUtils.getMethod(type, "System.Byte[]", "(System.IO.Stream)");
+				var resolveHandler = DotNetUtils.GetMethod(type, "System.Reflection.Assembly", "(System.Object,System.ResolveEventArgs)");
+				var decryptMethod = DotNetUtils.GetMethod(type, "System.Byte[]", "(System.IO.Stream)");
 				if (resolveHandler == null || !resolveHandler.IsStatic)
 					continue;
 				if (decryptMethod == null || !decryptMethod.IsStatic)
@@ -94,17 +94,17 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			}
 		}
 
-		public EmbeddedResource mergeResources() {
+		public EmbeddedResource MergeResources() {
 			if (rsrcResolveMethod == null)
 				return null;
-			var resource = DotNetUtils.getResource(module, DotNetUtils.getCodeStrings(rsrcResolveMethod)) as EmbeddedResource;
+			var resource = DotNetUtils.GetResource(module, DotNetUtils.GetCodeStrings(rsrcResolveMethod)) as EmbeddedResource;
 			if (resource == null)
 				return null;
-			DeobUtils.decryptAndAddResources(module, resource.Name.String, () => decryptResource(resource));
+			DeobUtils.DecryptAndAddResources(module, resource.Name.String, () => DecryptResource(resource));
 			return resource;
 		}
 
-		byte[] decryptResource(EmbeddedResource resource) {
+		byte[] DecryptResource(EmbeddedResource resource) {
 			var reader = resource.Data;
 			reader.Position = 0;
 			var key = reader.ReadString();
diff --git a/de4dot.code/deobfuscators/Agile_NET/StackFrameHelper.cs b/de4dot.code/deobfuscators/Agile_NET/StackFrameHelper.cs
index 88b415a6..a40d4290 100644
--- a/de4dot.code/deobfuscators/Agile_NET/StackFrameHelper.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/StackFrameHelper.cs
@@ -39,7 +39,7 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			this.module = module;
 		}
 
-		public void find() {
+		public void Find() {
 			foreach (var type in module.Types) {
 				if (!type.HasMethods)
 					continue;
@@ -55,7 +55,7 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 					var sig = method.MethodSig;
 					if (sig != null && method.IsStatic && method.HasBody &&
 						sig.Params.Count == 2 && !method.HasGenericParameters &&
-						!DotNetUtils.hasReturnValue(method) &&
+						!DotNetUtils.HasReturnValue(method) &&
 						sig.Params[0].GetFullName() == "System.Exception" &&
 						sig.Params[1].GetFullName() == "System.Object[]") {
 						errorMethod = method;
@@ -65,7 +65,7 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 				}
 				if (errorMethod != null) {
 					stackFrameHelperType = type;
-					exceptionLoggerRemover.add(errorMethod);
+					exceptionLoggerRemover.Add(errorMethod);
 					return;
 				}
 			}
diff --git a/de4dot.code/deobfuscators/Agile_NET/StringDecrypter.cs b/de4dot.code/deobfuscators/Agile_NET/StringDecrypter.cs
index 49c939fd..b13cbea0 100644
--- a/de4dot.code/deobfuscators/Agile_NET/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/StringDecrypter.cs
@@ -48,16 +48,16 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 
 		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");
+			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 : class, ICodedToken {
-			return DeobUtils.lookup(module, def, errorMessage);
+		T Lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
+			return DeobUtils.Lookup(module, def, errorMessage);
 		}
 
-		public void find() {
+		public void Find() {
 			stringDecrypterKey = new byte[1] { 0xFF };
 			foreach (var type in module.Types) {
 				if (type.FullName == "<D234>" || type.FullName == "<ClassD234>") {
@@ -73,7 +73,7 @@ namespace de4dot.code.deobfuscators.Agile_NET {
 			}
 		}
 
-		public string decrypt(string es) {
+		public string Decrypt(string es) {
 			if (stringDecrypterKey == null)
 				throw new ApplicationException("Trying to decrypt strings when stringDecrypterKey is null (could not find it!)");
 			char[] buf = new char[es.Length];
diff --git a/de4dot.code/deobfuscators/Agile_NET/vm/CilOperandInstructionRestorer.cs b/de4dot.code/deobfuscators/Agile_NET/vm/CilOperandInstructionRestorer.cs
index e9531741..313243c0 100644
--- a/de4dot.code/deobfuscators/Agile_NET/vm/CilOperandInstructionRestorer.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/vm/CilOperandInstructionRestorer.cs
@@ -29,7 +29,7 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 	class CilOperandInstructionRestorer {
 		MethodDef method;
 
-		public bool restore(MethodDef method) {
+		public bool Restore(MethodDef method) {
 			this.method = method;
 			bool atLeastOneFailed = false;
 
@@ -45,26 +45,26 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 				TypeSig operandType = null;
 				switch (instr.OpCode.Code) {
 				case Code.Ldelema:
-					var arrayType = MethodStack.getLoadedType(method, instrs, i, 1) as SZArraySig;
+					var arrayType = MethodStack.GetLoadedType(method, instrs, i, 1) as SZArraySig;
 					if (arrayType == null)
 						break;
 					operandType = arrayType.Next;
 					break;
 
 				case Code.Ldobj:
-					operandType = getPtrElementType(MethodStack.getLoadedType(method, instrs, i, 0));
+					operandType = GetPtrElementType(MethodStack.GetLoadedType(method, instrs, i, 0));
 					break;
 
 				case Code.Stobj:
-					operandType = MethodStack.getLoadedType(method, instrs, i, 0);
-					if (!isValidType(operandType))
-						operandType = getPtrElementType(MethodStack.getLoadedType(method, instrs, i, 1));
+					operandType = MethodStack.GetLoadedType(method, instrs, i, 0);
+					if (!IsValidType(operandType))
+						operandType = GetPtrElementType(MethodStack.GetLoadedType(method, instrs, i, 1));
 					break;
 
 				default:
 					continue;
 				}
-				if (!isValidType(operandType)) {
+				if (!IsValidType(operandType)) {
 					atLeastOneFailed = true;
 					continue;
 				}
@@ -75,7 +75,7 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			return !atLeastOneFailed;
 		}
 
-		static TypeSig getPtrElementType(TypeSig type) {
+		static TypeSig GetPtrElementType(TypeSig type) {
 			if (type == null)
 				return null;
 			if (type.IsPointer || type.IsByRef)
@@ -83,7 +83,7 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			return null;
 		}
 
-		bool isValidType(TypeSig type) {
+		bool IsValidType(TypeSig type) {
 			type = type.RemovePinnedAndModifiers();
 			if (type == null)
 				return false;
diff --git a/de4dot.code/deobfuscators/Agile_NET/vm/Csvm.cs b/de4dot.code/deobfuscators/Agile_NET/vm/Csvm.cs
index c8d8e00c..e3030940 100644
--- a/de4dot.code/deobfuscators/Agile_NET/vm/Csvm.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/vm/Csvm.cs
@@ -52,12 +52,12 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 				this.vmAssemblyRef = module.ResolveAssemblyRef(oldOne.vmAssemblyRef.Rid);
 		}
 
-		public void find() {
-			resource = findCsvmResource();
-			vmAssemblyRef = findVmAssemblyRef();
+		public void Find() {
+			resource = FindCsvmResource();
+			vmAssemblyRef = FindVmAssemblyRef();
 		}
 
-		AssemblyRef findVmAssemblyRef() {
+		AssemblyRef FindVmAssemblyRef() {
 			foreach (var memberRef in module.GetMemberRefs()) {
 				var sig = memberRef.MethodSig;
 				if (sig == null)
@@ -74,17 +74,17 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			return null;
 		}
 
-		EmbeddedResource findCsvmResource() {
-			return DotNetUtils.getResource(module, "_CSVM") as EmbeddedResource;
+		EmbeddedResource FindCsvmResource() {
+			return DotNetUtils.GetResource(module, "_CSVM") as EmbeddedResource;
 		}
 
-		public bool restore() {
+		public bool Restore() {
 			if (!Detected)
 				return true;
 
 			int oldIndent = Logger.Instance.IndentLevel;
 			try {
-				restore2();
+				Restore2();
 				return true;
 			}
 			catch {
@@ -95,66 +95,66 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			}
 		}
 
-		void restore2() {
+		void Restore2() {
 			Logger.v("Restoring CSVM methods");
-			Logger.Instance.indent();
+			Logger.Instance.Indent();
 
-			var opcodeDetector = getVmOpCodeHandlerDetector();
-			var csvmMethods = new CsvmDataReader(resource.Data).read();
+			var opcodeDetector = GetVmOpCodeHandlerDetector();
+			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.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);
+				converter.Convert(cilMethod, csvmMethod);
 				Logger.v("Restored method {0:X8}", cilMethod.MDToken.ToInt32());
-				printMethod(methodPrinter, cilMethod);
+				PrintMethod(methodPrinter, cilMethod);
 			}
-			Logger.Instance.deIndent();
+			Logger.Instance.DeIndent();
 		}
 
-		static void printMethod(MethodPrinter methodPrinter, MethodDef method) {
+		static void PrintMethod(MethodPrinter methodPrinter, MethodDef method) {
 			const LoggerEvent dumpLogLevel = LoggerEvent.Verbose;
 			if (Logger.Instance.IgnoresEvent(dumpLogLevel))
 				return;
 
-			Logger.Instance.indent();
+			Logger.Instance.Indent();
 
 			Logger.v("Locals:");
-			Logger.Instance.indent();
+			Logger.Instance.Indent();
 			for (int i = 0; i < method.Body.Variables.Count; i++)
 				Logger.v("#{0}: {1}", i, method.Body.Variables[i].Type);
-			Logger.Instance.deIndent();
+			Logger.Instance.DeIndent();
 
 			Logger.v("Code:");
-			Logger.Instance.indent();
-			methodPrinter.print(dumpLogLevel, method.Body.Instructions, method.Body.ExceptionHandlers);
-			Logger.Instance.deIndent();
+			Logger.Instance.Indent();
+			methodPrinter.Print(dumpLogLevel, method.Body.Instructions, method.Body.ExceptionHandlers);
+			Logger.Instance.DeIndent();
 
-			Logger.Instance.deIndent();
+			Logger.Instance.DeIndent();
 		}
 
-		VmOpCodeHandlerDetector getVmOpCodeHandlerDetector() {
+		VmOpCodeHandlerDetector GetVmOpCodeHandlerDetector() {
 			var vmFilename = vmAssemblyRef.Name + ".dll";
 			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);
+			var dict = (Dictionary<string, VmOpCodeHandlerDetector>)deobfuscatorContext.GetData(dataKey);
 			if (dict == null)
-				deobfuscatorContext.setData(dataKey, dict = new Dictionary<string, VmOpCodeHandlerDetector>(StringComparer.OrdinalIgnoreCase));
+				deobfuscatorContext.SetData(dataKey, dict = new Dictionary<string, VmOpCodeHandlerDetector>(StringComparer.OrdinalIgnoreCase));
 			VmOpCodeHandlerDetector detector;
 			if (dict.TryGetValue(vmModulePath, out detector))
 				return detector;
 			dict[vmModulePath] = detector = new VmOpCodeHandlerDetector(ModuleDefMD.Load(vmModulePath));
 
-			detector.findHandlers();
+			detector.FindHandlers();
 			Logger.v("CSVM opcodes:");
-			Logger.Instance.indent();
+			Logger.Instance.Indent();
 			for (int i = 0; i < detector.Handlers.Count; i++)
 				Logger.v("{0:X4}: {1}", i, detector.Handlers[i].Name);
-			Logger.Instance.deIndent();
+			Logger.Instance.DeIndent();
 
 			return detector;
 		}
diff --git a/de4dot.code/deobfuscators/Agile_NET/vm/CsvmDataReader.cs b/de4dot.code/deobfuscators/Agile_NET/vm/CsvmDataReader.cs
index aa746e96..60e810f5 100644
--- a/de4dot.code/deobfuscators/Agile_NET/vm/CsvmDataReader.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/vm/CsvmDataReader.cs
@@ -33,7 +33,7 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			this.reader = reader;
 		}
 
-		public List<CsvmMethodData> read() {
+		public List<CsvmMethodData> Read() {
 			int numMethods = reader.ReadInt32();
 			if (numMethods < 0)
 				throw new ApplicationException("Invalid number of methods");
diff --git a/de4dot.code/deobfuscators/Agile_NET/vm/CsvmToCilMethodConverter.cs b/de4dot.code/deobfuscators/Agile_NET/vm/CsvmToCilMethodConverter.cs
index dacc28d4..b468ef9e 100644
--- a/de4dot.code/deobfuscators/Agile_NET/vm/CsvmToCilMethodConverter.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/vm/CsvmToCilMethodConverter.cs
@@ -37,33 +37,33 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			this.opCodeDetector = opCodeDetector;
 		}
 
-		public void convert(MethodDef cilMethod, CsvmMethodData csvmMethod) {
-			var newInstructions = readInstructions(cilMethod, csvmMethod);
-			var newLocals = readLocals(cilMethod, csvmMethod);
-			var newExceptions = readExceptions(cilMethod, csvmMethod, newInstructions);
+		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);
-			fixArgs(newInstructions, cilMethod);
+			FixInstructionOperands(newInstructions);
+			FixLocals(newInstructions, cilMethod.Body.Variables);
+			FixArgs(newInstructions, cilMethod);
 
-			DotNetUtils.restoreBody(cilMethod, newInstructions, newExceptions);
+			DotNetUtils.RestoreBody(cilMethod, newInstructions, newExceptions);
 
-			if (!operandRestorer.restore(cilMethod))
+			if (!operandRestorer.Restore(cilMethod))
 				Logger.w("Failed to restore one or more instruction operands in CSVM method {0:X8}", cilMethod.MDToken.ToInt32());
-			restoreConstrainedPrefix(cilMethod);
+			RestoreConstrainedPrefix(cilMethod);
 		}
 
-		void fixLocals(IList<Instruction> instrs, IList<Local> locals) {
+		void FixLocals(IList<Instruction> instrs, IList<Local> locals) {
 			foreach (var instr in instrs) {
 				var op = instr.Operand as LocalOperand;
 				if (op == null)
 					continue;
 
-				updateLocalInstruction(instr, locals[op.local], op.local);
+				UpdateLocalInstruction(instr, locals[op.local], op.local);
 			}
 		}
 
-		static void updateLocalInstruction(Instruction instr, Local local, int index) {
+		static void UpdateLocalInstruction(Instruction instr, Local local, int index) {
 			object operand = null;
 			OpCode opcode;
 
@@ -128,17 +128,17 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			instr.Operand = operand;
 		}
 
-		void fixArgs(IList<Instruction> instrs, MethodDef method) {
+		void FixArgs(IList<Instruction> instrs, MethodDef method) {
 			foreach (var instr in instrs) {
 				var op = instr.Operand as ArgOperand;
 				if (op == null)
 					continue;
 
-				updateArgInstruction(instr, method.Parameters[op.arg], op.arg);
+				UpdateArgInstruction(instr, method.Parameters[op.arg], op.arg);
 			}
 		}
 
-		static void updateArgInstruction(Instruction instr, Parameter arg, int index) {
+		static void UpdateArgInstruction(Instruction instr, Parameter arg, int index) {
 			switch (instr.OpCode.Code) {
 			case Code.Ldarg:
 			case Code.Ldarg_S:
@@ -197,7 +197,7 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			}
 		}
 
-		List<Instruction> readInstructions(MethodDef cilMethod, CsvmMethodData csvmMethod) {
+		List<Instruction> ReadInstructions(MethodDef cilMethod, CsvmMethodData csvmMethod) {
 			var reader = new BinaryReader(new MemoryStream(csvmMethod.Instructions));
 			var instrs = new List<Instruction>();
 			uint offset = 0;
@@ -205,13 +205,13 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 				int vmOpCode = reader.ReadUInt16();
 				var instr = opCodeDetector.Handlers[vmOpCode].Read(reader);
 				instr.Offset = offset;
-				offset += (uint)getInstructionSize(instr);
+				offset += (uint)GetInstructionSize(instr);
 				instrs.Add(instr);
 			}
 			return instrs;
 		}
 
-		static int getInstructionSize(Instruction instr) {
+		static int GetInstructionSize(Instruction instr) {
 			var opcode = instr.OpCode;
 			if (opcode == null)
 				return 5;	// Load store/field
@@ -221,7 +221,7 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			return instr.OpCode.Size + (op.targetDisplacements.Length + 1) * 4;
 		}
 
-		List<Local> readLocals(MethodDef cilMethod, CsvmMethodData csvmMethod) {
+		List<Local> ReadLocals(MethodDef cilMethod, CsvmMethodData csvmMethod) {
 			var locals = new List<Local>();
 			var reader = new BinaryReader(new MemoryStream(csvmMethod.Locals));
 
@@ -234,12 +234,12 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 				throw new ApplicationException("Invalid number of locals");
 
 			for (int i = 0; i < numLocals; i++)
-				locals.Add(new Local(readTypeRef(reader)));
+				locals.Add(new Local(ReadTypeRef(reader)));
 
 			return locals;
 		}
 
-		TypeSig readTypeRef(BinaryReader reader) {
+		TypeSig ReadTypeRef(BinaryReader reader) {
 			var etype = (ElementType)reader.ReadInt32();
 			switch (etype) {
 			case ElementType.Void: return module.CorLibTypes.Void;
@@ -289,7 +289,7 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			}
 		}
 
-		List<ExceptionHandler> readExceptions(MethodDef 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>();
 
@@ -302,14 +302,14 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 
 			for (int i = 0; i < numExceptions; i++) {
 				var eh = new ExceptionHandler((ExceptionHandlerType)reader.ReadInt32());
-				eh.TryStart = getInstruction(cilInstructions, reader.ReadInt32());
-				eh.TryEnd = getInstructionEnd(cilInstructions, reader.ReadInt32());
-				eh.HandlerStart = getInstruction(cilInstructions, reader.ReadInt32());
-				eh.HandlerEnd = getInstructionEnd(cilInstructions, reader.ReadInt32());
+				eh.TryStart = GetInstruction(cilInstructions, reader.ReadInt32());
+				eh.TryEnd = GetInstructionEnd(cilInstructions, reader.ReadInt32());
+				eh.HandlerStart = GetInstruction(cilInstructions, reader.ReadInt32());
+				eh.HandlerEnd = GetInstructionEnd(cilInstructions, reader.ReadInt32());
 				if (eh.HandlerType == ExceptionHandlerType.Catch)
 					eh.CatchType = module.ResolveToken(reader.ReadUInt32()) as ITypeDefOrRef;
 				else if (eh.HandlerType == ExceptionHandlerType.Filter)
-					eh.FilterStart = getInstruction(cilInstructions, reader.ReadInt32());
+					eh.FilterStart = GetInstruction(cilInstructions, reader.ReadInt32());
 
 				ehs.Add(eh);
 			}
@@ -317,44 +317,44 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			return ehs;
 		}
 
-		static Instruction getInstruction(IList<Instruction> instrs, int index) {
+		static Instruction GetInstruction(IList<Instruction> instrs, int index) {
 			return instrs[index];
 		}
 
-		static Instruction getInstructionEnd(IList<Instruction> instrs, int index) {
+		static Instruction GetInstructionEnd(IList<Instruction> instrs, int index) {
 			index++;
 			if (index == instrs.Count)
 				return null;
 			return instrs[index];
 		}
 
-		static Instruction getInstruction(IList<Instruction> instrs, Instruction source, int displ) {
+		static Instruction GetInstruction(IList<Instruction> instrs, Instruction source, int displ) {
 			int sourceIndex = instrs.IndexOf(source);
 			if (sourceIndex < 0)
 				throw new ApplicationException("Could not find source instruction");
 			return instrs[sourceIndex + displ];
 		}
 
-		void fixInstructionOperands(IList<Instruction> instrs) {
+		void FixInstructionOperands(IList<Instruction> instrs) {
 			foreach (var instr in instrs) {
 				var op = instr.Operand as IVmOperand;
 				if (op != null)
-					instr.Operand = fixOperand(instrs, instr, op);
+					instr.Operand = FixOperand(instrs, instr, op);
 			}
 		}
 
-		object fixOperand(IList<Instruction> instrs, Instruction instr, IVmOperand vmOperand) {
+		object FixOperand(IList<Instruction> instrs, Instruction instr, IVmOperand vmOperand) {
 			if (vmOperand is TokenOperand)
-				return getMemberRef(((TokenOperand)vmOperand).token);
+				return GetMemberRef(((TokenOperand)vmOperand).token);
 
 			if (vmOperand is TargetDisplOperand)
-				return getInstruction(instrs, instr, ((TargetDisplOperand)vmOperand).displacement);
+				return GetInstruction(instrs, instr, ((TargetDisplOperand)vmOperand).displacement);
 
 			if (vmOperand is SwitchTargetDisplOperand) {
 				var targetDispls = ((SwitchTargetDisplOperand)vmOperand).targetDisplacements;
 				Instruction[] targets = new Instruction[targetDispls.Length];
 				for (int i = 0; i < targets.Length; i++)
-					targets[i] = getInstruction(instrs, instr, targetDispls[i]);
+					targets[i] = GetInstruction(instrs, instr, targetDispls[i]);
 				return targets;
 			}
 
@@ -362,20 +362,20 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 				return vmOperand;
 
 			if (vmOperand is LoadFieldOperand)
-				return fixLoadStoreFieldInstruction(instr, ((LoadFieldOperand)vmOperand).token, OpCodes.Ldsfld, OpCodes.Ldfld);
+				return FixLoadStoreFieldInstruction(instr, ((LoadFieldOperand)vmOperand).token, OpCodes.Ldsfld, OpCodes.Ldfld);
 
 			if (vmOperand is LoadFieldAddressOperand)
-				return fixLoadStoreFieldInstruction(instr, ((LoadFieldAddressOperand)vmOperand).token, OpCodes.Ldsflda, OpCodes.Ldflda);
+				return FixLoadStoreFieldInstruction(instr, ((LoadFieldAddressOperand)vmOperand).token, OpCodes.Ldsflda, OpCodes.Ldflda);
 
 			if (vmOperand is StoreFieldOperand)
-				return fixLoadStoreFieldInstruction(instr, ((StoreFieldOperand)vmOperand).token, OpCodes.Stsfld, OpCodes.Stfld);
+				return FixLoadStoreFieldInstruction(instr, ((StoreFieldOperand)vmOperand).token, OpCodes.Stsfld, OpCodes.Stfld);
 
 			throw new ApplicationException(string.Format("Unknown operand type: {0}", vmOperand.GetType()));
 		}
 
-		IField fixLoadStoreFieldInstruction(Instruction instr, int token, OpCode staticInstr, OpCode instanceInstr) {
+		IField FixLoadStoreFieldInstruction(Instruction instr, int token, OpCode staticInstr, OpCode instanceInstr) {
 			var fieldRef = module.ResolveToken(token) as IField;
-			var field = deobfuscatorContext.resolveField(fieldRef);
+			var field = deobfuscatorContext.ResolveField(fieldRef);
 			bool isStatic;
 			if (field == null) {
 				Logger.w("Could not resolve field {0:X8}. Assuming it's not static.", token);
@@ -387,14 +387,14 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			return fieldRef;
 		}
 
-		ITokenOperand getMemberRef(int token) {
+		ITokenOperand GetMemberRef(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(MethodDef method) {
+		static void RestoreConstrainedPrefix(MethodDef method) {
 			if (method == null || method.Body == null)
 				return;
 
@@ -410,17 +410,17 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 				var sig = calledMethod.MethodSig;
 				if (sig == null || !sig.HasThis)
 					continue;
-				var thisType = MethodStack.getLoadedType(method, instrs, i, sig.Params.Count) as ByRefSig;
+				var thisType = MethodStack.GetLoadedType(method, instrs, i, sig.Params.Count) as ByRefSig;
 				if (thisType == null)
 					continue;
-				if (hasPrefix(instrs, i, Code.Constrained))
+				if (HasPrefix(instrs, i, Code.Constrained))
 					continue;
 				instrs.Insert(i, OpCodes.Constrained.ToInstruction(thisType.Next.ToTypeDefOrRef()));
 				i++;
 			}
 		}
 
-		static bool hasPrefix(IList<Instruction> instrs, int index, Code prefix) {
+		static bool HasPrefix(IList<Instruction> instrs, int index, Code prefix) {
 			index--;
 			for (; index >= 0; index--) {
 				var instr = instrs[index];
diff --git a/de4dot.code/deobfuscators/Agile_NET/vm/FieldsInfo.cs b/de4dot.code/deobfuscators/Agile_NET/vm/FieldsInfo.cs
index e31aa98d..a6945092 100644
--- a/de4dot.code/deobfuscators/Agile_NET/vm/FieldsInfo.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/vm/FieldsInfo.cs
@@ -35,36 +35,36 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			foreach (var field in fields) {
 				var fieldTypeDef = field.FieldSig.GetFieldType().TryGetTypeDef();
 				if (fieldTypeDef != null && fieldTypeDef.IsEnum)
-					addEnum();
+					AddEnum();
 				else
-					add(field.FieldSig.GetFieldType());
+					Add(field.FieldSig.GetFieldType());
 			}
 		}
 
 		public FieldsInfo(object[] fieldTypes) {
 			foreach (var o in fieldTypes) {
 				if (o == EnumType)
-					addEnum();
+					AddEnum();
 				else
-					add((string)o);
+					Add((string)o);
 			}
 		}
 
-		void add(TypeSig type) {
-			add(type.GetFullName());
+		void Add(TypeSig type) {
+			Add(type.GetFullName());
 		}
 
-		void add(string typeFullName) {
+		void Add(string typeFullName) {
 			int count;
 			fieldTypes.TryGetValue(typeFullName, out count);
 			fieldTypes[typeFullName] = count + 1;
 		}
 
-		void addEnum() {
+		void AddEnum() {
 			numEnums++;
 		}
 
-		public bool isSame(FieldsInfo other) {
+		public bool IsSame(FieldsInfo other) {
 			if (numEnums != other.numEnums)
 				return false;
 			if (fieldTypes.Count != other.fieldTypes.Count)
diff --git a/de4dot.code/deobfuscators/Agile_NET/vm/OpCodeHandler.cs b/de4dot.code/deobfuscators/Agile_NET/vm/OpCodeHandler.cs
index 7b91dfc1..1a911df6 100644
--- a/de4dot.code/deobfuscators/Agile_NET/vm/OpCodeHandler.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/vm/OpCodeHandler.cs
@@ -31,24 +31,24 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 		public Predicate<UnknownHandlerInfo> Check { get; set; }
 		public Func<BinaryReader, Instruction> Read { get; set; }
 
-		public bool detect(UnknownHandlerInfo info) {
+		public bool Detect(UnknownHandlerInfo info) {
 			var sigInfo = OpCodeHandlerSigInfo;
 
-			if (!compare(sigInfo.NumStaticMethods, info.NumStaticMethods))
+			if (!Compare(sigInfo.NumStaticMethods, info.NumStaticMethods))
 				return false;
-			if (!compare(sigInfo.NumInstanceMethods, info.NumInstanceMethods))
+			if (!Compare(sigInfo.NumInstanceMethods, info.NumInstanceMethods))
 				return false;
-			if (!compare(sigInfo.NumVirtualMethods, info.NumVirtualMethods))
+			if (!Compare(sigInfo.NumVirtualMethods, info.NumVirtualMethods))
 				return false;
-			if (!compare(sigInfo.NumCtors, info.NumCtors))
+			if (!Compare(sigInfo.NumCtors, info.NumCtors))
 				return false;
-			if (!compare(sigInfo.ExecuteMethodThrows, info.ExecuteMethodThrows))
+			if (!Compare(sigInfo.ExecuteMethodThrows, info.ExecuteMethodThrows))
 				return false;
-			if (!compare(sigInfo.ExecuteMethodPops, info.ExecuteMethodPops))
+			if (!Compare(sigInfo.ExecuteMethodPops, info.ExecuteMethodPops))
 				return false;
-			if (!info.hasSameFieldTypes(sigInfo.RequiredFieldTypes))
+			if (!info.HasSameFieldTypes(sigInfo.RequiredFieldTypes))
 				return false;
-			if (sigInfo.ExecuteMethodLocals != null && !new LocalTypes(info.ExecuteMethod).all(sigInfo.ExecuteMethodLocals))
+			if (sigInfo.ExecuteMethodLocals != null && !new LocalTypes(info.ExecuteMethod).All(sigInfo.ExecuteMethodLocals))
 				return false;
 
 			if (Check != null)
@@ -56,7 +56,7 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			return true;
 		}
 
-		static bool compare(int? val1, int val2) {
+		static bool Compare(int? val1, int val2) {
 			if (!val1.HasValue)
 				return true;
 			return val1.Value == val2;
@@ -88,7 +88,7 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 		}
 
 		static bool newarr_check(UnknownHandlerInfo info) {
-			return DotNetUtils.callsMethod(info.ExecuteMethod, "System.Type System.Reflection.Module::ResolveType(System.Int32)");
+			return DotNetUtils.CallsMethod(info.ExecuteMethod, "System.Type System.Reflection.Module::ResolveType(System.Int32)");
 		}
 
 		static Instruction newarr_read(BinaryReader reader) {
@@ -286,7 +286,7 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 		}
 
 		static bool endfinally_check(UnknownHandlerInfo info) {
-			return DotNetUtils.callsMethod(info.ExecuteMethod, "System.Reflection.MethodInfo System.Type::GetMethod(System.String,System.Reflection.BindingFlags)");
+			return DotNetUtils.CallsMethod(info.ExecuteMethod, "System.Reflection.MethodInfo System.Type::GetMethod(System.String,System.Reflection.BindingFlags)");
 		}
 
 		static Instruction endfinally_read(BinaryReader reader) {
@@ -365,7 +365,7 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 		}
 
 		static bool ldtoken_check(UnknownHandlerInfo info) {
-			return DotNetUtils.callsMethod(info.ExecuteMethod, "System.Reflection.MemberInfo System.Reflection.Module::ResolveMember(System.Int32)");
+			return DotNetUtils.CallsMethod(info.ExecuteMethod, "System.Reflection.MemberInfo System.Reflection.Module::ResolveMember(System.Int32)");
 		}
 
 		static Instruction ldtoken_read(BinaryReader reader) {
@@ -376,9 +376,9 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 		}
 
 		static bool leave_check(UnknownHandlerInfo info) {
-			return !DotNetUtils.callsMethod(info.ExecuteMethod, "System.Reflection.MethodBase System.Reflection.Module::ResolveMethod(System.Int32)") &&
-				!DotNetUtils.callsMethod(info.ExecuteMethod, "System.Type System.Reflection.Module::ResolveType(System.Int32)") &&
-				!DotNetUtils.callsMethod(info.ExecuteMethod, "System.Reflection.MemberInfo System.Reflection.Module::ResolveMember(System.Int32)");
+			return !DotNetUtils.CallsMethod(info.ExecuteMethod, "System.Reflection.MethodBase System.Reflection.Module::ResolveMethod(System.Int32)") &&
+				!DotNetUtils.CallsMethod(info.ExecuteMethod, "System.Type System.Reflection.Module::ResolveType(System.Int32)") &&
+				!DotNetUtils.CallsMethod(info.ExecuteMethod, "System.Reflection.MemberInfo System.Reflection.Module::ResolveMember(System.Int32)");
 		}
 
 		static Instruction leave_read(BinaryReader reader) {
@@ -435,10 +435,10 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 		}
 
 		static bool nop_check(UnknownHandlerInfo info) {
-			return isEmptyMethod(info.ReadMethod) && isEmptyMethod(info.ExecuteMethod);
+			return IsEmptyMethod(info.ReadMethod) && IsEmptyMethod(info.ExecuteMethod);
 		}
 
-		static bool isEmptyMethod(MethodDef method) {
+		static bool IsEmptyMethod(MethodDef method) {
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code == Code.Ret)
 					return true;
@@ -453,7 +453,7 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 		}
 
 		static bool ret_check(UnknownHandlerInfo info) {
-			return DotNetUtils.callsMethod(info.ExecuteMethod, "System.Reflection.MethodBase System.Reflection.Module::ResolveMethod(System.Int32)");
+			return DotNetUtils.CallsMethod(info.ExecuteMethod, "System.Reflection.MethodBase System.Reflection.Module::ResolveMethod(System.Int32)");
 		}
 
 		static Instruction ret_read(BinaryReader reader) {
@@ -506,7 +506,7 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 		}
 
 		static bool throw_check(UnknownHandlerInfo info) {
-			return !DotNetUtils.callsMethod(info.ExecuteMethod, "System.Reflection.MethodInfo System.Type::GetMethod(System.String,System.Reflection.BindingFlags)");
+			return !DotNetUtils.CallsMethod(info.ExecuteMethod, "System.Reflection.MethodInfo System.Type::GetMethod(System.String,System.Reflection.BindingFlags)");
 		}
 
 		static Instruction throw_read(BinaryReader reader) {
diff --git a/de4dot.code/deobfuscators/Agile_NET/vm/UnknownHandlerInfo.cs b/de4dot.code/deobfuscators/Agile_NET/vm/UnknownHandlerInfo.cs
index 31404095..05557708 100644
--- a/de4dot.code/deobfuscators/Agile_NET/vm/UnknownHandlerInfo.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/vm/UnknownHandlerInfo.cs
@@ -67,17 +67,17 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 		public UnknownHandlerInfo(TypeDef type, CsvmInfo csvmInfo) {
 			this.type = type;
 			this.csvmInfo = csvmInfo;
-			fieldsInfo = new FieldsInfo(getFields(type));
-			countMethods();
-			findOverrideMethods();
-			executeMethodThrows = countThrows(executeMethod);
-			executeMethodPops = countPops(executeMethod);
+			fieldsInfo = new FieldsInfo(GetFields(type));
+			CountMethods();
+			FindOverrideMethods();
+			executeMethodThrows = CountThrows(executeMethod);
+			executeMethodPops = CountPops(executeMethod);
 		}
 
-		static internal IEnumerable<FieldDef> getFields(TypeDef type) {
+		static internal IEnumerable<FieldDef> GetFields(TypeDef type) {
 			var typeFields = new FieldDefAndDeclaringTypeDict<FieldDef>();
 			foreach (var field in type.Fields)
-				typeFields.add(field, field);
+				typeFields.Add(field, field);
 			var realFields = new Dictionary<FieldDef, bool>();
 			foreach (var method in type.Methods) {
 				if (method.Body == null)
@@ -86,7 +86,7 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 					var fieldRef = instr.Operand as IField;
 					if (fieldRef == null)
 						continue;
-					var field = typeFields.find(fieldRef);
+					var field = typeFields.Find(fieldRef);
 					if (field == null)
 						continue;
 					realFields[field] = true;
@@ -95,7 +95,7 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			return realFields.Keys;
 		}
 
-		void countMethods() {
+		void CountMethods() {
 			foreach (var method in type.Methods) {
 				if (method.Name == ".cctor") {
 				}
@@ -110,16 +110,16 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			}
 		}
 
-		void findOverrideMethods() {
+		void FindOverrideMethods() {
 			foreach (var method in type.Methods) {
 				if (!method.IsVirtual)
 					continue;
-				if (DotNetUtils.isMethod(method, "System.Void", "(System.IO.BinaryReader)")) {
+				if (DotNetUtils.IsMethod(method, "System.Void", "(System.IO.BinaryReader)")) {
 					if (readMethod != null)
 						throw new ApplicationException("Found another read method");
 					readMethod = method;
 				}
-				else if (!DotNetUtils.hasReturnValue(method) && method.MethodSig.GetParamCount() == 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.Agile_NET.vm {
 				throw new ApplicationException("Could not find execute method");
 		}
 
-		static int countThrows(MethodDef method) {
+		static int CountThrows(MethodDef method) {
 			int count = 0;
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code == Code.Throw)
@@ -141,7 +141,7 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			return count;
 		}
 
-		int countPops(MethodDef 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)
@@ -155,8 +155,8 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			return count;
 		}
 
-		public bool hasSameFieldTypes(object[] fieldTypes) {
-			return new FieldsInfo(fieldTypes).isSame(fieldsInfo);
+		public bool HasSameFieldTypes(object[] fieldTypes) {
+			return new FieldsInfo(fieldTypes).IsSame(fieldsInfo);
 		}
 	}
 }
diff --git a/de4dot.code/deobfuscators/Agile_NET/vm/VmOpCodeHandlerDetector.cs b/de4dot.code/deobfuscators/Agile_NET/vm/VmOpCodeHandlerDetector.cs
index 8686c10f..5be219cc 100644
--- a/de4dot.code/deobfuscators/Agile_NET/vm/VmOpCodeHandlerDetector.cs
+++ b/de4dot.code/deobfuscators/Agile_NET/vm/VmOpCodeHandlerDetector.cs
@@ -55,33 +55,33 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			this.module = module;
 		}
 
-		public void findHandlers() {
+		public void FindHandlers() {
 			if (opCodeHandlers != null)
 				return;
-			var vmHandlerTypes = findVmHandlerTypes();
+			var vmHandlerTypes = FindVmHandlerTypes();
 			if (vmHandlerTypes == null)
 				throw new ApplicationException("Could not find CSVM opcode handler types");
 
-			detectHandlers(vmHandlerTypes, createCsvmInfo());
+			DetectHandlers(vmHandlerTypes, CreateCsvmInfo());
 		}
 
-		internal CsvmInfo createCsvmInfo() {
+		internal CsvmInfo CreateCsvmInfo() {
 			var csvmInfo = new CsvmInfo();
-			csvmInfo.StackValue = findStackValueType();
-			csvmInfo.Stack = findStackType(csvmInfo.StackValue);
-			initStackTypeMethods(csvmInfo);
+			csvmInfo.StackValue = FindStackValueType();
+			csvmInfo.Stack = FindStackType(csvmInfo.StackValue);
+			InitStackTypeMethods(csvmInfo);
 			return csvmInfo;
 		}
 
-		TypeDef findStackValueType() {
+		TypeDef FindStackValueType() {
 			foreach (var type in module.Types) {
-				if (isStackType(type))
+				if (IsStackType(type))
 					return type;
 			}
 			return null;
 		}
 
-		static bool isStackType(TypeDef type) {
+		static bool IsStackType(TypeDef type) {
 			if (type.Fields.Count != 2)
 				return false;
 
@@ -100,20 +100,20 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			return true;
 		}
 
-		TypeDef findStackType(TypeDef stackValueType) {
+		TypeDef FindStackType(TypeDef stackValueType) {
 			foreach (var type in module.Types) {
-				if (isStackType(type, stackValueType))
+				if (IsStackType(type, stackValueType))
 					return type;
 			}
 			return null;
 		}
 
-		bool isStackType(TypeDef type, TypeDef stackValueType) {
+		bool IsStackType(TypeDef type, TypeDef stackValueType) {
 			if (type.Interfaces.Count != 2)
 				return false;
-			if (!implementsInterface(type, "System.Collections.ICollection"))
+			if (!ImplementsInterface(type, "System.Collections.ICollection"))
 				return false;
-			if (!implementsInterface(type, "System.Collections.IEnumerable"))
+			if (!ImplementsInterface(type, "System.Collections.IEnumerable"))
 				return false;
 			if (type.NestedTypes.Count == 0)
 				return false;
@@ -140,7 +140,7 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			return true;
 		}
 
-		static bool implementsInterface(TypeDef type, string ifaceName) {
+		static bool ImplementsInterface(TypeDef type, string ifaceName) {
 			foreach (var iface in type.Interfaces) {
 				if (iface.Interface.FullName == ifaceName)
 					return true;
@@ -148,11 +148,11 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			return false;
 		}
 
-		void initStackTypeMethods(CsvmInfo csvmInfo) {
+		void InitStackTypeMethods(CsvmInfo csvmInfo) {
 			foreach (var method in csvmInfo.Stack.Methods) {
 				var sig = method.MethodSig;
 				if (sig != null && sig.Params.Count == 0 && sig.RetType.TryGetTypeDef() == csvmInfo.StackValue) {
-					if (hasAdd(method))
+					if (HasAdd(method))
 						csvmInfo.PopMethod = method;
 					else
 						csvmInfo.PeekMethod = method;
@@ -160,7 +160,7 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			}
 		}
 
-		static bool hasAdd(MethodDef method) {
+		static bool HasAdd(MethodDef method) {
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code == Code.Add)
 					return true;
@@ -168,7 +168,7 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			return false;
 		}
 
-		List<TypeDef> findVmHandlerTypes() {
+		List<TypeDef> FindVmHandlerTypes() {
 			var requiredFields = new string[] {
 				null,
 				"System.Collections.Generic.Dictionary`2<System.UInt16,System.Type>",
@@ -180,11 +180,11 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 				if (cctor == null)
 					continue;
 				requiredFields[0] = type.FullName;
-				if (!new FieldTypes(type).exactly(requiredFields))
+				if (!new FieldTypes(type).Exactly(requiredFields))
 					continue;
 
-				cflowDeobfuscator.deobfuscate(cctor);
-				var handlers = findVmHandlerTypes(cctor);
+				cflowDeobfuscator.Deobfuscate(cctor);
+				var handlers = FindVmHandlerTypes(cctor);
 				if (handlers.Count != 31)
 					continue;
 
@@ -194,7 +194,7 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			return null;
 		}
 
-		static List<TypeDef> findVmHandlerTypes(MethodDef method) {
+		static List<TypeDef> FindVmHandlerTypes(MethodDef method) {
 			var list = new List<TypeDef>();
 
 			foreach (var instr in method.Body.Instructions) {
@@ -210,7 +210,7 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 			return list;
 		}
 
-		void detectHandlers(List<TypeDef> handlerTypes, CsvmInfo csvmInfo) {
+		void DetectHandlers(List<TypeDef> handlerTypes, CsvmInfo csvmInfo) {
 			opCodeHandlers = new List<OpCodeHandler>();
 			var detected = new List<OpCodeHandler>();
 
@@ -221,14 +221,14 @@ namespace de4dot.code.deobfuscators.Agile_NET.vm {
 					var info = new UnknownHandlerInfo(handlerType, csvmInfo);
 					detected.Clear();
 					foreach (var opCodeHandler in handlersList) {
-						if (opCodeHandler.detect(info))
+						if (opCodeHandler.Detect(info))
 							detected.Add(opCodeHandler);
 					}
 					if (detected.Count != 1)
 						goto next;
 					opCodeHandlers.Add(detected[0]);
 				}
-				if (new List<OpCodeHandler>(Utils.unique(opCodeHandlers)).Count == opCodeHandlers.Count)
+				if (new List<OpCodeHandler>(Utils.Unique(opCodeHandlers)).Count == opCodeHandlers.Count)
 					return;
 next: ;
 			}
diff --git a/de4dot.code/deobfuscators/ArrayFinder.cs b/de4dot.code/deobfuscators/ArrayFinder.cs
index 3d0620d8..821405eb 100644
--- a/de4dot.code/deobfuscators/ArrayFinder.cs
+++ b/de4dot.code/deobfuscators/ArrayFinder.cs
@@ -25,16 +25,16 @@ using de4dot.blocks.cflow;
 
 namespace de4dot.code.deobfuscators {
 	static class ArrayFinder {
-		public static List<byte[]> getArrays(MethodDef method) {
-			return getArrays(method, null);
+		public static List<byte[]> GetArrays(MethodDef method) {
+			return GetArrays(method, null);
 		}
 
-		public static List<byte[]> getArrays(MethodDef method, IType arrayElementType) {
+		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++) {
 				IType type;
-				var ary = getArray(instrs, ref i, out type);
+				var ary = GetArray(instrs, ref i, out type);
 				if (ary == null)
 					break;
 				if (arrayElementType != null && !new SigComparer().Equals(type, arrayElementType))
@@ -45,7 +45,7 @@ namespace de4dot.code.deobfuscators {
 			return arrays;
 		}
 
-		public static byte[] getArray(IList<Instruction> instrs, ref int index, out IType 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)
@@ -71,54 +71,54 @@ namespace de4dot.code.deobfuscators {
 			return null;
 		}
 
-		public static byte[] getInitializedByteArray(MethodDef method, int arraySize) {
-			int newarrIndex = findNewarr(method, 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);
+			return GetInitializedByteArray(arraySize, method, ref newarrIndex);
 		}
 
-		public static byte[] getInitializedByteArray(int arraySize, MethodDef method, ref int newarrIndex) {
-			var resultValueArray = getInitializedArray(arraySize, method, ref newarrIndex, Code.Stelem_I1);
+		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];
 			for (int i = 0; i < resultArray.Length; i++) {
 				var intValue = resultValueArray[i] as Int32Value;
-				if (intValue == null || !intValue.allBitsValid())
+				if (intValue == null || !intValue.AllBitsValid())
 					return null;
 				resultArray[i] = (byte)intValue.value;
 			}
 			return resultArray;
 		}
 
-		public static short[] getInitializedInt16Array(int arraySize, MethodDef method, ref int newarrIndex) {
-			var resultValueArray = getInitializedArray(arraySize, method, ref newarrIndex, Code.Stelem_I2);
+		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];
 			for (int i = 0; i < resultArray.Length; i++) {
 				var intValue = resultValueArray[i] as Int32Value;
-				if (intValue == null || !intValue.allBitsValid())
+				if (intValue == null || !intValue.AllBitsValid())
 					return null;
 				resultArray[i] = (short)intValue.value;
 			}
 			return resultArray;
 		}
 
-		public static int[] getInitializedInt32Array(int arraySize, MethodDef method, ref int newarrIndex) {
-			var resultValueArray = getInitializedArray(arraySize, method, ref newarrIndex, Code.Stelem_I4);
+		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];
 			for (int i = 0; i < resultArray.Length; i++) {
 				var intValue = resultValueArray[i] as Int32Value;
-				if (intValue == null || !intValue.allBitsValid())
+				if (intValue == null || !intValue.AllBitsValid())
 					return null;
 				resultArray[i] = (int)intValue.value;
 			}
 			return resultArray;
 		}
 
-		public static uint[] getInitializedUInt32Array(int arraySize, MethodDef method, ref int newarrIndex) {
-			var resultArray = getInitializedInt32Array(arraySize, method, ref 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,12 +128,12 @@ namespace de4dot.code.deobfuscators {
 			return ary;
 		}
 
-		public static Value[] getInitializedArray(int arraySize, MethodDef 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);
 			var theArray = new UnknownValue();
-			emulator.push(theArray);
+			emulator.Push(theArray);
 
 			var instructions = method.Body.Instructions;
 			int i;
@@ -158,22 +158,22 @@ namespace de4dot.code.deobfuscators {
 				case Code.Starg_S:
 				case Code.Stsfld:
 				case Code.Stfld:
-					if (emulator.peek() == theArray && i != newarrIndex + 1 && i != newarrIndex + 2)
+					if (emulator.Peek() == theArray && i != newarrIndex + 1 && i != newarrIndex + 2)
 						goto done;
 					break;
 				}
 
 				if (instr.OpCode.Code == stelemOpCode) {
-					var value = emulator.pop();
-					var index = emulator.pop() as Int32Value;
-					var array = emulator.pop();
-					if (ReferenceEquals(array, theArray) && index != null && index.allBitsValid()) {
+					var value = emulator.Pop();
+					var index = emulator.Pop() as Int32Value;
+					var array = emulator.Pop();
+					if (ReferenceEquals(array, theArray) && index != null && index.AllBitsValid()) {
 						if (0 <= index.value && index.value < resultValueArray.Length)
 							resultValueArray[index.value] = value;
 					}
 				}
 				else
-					emulator.emulate(instr);
+					emulator.Emulate(instr);
 			}
 done:
 			if (i != newarrIndex + 1)
@@ -183,17 +183,17 @@ done:
 			return resultValueArray;
 		}
 
-		static int findNewarr(MethodDef method, int arraySize) {
+		static int FindNewarr(MethodDef method, int arraySize) {
 			for (int i = 0; ; i++) {
 				int size;
-				if (!findNewarr(method, ref i, out size))
+				if (!FindNewarr(method, ref i, out size))
 					return -1;
 				if (size == arraySize)
 					return i;
 			}
 		}
 
-		public static bool findNewarr(MethodDef 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];
diff --git a/de4dot.code/deobfuscators/Babel_NET/AssemblyResolver.cs b/de4dot.code/deobfuscators/Babel_NET/AssemblyResolver.cs
index c0a868ee..86c9a7d3 100644
--- a/de4dot.code/deobfuscators/Babel_NET/AssemblyResolver.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/AssemblyResolver.cs
@@ -69,7 +69,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			this.resourceDecrypter = resourceDecrypter;
 		}
 
-		public void find() {
+		public void Find() {
 			var requiredTypes = new string[] {
 				"System.Object",
 				"System.Int32",
@@ -78,17 +78,17 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			foreach (var type in module.Types) {
 				if (type.HasEvents)
 					continue;
-				if (!new FieldTypes(type).exactly(requiredTypes))
+				if (!new FieldTypes(type).Exactly(requiredTypes))
 					continue;
 
 				MethodDef regMethod, handler;
-				if (!BabelUtils.findRegisterMethod(type, out regMethod, out handler))
+				if (!BabelUtils.FindRegisterMethod(type, out regMethod, out handler))
 					continue;
 
-				var decryptMethod = findDecryptMethod(type);
+				var decryptMethod = FindDecryptMethod(type);
 				if (decryptMethod == null)
 					throw new ApplicationException("Couldn't find resource type decrypt method");
-				resourceDecrypter.DecryptMethod = ResourceDecrypter.findDecrypterMethod(decryptMethod);
+				resourceDecrypter.DecryptMethod = ResourceDecrypter.FindDecrypterMethod(decryptMethod);
 
 				resolverType = type;
 				registerMethod = regMethod;
@@ -96,26 +96,26 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			}
 		}
 
-		static MethodDef findDecryptMethod(TypeDef type) {
+		static MethodDef FindDecryptMethod(TypeDef type) {
 			foreach (var method in type.Methods) {
-				if (!DotNetUtils.isMethod(method, "System.Void", "(System.IO.Stream)"))
+				if (!DotNetUtils.IsMethod(method, "System.Void", "(System.IO.Stream)"))
 					continue;
 				return method;
 			}
 			return null;
 		}
 
-		public void initialize(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
+		public void Initialize(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
 			if (resolverType == null)
 				return;
 
-			encryptedResource = BabelUtils.findEmbeddedResource(module, resolverType, simpleDeobfuscator, deob);
+			encryptedResource = BabelUtils.FindEmbeddedResource(module, resolverType, simpleDeobfuscator, deob);
 			if (encryptedResource == null) {
 				Logger.w("Could not find embedded assemblies resource");
 				return;
 			}
 
-			var decrypted = resourceDecrypter.decrypt(encryptedResource.Data.ReadAllBytes());
+			var decrypted = resourceDecrypter.Decrypt(encryptedResource.Data.ReadAllBytes());
 			var reader = new BinaryReader(new MemoryStream(decrypted));
 			int numAssemblies = reader.ReadInt32();
 			embeddedAssemblyInfos = new EmbeddedAssemblyInfo[numAssemblies];
@@ -123,7 +123,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				string name = reader.ReadString();
 				var data = reader.ReadBytes(reader.ReadInt32());
 				var mod = ModuleDefMD.Load(data);
-				embeddedAssemblyInfos[i] = new EmbeddedAssemblyInfo(name, DeobUtils.getExtension(mod.Kind), 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 d1783fd4..be4982dd 100644
--- a/de4dot.code/deobfuscators/Babel_NET/BabelMethodCallInliner.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/BabelMethodCallInliner.cs
@@ -35,7 +35,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			branchEmulator = new BranchEmulator(emulator, this);
 		}
 
-		public static List<MethodDef> find(ModuleDefMD module, IEnumerable<MethodDef> notInlinedMethods) {
+		public static List<MethodDef> Find(ModuleDefMD module, IEnumerable<MethodDef> notInlinedMethods) {
 			var notInlinedMethodsDict = new Dictionary<MethodDef, bool>();
 			foreach (var method in notInlinedMethods)
 				notInlinedMethodsDict[method] = true;
@@ -44,7 +44,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 
 			foreach (var type in module.GetTypes()) {
 				foreach (var method in type.Methods) {
-					if (!notInlinedMethodsDict.ContainsKey(method) && canInline(method))
+					if (!notInlinedMethodsDict.ContainsKey(method) && CanInline(method))
 						inlinedMethods.Add(method);
 				}
 			}
@@ -52,15 +52,15 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return inlinedMethods;
 		}
 
-		void IBranchHandler.handleNormal(int stackArgs, bool isTaken) {
+		void IBranchHandler.HandleNormal(int stackArgs, bool isTaken) {
 			if (!isTaken)
 				emulateIndex++;
 			else
 				emulateIndex = instructions.IndexOf((Instruction)instructions[emulateIndex].Operand);
 		}
 
-		bool IBranchHandler.handleSwitch(Int32Value switchIndex) {
-			if (!switchIndex.allBitsValid())
+		bool IBranchHandler.HandleSwitch(Int32Value switchIndex) {
+			if (!switchIndex.AllBitsValid())
 				return false;
 			var instr = instructions[emulateIndex];
 			var targets = (Instruction[])instr.Operand;
@@ -71,20 +71,20 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return true;
 		}
 
-		protected override bool deobfuscateInternal() {
+		protected override bool DeobfuscateInternal() {
 			bool changed = false;
 			var instructions = block.Instructions;
 			for (int i = 0; i < instructions.Count; i++) {
 				var instr = instructions[i].Instruction;
 				if (instr.OpCode.Code == Code.Call)
-					changed |= inlineMethod(instr, i);
+					changed |= InlineMethod(instr, i);
 			}
 			instructions = null;
 			return changed;
 		}
 
-		static bool canInline(MethodDef method) {
-			if (!DotNetUtils.isMethod(method, "System.Int32", "(System.Int32)"))
+		static bool CanInline(MethodDef method) {
+			if (!DotNetUtils.IsMethod(method, "System.Int32", "(System.Int32)"))
 				return false;
 			if (!method.IsAssembly)
 				return false;
@@ -94,16 +94,16 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return method.IsStatic;
 		}
 
-		bool canInline2(MethodDef method) {
-			return canInline(method) && method != blocks.Method;
+		bool CanInline2(MethodDef method) {
+			return CanInline(method) && method != blocks.Method;
 		}
 
-		bool inlineMethod(Instruction callInstr, int instrIndex) {
+		bool InlineMethod(Instruction callInstr, int instrIndex) {
 			var methodToInline = callInstr.Operand as MethodDef;
 			if (methodToInline == null)
 				return false;
 
-			if (!canInline2(methodToInline))
+			if (!CanInline2(methodToInline))
 				return false;
 			var body = methodToInline.Body;
 			if (body == null)
@@ -113,10 +113,10 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				return false;
 
 			var ldci4 = block.Instructions[instrIndex - 1];
-			if (!ldci4.isLdcI4())
+			if (!ldci4.IsLdcI4())
 				return false;
 			int newValue;
-			if (!getNewValue(methodToInline, ldci4.getLdcI4Value(), out newValue))
+			if (!GetNewValue(methodToInline, ldci4.GetLdcI4Value(), out newValue))
 				return false;
 
 			block.Instructions[instrIndex - 1] = new Instr(OpCodes.Nop.ToInstruction());
@@ -124,10 +124,10 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return true;
 		}
 
-		bool getNewValue(MethodDef 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));
+			emulator.Initialize(method);
+			emulator.SetArg(method.Parameters[0], new Int32Value(arg));
 
 			Instruction instr;
 			emulateIndex = 0;
@@ -179,7 +179,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				case Code.Mul:
 				case Code.Rem:
 				case Code.Div:
-					emulator.emulate(instr);
+					emulator.Emulate(instr);
 					emulateIndex++;
 					break;
 
@@ -210,16 +210,16 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				case Code.Brtrue:
 				case Code.Brtrue_S:
 				case Code.Switch:
-					if (!branchEmulator.emulate(instr))
+					if (!branchEmulator.Emulate(instr))
 						return false;
 					break;
 
 				case Code.Ret:
-					var retValue = emulator.pop();
-					if (!retValue.isInt32())
+					var retValue = emulator.Pop();
+					if (!retValue.IsInt32())
 						return false;
 					var retValue2 = (Int32Value)retValue;
-					if (!retValue2.allBitsValid())
+					if (!retValue2.AllBitsValid())
 						return false;
 					newValue = retValue2.value;
 					return true;
@@ -233,10 +233,10 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			}
 		}
 
-		protected override bool isCompatibleType(int paramIndex, IType origType, IType newType) {
+		protected override bool IsCompatibleType(int paramIndex, IType origType, IType newType) {
 			if (new SigComparer(SigComparerOptions.IgnoreModifiers).Equals(origType, newType))
 				return true;
-			if (isValueType(newType) || isValueType(origType))
+			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 443977d4..9f6f2da0 100644
--- a/de4dot.code/deobfuscators/Babel_NET/BabelUtils.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/BabelUtils.cs
@@ -25,57 +25,57 @@ using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Babel_NET {
 	static class BabelUtils {
-		public static EmbeddedResource findEmbeddedResource(ModuleDefMD module, TypeDef decrypterType) {
-			return findEmbeddedResource(module, decrypterType, (method) => { });
+		public static EmbeddedResource FindEmbeddedResource(ModuleDefMD module, TypeDef decrypterType) {
+			return FindEmbeddedResource(module, decrypterType, (method) => { });
 		}
 
-		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(ModuleDefMD module, TypeDef decrypterType, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
+			return FindEmbeddedResource(module, decrypterType, (method) => {
+				simpleDeobfuscator.Deobfuscate(method);
+				simpleDeobfuscator.DecryptStrings(method, deob);
 			});
 		}
 
-		public static EmbeddedResource findEmbeddedResource(ModuleDefMD module, TypeDef decrypterType, Action<MethodDef> fixMethod) {
+		public static EmbeddedResource FindEmbeddedResource(ModuleDefMD module, TypeDef decrypterType, Action<MethodDef> fixMethod) {
 			foreach (var method in decrypterType.Methods) {
-				if (!DotNetUtils.isMethod(method, "System.String", "()"))
+				if (!DotNetUtils.IsMethod(method, "System.String", "()"))
 					continue;
 				if (!method.IsStatic)
 					continue;
 				fixMethod(method);
-				var resource = findEmbeddedResource1(module, method) ?? findEmbeddedResource2(module, method);
+				var resource = FindEmbeddedResource1(module, method) ?? FindEmbeddedResource2(module, method);
 				if (resource != null)
 					return resource;
 			}
 			return null;
 		}
 
-		static EmbeddedResource findEmbeddedResource1(ModuleDefMD module, MethodDef method) {
-			foreach (var s in DotNetUtils.getCodeStrings(method)) {
-				var resource = DotNetUtils.getResource(module, s) as EmbeddedResource;
+		static EmbeddedResource FindEmbeddedResource1(ModuleDefMD module, MethodDef method) {
+			foreach (var s in DotNetUtils.GetCodeStrings(method)) {
+				var resource = DotNetUtils.GetResource(module, s) as EmbeddedResource;
 				if (resource != null)
 					return resource;
 			}
 			return null;
 		}
 
-		static EmbeddedResource findEmbeddedResource2(ModuleDefMD module, MethodDef method) {
-			var strings = new List<string>(DotNetUtils.getCodeStrings(method));
+		static EmbeddedResource FindEmbeddedResource2(ModuleDefMD module, MethodDef method) {
+			var strings = new List<string>(DotNetUtils.GetCodeStrings(method));
 			if (strings.Count != 1)
 				return null;
 			var encryptedString = strings[0];
 
 			int xorKey;
-			if (!getXorKey2(method, out xorKey))
+			if (!GetXorKey2(method, out xorKey))
 				return null;
 
 			var sb = new StringBuilder(encryptedString.Length);
 			foreach (var c in encryptedString)
 				sb.Append((char)(c ^ xorKey));
-			return DotNetUtils.getResource(module, sb.ToString()) as EmbeddedResource;
+			return DotNetUtils.GetResource(module, sb.ToString()) as EmbeddedResource;
 		}
 
-		static bool getXorKey2(MethodDef 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];
@@ -97,7 +97,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return false;
 		}
 
-		public static bool findRegisterMethod(TypeDef type, out MethodDef regMethod, out MethodDef 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;
@@ -110,11 +110,11 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 					var handlerRef = instr.Operand as IMethod;
 					if (handlerRef == null)
 						continue;
-					if (!DotNetUtils.isMethod(handlerRef, "System.Reflection.Assembly", "(System.Object,System.ResolveEventArgs)"))
+					if (!DotNetUtils.IsMethod(handlerRef, "System.Reflection.Assembly", "(System.Object,System.ResolveEventArgs)"))
 						continue;
 					if (!new SigComparer().Equals(type, handlerRef.DeclaringType))
 						continue;
-					handler = DotNetUtils.getMethod(type, handlerRef);
+					handler = DotNetUtils.GetMethod(type, handlerRef);
 					if (handler == null)
 						continue;
 					if (handler.Body == null || handler.Body.ExceptionHandlers.Count != 1)
diff --git a/de4dot.code/deobfuscators/Babel_NET/ConstantsDecrypter.cs b/de4dot.code/deobfuscators/Babel_NET/ConstantsDecrypter.cs
index 93bd8b86..eb22001f 100644
--- a/de4dot.code/deobfuscators/Babel_NET/ConstantsDecrypter.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/ConstantsDecrypter.cs
@@ -85,42 +85,42 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			this.initializedDataCreator = initializedDataCreator;
 		}
 
-		public void find() {
+		public void Find() {
 			foreach (var type in module.Types) {
-				if (!isConstantDecrypter(type))
+				if (!IsConstantDecrypter(type))
 					continue;
 
-				int32Decrypter = DotNetUtils.getMethod(type, "System.Int32", "(System.Int32)");
-				int64Decrypter = DotNetUtils.getMethod(type, "System.Int64", "(System.Int32)");
-				singleDecrypter = DotNetUtils.getMethod(type, "System.Single", "(System.Int32)");
-				doubleDecrypter = DotNetUtils.getMethod(type, "System.Double", "(System.Int32)");
-				arrayDecrypter = DotNetUtils.getMethod(type, "System.Array", "(System.Byte[])");
+				int32Decrypter = DotNetUtils.GetMethod(type, "System.Int32", "(System.Int32)");
+				int64Decrypter = DotNetUtils.GetMethod(type, "System.Int64", "(System.Int32)");
+				singleDecrypter = DotNetUtils.GetMethod(type, "System.Single", "(System.Int32)");
+				doubleDecrypter = DotNetUtils.GetMethod(type, "System.Double", "(System.Int32)");
+				arrayDecrypter = DotNetUtils.GetMethod(type, "System.Array", "(System.Byte[])");
 				decrypterType = type;
 				return;
 			}
 		}
 
-		bool isConstantDecrypter(TypeDef type) {
+		bool IsConstantDecrypter(TypeDef type) {
 			if (type.HasEvents)
 				return false;
 			if (type.NestedTypes.Count != 1)
 				return false;
 
 			var nested = type.NestedTypes[0];
-			if (!checkNestedFields(nested))
+			if (!CheckNestedFields(nested))
 				return false;
 
-			resourceDecrypter.DecryptMethod = ResourceDecrypter.findDecrypterMethod(nested.FindMethod(".ctor"));
+			resourceDecrypter.DecryptMethod = ResourceDecrypter.FindDecrypterMethod(nested.FindMethod(".ctor"));
 
-			if (DotNetUtils.getMethod(type, "System.Int32", "(System.Int32)") == null)
+			if (DotNetUtils.GetMethod(type, "System.Int32", "(System.Int32)") == null)
 				return false;
-			if (DotNetUtils.getMethod(type, "System.Int64", "(System.Int32)") == null)
+			if (DotNetUtils.GetMethod(type, "System.Int64", "(System.Int32)") == null)
 				return false;
-			if (DotNetUtils.getMethod(type, "System.Single", "(System.Int32)") == null)
+			if (DotNetUtils.GetMethod(type, "System.Single", "(System.Int32)") == null)
 				return false;
-			if (DotNetUtils.getMethod(type, "System.Double", "(System.Int32)") == null)
+			if (DotNetUtils.GetMethod(type, "System.Double", "(System.Int32)") == null)
 				return false;
-			if (DotNetUtils.getMethod(type, "System.Array", "(System.Byte[])") == null)
+			if (DotNetUtils.GetMethod(type, "System.Array", "(System.Byte[])") == null)
 				return false;
 
 			return true;
@@ -132,8 +132,8 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			"System.Single[]",
 			"System.Double[]",
 		};
-		bool checkNestedFields(TypeDef nested) {
-			if (!new FieldTypes(nested).all(requiredTypes))
+		bool CheckNestedFields(TypeDef nested) {
+			if (!new FieldTypes(nested).All(requiredTypes))
 				return false;
 			foreach (var field in nested.Fields) {
 				if (new SigComparer().Equals(nested, field.FieldSig.GetFieldType()))
@@ -142,17 +142,17 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return false;
 		}
 
-		public void initialize(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
+		public void Initialize(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
 			if (decrypterType == null)
 				return;
 
-			encryptedResource = BabelUtils.findEmbeddedResource(module, decrypterType, simpleDeobfuscator, deob);
+			encryptedResource = BabelUtils.FindEmbeddedResource(module, decrypterType, simpleDeobfuscator, deob);
 			if (encryptedResource == null) {
 				Logger.w("Could not find encrypted constants resource");
 				return;
 			}
 
-			var decrypted = resourceDecrypter.decrypt(encryptedResource.Data.ReadAllBytes());
+			var decrypted = resourceDecrypter.Decrypt(encryptedResource.Data.ReadAllBytes());
 			var reader = new BinaryReader(new MemoryStream(decrypted));
 			int count;
 
@@ -177,19 +177,19 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				decryptedDoubles[count] = reader.ReadDouble();
 		}
 
-		public int decryptInt32(int index) {
+		public int DecryptInt32(int index) {
 			return decryptedInts[index];
 		}
 
-		public long decryptInt64(int index) {
+		public long DecryptInt64(int index) {
 			return decryptedLongs[index];
 		}
 
-		public float decryptSingle(int index) {
+		public float DecryptSingle(int index) {
 			return decryptedFloats[index];
 		}
 
-		public double decryptDouble(int index) {
+		public double DecryptDouble(int index) {
 			return decryptedDoubles[index];
 		}
 
@@ -206,19 +206,19 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			}
 		}
 
-		public void deobfuscate(Blocks blocks) {
+		public void Deobfuscate(Blocks blocks) {
 			if (arrayDecrypter == null)
 				return;
 
 			var infos = new List<ArrayInfo>();
-			foreach (var block in blocks.MethodBlocks.getAllBlocks()) {
+			foreach (var block in blocks.MethodBlocks.GetAllBlocks()) {
 				var instrs = block.Instructions;
 				infos.Clear();
 				for (int i = 0; i < instrs.Count - 6; i++) {
 					int index = i;
 
 					var ldci4 = instrs[index++];
-					if (!ldci4.isLdcI4())
+					if (!ldci4.IsLdcI4())
 						continue;
 
 					var newarr = instrs[index++];
@@ -240,7 +240,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 					var call1 = instrs[index++];
 					if (call1.OpCode.Code != Code.Call && call1.OpCode.Code != Code.Callvirt)
 						continue;
-					if (!DotNetUtils.isMethod(call1.Operand as IMethod, "System.Void", "(System.Array,System.RuntimeFieldHandle)"))
+					if (!DotNetUtils.IsMethod(call1.Operand as IMethod, "System.Void", "(System.Array,System.RuntimeFieldHandle)"))
 						continue;
 
 					var call2 = instrs[index++];
@@ -266,16 +266,16 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				infos.Reverse();
 				foreach (var info in infos) {
 					var elemSize = info.arrayType.Next.ElementType.GetPrimitiveSize();
-					var decrypted = decryptArray(info.encryptedField.InitialValue, elemSize);
+					var decrypted = DecryptArray(info.encryptedField.InitialValue, elemSize);
 
-					initializedDataCreator.addInitializeArrayCode(block, info.start, info.len, info.arrayType.Next.ToTypeDefOrRef(), decrypted);
+					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);
 				}
 			}
 		}
 
-		byte[] decryptArray(byte[] encryptedData, int elemSize) {
-			var decrypted = resourceDecrypter.decrypt(encryptedData);
+		byte[] DecryptArray(byte[] encryptedData, int elemSize) {
+			var decrypted = resourceDecrypter.Decrypt(encryptedData);
 			var ary = (Array)new BinaryFormatter().Deserialize(new MemoryStream(decrypted));
 			if (ary is byte[])
 				return (byte[])ary;
diff --git a/de4dot.code/deobfuscators/Babel_NET/Deobfuscator.cs b/de4dot.code/deobfuscators/Babel_NET/Deobfuscator.cs
index 18195f79..9b62c2e0 100644
--- a/de4dot.code/deobfuscators/Babel_NET/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/Deobfuscator.cs
@@ -36,12 +36,12 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 
 		public DeobfuscatorInfo()
 			: base() {
-			inlineMethods = new BoolOption(null, makeArgName("inline"), "Inline short methods", true);
-			removeInlinedMethods = new BoolOption(null, makeArgName("remove-inlined"), "Remove inlined methods", true);
-			decryptMethods = new BoolOption(null, makeArgName("methods"), "Decrypt methods", true);
-			decryptResources = new BoolOption(null, makeArgName("rsrc"), "Decrypt resources", true);
-			decryptConstants = new BoolOption(null, makeArgName("consts"), "Decrypt constants and arrays", true);
-			dumpEmbeddedAssemblies = new BoolOption(null, makeArgName("embedded"), "Dump embedded assemblies", true);
+			inlineMethods = new BoolOption(null, MakeArgName("inline"), "Inline short methods", true);
+			removeInlinedMethods = new BoolOption(null, MakeArgName("remove-inlined"), "Remove inlined methods", true);
+			decryptMethods = new BoolOption(null, MakeArgName("methods"), "Decrypt methods", true);
+			decryptResources = new BoolOption(null, MakeArgName("rsrc"), "Decrypt resources", true);
+			decryptConstants = new BoolOption(null, MakeArgName("consts"), "Decrypt constants and arrays", true);
+			dumpEmbeddedAssemblies = new BoolOption(null, MakeArgName("embedded"), "Dump embedded assemblies", true);
 		}
 
 		public override string Name {
@@ -52,7 +52,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			get { return THE_TYPE; }
 		}
 
-		public override IDeobfuscator createDeobfuscator() {
+		public override IDeobfuscator CreateDeobfuscator() {
 			return new Deobfuscator(new Deobfuscator.Options {
 				ValidNameRegex = validNameRegex.get(),
 				InlineMethods = inlineMethods.get(),
@@ -64,7 +64,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			});
 		}
 
-		protected override IEnumerable<Option> getOptionsInternal() {
+		protected override IEnumerable<Option> GetOptionsInternal() {
 			return new List<Option>() {
 				inlineMethods,
 				removeInlinedMethods,
@@ -132,20 +132,20 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			this.options = options;
 		}
 
-		public override void init(ModuleDefMD module) {
-			base.init(module);
+		public override void Initialize(ModuleDefMD module) {
+			base.Initialize(module);
 		}
 
-		protected override int detectInternal() {
+		protected override int DetectInternal() {
 			int val = 0;
 
-			int sum = toInt32(resourceResolver.Detected) +
-					toInt32(assemblyResolver.Detected) +
-					toInt32(stringDecrypter.Detected) +
-					toInt32(constantsDecrypter.Detected) +
-					toInt32(proxyCallFixer.Detected) +
-					toInt32(methodsDecrypter.Detected) +
-					toInt32(hasMetadataStream("Babel"));
+			int sum = ToInt32(resourceResolver.Detected) +
+					ToInt32(assemblyResolver.Detected) +
+					ToInt32(stringDecrypter.Detected) +
+					ToInt32(constantsDecrypter.Detected) +
+					ToInt32(proxyCallFixer.Detected) +
+					ToInt32(methodsDecrypter.Detected) +
+					ToInt32(HasMetadataStream("Babel"));
 			if (sum > 0)
 				val += 100 + 10 * (sum - 1);
 			if (foundBabelAttribute)
@@ -154,35 +154,35 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return val;
 		}
 
-		protected override void scanForObfuscator() {
-			findBabelAttribute();
+		protected override void ScanForObfuscator() {
+			FindBabelAttribute();
 			var resourceDecrypterCreator = new ResourceDecrypterCreator(module, DeobfuscatedFile);
-			resourceResolver = new ResourceResolver(module, resourceDecrypterCreator.create(), DeobfuscatedFile);
-			resourceResolver.find();
-			assemblyResolver = new AssemblyResolver(module, resourceDecrypterCreator.create());
-			assemblyResolver.find();
-			stringDecrypter = new StringDecrypter(module, resourceDecrypterCreator.create());
-			stringDecrypter.find(DeobfuscatedFile);
-			constantsDecrypter = new ConstantsDecrypter(module, resourceDecrypterCreator.create(), initializedDataCreator);
-			constantsDecrypter.find();
+			resourceResolver = new ResourceResolver(module, resourceDecrypterCreator.Create(), DeobfuscatedFile);
+			resourceResolver.Find();
+			assemblyResolver = new AssemblyResolver(module, resourceDecrypterCreator.Create());
+			assemblyResolver.Find();
+			stringDecrypter = new StringDecrypter(module, resourceDecrypterCreator.Create());
+			stringDecrypter.Find(DeobfuscatedFile);
+			constantsDecrypter = new ConstantsDecrypter(module, resourceDecrypterCreator.Create(), initializedDataCreator);
+			constantsDecrypter.Find();
 			proxyCallFixer = new ProxyCallFixer(module);
-			proxyCallFixer.findDelegateCreator();
-			methodsDecrypter = new MethodsDecrypter(module, resourceDecrypterCreator.create(), DeobfuscatedFile.DeobfuscatorContext);
-			methodsDecrypter.find();
+			proxyCallFixer.FindDelegateCreator();
+			methodsDecrypter = new MethodsDecrypter(module, resourceDecrypterCreator.Create(), DeobfuscatedFile.DeobfuscatorContext);
+			methodsDecrypter.Find();
 		}
 
-		void findBabelAttribute() {
+		void FindBabelAttribute() {
 			foreach (var type in module.Types) {
 				if (type.FullName == "BabelAttribute" || type.FullName == "BabelObfuscatorAttribute") {
 					foundBabelAttribute = true;
-					checkVersion(type);
-					addAttributeToBeRemoved(type, "Obfuscator attribute");
+					CheckVersion(type);
+					AddAttributeToBeRemoved(type, "Obfuscator attribute");
 					return;
 				}
 			}
 		}
 
-		void checkVersion(TypeDef attr) {
+		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+)$");
@@ -193,107 +193,107 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			}
 		}
 
-		public override void deobfuscateBegin() {
-			base.deobfuscateBegin();
+		public override void DeobfuscateBegin() {
+			base.DeobfuscateBegin();
 
 			if (options.DecryptResources) {
-				addCctorInitCallToBeRemoved(resourceResolver.InitMethod);
-				addTypeToBeRemoved(resourceResolver.Type, "Resource resolver type");
+				AddCctorInitCallToBeRemoved(resourceResolver.InitMethod);
+				AddTypeToBeRemoved(resourceResolver.Type, "Resource resolver type");
 			}
 
-			decryptResources();
-			stringDecrypter.initialize();
+			DecryptResources();
+			stringDecrypter.Initialize();
 
 			if (Operations.DecryptStrings != OpDecryptString.None) {
 				if (stringDecrypter.Resource != null)
-					Logger.v("Adding string decrypter. Resource: {0}", Utils.toCsharpString(stringDecrypter.Resource.Name));
-				staticStringInliner.add(stringDecrypter.DecryptMethod, (method, gim, args) => {
-					return stringDecrypter.decrypt(args);
+					Logger.v("Adding string decrypter. Resource: {0}", Utils.ToCsharpString(stringDecrypter.Resource.Name));
+				staticStringInliner.Add(stringDecrypter.DecryptMethod, (method, gim, args) => {
+					return stringDecrypter.Decrypt(args);
 				});
-				DeobfuscatedFile.stringDecryptersAdded();
+				DeobfuscatedFile.StringDecryptersAdded();
 			}
 
 			if (options.DumpEmbeddedAssemblies) {
-				assemblyResolver.initialize(DeobfuscatedFile, this);
+				assemblyResolver.Initialize(DeobfuscatedFile, this);
 
 				// Need to dump the assemblies before decrypting methods in case there's a reference
 				// in the encrypted code to one of these assemblies.
-				dumpEmbeddedAssemblies();
+				DumpEmbeddedAssemblies();
 			}
 
 			if (options.DecryptMethods) {
-				methodsDecrypter.initialize(DeobfuscatedFile, this);
+				methodsDecrypter.Initialize(DeobfuscatedFile, this);
 				methodsDecrypter.decrypt();
 			}
 
 			if (options.DecryptConstants) {
-				constantsDecrypter.initialize(DeobfuscatedFile, this);
+				constantsDecrypter.Initialize(DeobfuscatedFile, this);
 
-				addTypeToBeRemoved(constantsDecrypter.Type, "Constants decrypter type");
-				addResourceToBeRemoved(constantsDecrypter.Resource, "Encrypted constants");
+				AddTypeToBeRemoved(constantsDecrypter.Type, "Constants decrypter type");
+				AddResourceToBeRemoved(constantsDecrypter.Resource, "Encrypted constants");
 				int32ValueInliner = new Int32ValueInliner();
-				int32ValueInliner.add(constantsDecrypter.Int32Decrypter, (method, gim, args) => constantsDecrypter.decryptInt32((int)args[0]));
+				int32ValueInliner.Add(constantsDecrypter.Int32Decrypter, (method, gim, args) => constantsDecrypter.DecryptInt32((int)args[0]));
 				int64ValueInliner = new Int64ValueInliner();
-				int64ValueInliner.add(constantsDecrypter.Int64Decrypter, (method, gim, args) => constantsDecrypter.decryptInt64((int)args[0]));
+				int64ValueInliner.Add(constantsDecrypter.Int64Decrypter, (method, gim, args) => constantsDecrypter.DecryptInt64((int)args[0]));
 				singleValueInliner = new SingleValueInliner();
-				singleValueInliner.add(constantsDecrypter.SingleDecrypter, (method, gim, args) => constantsDecrypter.decryptSingle((int)args[0]));
+				singleValueInliner.Add(constantsDecrypter.SingleDecrypter, (method, gim, args) => constantsDecrypter.DecryptSingle((int)args[0]));
 				doubleValueInliner = new DoubleValueInliner();
-				doubleValueInliner.add(constantsDecrypter.DoubleDecrypter, (method, gim, args) => constantsDecrypter.decryptDouble((int)args[0]));
+				doubleValueInliner.Add(constantsDecrypter.DoubleDecrypter, (method, gim, args) => constantsDecrypter.DecryptDouble((int)args[0]));
 			}
 
-			proxyCallFixer.find();
+			proxyCallFixer.Find();
 			startedDeobfuscating = true;
 		}
 
-		void dumpEmbeddedAssemblies() {
+		void DumpEmbeddedAssemblies() {
 			if (!options.DumpEmbeddedAssemblies)
 				return;
 			foreach (var info in assemblyResolver.EmbeddedAssemblyInfos)
-				DeobfuscatedFile.createAssemblyFile(info.data, Utils.getAssemblySimpleName(info.fullname), info.extension);
-			addTypeToBeRemoved(assemblyResolver.Type, "Assembly resolver type");
-			addCctorInitCallToBeRemoved(assemblyResolver.InitMethod);
-			addResourceToBeRemoved(assemblyResolver.EncryptedResource, "Embedded encrypted assemblies");
+				DeobfuscatedFile.CreateAssemblyFile(info.data, Utils.GetAssemblySimpleName(info.fullname), info.extension);
+			AddTypeToBeRemoved(assemblyResolver.Type, "Assembly resolver type");
+			AddCctorInitCallToBeRemoved(assemblyResolver.InitMethod);
+			AddResourceToBeRemoved(assemblyResolver.EncryptedResource, "Embedded encrypted assemblies");
 		}
 
-		void decryptResources() {
+		void DecryptResources() {
 			if (!options.DecryptResources)
 				return;
-			var rsrc = resourceResolver.mergeResources();
+			var rsrc = resourceResolver.MergeResources();
 			if (rsrc == null)
 				return;
-			addResourceToBeRemoved(rsrc, "Encrypted resources");
+			AddResourceToBeRemoved(rsrc, "Encrypted resources");
 		}
 
-		public override void deobfuscateMethodEnd(Blocks blocks) {
-			proxyCallFixer.deobfuscate(blocks);
+		public override void DeobfuscateMethodEnd(Blocks blocks) {
+			proxyCallFixer.Deobfuscate(blocks);
 			if (options.DecryptConstants) {
-				int32ValueInliner.decrypt(blocks);
-				int64ValueInliner.decrypt(blocks);
-				singleValueInliner.decrypt(blocks);
-				doubleValueInliner.decrypt(blocks);
-				constantsDecrypter.deobfuscate(blocks);
+				int32ValueInliner.Decrypt(blocks);
+				int64ValueInliner.Decrypt(blocks);
+				singleValueInliner.Decrypt(blocks);
+				doubleValueInliner.Decrypt(blocks);
+				constantsDecrypter.Deobfuscate(blocks);
 			}
-			base.deobfuscateMethodEnd(blocks);
+			base.DeobfuscateMethodEnd(blocks);
 		}
 
-		public override void deobfuscateEnd() {
-			removeInlinedMethods();
+		public override void DeobfuscateEnd() {
+			RemoveInlinedMethods();
 			if (CanRemoveStringDecrypterType) {
-				addResourceToBeRemoved(stringDecrypter.Resource, "Encrypted strings");
-				addTypeToBeRemoved(stringDecrypter.Type, "String decrypter type");
+				AddResourceToBeRemoved(stringDecrypter.Resource, "Encrypted strings");
+				AddTypeToBeRemoved(stringDecrypter.Type, "String decrypter type");
 			}
 
-			removeProxyDelegates(proxyCallFixer);
-			base.deobfuscateEnd();
+			RemoveProxyDelegates(proxyCallFixer);
+			base.DeobfuscateEnd();
 		}
 
-		void removeInlinedMethods() {
+		void RemoveInlinedMethods() {
 			if (!options.InlineMethods || !options.RemoveInlinedMethods)
 				return;
-			removeInlinedMethods(BabelMethodCallInliner.find(module, staticStringInliner.Methods));
+			RemoveInlinedMethods(BabelMethodCallInliner.Find(module, staticStringInliner.Methods));
 		}
 
-		public override IEnumerable<int> getStringDecrypterMethods() {
+		public override IEnumerable<int> GetStringDecrypterMethods() {
 			var list = new List<int>();
 			if (stringDecrypter.DecryptMethod != null)
 				list.Add(stringDecrypter.DecryptMethod.MDToken.ToInt32());
diff --git a/de4dot.code/deobfuscators/Babel_NET/ImageReader.cs b/de4dot.code/deobfuscators/Babel_NET/ImageReader.cs
index ba864f93..4051a703 100644
--- a/de4dot.code/deobfuscators/Babel_NET/ImageReader.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/ImageReader.cs
@@ -63,53 +63,53 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			this.memberRefConverter = new MemberRefConverter(module);
 		}
 
-		public bool initialize() {
+		public bool Initialize() {
 			if (reader.ReadInt32() != METHODS_SIG)
 				return false;
 
-			int metadataOffset = getMetadataOffset();
+			int metadataOffset = GetMetadataOffset();
 			if (metadataOffset < 0)
 				return false;
 			long pos = metadataOffset + 4;
 			reader.Position = pos;
 			int version = reader.ReadInt16();	// major, minor
 			if (version == 0x0001) {
-				initializeV10();
+				InitializeV10();
 				return true;
 			}
 
 			reader.Position = pos;
-			initializeV55();
+			InitializeV55();
 			return true;
 		}
 
-		void initializeV10() {
+		void InitializeV10() {
 			reader.ReadInt16();
 			int methodNamesOffset = (int)reader.ReadInt64();
 			int typeRefsOffset = (int)reader.ReadInt64();
 			int assemblyRefsOffset = (int)reader.ReadInt64();
 			int stringsOffset = (int)reader.ReadInt64();
 
-			initializeStrings(stringsOffset);
-			initializeAssemblyNames(assemblyRefsOffset);
-			initializeMethodNames(methodNamesOffset);
-			initializeTypeRefs(typeRefsOffset);
+			InitializeStrings(stringsOffset);
+			InitializeAssemblyNames(assemblyRefsOffset);
+			InitializeMethodNames(methodNamesOffset);
+			InitializeTypeRefs(typeRefsOffset);
 		}
 
-		void initializeV55() {
+		void InitializeV55() {
 			int methodNamesOffset = (int)reader.ReadInt64() ^ METADATA_SIG;
 			int typeRefsOffset = (int)reader.ReadInt64() ^ (METADATA_SIG << 1);
 			int assemblyRefsOffset = (int)reader.ReadInt64() ^ ((METADATA_SIG << 1) + 1);
 			int stringsOffset = (int)reader.ReadInt64() ^ (((METADATA_SIG << 1) + 1) << 1);
 
-			initializeStrings(stringsOffset);
-			initializeAssemblyNames(assemblyRefsOffset);
-			initializeMethodNames(methodNamesOffset);
-			initializeTypeRefs(typeRefsOffset);
+			InitializeStrings(stringsOffset);
+			InitializeAssemblyNames(assemblyRefsOffset);
+			InitializeMethodNames(methodNamesOffset);
+			InitializeTypeRefs(typeRefsOffset);
 		}
 
-		public void restore(string name, MethodDef method) {
-			var babelMethod = getMethod(name);
+		public void Restore(string name, MethodDef method) {
+			var babelMethod = GetMethod(name);
 			var body = method.Body;
 
 			body.MaxStack = babelMethod.MaxStack;
@@ -138,56 +138,56 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				body.ExceptionHandlers.Add(eh);
 		}
 
-		BabelMethodDef getMethod(string name) {
+		BabelMethodDef GetMethod(string name) {
 			int offset = methodOffsets[name];
 			methodOffsets.Remove(name);
 			reader.Position = offset;
-			return new MethodDefReader(this, reader).read();
+			return new MethodDefReader(this, reader).Read();
 		}
 
-		public string readString() {
-			return strings[readVariableLengthInt32()];
+		public string ReadString() {
+			return strings[ReadVariableLengthInt32()];
 		}
 
-		public TypeSig readTypeSig() {
-			return typeRefs[readVariableLengthInt32()];
+		public TypeSig ReadTypeSig() {
+			return typeRefs[ReadVariableLengthInt32()];
 		}
 
-		public TypeSig[] readTypeSigs() {
-			var refs = new TypeSig[readVariableLengthInt32()];
+		public TypeSig[] ReadTypeSigs() {
+			var refs = new TypeSig[ReadVariableLengthInt32()];
 			for (int i = 0; i < refs.Length; i++)
-				refs[i] = readTypeSig();
+				refs[i] = ReadTypeSig();
 			return refs;
 		}
 
-		public IField readFieldRef() {
-			var name = readString();
-			var declaringType = readTypeSig();
+		public IField ReadFieldRef() {
+			var name = ReadString();
+			var declaringType = ReadTypeSig();
 
-			var fields = getFields(resolve(declaringType), name);
+			var fields = GetFields(Resolve(declaringType), name);
 			if (fields == null || fields.Count != 1) {
 				throw new ApplicationException(string.Format("Couldn't find one field named '{0}' in type {1}",
 								name,
-								Utils.removeNewlines(declaringType)));
+								Utils.RemoveNewlines(declaringType)));
 			}
 
-			return memberRefConverter.convert(fields[0]);
+			return memberRefConverter.Convert(fields[0]);
 		}
 
-		static List<FieldDef> getFields(TypeDef type, string name) {
+		static List<FieldDef> GetFields(TypeDef type, string name) {
 			if (type == null)
 				return null;
 			return new List<FieldDef>(type.FindFields(name));
 		}
 
-		public IMethod readMethodRef() {
-			var babelMethodRef = new MethodRefReader(this, reader).read();
+		public IMethod ReadMethodRef() {
+			var babelMethodRef = new MethodRefReader(this, reader).Read();
 
-			var method = getMethodRef(babelMethodRef);
+			var method = GetMethodRef(babelMethodRef);
 			if (method == null) {
 				throw new ApplicationException(string.Format("Could not find method '{0}' in type '{1}'",
-							Utils.removeNewlines(babelMethodRef.Name),
-							Utils.removeNewlines(babelMethodRef.DeclaringType)));
+							Utils.RemoveNewlines(babelMethodRef.Name),
+							Utils.RemoveNewlines(babelMethodRef.DeclaringType)));
 			}
 
 			var git = babelMethodRef.DeclaringType.ToGenericInstSig();
@@ -198,33 +198,33 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return module.UpdateRowId(mr);
 		}
 
-		IMethod getMethodRef(BabelMethodreference babelMethodRef) {
-			var declaringType = resolve(babelMethodRef.DeclaringType);
+		IMethod GetMethodRef(BabelMethodreference babelMethodRef) {
+			var declaringType = Resolve(babelMethodRef.DeclaringType);
 			if (declaringType == null)
 				return null;
 
-			var methods = getMethods(declaringType, babelMethodRef);
+			var methods = GetMethods(declaringType, babelMethodRef);
 			if (methods.Count != 1) {
 				throw new ApplicationException(string.Format("Couldn't find one method named '{0}' in type {1}",
 								babelMethodRef.Name,
-								Utils.removeNewlines(declaringType)));
+								Utils.RemoveNewlines(declaringType)));
 			}
 
 			return methods[0];
 		}
 
-		List<IMethod> getMethods(TypeDef declaringType, BabelMethodreference babelMethodRef) {
+		List<IMethod> GetMethods(TypeDef declaringType, BabelMethodreference babelMethodRef) {
 			var methods = new List<IMethod>();
 
 			var gis = babelMethodRef.DeclaringType as GenericInstSig;
 			var gim = babelMethodRef.GenericArguments;
 			foreach (var method in declaringType.Methods) {
-				if (compareMethod(GenericArgsSubstitutor.create(method, gis, gim), babelMethodRef)) {
+				if (CompareMethod(GenericArgsSubstitutor.Create(method, gis, gim), babelMethodRef)) {
 					if (!babelMethodRef.IsGenericMethod)
-						methods.Add(memberRefConverter.convert(method));
+						methods.Add(memberRefConverter.Convert(method));
 					else {
 						var gim2 = new GenericInstMethodSig(babelMethodRef.GenericArguments);
-						var ms = module.UpdateRowId(new MethodSpecUser(memberRefConverter.convert(method), gim2));
+						var ms = module.UpdateRowId(new MethodSpecUser(memberRefConverter.Convert(method), gim2));
 						methods.Add(ms);
 					}
 				}
@@ -233,7 +233,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return methods;
 		}
 
-		bool compareMethod(IMethod method, BabelMethodreference babelMethodRef) {
+		bool CompareMethod(IMethod method, BabelMethodreference babelMethodRef) {
 			var sig = method.MethodSig;
 			if (sig.Params.Count != babelMethodRef.Parameters.Length)
 				return false;
@@ -255,7 +255,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return true;
 		}
 
-		TypeDef resolve(TypeSig type) {
+		TypeDef Resolve(TypeSig type) {
 			type = type.RemovePinnedAndModifiers();
 
 			var gis = type as GenericInstSig;
@@ -277,15 +277,15 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return null;
 		}
 
-		public MethodSig readCallSite() {
-			var returnType = readTypeSig();
-			var paramTypes = readTypeSigs();
+		public MethodSig ReadCallSite() {
+			var returnType = ReadTypeSig();
+			var paramTypes = ReadTypeSigs();
 			var callingConvention = (CR.CallingConvention)reader.ReadInt32();
 
-			return new MethodSig(convertCallingConvention(callingConvention), 0, returnType, paramTypes);
+			return new MethodSig(ConvertCallingConvention(callingConvention), 0, returnType, paramTypes);
 		}
 
-		static DR.CallingConvention convertCallingConvention(CR.CallingConvention callingConvention) {
+		static DR.CallingConvention ConvertCallingConvention(CR.CallingConvention callingConvention) {
 			switch (callingConvention) {
 			case CR.CallingConvention.Winapi:	return DR.CallingConvention.Default;
 			case CR.CallingConvention.Cdecl:	return DR.CallingConvention.C;
@@ -296,40 +296,40 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			}
 		}
 
-		void initializeStrings(int headerOffset) {
+		void InitializeStrings(int headerOffset) {
 			reader.Position = headerOffset;
 			if (reader.ReadInt32() != STRINGS_SIG)
 				throw new ApplicationException("Invalid strings sig");
 
-			strings = new string[readVariableLengthInt32()];
+			strings = new string[ReadVariableLengthInt32()];
 			for (int i = 0; i < strings.Length; i++)
 				strings[i] = reader.ReadString();
 		}
 
-		void initializeAssemblyNames(int headerOffset) {
+		void InitializeAssemblyNames(int headerOffset) {
 			reader.Position = headerOffset;
 			if (reader.ReadInt32() != ASSEMBLY_NAMES_SIG)
 				throw new ApplicationException("Invalid assembly names sig");
 
-			assemblyNames = new AssemblyRef[readVariableLengthInt32()];
+			assemblyNames = new AssemblyRef[ReadVariableLengthInt32()];
 			for (int i = 0; i < assemblyNames.Length; i++)
-				assemblyNames[i] = module.UpdateRowId(new AssemblyRefUser(new AssemblyNameInfo(readString())));
+				assemblyNames[i] = module.UpdateRowId(new AssemblyRefUser(new AssemblyNameInfo(ReadString())));
 		}
 
-		void initializeMethodNames(int headerOffset) {
+		void InitializeMethodNames(int headerOffset) {
 			reader.Position = headerOffset;
 			if (reader.ReadInt32() != METHOD_NAMES_SIG)
 				throw new ApplicationException("Invalid methods sig");
 
-			int numMethods = readVariableLengthInt32();
+			int numMethods = ReadVariableLengthInt32();
 			methodOffsets = new Dictionary<string, int>(numMethods, StringComparer.Ordinal);
 			for (int i = 0; i < numMethods; i++) {
-				var methodName = readString();
-				methodOffsets[methodName] = readVariableLengthInt32();
+				var methodName = ReadString();
+				methodOffsets[methodName] = ReadVariableLengthInt32();
 			}
 		}
 
-		void initializeTypeRefs(int headerOffset) {
+		void InitializeTypeRefs(int headerOffset) {
 			reader.Position = headerOffset;
 			if (reader.ReadInt32() != TYPEREFS_SIG)
 				throw new ApplicationException("Invalid typerefs sig");
@@ -342,26 +342,26 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				TypeId typeId = (TypeId)reader.ReadByte();
 				switch (typeId) {
 				case TypeId.TypeRef:
-					typeRefs.Add(readTypeRef());
+					typeRefs.Add(ReadTypeRef());
 					break;
 
 				case TypeId.GenericInstance:
 					List<int> genericArgs;
-					var git = readGenericInstanceType(out genericArgs);
+					var git = ReadGenericInstanceType(out genericArgs);
 					typeRefs.Add(git);
 					genericArgFixes[git] = genericArgs;
 					break;
 
 				case TypeId.Pointer:
-					typeRefs.Add(readPointerType());
+					typeRefs.Add(ReadPointerType());
 					break;
 
 				case TypeId.Array:
-					typeRefs.Add(readArrayType());
+					typeRefs.Add(ReadArrayType());
 					break;
 
 				case TypeId.ByRef:
-					typeRefs.Add(readByRefType());
+					typeRefs.Add(ReadByRefType());
 					break;
 
 				default:
@@ -376,21 +376,21 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			}
 		}
 
-		TypeSig readTypeRef() {
+		TypeSig ReadTypeRef() {
 			string ns, name;
-			parseReflectionTypeName(readString(), out ns, out name);
-			var asmRef = assemblyNames[readVariableLengthInt32()];
-			var declaringType = readTypeSig();
+			ParseReflectionTypeName(ReadString(), out ns, out name);
+			var asmRef = assemblyNames[ReadVariableLengthInt32()];
+			var declaringType = ReadTypeSig();
 			var typeRef = new TypeRefUser(module, ns, name);
 			if (declaringType != null)
-				typeRef.ResolutionScope = getTypeRef(declaringType);
+				typeRef.ResolutionScope = GetTypeRef(declaringType);
 			else
 				typeRef.ResolutionScope = asmRef;
 
-			return memberRefConverter.convert(typeRef);
+			return memberRefConverter.Convert(typeRef);
 		}
 
-		TypeRef getTypeRef(TypeSig type) {
+		TypeRef GetTypeRef(TypeSig type) {
 			var tdr = type as TypeDefOrRefSig;
 			if (tdr == null)
 				throw new ApplicationException("Not a type ref");
@@ -402,27 +402,27 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			throw new ApplicationException("Not a type ref");
 		}
 
-		static void parseReflectionTypeName(string fullName, out string ns, out string name) {
-			int index = getLastChar(fullName, '.');
+		static void ParseReflectionTypeName(string fullName, out string ns, out string name) {
+			int index = GetLastChar(fullName, '.');
 			if (index < 0) {
 				ns = "";
 				name = fullName;
 			}
 			else {
-				ns = unEscape(fullName.Substring(0, index));
+				ns = UnEscape(fullName.Substring(0, index));
 				name = fullName.Substring(index + 1);
 			}
 
-			index = getLastChar(name, '+');
+			index = GetLastChar(name, '+');
 			if (index < 0)
-				name = unEscape(name);
+				name = UnEscape(name);
 			else {
 				ns = "";
-				name = unEscape(name.Substring(index + 1));
+				name = UnEscape(name.Substring(index + 1));
 			}
 		}
 
-		static int getLastChar(string name, char c) {
+		static int GetLastChar(string name, char c) {
 			if (string.IsNullOrEmpty(name))
 				return -1;
 			int index = name.Length - 1;
@@ -438,7 +438,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			}
 		}
 
-		static string unEscape(string s) {
+		static string UnEscape(string s) {
 			var sb = new StringBuilder(s.Length);
 			for (int i = 0; i < s.Length; i++) {
 				if (s[i] == '\\' && i + 1 < s.Length)
@@ -448,44 +448,44 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return sb.ToString();
 		}
 
-		GenericInstSig readGenericInstanceType(out List<int> genericArgs) {
-			var git = new GenericInstSig(readTypeSig() as ClassOrValueTypeSig);
-			int numArgs = readVariableLengthInt32();
+		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++)
-				genericArgs.Add(readVariableLengthInt32());
+				genericArgs.Add(ReadVariableLengthInt32());
 			return git;
 		}
 
-		PtrSig readPointerType() {
-			return new PtrSig(readTypeSig());
+		PtrSig ReadPointerType() {
+			return new PtrSig(ReadTypeSig());
 		}
 
-		TypeSig readArrayType() {
-			var typeSig = readTypeSig();
-			int rank = readVariableLengthInt32();
+		TypeSig ReadArrayType() {
+			var typeSig = ReadTypeSig();
+			int rank = ReadVariableLengthInt32();
 			if (rank == 1)
 				return new SZArraySig(typeSig);
 			return new ArraySig(typeSig, rank);
 		}
 
-		ByRefSig readByRefType() {
-			return new ByRefSig(readTypeSig());
+		ByRefSig ReadByRefType() {
+			return new ByRefSig(ReadTypeSig());
 		}
 
-		public uint readVariableLengthUInt32() {
+		public uint ReadVariableLengthUInt32() {
 			uint val;
 			reader.ReadCompressedUInt32(out val);
 			return val;
 		}
 
-		public int readVariableLengthInt32() {
+		public int ReadVariableLengthInt32() {
 			uint val;
 			reader.ReadCompressedUInt32(out val);
 			return (int)val;
 		}
 
-		int getMetadataOffset() {
+		int GetMetadataOffset() {
 			reader.Position = reader.Length - 4;
 			for (int i = 0; i < 30; i++) {
 				if (reader.ReadInt32() == METADATA_SIG)
diff --git a/de4dot.code/deobfuscators/Babel_NET/InflaterCreator.cs b/de4dot.code/deobfuscators/Babel_NET/InflaterCreator.cs
index 38493606..be9e0a6f 100644
--- a/de4dot.code/deobfuscators/Babel_NET/InflaterCreator.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/InflaterCreator.cs
@@ -24,33 +24,33 @@ using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Babel_NET {
 	class InflaterCreator {
-		public static Inflater create(MethodDef method, bool noHeader) {
-			return create(findInflaterType(method), noHeader);
+		public static Inflater Create(MethodDef method, bool noHeader) {
+			return Create(FindInflaterType(method), noHeader);
 		}
 
-		public static Inflater create(TypeDef inflaterType, bool noHeader) {
+		public static Inflater Create(TypeDef inflaterType, bool noHeader) {
 			if (inflaterType == null)
-				return createNormal(noHeader);
-			var initHeaderMethod = findInitHeaderMethod(inflaterType);
+				return CreateNormal(noHeader);
+			var initHeaderMethod = FindInitHeaderMethod(inflaterType);
 			if (initHeaderMethod == null)
-				return createNormal(noHeader, "Could not find inflater init header method");
-			var magic = getMagic(initHeaderMethod);
+				return CreateNormal(noHeader, "Could not find inflater init header method");
+			var magic = GetMagic(initHeaderMethod);
 			if (!magic.HasValue)
-				return createNormal(noHeader);
+				return CreateNormal(noHeader);
 			return new BabelInflater(noHeader, magic.Value);
 		}
 
-		static Inflater createNormal(bool noHeader) {
-			return createNormal(noHeader, null);
+		static Inflater CreateNormal(bool noHeader) {
+			return CreateNormal(noHeader, null);
 		}
 
-		static Inflater createNormal(bool noHeader, string errorMessage) {
+		static Inflater CreateNormal(bool noHeader, string errorMessage) {
 			if (errorMessage != null)
 				Logger.w("{0}", errorMessage);
 			return new Inflater(noHeader);
 		}
 
-		static TypeDef findInflaterType(MethodDef method) {
+		static TypeDef FindInflaterType(MethodDef method) {
 			if (method == null || method.Body == null)
 				return null;
 			foreach (var instr in method.Body.Instructions) {
@@ -62,7 +62,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 
 				var type = calledMethod.DeclaringType;
 				foreach (var nested in type.NestedTypes) {
-					if (DeobUtils.hasInteger(nested.FindMethod(".ctor"), 0x8001))
+					if (DeobUtils.HasInteger(nested.FindMethod(".ctor"), 0x8001))
 						return type;
 				}
 			}
@@ -70,20 +70,20 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return null;
 		}
 
-		static MethodDef findInitHeaderMethod(TypeDef inflaterType) {
+		static MethodDef FindInitHeaderMethod(TypeDef inflaterType) {
 			foreach (var nested in inflaterType.NestedTypes) {
-				var method = findInitHeaderMethod2(nested);
+				var method = FindInitHeaderMethod2(nested);
 				if (method != null)
 					return method;
 			}
 			return null;
 		}
 
-		static MethodDef findInitHeaderMethod2(TypeDef nested) {
+		static MethodDef FindInitHeaderMethod2(TypeDef nested) {
 			foreach (var method in nested.Methods) {
 				if (method.IsStatic || method.Body == null)
 					continue;
-				if (!DotNetUtils.isMethod(method, "System.Boolean", "()"))
+				if (!DotNetUtils.IsMethod(method, "System.Boolean", "()"))
 					continue;
 
 				return method;
@@ -92,7 +92,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return null;
 		}
 
-		static int? getMagic(MethodDef method) {
+		static int? GetMagic(MethodDef method) {
 			if (method == null || method.Body == null)
 				return null;
 			var instrs = method.Body.Instructions;
diff --git a/de4dot.code/deobfuscators/Babel_NET/MemberReferenceConverter.cs b/de4dot.code/deobfuscators/Babel_NET/MemberReferenceConverter.cs
index 0a6aadf0..90e02215 100644
--- a/de4dot.code/deobfuscators/Babel_NET/MemberReferenceConverter.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/MemberReferenceConverter.cs
@@ -34,64 +34,64 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			this.module = module;
 		}
 
-		bool isInOurModule(IMemberRef memberRef) {
+		bool IsInOurModule(IMemberRef memberRef) {
 			return memberRef.Module == module;
 		}
 
-		Importer createImporter() {
+		Importer CreateImporter() {
 			return new Importer(module, ImporterOptions.TryToUseTypeDefs);
 		}
 
-		public TypeSig convert(TypeRef typeRef) {
-			return createImporter().Import(typeRef).ToTypeSig();
+		public TypeSig Convert(TypeRef typeRef) {
+			return CreateImporter().Import(typeRef).ToTypeSig();
 		}
 
-		ITypeDefOrRef convert(ITypeDefOrRef tdr) {
-			return (ITypeDefOrRef)createImporter().Import(tdr);
+		ITypeDefOrRef Convert(ITypeDefOrRef tdr) {
+			return (ITypeDefOrRef)CreateImporter().Import(tdr);
 		}
 
-		TypeSig convert2(TypeSig ts) {
-			return createImporter().Import(ts);
+		TypeSig Convert2(TypeSig ts) {
+			return CreateImporter().Import(ts);
 		}
 
-		public TypeSig convert(TypeSig ts) {
-			return createImporter().Import(ts);
+		public TypeSig Convert(TypeSig ts) {
+			return CreateImporter().Import(ts);
 		}
 
-		public IField convert(IField fieldRef) {
-			if (isInOurModule(fieldRef))
-				return tryGetFieldDef(fieldRef);
-			return createImporter().Import(fieldRef);
+		public IField Convert(IField fieldRef) {
+			if (IsInOurModule(fieldRef))
+				return TryGetFieldDef(fieldRef);
+			return CreateImporter().Import(fieldRef);
 		}
 
-		public IMethodDefOrRef convert(IMethod methodRef) {
+		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 (IMethodDefOrRef)tryGetMethodDef(methodRef);
-			return (IMethodDefOrRef)createImporter().Import(methodRef);
+			if (IsInOurModule(methodRef))
+				return (IMethodDefOrRef)TryGetMethodDef(methodRef);
+			return (IMethodDefOrRef)CreateImporter().Import(methodRef);
 		}
 
-		public IField tryGetFieldDef(IField fieldRef) {
+		public IField TryGetFieldDef(IField fieldRef) {
 			var fieldDef = fieldRef as FieldDef;
 			if (fieldDef != null)
 				return fieldDef;
 
-			var declaringType = DotNetUtils.getType(module, fieldRef.DeclaringType);
+			var declaringType = DotNetUtils.GetType(module, fieldRef.DeclaringType);
 			if (declaringType == null)
 				return fieldRef;
-			return DotNetUtils.getField(declaringType, fieldRef);
+			return DotNetUtils.GetField(declaringType, fieldRef);
 		}
 
-		public IMethod tryGetMethodDef(IMethod methodRef) {
+		public IMethod TryGetMethodDef(IMethod methodRef) {
 			var methodDef = methodRef as MethodDef;
 			if (methodDef != null)
 				return methodDef;
 
-			var declaringType = DotNetUtils.getType(module, methodRef.DeclaringType);
+			var declaringType = DotNetUtils.GetType(module, methodRef.DeclaringType);
 			if (declaringType == null)
 				return methodRef;
-			return DotNetUtils.getMethod(declaringType, methodRef);
+			return DotNetUtils.GetMethod(declaringType, methodRef);
 		}
 	}
 }
diff --git a/de4dot.code/deobfuscators/Babel_NET/MethodBodyReader.cs b/de4dot.code/deobfuscators/Babel_NET/MethodBodyReader.cs
index 05ad6833..6f0a9d19 100644
--- a/de4dot.code/deobfuscators/Babel_NET/MethodBodyReader.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/MethodBodyReader.cs
@@ -35,58 +35,58 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			this.imageReader = imageReader;
 		}
 
-		public void read(IList<Parameter> parameters) {
+		public void Read(IList<Parameter> parameters) {
 			this.parameters = parameters;
 			Flags2 = reader.ReadInt16();
 			MaxStack = reader.ReadUInt16();
-			SetLocals(imageReader.readTypeSigs());
-			ReadInstructions(imageReader.readVariableLengthInt32());
-			readExceptionHandlers(imageReader.readVariableLengthInt32());
+			SetLocals(imageReader.ReadTypeSigs());
+			ReadInstructions(imageReader.ReadVariableLengthInt32());
+			ReadExceptionHandlers(imageReader.ReadVariableLengthInt32());
 		}
 
 		protected override IField ReadInlineField(Instruction instr) {
-			return imageReader.readFieldRef();
+			return imageReader.ReadFieldRef();
 		}
 
 		protected override IMethod ReadInlineMethod(Instruction instr) {
-			return imageReader.readMethodRef();
+			return imageReader.ReadMethodRef();
 		}
 
 		protected override MethodSig ReadInlineSig(Instruction instr) {
-			return imageReader.readCallSite();
+			return imageReader.ReadCallSite();
 		}
 
 		protected override string ReadInlineString(Instruction instr) {
-			return imageReader.readString();
+			return imageReader.ReadString();
 		}
 
 		protected override ITokenOperand ReadInlineTok(Instruction instr) {
 			switch (reader.ReadByte()) {
-			case 0: return imageReader.readTypeSig().ToTypeDefOrRef();
-			case 1: return imageReader.readFieldRef();
-			case 2: return imageReader.readMethodRef();
+			case 0: return imageReader.ReadTypeSig().ToTypeDefOrRef();
+			case 1: return imageReader.ReadFieldRef();
+			case 2: return imageReader.ReadMethodRef();
 			default: throw new ApplicationException("Unknown token type");
 			}
 		}
 
 		protected override ITypeDefOrRef ReadInlineType(Instruction instr) {
-			return imageReader.readTypeSig().ToTypeDefOrRef();
+			return imageReader.ReadTypeSig().ToTypeDefOrRef();
 		}
 
-		void readExceptionHandlers(int numExceptionHandlers) {
+		void ReadExceptionHandlers(int numExceptionHandlers) {
 			exceptionHandlers = new List<ExceptionHandler>(numExceptionHandlers);
 			for (int i = 0; i < numExceptionHandlers; i++)
-				Add(readExceptionHandler());
+				Add(ReadExceptionHandler());
 		}
 
-		ExceptionHandler readExceptionHandler() {
+		ExceptionHandler ReadExceptionHandler() {
 			var ehType = (ExceptionHandlerType)reader.ReadByte();
-			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();
+			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 = GetInstructionThrow(tryOffset);
diff --git a/de4dot.code/deobfuscators/Babel_NET/MethodReferenceReader.cs b/de4dot.code/deobfuscators/Babel_NET/MethodReferenceReader.cs
index 64dc23db..e2dfd417 100644
--- a/de4dot.code/deobfuscators/Babel_NET/MethodReferenceReader.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/MethodReferenceReader.cs
@@ -77,7 +77,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			}
 		}
 
-		public void setBody(MethodBodyReader mbr) {
+		public void SetBody(MethodBodyReader mbr) {
 			Flags2 = mbr.Flags2;
 			MaxStack = mbr.MaxStack;
 			Locals = mbr.Locals;
@@ -85,7 +85,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			ExceptionHandlers = mbr.ExceptionHandlers;
 		}
 
-		public IList<Parameter> getRealParameters() {
+		public IList<Parameter> GetRealParameters() {
 			if (ThisParameter == null)
 				return Parameters;
 			var parameters = new Parameter[Parameters.Length + 1];
@@ -110,21 +110,21 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			this.bmr = bmr;
 		}
 
-		public BabelMethodreference read() {
-			bmr.Name = imageReader.readString();
-			bmr.DeclaringType = imageReader.readTypeSig();
-			bmr.ReturnType = imageReader.readTypeSig();
-			var argTypes = imageReader.readTypeSigs();
+		public BabelMethodreference Read() {
+			bmr.Name = imageReader.ReadString();
+			bmr.DeclaringType = imageReader.ReadTypeSig();
+			bmr.ReturnType = imageReader.ReadTypeSig();
+			var argTypes = imageReader.ReadTypeSigs();
 			bmr.Flags = reader.ReadByte();
 			if (bmr.IsGenericMethod)
-				bmr.GenericArguments = imageReader.readTypeSigs();
+				bmr.GenericArguments = imageReader.ReadTypeSigs();
 			else
 				bmr.GenericArguments = new TypeSig[0];
-			bmr.Parameters = readParameters(argTypes, bmr.HasThis);
+			bmr.Parameters = ReadParameters(argTypes, bmr.HasThis);
 			return bmr;
 		}
 
-		Parameter[] readParameters(IList<TypeSig> argTypes, bool hasThis) {
+		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++)
@@ -144,10 +144,10 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			this.methodBodyReader = new MethodBodyReader(imageReader, reader);
 		}
 
-		public BabelMethodDef read() {
-			methodRefReader.read();
-			methodBodyReader.read(bmd.getRealParameters());
-			bmd.setBody(methodBodyReader);
+		public BabelMethodDef Read() {
+			methodRefReader.Read();
+			methodBodyReader.Read(bmd.GetRealParameters());
+			bmd.SetBody(methodBodyReader);
 			return bmd;
 		}
 	}
diff --git a/de4dot.code/deobfuscators/Babel_NET/MethodsDecrypter.cs b/de4dot.code/deobfuscators/Babel_NET/MethodsDecrypter.cs
index 6941a6d9..72fdf49f 100644
--- a/de4dot.code/deobfuscators/Babel_NET/MethodsDecrypter.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/MethodsDecrypter.cs
@@ -46,26 +46,26 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			this.deobfuscatorContext = deobfuscatorContext;
 		}
 
-		public void find() {
+		public void Find() {
 			var requiredFields = new string[] {
 				"System.Threading.ReaderWriterLock",
 				"System.Collections.Hashtable",
 			};
 			foreach (var type in module.GetTypes()) {
 				var fieldTypes = new FieldTypes(type);
-				if (!fieldTypes.all(requiredFields))
+				if (!fieldTypes.All(requiredFields))
 					continue;
 				if (type.FindMethod("Finalize") == null)
 					continue;
-				var executeMethod = DotNetUtils.getMethod(type, "System.Object", "(System.String,System.Object[])");
+				var executeMethod = DotNetUtils.GetMethod(type, "System.Object", "(System.String,System.Object[])");
 				if (executeMethod == null || !executeMethod.IsStatic || executeMethod.Body == null)
 					continue;
 
-				var decrypterType = findMethodsDecrypterType(type);
+				var decrypterType = FindMethodsDecrypterType(type);
 				if (decrypterType == null)
 					continue;
 
-				resourceDecrypter.DecryptMethod = findDecryptMethod(decrypterType);
+				resourceDecrypter.DecryptMethod = FindDecryptMethod(decrypterType);
 
 				methodsDecrypterCreator = type;
 				methodsDecrypter = decrypterType;
@@ -74,25 +74,25 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			}
 		}
 
-		static MethodDef findDecryptMethod(TypeDef type) {
+		static MethodDef FindDecryptMethod(TypeDef type) {
 			foreach (var method in type.Methods) {
-				var decryptMethod = ResourceDecrypter.findDecrypterMethod(method);
+				var decryptMethod = ResourceDecrypter.FindDecrypterMethod(method);
 				if (decryptMethod != null)
 					return decryptMethod;
 			}
 			return null;
 		}
 
-		TypeDef findMethodsDecrypterType(TypeDef type) {
+		TypeDef FindMethodsDecrypterType(TypeDef type) {
 			foreach (var field in type.Fields) {
-				var fieldType = DotNetUtils.getType(module, field.FieldSig.GetFieldType());
+				var fieldType = DotNetUtils.GetType(module, field.FieldSig.GetFieldType());
 				if (fieldType == null)
 					continue;
 				if (fieldType.FindMethod("Finalize") == null)
 					continue;
-				if (!new FieldTypes(fieldType).exists("System.Collections.Hashtable"))
+				if (!new FieldTypes(fieldType).Exists("System.Collections.Hashtable"))
 					continue;
-				if (DotNetUtils.getMethod(fieldType, "System.String", "()") == null)
+				if (DotNetUtils.GetMethod(fieldType, "System.String", "()") == null)
 					continue;
 
 				return fieldType;
@@ -101,18 +101,18 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return null;
 		}
 
-		public void initialize(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
+		public void Initialize(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
 			if (methodsDecrypter == null)
 				return;
 
-			encryptedResource = BabelUtils.findEmbeddedResource(module, methodsDecrypter, simpleDeobfuscator, deob);
+			encryptedResource = BabelUtils.FindEmbeddedResource(module, methodsDecrypter, simpleDeobfuscator, deob);
 			if (encryptedResource != null)
-				addImageReader("", resourceDecrypter.decrypt(encryptedResource.Data.ReadAllBytes()));
+				AddImageReader("", resourceDecrypter.Decrypt(encryptedResource.Data.ReadAllBytes()));
 		}
 
-		ImageReader addImageReader(string name, byte[] data) {
+		ImageReader AddImageReader(string name, byte[] data) {
 			var imageReader = new ImageReader(deobfuscatorContext, module, data);
-			if (!imageReader.initialize()) {
+			if (!imageReader.Initialize()) {
 				Logger.w("Could not read encrypted methods");
 				return null;
 			}
@@ -152,43 +152,43 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 		public void decrypt() {
 			int numNonDecryptedMethods = 0;
 			int totalEncryptedMethods = 0;
-			foreach (var info in getEncryptedMethods()) {
+			foreach (var info in GetEncryptedMethods()) {
 				totalEncryptedMethods++;
-				var imageReader = getImageReader(info.feature);
+				var imageReader = GetImageReader(info.feature);
 				if (imageReader == null) {
 					numNonDecryptedMethods++;
 					continue;
 				}
 				Logger.v("Decrypting method {0:X8}", info.method.MDToken.ToInt32());
-				imageReader.restore(info.FullName, info.method);
+				imageReader.Restore(info.FullName, info.method);
 			}
 			if (numNonDecryptedMethods > 0)
 				Logger.w("{0}/{1} methods not decrypted", numNonDecryptedMethods, totalEncryptedMethods);
 		}
 
-		ImageReader getImageReader(string feature) {
+		ImageReader GetImageReader(string feature) {
 			ImageReader imageReader;
 			if (imageReaders.TryGetValue(feature, out imageReader))
 				return imageReader;
 
-			return createImageReader(feature);
+			return CreateImageReader(feature);
 		}
 
-		ImageReader createImageReader(string feature) {
+		ImageReader CreateImageReader(string feature) {
 			if (string.IsNullOrEmpty(feature))
 				return null;
 
 			try {
-				var encrypted = File.ReadAllBytes(getFile(Path.GetDirectoryName(module.Location), feature));
-				var decrypted = resourceDecrypter.decrypt(encrypted);
-				return addImageReader(feature, decrypted);
+				var encrypted = File.ReadAllBytes(GetFile(Path.GetDirectoryName(module.Location), feature));
+				var decrypted = resourceDecrypter.Decrypt(encrypted);
+				return AddImageReader(feature, decrypted);
 			}
 			catch {
 				return null;
 			}
 		}
 
-		static string getFile(string dir, string name) {
+		static string GetFile(string dir, string name) {
 			try {
 				var di = new DirectoryInfo(dir);
 				foreach (var file in di.GetFiles()) {
@@ -201,13 +201,13 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return null;
 		}
 
-		List<EncryptInfo> getEncryptedMethods() {
+		List<EncryptInfo> GetEncryptedMethods() {
 			var infos = new List<EncryptInfo>();
 
 			foreach (var type in module.GetTypes()) {
 				foreach (var method in type.Methods) {
 					EncryptInfo info;
-					if (checkEncryptedMethod(method, out info))
+					if (CheckEncryptedMethod(method, out info))
 						infos.Add(info);
 				}
 			}
@@ -215,14 +215,14 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return infos;
 		}
 
-		bool checkEncryptedMethod(MethodDef method, out EncryptInfo info) {
+		bool CheckEncryptedMethod(MethodDef method, out EncryptInfo info) {
 			info = null;
 			if (method.Body == null)
 				return false;
-			if (!callsExecuteMethod(method))
+			if (!CallsExecuteMethod(method))
 				return false;
 
-			var strings = DotNetUtils.getCodeStrings(method);
+			var strings = DotNetUtils.GetCodeStrings(method);
 			if (strings.Count != 1)
 				throw new ApplicationException(string.Format("Could not find name of encrypted method"));
 
@@ -238,7 +238,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return true;
 		}
 
-		bool callsExecuteMethod(MethodDef method) {
+		bool CallsExecuteMethod(MethodDef method) {
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Call && instr.OpCode.Code != Code.Callvirt)
 					continue;
diff --git a/de4dot.code/deobfuscators/Babel_NET/ProxyCallFixer.cs b/de4dot.code/deobfuscators/Babel_NET/ProxyCallFixer.cs
index 2c9ad078..12b5625e 100644
--- a/de4dot.code/deobfuscators/Babel_NET/ProxyCallFixer.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/ProxyCallFixer.cs
@@ -54,14 +54,14 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			get { return true; }
 		}
 
-		protected override object checkCctor(TypeDef type, MethodDef cctor) {
+		protected override object CheckCctor(TypeDef type, MethodDef cctor) {
 			var instructions = cctor.Body.Instructions;
 			for (int i = 0; i < instructions.Count; i++) {
 				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);
+				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 ITypeDefOrRef;
 					methodToken = instrs[1].GetLdcI4Value();
@@ -69,7 +69,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 					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) {
+				else if ((instrs = DotNetUtils.GetInstructions(instructions, i, OpCodes.Ldtoken, OpCodes.Ldc_I4, OpCodes.Ldtoken, OpCodes.Call)) != null) {
 					delegateType = instrs[0].Operand as ITypeDefOrRef;
 					methodToken = instrs[1].GetLdcI4Value();
 					declaringTypeToken = -1;
@@ -85,7 +85,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 					continue;
 				if (createMethod == null)
 					continue;
-				var proxyCreatorType = methodToType.find(createMethod);
+				var proxyCreatorType = methodToType.Find(createMethod);
 				if (proxyCreatorType == ProxyCreatorType.None)
 					continue;
 
@@ -95,7 +95,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return null;
 		}
 
-		protected override void getCallInfo(object context, FieldDef field, out IMethod 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) {
@@ -115,26 +115,26 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			calledMethod = method;
 		}
 
-		public void findDelegateCreator() {
+		public void FindDelegateCreator() {
 			var requiredTypes = new string[] {
 				"System.ModuleHandle",
 			};
 			foreach (var type in module.Types) {
-				if (!new FieldTypes(type).exactly(requiredTypes))
+				if (!new FieldTypes(type).Exactly(requiredTypes))
 					continue;
 
 				foreach (var method in type.Methods) {
 					if (!method.IsStatic || method.Body == null)
 						continue;
-					if (!DotNetUtils.isMethod(method, "System.Void", "(System.RuntimeTypeHandle,System.Int32,System.RuntimeFieldHandle)") &&
-						!DotNetUtils.isMethod(method, "System.Void", "(System.RuntimeTypeHandle,System.Int32,System.Int32,System.RuntimeFieldHandle)"))
+					if (!DotNetUtils.IsMethod(method, "System.Void", "(System.RuntimeTypeHandle,System.Int32,System.RuntimeFieldHandle)") &&
+						!DotNetUtils.IsMethod(method, "System.Void", "(System.RuntimeTypeHandle,System.Int32,System.Int32,System.RuntimeFieldHandle)"))
 						continue;
-					var creatorType = getProxyCreatorType(method);
+					var creatorType = GetProxyCreatorType(method);
 					if (creatorType == ProxyCreatorType.None)
 						continue;
 
-					methodToType.add(method, creatorType);
-					setDelegateCreatorMethod(method);
+					methodToType.Add(method, creatorType);
+					SetDelegateCreatorMethod(method);
 				}
 
 				if (methodToType.Count == 0)
@@ -144,15 +144,15 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			}
 		}
 
-		ProxyCreatorType getProxyCreatorType(MethodDef methodToCheck) {
-			foreach (var calledMethod in DotNetUtils.getCalledMethods(module, methodToCheck)) {
+		ProxyCreatorType GetProxyCreatorType(MethodDef methodToCheck) {
+			foreach (var calledMethod in DotNetUtils.GetCalledMethods(module, methodToCheck)) {
 				if (!calledMethod.IsStatic || calledMethod.Body == null)
 					continue;
 				if (!new SigComparer().Equals(methodToCheck.DeclaringType, calledMethod.DeclaringType))
 					continue;
-				if (DotNetUtils.isMethod(calledMethod, "System.Void", "(System.Reflection.FieldInfo,System.Type,System.Reflection.MethodInfo)"))
+				if (DotNetUtils.IsMethod(calledMethod, "System.Void", "(System.Reflection.FieldInfo,System.Type,System.Reflection.MethodInfo)"))
 					return ProxyCreatorType.CallOrCallvirt;
-				if (DotNetUtils.isMethod(calledMethod, "System.Void", "(System.Reflection.FieldInfo,System.Type,System.Reflection.ConstructorInfo)"))
+				if (DotNetUtils.IsMethod(calledMethod, "System.Void", "(System.Reflection.FieldInfo,System.Type,System.Reflection.ConstructorInfo)"))
 					return ProxyCreatorType.Newobj;
 			}
 			return ProxyCreatorType.None;
diff --git a/de4dot.code/deobfuscators/Babel_NET/ResourceDecrypter.cs b/de4dot.code/deobfuscators/Babel_NET/ResourceDecrypter.cs
index c0cbcd67..6aad0fc2 100644
--- a/de4dot.code/deobfuscators/Babel_NET/ResourceDecrypter.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/ResourceDecrypter.cs
@@ -34,7 +34,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			this.simpleDeobfuscator = simpleDeobfuscator;
 		}
 
-		public ResourceDecrypter create() {
+		public ResourceDecrypter Create() {
 			return new ResourceDecrypter(module, simpleDeobfuscator);
 		}
 	}
@@ -51,7 +51,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 		}
 
 		interface IDecrypter {
-			byte[] decrypt(byte[] encryptedData);
+			byte[] Decrypt(byte[] encryptedData);
 		}
 
 		// v3.0
@@ -62,20 +62,20 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				this.module = module;
 			}
 
-			public byte[] decrypt(byte[] encryptedData) {
+			public byte[] Decrypt(byte[] encryptedData) {
 				byte[] key, iv;
 				var reader = new BinaryReader(new MemoryStream(encryptedData));
-				bool isCompressed = getHeaderData(reader, out key, out iv);
-				var data = DeobUtils.desDecrypt(encryptedData,
+				bool isCompressed = GetHeaderData(reader, out key, out iv);
+				var data = DeobUtils.DesDecrypt(encryptedData,
 										(int)reader.BaseStream.Position,
 										(int)(reader.BaseStream.Length - reader.BaseStream.Position),
 										key, iv);
 				if (isCompressed)
-					data = DeobUtils.inflate(data, true);
+					data = DeobUtils.Inflate(data, true);
 				return data;
 			}
 
-			bool getHeaderData(BinaryReader reader, out byte[] key, out byte[] iv) {
+			bool GetHeaderData(BinaryReader reader, out byte[] key, out byte[] iv) {
 				iv = reader.ReadBytes(reader.ReadByte());
 				bool hasEmbeddedKey = reader.ReadBoolean();
 				if (hasEmbeddedKey)
@@ -98,17 +98,17 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				this.module = module;
 			}
 
-			public byte[] decrypt(byte[] encryptedData) {
+			public byte[] Decrypt(byte[] encryptedData) {
 				int index = 0;
 				byte[] key, iv;
-				bool isCompressed = getKeyIv(getHeaderData(encryptedData, ref index), out key, out iv);
-				var data = DeobUtils.desDecrypt(encryptedData, index, encryptedData.Length - index, key, iv);
+				bool isCompressed = GetKeyIv(GetHeaderData(encryptedData, ref index), out key, out iv);
+				var data = DeobUtils.DesDecrypt(encryptedData, index, encryptedData.Length - index, key, iv);
 				if (isCompressed)
-					data = DeobUtils.inflate(data, true);
+					data = DeobUtils.Inflate(data, true);
 				return data;
 			}
 
-			byte[] getHeaderData(byte[] encryptedData, ref int index) {
+			byte[] GetHeaderData(byte[] encryptedData, ref int index) {
 				bool xorDecrypt = encryptedData[index++] != 0;
 				var headerData = new byte[BitConverter.ToUInt16(encryptedData, index)];
 				Array.Copy(encryptedData, index + 2, headerData, 0, headerData.Length);
@@ -124,7 +124,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				return headerData;
 			}
 
-			bool getKeyIv(byte[] headerData, out byte[] key, out byte[] iv) {
+			bool GetKeyIv(byte[] headerData, out byte[] key, out byte[] iv) {
 				var reader = new BinaryReader(new MemoryStream(headerData));
 
 				// 3.0 - 3.5 don't have this field
@@ -157,20 +157,20 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 
 			public Decrypter3(ModuleDefMD module, MethodDef decryptMethod) {
 				this.module = module;
-				this.inflater = InflaterCreator.create(decryptMethod, true);
+				this.inflater = InflaterCreator.Create(decryptMethod, true);
 			}
 
-			public byte[] decrypt(byte[] encryptedData) {
+			public byte[] Decrypt(byte[] encryptedData) {
 				int index = 0;
 				byte[] key, iv;
-				bool isCompressed = getKeyIv(getHeaderData(encryptedData, ref index), out key, out iv);
-				var data = DeobUtils.desDecrypt(encryptedData, index, encryptedData.Length - index, key, iv);
+				bool isCompressed = GetKeyIv(GetHeaderData(encryptedData, ref index), out key, out iv);
+				var data = DeobUtils.DesDecrypt(encryptedData, index, encryptedData.Length - index, key, iv);
 				if (isCompressed)
-					data = DeobUtils.inflate(data, inflater);
+					data = DeobUtils.Inflate(data, inflater);
 				return data;
 			}
 
-			byte[] getHeaderData(byte[] encryptedData, ref int index) {
+			byte[] GetHeaderData(byte[] encryptedData, ref int index) {
 				bool xorDecrypt = encryptedData[index++] != 0;
 				var headerData = new byte[BitConverter.ToUInt16(encryptedData, index)];
 				Array.Copy(encryptedData, index + 2, headerData, 0, headerData.Length);
@@ -186,7 +186,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				return headerData;
 			}
 
-			bool getKeyIv(byte[] headerData, out byte[] key, out byte[] iv) {
+			bool GetKeyIv(byte[] headerData, out byte[] key, out byte[] iv) {
 				var reader = new BinaryReader(new MemoryStream(headerData));
 
 				var license = reader.ReadString();
@@ -214,14 +214,14 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 					return;
 				if (decryptMethod == null) {
 					decryptMethod = value;
-					simpleDeobfuscator.deobfuscate(decryptMethod);
+					simpleDeobfuscator.Deobfuscate(decryptMethod);
 				}
 				else if (decryptMethod != value)
 					throw new ApplicationException("Found another decrypter method");
 			}
 		}
 
-		public static MethodDef findDecrypterMethod(MethodDef method) {
+		public static MethodDef FindDecrypterMethod(MethodDef method) {
 			if (method == null || method.Body == null)
 				return null;
 
@@ -231,7 +231,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				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)"))
+				if (!DotNetUtils.IsMethod(calledMethod, "System.IO.MemoryStream", "(System.IO.Stream)"))
 					continue;
 
 				return calledMethod;
@@ -240,21 +240,21 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return null;
 		}
 
-		public byte[] decrypt(byte[] encryptedData) {
+		public byte[] Decrypt(byte[] encryptedData) {
 			if (decrypter == null)
-				decrypter = createDecrypter(encryptedData);
-			return decrypter.decrypt(encryptedData);
+				decrypter = CreateDecrypter(encryptedData);
+			return decrypter.Decrypt(encryptedData);
 		}
 
-		IDecrypter createDecrypter(byte[] encryptedData) {
-			if (decryptMethod != null && DeobUtils.hasInteger(decryptMethod, 6))
+		IDecrypter CreateDecrypter(byte[] encryptedData) {
+			if (decryptMethod != null && DeobUtils.HasInteger(decryptMethod, 6))
 				return new Decrypter3(module, decryptMethod);
-			if (isV30(encryptedData))
+			if (IsV30(encryptedData))
 				return new Decrypter1(module);
 			return new Decrypter2(module);
 		}
 
-		static bool isV30(byte[] data) {
+		static bool IsV30(byte[] data) {
 			return data.Length > 10 && data[0] == 8 && data[9] <= 1 && data[10] == 8;
 		}
 	}
diff --git a/de4dot.code/deobfuscators/Babel_NET/ResourceResolver.cs b/de4dot.code/deobfuscators/Babel_NET/ResourceResolver.cs
index 201c4218..c5cc11ef 100644
--- a/de4dot.code/deobfuscators/Babel_NET/ResourceResolver.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/ResourceResolver.cs
@@ -54,7 +54,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			this.simpleDeobfuscator = simpleDeobfuscator;
 		}
 
-		public void find() {
+		public void Find() {
 			var requiredTypes = new string[] {
 				"System.Reflection.Assembly",
 				"System.Object",
@@ -64,22 +64,22 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			foreach (var type in module.Types) {
 				if (type.HasEvents)
 					continue;
-				if (!new FieldTypes(type).all(requiredTypes))
+				if (!new FieldTypes(type).All(requiredTypes))
 					continue;
 
 				MethodDef regMethod, handler;
-				if (!BabelUtils.findRegisterMethod(type, out regMethod, out handler))
+				if (!BabelUtils.FindRegisterMethod(type, out regMethod, out handler))
 					continue;
 
-				var resource = BabelUtils.findEmbeddedResource(module, type);
+				var resource = BabelUtils.FindEmbeddedResource(module, type);
 				if (resource == null)
 					continue;
 
-				var decryptMethod = findDecryptMethod(type);
+				var decryptMethod = FindDecryptMethod(type);
 				if (decryptMethod == null)
 					throw new ApplicationException("Couldn't find resource type decrypt method");
-				resourceDecrypter.DecryptMethod = ResourceDecrypter.findDecrypterMethod(decryptMethod);
-				initXorKeys(decryptMethod);
+				resourceDecrypter.DecryptMethod = ResourceDecrypter.FindDecrypterMethod(decryptMethod);
+				InitXorKeys(decryptMethod);
 
 				resolverType = type;
 				registerMethod = regMethod;
@@ -88,17 +88,17 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			}
 		}
 
-		static MethodDef findDecryptMethod(TypeDef type) {
+		static MethodDef FindDecryptMethod(TypeDef type) {
 			foreach (var method in type.Methods) {
-				if (!DotNetUtils.isMethod(method, "System.Reflection.Assembly", "(System.IO.Stream)"))
+				if (!DotNetUtils.IsMethod(method, "System.Reflection.Assembly", "(System.IO.Stream)"))
 					continue;
 				return method;
 			}
 			return null;
 		}
 
-		void initXorKeys(MethodDef method) {
-			simpleDeobfuscator.deobfuscate(method);
+		void InitXorKeys(MethodDef method) {
+			simpleDeobfuscator.Deobfuscate(method);
 			var ints = new List<int>();
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count; i++) {
@@ -128,17 +128,17 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			}
 		}
 
-		public EmbeddedResource mergeResources() {
+		public EmbeddedResource MergeResources() {
 			if (encryptedResource == null)
 				return null;
-			DeobUtils.decryptAndAddResources(module, encryptedResource.Name.String, () => decryptResourceAssembly());
+			DeobUtils.DecryptAndAddResources(module, encryptedResource.Name.String, () => DecryptResourceAssembly());
 			var result = encryptedResource;
 			encryptedResource = null;
 			return result;
 		}
 
-		byte[] decryptResourceAssembly() {
-			var decrypted = resourceDecrypter.decrypt(encryptedResource.Data.ReadAllBytes());
+		byte[] DecryptResourceAssembly() {
+			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 b675bf84..bda53b08 100644
--- a/de4dot.code/deobfuscators/Babel_NET/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/Babel_NET/StringDecrypter.cs
@@ -39,8 +39,8 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 		interface IDecrypterInfo {
 			MethodDef Decrypter { get; }
 			bool NeedsResource { get; }
-			void initialize(ModuleDefMD module, EmbeddedResource resource);
-			string decrypt(object[] args);
+			void Initialize(ModuleDefMD module, EmbeddedResource resource);
+			string Decrypt(object[] args);
 		}
 
 		// Babel .NET 2.x
@@ -50,14 +50,14 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				get { return false; }
 			}
 
-			public void initialize(ModuleDefMD module, EmbeddedResource resource) {
+			public void Initialize(ModuleDefMD module, EmbeddedResource resource) {
 			}
 
-			public string decrypt(object[] args) {
-				return decrypt((string)args[0], (int)args[1]);
+			public string Decrypt(object[] args) {
+				return Decrypt((string)args[0], (int)args[1]);
 			}
 
-			string decrypt(string s, int k) {
+			string Decrypt(string s, int k) {
 				var sb = new StringBuilder(s.Length);
 				foreach (var c in s)
 					sb.Append((char)(c ^ k));
@@ -73,17 +73,17 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				get { return true; }
 			}
 
-			public void initialize(ModuleDefMD module, EmbeddedResource resource) {
+			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));
 			}
 
-			public string decrypt(object[] args) {
-				return decrypt((string)args[0], (int)args[1]);
+			public string Decrypt(object[] args) {
+				return Decrypt((string)args[0], (int)args[1]);
 			}
 
-			string decrypt(string s, int k) {
+			string Decrypt(string s, int k) {
 				var sb = new StringBuilder(s.Length);
 				byte b = key[(byte)k];
 				foreach (var c in s)
@@ -107,33 +107,33 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				this.resourceDecrypter = resourceDecrypter;
 			}
 
-			public void initialize(ModuleDefMD module, EmbeddedResource resource) {
-				var decrypted = resourceDecrypter.decrypt(resource.Data.ReadAllBytes());
+			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();
+					offsetToString[GetOffset((int)reader.BaseStream.Position)] = reader.ReadString();
 			}
 
 			MethodDef dummyMethod;
-			int getOffset(int offset) {
+			int GetOffset(int offset) {
 				if (OffsetCalcInstructions == null || OffsetCalcInstructions.Count == 0)
 					return offset;
 				if (dummyMethod == null) {
 					dummyMethod = new MethodDefUser();
 					dummyMethod.Body = new CilBody();
 				}
-				emulator.init(dummyMethod);
-				emulator.push(new Int32Value(offset));
+				emulator.Initialize(dummyMethod);
+				emulator.Push(new Int32Value(offset));
 				foreach (var instr in OffsetCalcInstructions)
-					emulator.emulate(instr);
-				return ((Int32Value)emulator.pop()).value;
+					emulator.Emulate(instr);
+				return ((Int32Value)emulator.Pop()).value;
 			}
 
-			public string decrypt(object[] args) {
-				return decrypt((int)args[0]);
+			public string Decrypt(object[] args) {
+				return Decrypt((int)args[0]);
 			}
 
-			string decrypt(int offset) {
+			string Decrypt(int offset) {
 				return offsetToString[offset];
 			}
 		}
@@ -159,10 +159,10 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			this.resourceDecrypter = resourceDecrypter;
 		}
 
-		public void find(ISimpleDeobfuscator simpleDeobfuscator) {
+		public void Find(ISimpleDeobfuscator simpleDeobfuscator) {
 			this.simpleDeobfuscator = simpleDeobfuscator;
 			foreach (var type in module.Types) {
-				var info = checkDecrypterType(type);
+				var info = CheckDecrypterType(type);
 				if (info == null)
 					continue;
 
@@ -172,7 +172,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			}
 		}
 
-		IDecrypterInfo checkDecrypterType(TypeDef type) {
+		IDecrypterInfo CheckDecrypterType(TypeDef type) {
 			if (type.HasEvents)
 				return null;
 			if (type.NestedTypes.Count > 2)
@@ -181,34 +181,34 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				return null;
 
 			foreach (var nested in type.NestedTypes) {
-				var info = checkNested(type, nested);
+				var info = CheckNested(type, nested);
 				if (info != null)
 					return info;
 			}
 
-			return checkDecrypterTypeBabel2x(type);
+			return CheckDecrypterTypeBabel2x(type);
 		}
 
-		IDecrypterInfo checkDecrypterTypeBabel2x(TypeDef type) {
+		IDecrypterInfo CheckDecrypterTypeBabel2x(TypeDef type) {
 			if (type.HasEvents || type.HasProperties || type.HasNestedTypes)
 				return null;
 			if (type.HasFields || type.Methods.Count != 1)
 				return null;
 			var decrypter = type.Methods[0];
-			if (!checkDecryptMethodBabel2x(decrypter))
+			if (!CheckDecryptMethodBabel2x(decrypter))
 				return null;
 
 			return new DecrypterInfoV1 { Decrypter = decrypter };
 		}
 
-		bool checkDecryptMethodBabel2x(MethodDef method) {
+		bool CheckDecryptMethodBabel2x(MethodDef method) {
 			if (!method.IsStatic || !method.IsPublic)
 				return false;
 			if (method.Body == null)
 				return false;
 			if (method.Name == ".cctor")
 				return false;
-			if (!DotNetUtils.isMethod(method, "System.String", "(System.String,System.Int32)"))
+			if (!DotNetUtils.IsMethod(method, "System.String", "(System.String,System.Int32)"))
 				return false;
 
 			int stringLength = 0, stringToCharArray = 0, stringCtor = 0;
@@ -243,7 +243,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return stringLength == 1 && stringToCharArray == 1 && stringCtor == 1;
 		}
 
-		IDecrypterInfo checkNested(TypeDef type, TypeDef nested) {
+		IDecrypterInfo CheckNested(TypeDef type, TypeDef nested) {
 			if (nested.HasProperties || nested.HasEvents)
 				return null;
 
@@ -253,50 +253,50 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			if (nested.Fields.Count == 1 || nested.Fields.Count == 3) {
 				// 4.0+
 
-				if (!hasFieldType(nested.Fields, nested))
+				if (!HasFieldType(nested.Fields, nested))
 					return null;
 
-				var decrypterBuilderMethod = DotNetUtils.getMethod(nested, "System.Reflection.Emit.MethodBuilder", "(System.Reflection.Emit.TypeBuilder)");
+				var decrypterBuilderMethod = DotNetUtils.GetMethod(nested, "System.Reflection.Emit.MethodBuilder", "(System.Reflection.Emit.TypeBuilder)");
 				if (decrypterBuilderMethod == null)
 					return null;
 
-				resourceDecrypter.DecryptMethod = ResourceDecrypter.findDecrypterMethod(nested.FindMethod(".ctor"));
+				resourceDecrypter.DecryptMethod = ResourceDecrypter.FindDecrypterMethod(nested.FindMethod(".ctor"));
 
-				var nestedDecrypter = DotNetUtils.getMethod(nested, "System.String", "(System.Int32)");
+				var nestedDecrypter = DotNetUtils.GetMethod(nested, "System.String", "(System.Int32)");
 				if (nestedDecrypter == null || nestedDecrypter.IsStatic)
 					return null;
-				var decrypter = DotNetUtils.getMethod(type, "System.String", "(System.Int32)");
+				var decrypter = DotNetUtils.GetMethod(type, "System.String", "(System.Int32)");
 				if (decrypter == null || !decrypter.IsStatic)
 					return null;
 
-				simpleDeobfuscator.deobfuscate(decrypterBuilderMethod);
+				simpleDeobfuscator.Deobfuscate(decrypterBuilderMethod);
 				return new DecrypterInfoV3(resourceDecrypter) {
 					Decrypter = decrypter,
-					OffsetCalcInstructions = getOffsetCalcInstructions(decrypterBuilderMethod),
+					OffsetCalcInstructions = GetOffsetCalcInstructions(decrypterBuilderMethod),
 				};
 			}
 			else if (nested.Fields.Count == 2) {
 				// 3.0 - 3.5
 
-				if (checkFields(nested, "System.Collections.Hashtable", nested)) {
+				if (CheckFields(nested, "System.Collections.Hashtable", nested)) {
 					// 3.0 - 3.5
-					var nestedDecrypter = DotNetUtils.getMethod(nested, "System.String", "(System.Int32)");
+					var nestedDecrypter = DotNetUtils.GetMethod(nested, "System.String", "(System.Int32)");
 					if (nestedDecrypter == null || nestedDecrypter.IsStatic)
 						return null;
-					var decrypter = DotNetUtils.getMethod(type, "System.String", "(System.Int32)");
+					var decrypter = DotNetUtils.GetMethod(type, "System.String", "(System.Int32)");
 					if (decrypter == null || !decrypter.IsStatic)
 						return null;
 
-					resourceDecrypter.DecryptMethod = ResourceDecrypter.findDecrypterMethod(nested.FindMethod(".ctor"));
+					resourceDecrypter.DecryptMethod = ResourceDecrypter.FindDecrypterMethod(nested.FindMethod(".ctor"));
 
 					return new DecrypterInfoV3(resourceDecrypter) { Decrypter = decrypter };
 				}
-				else if (checkFields(nested, "System.Byte[]", nested)) {
+				else if (CheckFields(nested, "System.Byte[]", nested)) {
 					// 3.0
-					var nestedDecrypter = DotNetUtils.getMethod(nested, "System.String", "(System.String,System.Int32)");
+					var nestedDecrypter = DotNetUtils.GetMethod(nested, "System.String", "(System.String,System.Int32)");
 					if (nestedDecrypter == null || nestedDecrypter.IsStatic)
 						return null;
-					var decrypter = DotNetUtils.getMethod(type, "System.String", "(System.String,System.Int32)");
+					var decrypter = DotNetUtils.GetMethod(type, "System.String", "(System.String,System.Int32)");
 					if (decrypter == null || !decrypter.IsStatic)
 						return null;
 
@@ -309,7 +309,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return null;
 		}
 
-		class ReflectionToDot10MethodCreator {
+		class ReflectionToDNLibMethodCreator {
 			MethodDef method;
 			List<Instruction> instructions = new List<Instruction>();
 			InstructionEmulator emulator;
@@ -331,12 +331,12 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				get { return instructions; }
 			}
 
-			public ReflectionToDot10MethodCreator(MethodDef method) {
+			public ReflectionToDNLibMethodCreator(MethodDef method) {
 				this.method = method;
 				this.emulator = new InstructionEmulator(method);
 			}
 
-			public bool create() {
+			public bool Create() {
 				int arrayIndex;
 				Value array;
 				object value;
@@ -348,60 +348,60 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 
 					case Code.Newarr:
 						var arrayType = (ITypeDefOrRef)instr.Operand;
-						int arrayCount = ((Int32Value)emulator.pop()).value;
+						int arrayCount = ((Int32Value)emulator.Pop()).value;
 						if (arrayType.FullName == "System.Char")
-							emulator.push(new UserValue(new char[arrayCount]));
+							emulator.Push(new UserValue(new char[arrayCount]));
 						else
-							emulator.push(new UnknownValue());
+							emulator.Push(new UnknownValue());
 						break;
 
 					case Code.Call:
 					case Code.Callvirt:
-						if (!doCall(instr))
+						if (!DoCall(instr))
 							return false;
 						break;
 
 					case Code.Ldelem_U1:
-						arrayIndex = ((Int32Value)emulator.pop()).value;
-						array = (Value)emulator.pop();
+						arrayIndex = ((Int32Value)emulator.Pop()).value;
+						array = (Value)emulator.Pop();
 						if (array is UserValue)
-							emulator.push(new Int32Value(((byte[])((UserValue)array).obj)[arrayIndex]));
+							emulator.Push(new Int32Value(((byte[])((UserValue)array).obj)[arrayIndex]));
 						else
-							emulator.push(Int32Value.createUnknownUInt8());
+							emulator.Push(Int32Value.CreateUnknownUInt8());
 						break;
 
 					case Code.Stelem_I1:
-						value = emulator.pop();
-						arrayIndex = ((Int32Value)emulator.pop()).value;
-						array = (Value)emulator.pop();
+						value = emulator.Pop();
+						arrayIndex = ((Int32Value)emulator.Pop()).value;
+						array = (Value)emulator.Pop();
 						if (array is UserValue)
 							((byte[])((UserValue)array).obj)[arrayIndex] = (byte)((Int32Value)value).value;
 						break;
 
 					case Code.Stelem_I2:
-						value = emulator.pop();
-						arrayIndex = ((Int32Value)emulator.pop()).value;
-						array = (Value)emulator.pop();
+						value = emulator.Pop();
+						arrayIndex = ((Int32Value)emulator.Pop()).value;
+						array = (Value)emulator.Pop();
 						if (array is UserValue)
 							((char[])((UserValue)array).obj)[arrayIndex] = (char)((Int32Value)value).value;
 						break;
 
 					case Code.Ldelem_Ref:
-						arrayIndex = ((Int32Value)emulator.pop()).value;
-						array = (Value)emulator.pop();
+						arrayIndex = ((Int32Value)emulator.Pop()).value;
+						array = (Value)emulator.Pop();
 						var userValue = array as UserValue;
 						if (userValue != null && userValue.obj is string[])
-							emulator.push(new StringValue(((string[])userValue.obj)[arrayIndex]));
+							emulator.Push(new StringValue(((string[])userValue.obj)[arrayIndex]));
 						else
-							emulator.push(new UnknownValue());
+							emulator.Push(new UnknownValue());
 						break;
 
 					case Code.Ldsfld:
-						emulator.push(new UserValue((IField)instr.Operand));
+						emulator.Push(new UserValue((IField)instr.Operand));
 						break;
 
 					default:
-						emulator.emulate(instr);
+						emulator.Emulate(instr);
 						break;
 					}
 
@@ -409,47 +409,47 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				}
 			}
 
-			bool doCall(Instruction instr) {
+			bool DoCall(Instruction instr) {
 				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)));
+					emulator.Push(new UserValue(Convert.FromBase64String(((StringValue)emulator.Pop()).value)));
 					return true;
 				}
 				else if (fn == "System.String System.Text.Encoding::GetString(System.Byte[])") {
-					emulator.push(new StringValue(Encoding.UTF8.GetString((byte[])((UserValue)emulator.pop()).obj)));
+					emulator.Push(new StringValue(Encoding.UTF8.GetString((byte[])((UserValue)emulator.Pop()).obj)));
 					return true;
 				}
 				else if (fn == "System.Int32 System.Int32::Parse(System.String)") {
-					emulator.push(new Int32Value(int.Parse(((StringValue)emulator.pop()).value)));
+					emulator.Push(new Int32Value(int.Parse(((StringValue)emulator.Pop()).value)));
 					return true;
 				}
 				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)));
+					var ary = (char[])((UserValue)emulator.Pop()).obj;
+					var s = ((StringValue)emulator.Pop()).value;
+					emulator.Push(new UserValue(s.Split(ary)));
 					return true;
 				}
 				else if (sig != null && sig.HasThis && calledMethod.DeclaringType.FullName == "System.Reflection.Emit.ILGenerator" && calledMethod.Name == "Emit") {
 					Value operand = null;
 					if (calledMethod.MethodSig.GetParamCount() == 2)
-						operand = emulator.pop();
-					var opcode = reflectionToOpCode((IField)((UserValue)emulator.pop()).obj);
-					emulator.pop();	// the this ptr
-					addInstruction(new Instruction {
+						operand = emulator.Pop();
+					var opcode = ReflectionToOpCode((IField)((UserValue)emulator.Pop()).obj);
+					emulator.Pop();	// the this ptr
+					AddInstruction(new Instruction {
 						OpCode = opcode,
-						Operand = createDot10Operand(opcode, operand),
+						Operand = CreateDNLibOperand(opcode, operand),
 					});
 					return true;
 				}
 				else {
-					emulator.emulate(instr);
+					emulator.Emulate(instr);
 					return true;
 				}
 			}
 
-			object createDot10Operand(OpCode opcode, Value op) {
+			object CreateDNLibOperand(OpCode opcode, Value op) {
 				if (op is Int32Value)
 					return ((Int32Value)op).value;
 				if (op is StringValue)
@@ -457,11 +457,11 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 				return null;
 			}
 
-			void addInstruction(Instruction instr) {
+			void AddInstruction(Instruction instr) {
 				instructions.Add(instr);
 			}
 
-			static OpCode reflectionToOpCode(IField reflectionField) {
+			static OpCode ReflectionToOpCode(IField reflectionField) {
 				var field = typeof(OpCodes).GetField(reflectionField.Name.String);
 				if (field == null || field.FieldType != typeof(OpCode))
 					return null;
@@ -469,19 +469,19 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			}
 		}
 
-		static List<Instruction> getOffsetCalcInstructions(MethodDef method) {
-			var creator = new ReflectionToDot10MethodCreator(method);
-			creator.create();
+		static List<Instruction> GetOffsetCalcInstructions(MethodDef method) {
+			var creator = new ReflectionToDNLibMethodCreator(method);
+			creator.Create();
 			var instrs = creator.Instructions;
 
 			int index = 0;
 
-			index = findInstruction(instrs, index, OpCodes.Conv_I4);
+			index = FindInstruction(instrs, index, OpCodes.Conv_I4);
 			if (index < 0)
 				return null;
 			int startInstr = ++index;
 
-			index = findInstruction(instrs, index, OpCodes.Box);
+			index = FindInstruction(instrs, index, OpCodes.Box);
 			if (index < 0)
 				return null;
 			int endInstr = index - 1;
@@ -492,7 +492,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return transformInstructions;
 		}
 
-		static int findInstruction(IList<Instruction> instrs, int index, OpCode opcode) {
+		static int FindInstruction(IList<Instruction> instrs, int index, OpCode opcode) {
 			if (index < 0)
 				return -1;
 			for (int i = index; i < instrs.Count; i++) {
@@ -502,7 +502,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return -1;
 		}
 
-		static bool hasFieldType(IEnumerable<FieldDef> fields, TypeDef fieldType) {
+		static bool HasFieldType(IEnumerable<FieldDef> fields, TypeDef fieldType) {
 			foreach (var field in fields) {
 				if (new SigComparer().Equals(field.FieldSig.GetFieldType(), fieldType))
 					return true;
@@ -510,7 +510,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return false;
 		}
 
-		static int getOffsetMagic(MethodDef method) {
+		static int GetOffsetMagic(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 4; i++) {
 				int index = i;
@@ -552,7 +552,7 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return 0;
 		}
 
-		bool checkFields(TypeDef type, string fieldType1, TypeDef fieldType2) {
+		bool CheckFields(TypeDef type, string fieldType1, TypeDef fieldType2) {
 			if (type.Fields.Count != 2)
 				return false;
 			if (type.Fields[0].FieldSig.GetFieldType().GetFullName() != fieldType1 &&
@@ -564,23 +564,23 @@ namespace de4dot.code.deobfuscators.Babel_NET {
 			return true;
 		}
 
-		public void initialize() {
+		public void Initialize() {
 			if (decrypterType == null)
 				return;
 			if (encryptedResource != null)
 				return;
 
 			if (decrypterInfo.NeedsResource) {
-				encryptedResource = BabelUtils.findEmbeddedResource(module, decrypterType);
+				encryptedResource = BabelUtils.FindEmbeddedResource(module, decrypterType);
 				if (encryptedResource == null)
 					return;
 			}
 
-			decrypterInfo.initialize(module, encryptedResource);
+			decrypterInfo.Initialize(module, encryptedResource);
 		}
 
-		public string decrypt(object[] args) {
-			return decrypterInfo.decrypt(args);
+		public string Decrypt(object[] args) {
+			return decrypterInfo.Decrypt(args);
 		}
 	}
 }
diff --git a/de4dot.code/deobfuscators/Blowfish.cs b/de4dot.code/deobfuscators/Blowfish.cs
index 9fcc1921..13a8161b 100644
--- a/de4dot.code/deobfuscators/Blowfish.cs
+++ b/de4dot.code/deobfuscators/Blowfish.cs
@@ -294,10 +294,10 @@ namespace de4dot.code.deobfuscators {
 		}
 
 		public Blowfish(byte[] key) {
-			init(key);
+			Initialize(key);
 		}
 
-		public void init(byte[] key) {
+		public void Initialize(byte[] key) {
 			Array.Copy(Sboxes, S, S.Length);
 			int kl = key.Length;
 			for (int i = 0, ki = 0; i < 18; i++) {
@@ -307,22 +307,22 @@ namespace de4dot.code.deobfuscators {
 
 			uint xl = 0, xr = 0;
 			for (int i = 0; i < 18; i += 2) {
-				encrypt(ref xl, ref xr);
+				Encrypt(ref xl, ref xr);
 				P[i] = xl;
 				P[i + 1] = xr;
 			}
 			for (int i = 0; i < 1024; i += 2) {
-				encrypt(ref xl, ref xr);
+				Encrypt(ref xl, ref xr);
 				S[i] = xl;
 				S[i + 1] = xr;
 			}
 		}
 
-		public void encrypt_LE(byte[] data) {
+		public void Encrypt_LE(byte[] data) {
 			for (int i = 0; i + 8 <= data.Length; i += 8) {
 				uint xl = BitConverter.ToUInt32(data, i);
 				uint xr = BitConverter.ToUInt32(data, i + 4);
-				encrypt(ref xl, ref xr);
+				Encrypt(ref xl, ref xr);
 				data[i] = (byte)xl;
 				data[i + 1] = (byte)(xl >> 8);
 				data[i + 2] = (byte)(xl >> 16);
@@ -334,11 +334,11 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		public void encrypt(byte[] data) {
+		public void Encrypt(byte[] data) {
 			for (int i = 0; i + 8 <= data.Length; i += 8) {
 				uint xl = (uint)((data[i] << 24) | (data[i + 1] << 16) | (data[i + 2] << 8) | data[i + 3]);
 				uint xr = (uint)((data[i + 4] << 24) | (data[i + 5] << 16) | (data[i + 6] << 8) | data[i + 7]);
-				encrypt(ref xl, ref xr);
+				Encrypt(ref xl, ref xr);
 				data[i] = (byte)(xl >> 24);
 				data[i + 1] = (byte)(xl >> 16);
 				data[i + 2] = (byte)(xl >> 8);
@@ -350,7 +350,7 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		protected virtual void encrypt(ref uint rxl, ref uint rxr) {
+		protected virtual void Encrypt(ref uint rxl, ref uint rxr) {
 			uint xl = rxl, xr = rxr;
 			for (int i = 0; i < 16; i++) {
 				xl ^= P[i];
@@ -363,11 +363,11 @@ namespace de4dot.code.deobfuscators {
 			rxl = xr ^ P[17];
 		}
 
-		public void decrypt_LE(byte[] data) {
+		public void Decrypt_LE(byte[] data) {
 			for (int i = 0; i + 8 <= data.Length; i += 8) {
 				uint xl = BitConverter.ToUInt32(data, i);
 				uint xr = BitConverter.ToUInt32(data, i + 4);
-				decrypt(ref xl, ref xr);
+				Decrypt(ref xl, ref xr);
 				data[i] = (byte)xl;
 				data[i + 1] = (byte)(xl >> 8);
 				data[i + 2] = (byte)(xl >> 16);
@@ -379,11 +379,11 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		public void decrypt(byte[] data) {
+		public void Decrypt(byte[] data) {
 			for (int i = 0; i + 8 <= data.Length; i += 8) {
 				uint xl = (uint)((data[i] << 24) | (data[i + 1] << 16) | (data[i + 2] << 8) | data[i + 3]);
 				uint xr = (uint)((data[i + 4] << 24) | (data[i + 5] << 16) | (data[i + 6] << 8) | data[i + 7]);
-				decrypt(ref xl, ref xr);
+				Decrypt(ref xl, ref xr);
 				data[i] = (byte)(xl >> 24);
 				data[i + 1] = (byte)(xl >> 16);
 				data[i + 2] = (byte)(xl >> 8);
@@ -395,7 +395,7 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		protected virtual void decrypt(ref uint rxl, ref uint rxr) {
+		protected virtual void Decrypt(ref uint rxl, ref uint rxr) {
 			uint xl = rxl, xr = rxr;
 			for (int i = 17; i >= 2; i--) {
 				xl ^= P[i];
diff --git a/de4dot.code/deobfuscators/CRC32.cs b/de4dot.code/deobfuscators/CRC32.cs
index 7739abe8..62f4050d 100644
--- a/de4dot.code/deobfuscators/CRC32.cs
+++ b/de4dot.code/deobfuscators/CRC32.cs
@@ -86,7 +86,7 @@ namespace de4dot.code.deobfuscators {
 			0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D,
 		};
 
-		public static uint checksum(byte[] data) {
+		public static uint CheckSum(byte[] data) {
 			if (data == null)
 				return 0;
 			uint cs = uint.MaxValue;
diff --git a/de4dot.code/deobfuscators/CodeFort/AssemblyData.cs b/de4dot.code/deobfuscators/CodeFort/AssemblyData.cs
index 668bdd2d..043e0583 100644
--- a/de4dot.code/deobfuscators/CodeFort/AssemblyData.cs
+++ b/de4dot.code/deobfuscators/CodeFort/AssemblyData.cs
@@ -26,15 +26,15 @@ using System.Text;
 
 namespace de4dot.code.deobfuscators.CodeFort {
 	interface ICFType {
-		Type get(SerializedTypes serializedTypes);
+		Type Get(SerializedTypes serializedTypes);
 	}
 
 	static class ITypeCreator {
-		public static ICFType create(string name) {
+		public static ICFType Create(string name) {
 			return new StringType(name);
 		}
 
-		public static ICFType create(Type type) {
+		public static ICFType Create(Type type) {
 			return new ExistingType(type);
 		}
 	}
@@ -46,8 +46,8 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			this.name = name;
 		}
 
-		public Type get(SerializedTypes serializedTypes) {
-			return serializedTypes.getBuilderType(name);
+		public Type Get(SerializedTypes serializedTypes) {
+			return serializedTypes.GetBuilderType(name);
 		}
 
 		public override string ToString() {
@@ -62,7 +62,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			this.type = type;
 		}
 
-		public Type get(SerializedTypes serializedTypes) {
+		public Type Get(SerializedTypes serializedTypes) {
 			return type;
 		}
 
@@ -76,11 +76,11 @@ namespace de4dot.code.deobfuscators.CodeFort {
 		ICFType[] genericArgs;
 
 		public GenericType(string type, ICFType[] genericArgs)
-			: this(ITypeCreator.create(type), genericArgs) {
+			: this(ITypeCreator.Create(type), genericArgs) {
 		}
 
 		public GenericType(Type type, ICFType[] genericArgs)
-			: this(ITypeCreator.create(type), genericArgs) {
+			: this(ITypeCreator.Create(type), genericArgs) {
 		}
 
 		public GenericType(ICFType type, ICFType[] genericArgs) {
@@ -88,17 +88,17 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			this.genericArgs = genericArgs;
 		}
 
-		public Type get(SerializedTypes serializedTypes) {
-			var genericType = type.get(serializedTypes);
+		public Type Get(SerializedTypes serializedTypes) {
+			var genericType = type.Get(serializedTypes);
 			var types = new List<Type>(genericArgs.Length);
 			foreach (var ga in genericArgs)
-				types.Add(ga.get(serializedTypes));
+				types.Add(ga.Get(serializedTypes));
 			return genericType.MakeGenericType(types.ToArray());
 		}
 
 		public override string ToString() {
 			var sb = new StringBuilder();
-			sb.Append(getTypeName());
+			sb.Append(GetTypeName());
 			if (genericArgs != null && genericArgs.Length > 0) {
 				sb.Append('<');
 				for (int i = 0; i < genericArgs.Length; i++) {
@@ -111,7 +111,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			return sb.ToString();
 		}
 
-		string getTypeName() {
+		string GetTypeName() {
 			var typeName = type.ToString();
 			int index = typeName.LastIndexOf('`');
 			if (index < 0)
@@ -122,11 +122,11 @@ namespace de4dot.code.deobfuscators.CodeFort {
 
 	class ListType : GenericType {
 		public ListType(string type)
-			: this(ITypeCreator.create(type)) {
+			: this(ITypeCreator.Create(type)) {
 		}
 
 		public ListType(Type type)
-			: this(ITypeCreator.create(type)) {
+			: this(ITypeCreator.Create(type)) {
 		}
 
 		public ListType(ICFType type)
@@ -161,7 +161,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 		}
 
 		public TypeInfo(string name, string dcNamespace, string dcName, TypeFieldInfo[] fieldInfos)
-			: this(ITypeCreator.create(typeof(object)), name, dcNamespace, dcName, fieldInfos) {
+			: this(ITypeCreator.Create(typeof(object)), name, dcNamespace, dcName, fieldInfos) {
 		}
 
 		public TypeInfo(ICFType baseType, string name, string dcName, TypeFieldInfo[] fieldInfos)
@@ -181,11 +181,11 @@ namespace de4dot.code.deobfuscators.CodeFort {
 		public readonly string dmName;
 
 		public TypeFieldInfo(string type, string name, string dmName)
-			: this(ITypeCreator.create(type), name, dmName) {
+			: this(ITypeCreator.Create(type), name, dmName) {
 		}
 
 		public TypeFieldInfo(Type type, string name, string dmName)
-			: this(ITypeCreator.create(type), name, dmName) {
+			: this(ITypeCreator.Create(type), name, dmName) {
 		}
 
 		public TypeFieldInfo(ICFType type, string name, string dmName) {
@@ -317,7 +317,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 				new TypeFieldInfo("TypeRef", "ReturnType", "T"),
 			}),
 
-			new TypeInfo(ITypeCreator.create("MemberRef"), "MethodRef", "i", new TypeFieldInfo[] {
+			new TypeInfo(ITypeCreator.Create("MemberRef"), "MethodRef", "i", new TypeFieldInfo[] {
 				new TypeFieldInfo(new ListType("ParameterRef"), "Parameters", "P"),
 				new TypeFieldInfo(typeof(int), "CallingConventions", "V"),
 			}),
@@ -341,18 +341,18 @@ namespace de4dot.code.deobfuscators.CodeFort {
 				new TypeFieldInfo("TypeRef", "Type", "T"),
 			}),
 
-			new TypeInfo(ITypeCreator.create("MemberDef"), "PropertyDef", "n", new TypeFieldInfo[] {
+			new TypeInfo(ITypeCreator.Create("MemberDef"), "PropertyDef", "n", new TypeFieldInfo[] {
 				new TypeFieldInfo("MethodDef", "GetMethod", "G"),
 				new TypeFieldInfo(new ListType("ParameterDef"), "ParameterTypes", "P"),
 				new TypeFieldInfo("MethodDef", "SetMethod", "S"),
 			}),
 
-			new TypeInfo(ITypeCreator.create("MemberDef"), "EventDef", "o", new TypeFieldInfo[] {
+			new TypeInfo(ITypeCreator.Create("MemberDef"), "EventDef", "o", new TypeFieldInfo[] {
 				new TypeFieldInfo("MethodDef", "AddOnMethod", "A"),
 				new TypeFieldInfo("MethodDef", "RemoveOnMethod", "R"),
 			}),
 
-			new TypeInfo(ITypeCreator.create("MemberDef"), "MethodDef", "p", new TypeFieldInfo[] {
+			new TypeInfo(ITypeCreator.Create("MemberDef"), "MethodDef", "p", new TypeFieldInfo[] {
 				new TypeFieldInfo(new ListType("Instruction"), "Instructions", "A"),
 				new TypeFieldInfo(typeof(CallingConventions), "CallingConventions", "C"),
 				new TypeFieldInfo(typeof(MethodImplAttributes), "MethodImplAttributes", "I"),
@@ -398,20 +398,20 @@ namespace de4dot.code.deobfuscators.CodeFort {
 
 		public SerializedTypes(ModuleBuilder moduleBuilder) {
 			this.moduleBuilder = moduleBuilder;
-			createTypeBuilders();
-			initializeEnums();
-			initializeTypes();
-			createTypes();
+			CreateTypeBuilders();
+			InitializeEnums();
+			InitializeTypes();
+			CreateTypes();
 		}
 
-		void createTypeBuilders() {
+		void CreateTypeBuilders() {
 			foreach (var info in enumInfos)
-				add(info.name, moduleBuilder.DefineEnum(info.name, TypeAttributes.Public, info.underlyingType));
+				Add(info.name, moduleBuilder.DefineEnum(info.name, TypeAttributes.Public, info.underlyingType));
 			foreach (var info in typeInfos)
-				add(info.name, moduleBuilder.DefineType(info.name, TypeAttributes.Public, info.baseType.get(this)));
+				Add(info.name, moduleBuilder.DefineType(info.name, TypeAttributes.Public, info.baseType.Get(this)));
 		}
 
-		CustomAttributeBuilder createDataContractAttribute(string ns, string name, bool isReference) {
+		CustomAttributeBuilder CreateDataContractAttribute(string ns, string name, bool isReference) {
 			var dcAttr = Type.GetType("System.Runtime.Serialization.DataContractAttribute," + serializationAssemblyname);
 			var ctor = dcAttr.GetConstructor(Type.EmptyTypes);
 			var propCreator = new PropertyInfoCreator(dcAttr);
@@ -421,7 +421,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			return new CustomAttributeBuilder(ctor, new object[0], propCreator.Properties, propCreator.Values);
 		}
 
-		CustomAttributeBuilder createEnumMemberAttribute(string value) {
+		CustomAttributeBuilder CreateEnumMemberAttribute(string value) {
 			var emAttr = Type.GetType("System.Runtime.Serialization.EnumMemberAttribute," + serializationAssemblyname);
 			var ctor = emAttr.GetConstructor(Type.EmptyTypes);
 			var propCreator = new PropertyInfoCreator(emAttr);
@@ -429,7 +429,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			return new CustomAttributeBuilder(ctor, new object[0], propCreator.Properties, propCreator.Values);
 		}
 
-		CustomAttributeBuilder createDataMemberAttribute(string name, bool emitDefaultValue) {
+		CustomAttributeBuilder CreateDataMemberAttribute(string name, bool emitDefaultValue) {
 			var dmAttr = Type.GetType("System.Runtime.Serialization.DataMemberAttribute," + serializationAssemblyname);
 			var ctor = dmAttr.GetConstructor(Type.EmptyTypes);
 			var propCreator = new PropertyInfoCreator(dmAttr);
@@ -438,41 +438,41 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			return new CustomAttributeBuilder(ctor, new object[0], propCreator.Properties, propCreator.Values);
 		}
 
-		void add(string name, EnumBuilder builder) {
+		void Add(string name, EnumBuilder builder) {
 			if (enumBuilders.ContainsKey(name))
 				throw new ApplicationException(string.Format("Enum {0} already exists", name));
 			enumBuilders[name] = builder;
 		}
 
-		void add(string name, TypeBuilder builder) {
+		void Add(string name, TypeBuilder builder) {
 			if (typeBuilders.ContainsKey(name))
 				throw new ApplicationException(string.Format("Type {0} already exists", name));
 			typeBuilders[name] = builder;
 		}
 
-		void initializeEnums() {
+		void InitializeEnums() {
 			foreach (var info in enumInfos) {
 				var builder = enumBuilders[info.name];
-				builder.SetCustomAttribute(createDataContractAttribute(info.dcNamespace, info.dcName, false));
+				builder.SetCustomAttribute(CreateDataContractAttribute(info.dcNamespace, info.dcName, false));
 				foreach (var fieldInfo in info.fieldInfos) {
 					var fieldBuilder = builder.DefineLiteral(fieldInfo.name, fieldInfo.value);
-					fieldBuilder.SetCustomAttribute(createEnumMemberAttribute(fieldInfo.emValue));
+					fieldBuilder.SetCustomAttribute(CreateEnumMemberAttribute(fieldInfo.emValue));
 				}
 			}
 		}
 
-		void initializeTypes() {
+		void InitializeTypes() {
 			foreach (var info in typeInfos) {
 				var builder = typeBuilders[info.name];
-				builder.SetCustomAttribute(createDataContractAttribute(info.dcNamespace, info.dcName, true));
+				builder.SetCustomAttribute(CreateDataContractAttribute(info.dcNamespace, info.dcName, true));
 				foreach (var fieldInfo in info.fieldInfos) {
-					var fieldBuilder = builder.DefineField(fieldInfo.name, fieldInfo.type.get(this), FieldAttributes.Public);
-					fieldBuilder.SetCustomAttribute(createDataMemberAttribute(fieldInfo.dmName, false));
+					var fieldBuilder = builder.DefineField(fieldInfo.name, fieldInfo.type.Get(this), FieldAttributes.Public);
+					fieldBuilder.SetCustomAttribute(CreateDataMemberAttribute(fieldInfo.dmName, false));
 				}
 			}
 		}
 
-		void createTypes() {
+		void CreateTypes() {
 			foreach (var info in enumInfos)
 				createdTypes[info.name] = enumBuilders[info.name].CreateType();
 			foreach (var info in typeInfos)
@@ -482,7 +482,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			typeBuilders = null;
 		}
 
-		public Type getBuilderType(string name) {
+		public Type GetBuilderType(string name) {
 			EnumBuilder enumBuilder;
 			if (enumBuilders.TryGetValue(name, out enumBuilder))
 				return enumBuilder;
@@ -494,32 +494,32 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			throw new ApplicationException(string.Format("Could not find type {0}", name));
 		}
 
-		Type getType(string name) {
+		Type GetType(string name) {
 			return createdTypes[name];
 		}
 
-		public object deserialize(byte[] data) {
+		public object Deserialize(byte[] data) {
 			var serializerType = Type.GetType("System.Runtime.Serialization.DataContractSerializer," + serializationAssemblyname);
 			if (serializerType == null)
 				throw new ApplicationException("You need .NET 3.0 or later to decrypt the assembly");
 			var quotasType = Type.GetType("System.Xml.XmlDictionaryReaderQuotas," + serializationAssemblyname);
 			var serializerCtor = serializerType.GetConstructor(new Type[] { typeof(Type), typeof(IEnumerable<Type>) });
-			var serializer = serializerCtor.Invoke(new object[] { getType("AllTypes"), new Type[] {
-				getType("MemberTypes1"),
-				getType("Instruction"),
-				getType("InstructionType"),
-				getType("InstructionLabel"),
-				getType("LocalVariable"),
-				getType("ParameterDef"),
-				getType("TypeDef"),
-				getType("MemberDef"),
-				getType("MethodDef"),
-				getType("EventDef"),
-				getType("PropertyDef"),
-				getType("ParameterRef"),
-				getType("TypeRef"),
-				getType("MemberRef"),
-				getType("MethodRef"),
+			var serializer = serializerCtor.Invoke(new object[] { GetType("AllTypes"), new Type[] {
+				GetType("MemberTypes1"),
+				GetType("Instruction"),
+				GetType("InstructionType"),
+				GetType("InstructionLabel"),
+				GetType("LocalVariable"),
+				GetType("ParameterDef"),
+				GetType("TypeDef"),
+				GetType("MemberDef"),
+				GetType("MethodDef"),
+				GetType("EventDef"),
+				GetType("PropertyDef"),
+				GetType("ParameterRef"),
+				GetType("TypeRef"),
+				GetType("MemberRef"),
+				GetType("MethodRef"),
 			}});
 
 			var xmlReaderType = Type.GetType("System.Xml.XmlDictionaryReader," + serializationAssemblyname);
diff --git a/de4dot.code/deobfuscators/CodeFort/AssemblyDecrypter.cs b/de4dot.code/deobfuscators/CodeFort/AssemblyDecrypter.cs
index 65735fbe..d60b3b72 100644
--- a/de4dot.code/deobfuscators/CodeFort/AssemblyDecrypter.cs
+++ b/de4dot.code/deobfuscators/CodeFort/AssemblyDecrypter.cs
@@ -85,10 +85,10 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			this.embedPassword = oldOne.embedPassword;
 		}
 
-		public void find() {
-			if (findEncrypted())
+		public void Find() {
+			if (FindEncrypted())
 				return;
-			findEmbedded();
+			FindEmbedded();
 		}
 
 		static readonly string[] encryptedRequiredLocals = new string[] {
@@ -102,16 +102,16 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			"System.Reflection.Assembly",
 			"System.Type[]",
 		};
-		bool findEncrypted() {
+		bool FindEncrypted() {
 			var ep = module.EntryPoint;
 			if (ep == null || ep.Body == null)
 				return false;
-			if (!DotNetUtils.isMethod(ep, "System.Void", "(System.String[])"))
+			if (!DotNetUtils.IsMethod(ep, "System.Void", "(System.String[])"))
 				return false;
-			var initMethod = checkCalledMethods(ep);
-			if (initMethod == null || !new LocalTypes(initMethod).all(encryptedRequiredLocals))
+			var initMethod = CheckCalledMethods(ep);
+			if (initMethod == null || !new LocalTypes(initMethod).All(encryptedRequiredLocals))
 				return false;
-			var resource = getResource();
+			var resource = GetResource();
 			if (resource == null)
 				return false;
 
@@ -119,11 +119,11 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			return true;
 		}
 
-		MethodDef checkCalledMethods(MethodDef method) {
+		MethodDef CheckCalledMethods(MethodDef method) {
 			int calls = 0;
 			TypeDef type = null;
 			MethodDef initMethod = null;
-			foreach (var calledMethod in DotNetUtils.getCalledMethods(module, method)) {
+			foreach (var calledMethod in DotNetUtils.GetCalledMethods(module, method)) {
 				calls++;
 				if (type != null && calledMethod.DeclaringType != type)
 					return null;
@@ -136,23 +136,23 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			return initMethod;
 		}
 
-		EmbeddedResource getResource() {
-			return DotNetUtils.getResource(module, "_") as EmbeddedResource;
+		EmbeddedResource GetResource() {
+			return DotNetUtils.GetResource(module, "_") as EmbeddedResource;
 		}
 
-		bool findEmbedded() {
-			return findEmbedded(DotNetUtils.getModuleTypeCctor(module)) ||
-				findEmbedded(module.EntryPoint);
+		bool FindEmbedded() {
+			return FindEmbedded(DotNetUtils.GetModuleTypeCctor(module)) ||
+				FindEmbedded(module.EntryPoint);
 		}
 
-		bool findEmbedded(MethodDef method) {
+		bool FindEmbedded(MethodDef method) {
 			if (method == null || method.Body == null)
 				return false;
-			foreach (var calledMethod in DotNetUtils.getCalledMethods(module, method)) {
-				var resolver = checkInitMethod(calledMethod);
+			foreach (var calledMethod in DotNetUtils.GetCalledMethods(module, method)) {
+				var resolver = CheckInitMethod(calledMethod);
 				if (resolver == null)
 					continue;
-				if (!checkType(calledMethod.DeclaringType))
+				if (!CheckType(calledMethod.DeclaringType))
 					continue;
 
 				embedInitMethod = calledMethod;
@@ -163,39 +163,39 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			return false;
 		}
 
-		MethodDef checkInitMethod(MethodDef method) {
+		MethodDef CheckInitMethod(MethodDef method) {
 			if (method == null || !method.IsStatic || method.Body == null)
 				return null;
-			if (!DotNetUtils.isMethod(method, "System.Void", "()"))
+			if (!DotNetUtils.IsMethod(method, "System.Void", "()"))
 				return null;
 
-			var resolver = DeobUtils.getResolveMethod(method);
+			var resolver = DeobUtils.GetResolveMethod(method);
 			if (resolver == null || resolver.DeclaringType != method.DeclaringType)
 				return null;
 
 			return resolver;
 		}
 
-		bool checkType(TypeDef type) {
-			if (DotNetUtils.getMethod(type, "System.Byte[]", "(System.Byte[],System.String,System.String,System.Int32,System.String,System.Int32)") == null)
+		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)
+			if (DotNetUtils.GetMethod(type, "System.String", "(System.String)") == null)
 				return false;
-			if (DotNetUtils.getMethod(type, "System.Byte[]", "(System.Reflection.Assembly,System.String)") == null)
+			if (DotNetUtils.GetMethod(type, "System.Byte[]", "(System.Reflection.Assembly,System.String)") == null)
 				return false;
-			if (DotNetUtils.getMethod(type, "System.Void", "(System.IO.Stream,System.IO.Stream)") == null)
+			if (DotNetUtils.GetMethod(type, "System.Void", "(System.IO.Stream,System.IO.Stream)") == null)
 				return false;
 
 			return true;
 		}
 
-		public byte[] decrypt() {
+		public byte[] Decrypt() {
 			if (assemblyEncryptedResource == null)
 				return null;
 
 			assemblyEncryptedResource.Data.Position = 0;
 			var reader = new BinaryReader(assemblyEncryptedResource.Data.CreateStream());
-			var encryptedData = DeobUtils.gunzip(reader.BaseStream, reader.ReadInt32());
+			var encryptedData = DeobUtils.Gunzip(reader.BaseStream, reader.ReadInt32());
 			reader = new BinaryReader(new MemoryStream(encryptedData));
 			var serializedData = reader.ReadBytes(reader.ReadInt32());
 			for (int i = 0; i < serializedData.Length; i++)
@@ -204,30 +204,30 @@ namespace de4dot.code.deobfuscators.CodeFort {
 
 			var passwordFinder = new PasswordFinder(serializedData);
 			PasswordInfo mainAsmPassword;
-			passwordFinder.find(out mainAsmPassword, out embedPassword);
+			passwordFinder.Find(out mainAsmPassword, out embedPassword);
 
-			return decrypt(mainAsmPassword, encryptedAssembly);
+			return Decrypt(mainAsmPassword, encryptedAssembly);
 		}
 
-		static byte[] decrypt(PasswordInfo password, byte[] data) {
+		static byte[] Decrypt(PasswordInfo password, byte[] data) {
 			const int iterations = 2;
 			const int numBits = 0x100;
 			var key = new Rfc2898DeriveBytes(password.passphrase, Encoding.UTF8.GetBytes(password.salt), iterations).GetBytes(numBits / 8);
-			return DeobUtils.aesDecrypt(data, key, Encoding.UTF8.GetBytes(password.iv));
+			return DeobUtils.AesDecrypt(data, key, Encoding.UTF8.GetBytes(password.iv));
 		}
 
-		static byte[] gunzip(byte[] data) {
+		static byte[] Gunzip(byte[] data) {
 			var reader = new BinaryReader(new MemoryStream(data));
-			return DeobUtils.gunzip(reader.BaseStream, reader.ReadInt32());
+			return DeobUtils.Gunzip(reader.BaseStream, reader.ReadInt32());
 		}
 
-		public List<AssemblyInfo> getAssemblyInfos(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
+		public List<AssemblyInfo> GetAssemblyInfos(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
 			var infos = new List<AssemblyInfo>();
 
 			if (embedResolverMethod != null) {
-				simpleDeobfuscator.deobfuscate(embedResolverMethod);
-				simpleDeobfuscator.decryptStrings(embedResolverMethod, deob);
-				embedPassword = getEmbedPassword(embedResolverMethod);
+				simpleDeobfuscator.Deobfuscate(embedResolverMethod);
+				simpleDeobfuscator.DecryptStrings(embedResolverMethod, deob);
+				embedPassword = GetEmbedPassword(embedResolverMethod);
 			}
 
 			if (embedPassword == null)
@@ -240,15 +240,15 @@ namespace de4dot.code.deobfuscators.CodeFort {
 				if (!Regex.IsMatch(resource.Name.String, "^cfd_([0-9a-f]{2})+_$"))
 					continue;
 
-				var asmData = decrypt(embedPassword, gunzip(resource.Data.ReadAllBytes()));
+				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)));
+				infos.Add(new AssemblyInfo(asmData, resource, mod.Assembly.FullName, mod.Assembly.Name.String, DeobUtils.GetExtension(mod.Kind)));
 			}
 
 			return infos;
 		}
 
-		static PasswordInfo getEmbedPassword(MethodDef method) {
+		static PasswordInfo GetEmbedPassword(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 3; i++) {
 				int index = i;
@@ -256,12 +256,12 @@ namespace de4dot.code.deobfuscators.CodeFort {
 				var ldstr1 = instrs[index++];
 				if (ldstr1.OpCode.Code != Code.Ldstr)
 					continue;
-				var passphrase = getString(ldstr1, instrs, ref index);
+				var passphrase = GetString(ldstr1, instrs, ref index);
 
 				var ldstr2 = instrs[index++];
 				if (ldstr2.OpCode.Code != Code.Ldstr)
 					continue;
-				var salt = getString(ldstr2, instrs, ref index);
+				var salt = GetString(ldstr2, instrs, ref index);
 
 				var ldci4 = instrs[index++];
 				if (!ldci4.IsLdcI4())
@@ -270,7 +270,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 				var ldstr3 = instrs[index++];
 				if (ldstr3.OpCode.Code != Code.Ldstr)
 					continue;
-				var iv = getString(ldstr3, instrs, ref index);
+				var iv = GetString(ldstr3, instrs, ref index);
 
 				return new PasswordInfo(passphrase, salt, iv);
 			}
@@ -278,7 +278,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			return null;
 		}
 
-		static string getString(Instruction ldstr, IList<Instruction> instrs, ref int index) {
+		static string GetString(Instruction ldstr, IList<Instruction> instrs, ref int index) {
 			var s = (string)ldstr.Operand;
 			if (index >= instrs.Count)
 				return s;
diff --git a/de4dot.code/deobfuscators/CodeFort/CfMethodCallInliner.cs b/de4dot.code/deobfuscators/CodeFort/CfMethodCallInliner.cs
index 2bc76f0e..b4a0d307 100644
--- a/de4dot.code/deobfuscators/CodeFort/CfMethodCallInliner.cs
+++ b/de4dot.code/deobfuscators/CodeFort/CfMethodCallInliner.cs
@@ -30,11 +30,11 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			this.proxyCallFixer = proxyCallFixer;
 		}
 
-		protected override bool canInline(MethodDef method) {
-			return proxyCallFixer.isProxyTargetMethod(method);
+		protected override bool CanInline(MethodDef method) {
+			return proxyCallFixer.IsProxyTargetMethod(method);
 		}
 
-		protected override bool isCompatibleType(int paramIndex, IType origType, IType 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 d813f36c..62805fe6 100644
--- a/de4dot.code/deobfuscators/CodeFort/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/CodeFort/Deobfuscator.cs
@@ -31,7 +31,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 
 		public DeobfuscatorInfo()
 			: base(DEFAULT_REGEX) {
-			dumpEmbeddedAssemblies = new BoolOption(null, makeArgName("embedded"), "Dump embedded assemblies", true);
+			dumpEmbeddedAssemblies = new BoolOption(null, MakeArgName("embedded"), "Dump embedded assemblies", true);
 		}
 
 		public override string Name {
@@ -42,14 +42,14 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			get { return THE_TYPE; }
 		}
 
-		public override IDeobfuscator createDeobfuscator() {
+		public override IDeobfuscator CreateDeobfuscator() {
 			return new Deobfuscator(new Deobfuscator.Options {
 				ValidNameRegex = validNameRegex.get(),
 				DumpEmbeddedAssemblies = dumpEmbeddedAssemblies.get(),
 			});
 		}
 
-		protected override IEnumerable<Option> getOptionsInternal() {
+		protected override IEnumerable<Option> GetOptionsInternal() {
 			return new List<Option>() {
 				dumpEmbeddedAssemblies,
 			};
@@ -84,91 +84,91 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			this.options = options;
 		}
 
-		protected override int detectInternal() {
+		protected override int DetectInternal() {
 			int val = 0;
 
-			int sum = toInt32(proxyCallFixer.Detected) +
-					toInt32(stringDecrypter.Detected) +
-					toInt32(assemblyDecrypter.Detected);
+			int sum = ToInt32(proxyCallFixer.Detected) +
+					ToInt32(stringDecrypter.Detected) +
+					ToInt32(assemblyDecrypter.Detected);
 			if (sum > 0)
 				val += 100 + 10 * (sum - 1);
 
 			return val;
 		}
 
-		protected override void scanForObfuscator() {
+		protected override void ScanForObfuscator() {
 			proxyCallFixer = new ProxyCallFixer(module);
-			proxyCallFixer.findDelegateCreator();
+			proxyCallFixer.FindDelegateCreator();
 			stringDecrypter = new StringDecrypter(module);
-			stringDecrypter.find();
+			stringDecrypter.Find();
 			assemblyDecrypter = new AssemblyDecrypter(module);
-			assemblyDecrypter.find();
+			assemblyDecrypter.Find();
 		}
 
-		public override bool getDecryptedModule(int count, ref byte[] newFileData, ref DumpedMethods dumpedMethods) {
+		public override bool GetDecryptedModule(int count, ref byte[] newFileData, ref DumpedMethods dumpedMethods) {
 			if (count != 0 || !assemblyDecrypter.EncryptedDetected)
 				return false;
 
-			newFileData = assemblyDecrypter.decrypt();
+			newFileData = assemblyDecrypter.Decrypt();
 			return newFileData != null;
 		}
 
-		public override IDeobfuscator moduleReloaded(ModuleDefMD module) {
+		public override IDeobfuscator ModuleReloaded(ModuleDefMD module) {
 			var newOne = new Deobfuscator(options);
-			newOne.setModule(module);
+			newOne.SetModule(module);
 			newOne.proxyCallFixer = new ProxyCallFixer(module);
-			newOne.proxyCallFixer.findDelegateCreator();
+			newOne.proxyCallFixer.FindDelegateCreator();
 			newOne.stringDecrypter = new StringDecrypter(module);
-			newOne.stringDecrypter.find();
+			newOne.stringDecrypter.Find();
 			newOne.assemblyDecrypter = new AssemblyDecrypter(module, assemblyDecrypter);
-			newOne.assemblyDecrypter.find();
+			newOne.assemblyDecrypter.Find();
 			return newOne;
 		}
 
-		public override void deobfuscateBegin() {
-			base.deobfuscateBegin();
+		public override void DeobfuscateBegin() {
+			base.DeobfuscateBegin();
 
-			staticStringInliner.add(stringDecrypter.Method, (method, gim, args) => stringDecrypter.decrypt((string)args[0]));
-			DeobfuscatedFile.stringDecryptersAdded();
+			staticStringInliner.Add(stringDecrypter.Method, (method, gim, args) => stringDecrypter.Decrypt((string)args[0]));
+			DeobfuscatedFile.StringDecryptersAdded();
 
-			proxyCallFixer.find();
+			proxyCallFixer.Find();
 			cfMethodCallInliner = new CfMethodCallInliner(proxyCallFixer);
 
-			dumpEmbeddedAssemblies();
+			DumpEmbeddedAssemblies();
 		}
 
-		void dumpEmbeddedAssemblies() {
+		void DumpEmbeddedAssemblies() {
 			if (assemblyDecrypter.MainAssemblyHasAssemblyResolver && !options.DumpEmbeddedAssemblies)
 				return;
-			foreach (var info in assemblyDecrypter.getAssemblyInfos(DeobfuscatedFile, this)) {
-				DeobfuscatedFile.createAssemblyFile(info.data, info.asmSimpleName, info.extension);
-				addResourceToBeRemoved(info.resource, string.Format("Embedded assembly: {0}", info.asmFullName));
+			foreach (var info in assemblyDecrypter.GetAssemblyInfos(DeobfuscatedFile, this)) {
+				DeobfuscatedFile.CreateAssemblyFile(info.data, info.asmSimpleName, info.extension);
+				AddResourceToBeRemoved(info.resource, string.Format("Embedded assembly: {0}", info.asmFullName));
 			}
-			addCctorInitCallToBeRemoved(assemblyDecrypter.InitMethod);
-			addCallToBeRemoved(module.EntryPoint, assemblyDecrypter.InitMethod);
-			addTypeToBeRemoved(assemblyDecrypter.Type, "Assembly resolver type");
+			AddCctorInitCallToBeRemoved(assemblyDecrypter.InitMethod);
+			AddCallToBeRemoved(module.EntryPoint, assemblyDecrypter.InitMethod);
+			AddTypeToBeRemoved(assemblyDecrypter.Type, "Assembly resolver type");
 		}
 
-		public override void deobfuscateMethodEnd(Blocks blocks) {
-			proxyCallFixer.deobfuscate(blocks);
-			inlineMethods(blocks);
-			base.deobfuscateMethodEnd(blocks);
+		public override void DeobfuscateMethodEnd(Blocks blocks) {
+			proxyCallFixer.Deobfuscate(blocks);
+			InlineMethods(blocks);
+			base.DeobfuscateMethodEnd(blocks);
 		}
 
-		void inlineMethods(Blocks blocks) {
-			cfMethodCallInliner.deobfuscateBegin(blocks);
-			cfMethodCallInliner.deobfuscate(blocks.MethodBlocks.getAllBlocks());
+		void InlineMethods(Blocks blocks) {
+			cfMethodCallInliner.DeobfuscateBegin(blocks);
+			cfMethodCallInliner.Deobfuscate(blocks.MethodBlocks.GetAllBlocks());
 		}
 
-		public override void deobfuscateEnd() {
-			removeProxyDelegates(proxyCallFixer);
-			addTypeToBeRemoved(proxyCallFixer.ProxyMethodsType, "Type with proxy methods");
+		public override void DeobfuscateEnd() {
+			RemoveProxyDelegates(proxyCallFixer);
+			AddTypeToBeRemoved(proxyCallFixer.ProxyMethodsType, "Type with proxy methods");
 			if (CanRemoveStringDecrypterType)
-				addTypeToBeRemoved(stringDecrypter.Type, "String decrypter type");
-			base.deobfuscateEnd();
+				AddTypeToBeRemoved(stringDecrypter.Type, "String decrypter type");
+			base.DeobfuscateEnd();
 		}
 
-		public override IEnumerable<int> getStringDecrypterMethods() {
+		public override IEnumerable<int> GetStringDecrypterMethods() {
 			var list = new List<int>();
 			if (stringDecrypter.Method != null)
 				list.Add(stringDecrypter.Method.MDToken.ToInt32());
diff --git a/de4dot.code/deobfuscators/CodeFort/PasswordFinder.cs b/de4dot.code/deobfuscators/CodeFort/PasswordFinder.cs
index 89f114f4..d6d8051c 100644
--- a/de4dot.code/deobfuscators/CodeFort/PasswordFinder.cs
+++ b/de4dot.code/deobfuscators/CodeFort/PasswordFinder.cs
@@ -53,34 +53,34 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			}
 
 			public string Name {
-				get { return (string)readField("Name"); }
+				get { return (string)ReadField("Name"); }
 			}
 
 			public List<Obj> Members {
-				get { return getList("Members"); }
+				get { return GetList("Members"); }
 			}
 
 			public List<Obj> Instructions {
-				get { return getList("Instructions"); }
+				get { return GetList("Instructions"); }
 			}
 
 			public object Operand {
-				get { return readField("Operand"); }
+				get { return ReadField("Operand"); }
 			}
 
 			public string OpCode {
-				get { return (string)readField("OpCode"); }
+				get { return (string)ReadField("OpCode"); }
 			}
 
 			public Obj MemberDef {
-				get { return new Obj(readField("MemberDef")); }
+				get { return new Obj(ReadField("MemberDef")); }
 			}
 
-			protected object readField(string name) {
-				return PasswordFinder.readField(obj, name);
+			protected object ReadField(string name) {
+				return PasswordFinder.ReadField(obj, name);
 			}
 
-			public Obj findMethod(string name) {
+			public Obj FindMethod(string name) {
 				foreach (var member in Members) {
 					if (member.obj.GetType().ToString() != "MethodDef")
 						continue;
@@ -93,11 +93,11 @@ namespace de4dot.code.deobfuscators.CodeFort {
 				throw new ApplicationException(string.Format("Could not find method {0}", name));
 			}
 
-			List<Obj> getList(string name) {
-				return convertList((System.Collections.IList)readField(name));
+			List<Obj> GetList(string name) {
+				return ConvertList((System.Collections.IList)ReadField(name));
 			}
 
-			static List<Obj> convertList(System.Collections.IList inList) {
+			static List<Obj> ConvertList(System.Collections.IList inList) {
 				var outList = new List<Obj>(inList.Count);
 				foreach (var e in inList)
 					outList.Add(new Obj(e));
@@ -113,7 +113,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			this.serializedData = serializedData;
 		}
 
-		static object readField(object instance, string name) {
+		static object ReadField(object instance, string name) {
 			return instance.GetType().GetField(name).GetValue(instance);
 		}
 
@@ -121,18 +121,18 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			return (System.Collections.IList)obj;
 		}
 
-		public void find(out PasswordInfo mainAsmPassword, out PasswordInfo embedPassword) {
+		public void Find(out PasswordInfo mainAsmPassword, out PasswordInfo embedPassword) {
 			var asmBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName("asm"), AssemblyBuilderAccess.Run);
 			var moduleBuilder = asmBuilder.DefineDynamicModule("mod");
 			var serializedTypes = new SerializedTypes(moduleBuilder);
-			var allTypes = serializedTypes.deserialize(serializedData);
-			asmTypes = toList(readField(allTypes, "Types"));
+			var allTypes = serializedTypes.Deserialize(serializedData);
+			asmTypes = toList(ReadField(allTypes, "Types"));
 
-			mainAsmPassword = findMainAssemblyPassword();
-			embedPassword = findEmbedPassword();
+			mainAsmPassword = FindMainAssemblyPassword();
+			embedPassword = FindEmbedPassword();
 		}
 
-		Obj findType(string name) {
+		Obj FindType(string name) {
 			foreach (var tmp in asmTypes) {
 				var type = new Obj(tmp);
 				if (type.Name == name)
@@ -141,17 +141,17 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			return null;
 		}
 
-		PasswordInfo findMainAssemblyPassword() {
-			var type = findType("BootstrapDynArguments");
-			var cctor = type.findMethod(".cctor");
+		PasswordInfo FindMainAssemblyPassword() {
+			var type = FindType("BootstrapDynArguments");
+			var cctor = type.FindMethod(".cctor");
 			var instrs = cctor.Instructions;
-			var passphrase = findStringStoreValue(instrs, "KeyPassphrase");
-			var salt = findStringStoreValue(instrs, "KeySaltValue");
-			var iv = findStringStoreValue(instrs, "KeyIV");
+			var passphrase = FindStringStoreValue(instrs, "KeyPassphrase");
+			var salt = FindStringStoreValue(instrs, "KeySaltValue");
+			var iv = FindStringStoreValue(instrs, "KeyIV");
 			return new PasswordInfo(passphrase, salt, iv);
 		}
 
-		static string findStringStoreValue(List<Obj> instrs, string fieldName) {
+		static string FindStringStoreValue(List<Obj> instrs, string fieldName) {
 			for (int i = 0; i < instrs.Count - 1; i++) {
 				var ldstr = instrs[i];
 				if (ldstr.OpCode != "ldstr")
@@ -171,11 +171,11 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			return null;
 		}
 
-		PasswordInfo findEmbedPassword() {
-			var type = findType("CilEmbeddingHelper");
+		PasswordInfo FindEmbedPassword() {
+			var type = FindType("CilEmbeddingHelper");
 			if (type == null)
 				return null;
-			var method = type.findMethod("CurrentDomain_AssemblyResolve");
+			var method = type.FindMethod("CurrentDomain_AssemblyResolve");
 			var instrs = method.Instructions;
 			for (int i = 0; i < instrs.Count - 3; i++) {
 				int index = i;
@@ -183,12 +183,12 @@ namespace de4dot.code.deobfuscators.CodeFort {
 				var ldstr1 = instrs[index++];
 				if (ldstr1.OpCode != "ldstr")
 					continue;
-				var passphrase = getString(ldstr1, instrs, ref index);
+				var passphrase = GetString(ldstr1, instrs, ref index);
 
 				var ldstr2 = instrs[index++];
 				if (ldstr2.OpCode != "ldstr")
 					continue;
-				var salt = getString(ldstr2, instrs, ref index);
+				var salt = GetString(ldstr2, instrs, ref index);
 
 				var ldc = instrs[index++];
 				if (!ldc.OpCode.StartsWith("ldc.i4"))
@@ -197,7 +197,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 				var ldstr3 = instrs[index++];
 				if (ldstr3.OpCode != "ldstr")
 					continue;
-				var iv = getString(ldstr3, instrs, ref index);
+				var iv = GetString(ldstr3, instrs, ref index);
 
 				return new PasswordInfo(passphrase, salt, iv);
 			}
@@ -205,7 +205,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			return null;
 		}
 
-		static string getString(Obj ldstr, List<Obj> instrs, ref int index) {
+		static string GetString(Obj ldstr, List<Obj> instrs, ref int index) {
 			var s = (string)ldstr.Operand;
 			if (index >= instrs.Count)
 				return s;
diff --git a/de4dot.code/deobfuscators/CodeFort/ProxyCallFixer.cs b/de4dot.code/deobfuscators/CodeFort/ProxyCallFixer.cs
index 98aaa2b8..352beac0 100644
--- a/de4dot.code/deobfuscators/CodeFort/ProxyCallFixer.cs
+++ b/de4dot.code/deobfuscators/CodeFort/ProxyCallFixer.cs
@@ -36,30 +36,30 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			: base(module) {
 		}
 
-		public bool isProxyTargetMethod(IMethod method) {
-			return proxyTargetMethods.find(method);
+		public bool IsProxyTargetMethod(IMethod method) {
+			return proxyTargetMethods.Find(method);
 		}
 
-		public void findDelegateCreator() {
+		public void FindDelegateCreator() {
 			foreach (var type in module.Types) {
-				var creatorMethod = checkType(type);
+				var creatorMethod = CheckType(type);
 				if (creatorMethod == null)
 					continue;
 
-				setDelegateCreatorMethod(creatorMethod);
+				SetDelegateCreatorMethod(creatorMethod);
 				return;
 			}
 		}
 
-		static MethodDef checkType(TypeDef type) {
+		static MethodDef CheckType(TypeDef type) {
 			if (type.Fields.Count != 1)
 				return null;
 			if (type.Fields[0].FieldSig.GetFieldType().GetFullName() != "System.Reflection.Module")
 				return null;
-			return checkMethods(type);
+			return CheckMethods(type);
 		}
 
-		static MethodDef checkMethods(TypeDef type) {
+		static MethodDef CheckMethods(TypeDef type) {
 			if (type.Methods.Count != 3)
 				return null;
 
@@ -67,11 +67,11 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			foreach (var method in type.Methods) {
 				if (method.Name == ".cctor")
 					continue;
-				if (DotNetUtils.isMethod(method, "System.Void", "(System.Int32)")) {
+				if (DotNetUtils.IsMethod(method, "System.Void", "(System.Int32)")) {
 					creatorMethod = method;
 					continue;
 				}
-				if (DotNetUtils.isMethod(method, "System.MulticastDelegate", "(System.Type,System.Reflection.MethodInfo,System.Int32)"))
+				if (DotNetUtils.IsMethod(method, "System.MulticastDelegate", "(System.Type,System.Reflection.MethodInfo,System.Int32)"))
 					continue;
 
 				return null;
@@ -79,7 +79,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			return creatorMethod;
 		}
 
-		protected override object checkCctor(ref TypeDef type, MethodDef cctor) {
+		protected override object CheckCctor(ref TypeDef type, MethodDef cctor) {
 			var instrs = cctor.Body.Instructions;
 			if (instrs.Count != 3)
 				return null;
@@ -89,7 +89,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			var call = instrs[1];
 			if (call.OpCode.Code != Code.Call)
 				return null;
-			if (!isDelegateCreatorMethod(call.Operand as MethodDef))
+			if (!IsDelegateCreatorMethod(call.Operand as MethodDef))
 				return null;
 			int rid = ldci4.GetLdcI4Value();
 			if (cctor.DeclaringType.Rid != rid)
@@ -97,22 +97,22 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			return rid;
 		}
 
-		protected override void getCallInfo(object context, FieldDef field, out IMethod calledMethod, out OpCode callOpcode) {
+		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 = (rid << 4) + (uint)HexToInt((char)((byte)c + 0x2F));
 			rid &= 0x00FFFFFF;
 			calledMethod = module.ResolveMemberRef(rid);
-			var calledMethodDef = DotNetUtils.getMethod2(module, calledMethod);
+			var calledMethodDef = DotNetUtils.GetMethod2(module, calledMethod);
 			if (calledMethodDef != null) {
 				proxyMethodsType = calledMethodDef.DeclaringType;
-				proxyTargetMethods.add(calledMethodDef, true);
+				proxyTargetMethods.Add(calledMethodDef, true);
 				calledMethod = calledMethodDef;
 			}
 			callOpcode = OpCodes.Call;
 		}
 
-		static int hexToInt(char c) {
+		static int HexToInt(char c) {
 			if ('0' <= c && c <= '9')
 				return c - '0';
 			if ('a' <= c && c <= 'f')
diff --git a/de4dot.code/deobfuscators/CodeFort/StringDecrypter.cs b/de4dot.code/deobfuscators/CodeFort/StringDecrypter.cs
index a355b5f4..ed9641b2 100644
--- a/de4dot.code/deobfuscators/CodeFort/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/CodeFort/StringDecrypter.cs
@@ -43,9 +43,9 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			this.module = module;
 		}
 
-		public void find() {
+		public void Find() {
 			foreach (var type in module.Types) {
-				var method = checkType(type);
+				var method = CheckType(type);
 				if (method == null)
 					continue;
 
@@ -53,22 +53,22 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			}
 		}
 
-		static MethodDef checkType(TypeDef type) {
+		static MethodDef CheckType(TypeDef type) {
 			if (type.HasFields)
 				return null;
-			return checkMethods(type);
+			return CheckMethods(type);
 		}
 
-		static MethodDef checkMethods(TypeDef type) {
+		static MethodDef CheckMethods(TypeDef type) {
 			MethodDef decryptMethod = null;
 			foreach (var method in type.Methods) {
 				if (method.Name == ".cctor")
 					continue;
 				if (!method.IsStatic || method.Body == null)
 					return null;
-				if (!DotNetUtils.isMethod(method, "System.String", "(System.String)"))
+				if (!DotNetUtils.IsMethod(method, "System.String", "(System.String)"))
 					return null;
-				if (!hasDouble(method, 3992.0))
+				if (!HasDouble(method, 3992.0))
 					return null;
 
 				decryptMethod = method;
@@ -76,7 +76,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			return decryptMethod;
 		}
 
-		static bool hasDouble(MethodDef 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) {
@@ -88,7 +88,7 @@ namespace de4dot.code.deobfuscators.CodeFort {
 			return false;
 		}
 
-		public string decrypt(string s) {
+		public string Decrypt(string s) {
 			var bytes = new byte[s.Length];
 			for (int i = 0; i < s.Length; i++)
 				bytes[i] = (byte)(s[i] ^ 0x3F);
diff --git a/de4dot.code/deobfuscators/CodeVeil/AssemblyResolver.cs b/de4dot.code/deobfuscators/CodeVeil/AssemblyResolver.cs
index 5cdb4107..ed2bc9f7 100644
--- a/de4dot.code/deobfuscators/CodeVeil/AssemblyResolver.cs
+++ b/de4dot.code/deobfuscators/CodeVeil/AssemblyResolver.cs
@@ -46,7 +46,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 
 			public AssemblyInfo(string fullName, string extension, byte[] data) {
 				this.fullName = fullName;
-				this.simpleName = Utils.getAssemblySimpleName(fullName);
+				this.simpleName = Utils.GetAssemblySimpleName(fullName);
 				this.extension = extension;
 				this.data = data;
 			}
@@ -100,31 +100,31 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			this.module = module;
 		}
 
-		public void initialize() {
-			if (!findTypeAndResources())
+		public void Initialize() {
+			if (!FindTypeAndResources())
 				return;
 
-			findEmbeddedAssemblies();
+			FindEmbeddedAssemblies();
 		}
 
-		bool findTypeAndResources() {
-			var bundleDataTmp = DotNetUtils.getResource(module, ".bundle.dat") as EmbeddedResource;
-			var bundleXmlFileTmp = DotNetUtils.getResource(module, ".bundle.manifest") as EmbeddedResource;
+		bool FindTypeAndResources() {
+			var bundleDataTmp = DotNetUtils.GetResource(module, ".bundle.dat") as EmbeddedResource;
+			var bundleXmlFileTmp = DotNetUtils.GetResource(module, ".bundle.manifest") as EmbeddedResource;
 			if (bundleDataTmp == null || bundleXmlFileTmp == null)
 				return false;
 
-			var bundleTypeTmp = findBundleType();
+			var bundleTypeTmp = FindBundleType();
 			if (bundleTypeTmp == null)
 				return false;
 
 			bundleData = bundleDataTmp;
 			bundleXmlFile = bundleXmlFileTmp;
 			bundleType = bundleTypeTmp;
-			findOtherTypes();
+			FindOtherTypes();
 			return true;
 		}
 
-		void findEmbeddedAssemblies() {
+		void FindEmbeddedAssemblies() {
 			var data = bundleData.Data.ReadAllBytes();
 
 			var doc = new XmlDocument();
@@ -145,19 +145,19 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 					continue;
 				}
 
-				int offset = getAttributeValueInt32(assemblyElem, "offset");
+				int offset = GetAttributeValueInt32(assemblyElem, "offset");
 				if (offset < 0) {
 					Logger.w("Could not find offset attribute");
 					continue;
 				}
 
-				var assemblyData = DeobUtils.inflate(data, offset, data.Length - offset, true);
+				var assemblyData = DeobUtils.Inflate(data, offset, data.Length - offset, true);
 				var mod = ModuleDefMD.Load(assemblyData);
-				infos.Add(new AssemblyInfo(mod.Assembly.FullName, DeobUtils.getExtension(mod.Kind), assemblyData));
+				infos.Add(new AssemblyInfo(mod.Assembly.FullName, DeobUtils.GetExtension(mod.Kind), assemblyData));
 			}
 		}
 
-		static int getAttributeValueInt32(XmlElement elem, string attrName) {
+		static int GetAttributeValueInt32(XmlElement elem, string attrName) {
 			var str = elem.GetAttribute(attrName);
 			if (string.IsNullOrEmpty(str))
 				return -1;
@@ -169,7 +169,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return value;
 		}
 
-		TypeDef findBundleType() {
+		TypeDef FindBundleType() {
 			foreach (var type in module.Types) {
 				if (type.Namespace != "")
 					continue;
@@ -179,13 +179,13 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 				var ctor = type.FindMethod(".ctor");
 				if (ctor == null || !ctor.IsPrivate)
 					continue;
-				if (!DotNetUtils.isMethod(ctor, "System.Void", "(System.Reflection.Assembly)"))
+				if (!DotNetUtils.IsMethod(ctor, "System.Void", "(System.Reflection.Assembly)"))
 					continue;
 
-				var initMethodTmp = findInitMethod(type);
+				var initMethodTmp = FindInitMethod(type);
 				if (initMethodTmp == null)
 					continue;
-				var getTempFilenameMethod = findGetTempFilenameMethod(type);
+				var getTempFilenameMethod = FindGetTempFilenameMethod(type);
 				if (getTempFilenameMethod == null)
 					continue;
 
@@ -195,13 +195,13 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return null;
 		}
 
-		MethodDef findInitMethod(TypeDef type) {
+		MethodDef FindInitMethod(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
 				if (!method.IsPublic && !method.IsAssembly)
 					continue;
-				if (!DotNetUtils.isMethod(method, "System.Void", "(System.Reflection.Assembly)"))
+				if (!DotNetUtils.IsMethod(method, "System.Void", "(System.Reflection.Assembly)"))
 					continue;
 
 				return method;
@@ -210,13 +210,13 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return null;
 		}
 
-		MethodDef findGetTempFilenameMethod(TypeDef type) {
+		MethodDef FindGetTempFilenameMethod(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (method.IsStatic || method.Body == null)
 					continue;
 				if (!method.IsPublic && !method.IsAssembly)
 					continue;
-				if (!DotNetUtils.isMethod(method, "System.String", "(System.String)"))
+				if (!DotNetUtils.IsMethod(method, "System.String", "(System.String)"))
 					continue;
 
 				return method;
@@ -225,13 +225,13 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return null;
 		}
 
-		void findOtherTypes() {
-			findAssemblyManagerType();
-			findXmlParserType();
-			findStreamProviderType();
+		void FindOtherTypes() {
+			FindAssemblyManagerType();
+			FindXmlParserType();
+			FindStreamProviderType();
 		}
 
-		void findAssemblyManagerType() {
+		void FindAssemblyManagerType() {
 			if (bundleType == null)
 				return;
 
@@ -260,7 +260,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			}
 		}
 
-		void findXmlParserType() {
+		void FindXmlParserType() {
 			if (assemblyManagerType == null)
 				return;
 			foreach (var field in assemblyManagerType.Fields) {
@@ -268,7 +268,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 				if (type == null || type.IsInterface)
 					continue;
 				var ctor = type.FindMethod(".ctor");
-				if (!DotNetUtils.isMethod(ctor, "System.Void", "()"))
+				if (!DotNetUtils.IsMethod(ctor, "System.Void", "()"))
 					continue;
 				if (type.Fields.Count != 1)
 					continue;
@@ -289,11 +289,11 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			}
 		}
 
-		void findStreamProviderType() {
+		void FindStreamProviderType() {
 			if (bundleType == null)
 				return;
 			var ctor = bundleType.FindMethod(".ctor");
-			if (!DotNetUtils.isMethod(ctor, "System.Void", "(System.Reflection.Assembly)"))
+			if (!DotNetUtils.IsMethod(ctor, "System.Void", "(System.Reflection.Assembly)"))
 				return;
 			foreach (var instr in ctor.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Newobj)
@@ -303,7 +303,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 					continue;
 				if (newobjCtor.DeclaringType == assemblyManagerType)
 					continue;
-				if (!DotNetUtils.isMethod(newobjCtor, "System.Void", "(System.Reflection.Assembly,System.String)"))
+				if (!DotNetUtils.IsMethod(newobjCtor, "System.Void", "(System.Reflection.Assembly,System.String)"))
 					continue;
 				var type = newobjCtor.DeclaringType;
 				if (type.Interfaces.Count != 1)
diff --git a/de4dot.code/deobfuscators/CodeVeil/Deobfuscator.cs b/de4dot.code/deobfuscators/CodeVeil/Deobfuscator.cs
index dfb7e573..6e546b4a 100644
--- a/de4dot.code/deobfuscators/CodeVeil/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/CodeVeil/Deobfuscator.cs
@@ -40,13 +40,13 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			get { return THE_TYPE; }
 		}
 
-		public override IDeobfuscator createDeobfuscator() {
+		public override IDeobfuscator CreateDeobfuscator() {
 			return new Deobfuscator(new Deobfuscator.Options {
 				ValidNameRegex = validNameRegex.get(),
 			});
 		}
 
-		protected override IEnumerable<Option> getOptionsInternal() {
+		protected override IEnumerable<Option> GetOptionsInternal() {
 			return new List<Option>() {
 			};
 		}
@@ -85,35 +85,35 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			StringFeatures = StringFeatures.AllowStaticDecryption | StringFeatures.AllowDynamicDecryption;
 		}
 
-		protected override int detectInternal() {
+		protected override int DetectInternal() {
 			int val = 0;
 
-			int sum = toInt32(mainType.Detected) +
-					toInt32(methodsDecrypter.Detected) +
-					toInt32(stringDecrypter.Detected) +
-					toInt32(proxyCallFixer.Detected);
+			int sum = ToInt32(mainType.Detected) +
+					ToInt32(methodsDecrypter.Detected) +
+					ToInt32(stringDecrypter.Detected) +
+					ToInt32(proxyCallFixer.Detected);
 			if (sum > 0)
 				val += 100 + 10 * (sum - 1);
 
 			return val;
 		}
 
-		protected override void scanForObfuscator() {
-			findKillType();
+		protected override void ScanForObfuscator() {
+			FindKillType();
 			mainType = new MainType(module);
-			mainType.find();
+			mainType.Find();
 			proxyCallFixer = new ProxyCallFixer(module, mainType);
-			proxyCallFixer.findDelegateCreator();
+			proxyCallFixer.FindDelegateCreator();
 			methodsDecrypter = new MethodsDecrypter(mainType);
-			methodsDecrypter.find();
+			methodsDecrypter.Find();
 			stringDecrypter = new StringDecrypter(module, mainType);
-			stringDecrypter.find();
-			var version = detectVersion();
+			stringDecrypter.Find();
+			var version = DetectVersion();
 			if (!string.IsNullOrEmpty(version))
 				obfuscatorName = obfuscatorName + " " + version;
 		}
 
-		string detectVersion() {
+		string DetectVersion() {
 			if (mainType.Detected) {
 				switch (mainType.Version) {
 				case ObfuscatorVersion.Unknown:
@@ -139,7 +139,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return null;
 		}
 
-		void findKillType() {
+		void FindKillType() {
 			foreach (var type in module.Types) {
 				if (type.FullName == "____KILL") {
 					killType = type;
@@ -148,134 +148,134 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			}
 		}
 
-		public override bool getDecryptedModule(int count, ref byte[] newFileData, ref DumpedMethods dumpedMethods) {
+		public override bool GetDecryptedModule(int count, ref byte[] newFileData, ref DumpedMethods dumpedMethods) {
 			if (count != 0 || !methodsDecrypter.Detected)
 				return false;
 
-			var fileData = DeobUtils.readModule(module);
-			if (!methodsDecrypter.decrypt(fileData, ref dumpedMethods))
+			var fileData = DeobUtils.ReadModule(module);
+			if (!methodsDecrypter.Decrypt(fileData, ref dumpedMethods))
 				return false;
 
 			newFileData = fileData;
 			return true;
 		}
 
-		public override IDeobfuscator moduleReloaded(ModuleDefMD module) {
+		public override IDeobfuscator ModuleReloaded(ModuleDefMD module) {
 			var newOne = new Deobfuscator(options);
-			newOne.setModule(module);
+			newOne.SetModule(module);
 			newOne.mainType = new MainType(module, mainType);
 			newOne.methodsDecrypter = new MethodsDecrypter(mainType, methodsDecrypter);
 			newOne.stringDecrypter = new StringDecrypter(module, newOne.mainType, stringDecrypter);
 			newOne.proxyCallFixer = new ProxyCallFixer(module, newOne.mainType, proxyCallFixer);
-			newOne.killType = DeobUtils.lookup(module, killType, "Could not find KILL type");
+			newOne.killType = DeobUtils.Lookup(module, killType, "Could not find KILL type");
 			return newOne;
 		}
 
-		public override void deobfuscateBegin() {
-			base.deobfuscateBegin();
+		public override void DeobfuscateBegin() {
+			base.DeobfuscateBegin();
 
-			addTypeToBeRemoved(killType, "KILL type");
+			AddTypeToBeRemoved(killType, "KILL type");
 
-			mainType.initialize();
+			mainType.Initialize();
 			foreach (var initMethod in mainType.OtherInitMethods) {
-				addCctorInitCallToBeRemoved(initMethod);
-				addCtorInitCallToBeRemoved(initMethod);
+				AddCctorInitCallToBeRemoved(initMethod);
+				AddCtorInitCallToBeRemoved(initMethod);
 			}
 
 			if (Operations.DecryptStrings != OpDecryptString.None) {
-				stringDecrypter.initialize();
-				staticStringInliner.add(stringDecrypter.DecryptMethod, (method, gim, args) => {
-					return stringDecrypter.decrypt((int)args[0]);
+				stringDecrypter.Initialize();
+				staticStringInliner.Add(stringDecrypter.DecryptMethod, (method, gim, args) => {
+					return stringDecrypter.Decrypt((int)args[0]);
 				});
-				DeobfuscatedFile.stringDecryptersAdded();
-				addModuleCctorInitCallToBeRemoved(stringDecrypter.InitMethod);
-				addCallToBeRemoved(mainType.getInitStringDecrypterMethod(stringDecrypter.InitMethod), stringDecrypter.InitMethod);
+				DeobfuscatedFile.StringDecryptersAdded();
+				AddModuleCctorInitCallToBeRemoved(stringDecrypter.InitMethod);
+				AddCallToBeRemoved(mainType.GetInitStringDecrypterMethod(stringDecrypter.InitMethod), stringDecrypter.InitMethod);
 			}
 
 			assemblyResolver = new AssemblyResolver(module);
-			assemblyResolver.initialize();
-			dumpEmbeddedAssemblies();
+			assemblyResolver.Initialize();
+			DumpEmbeddedAssemblies();
 
-			removeTamperDetection();
+			RemoveTamperDetection();
 
-			proxyCallFixer.initialize();
-			proxyCallFixer.find();
+			proxyCallFixer.Initialize();
+			proxyCallFixer.Find();
 
 			resourceDecrypter = new ResourceDecrypter(module);
-			resourceDecrypter.initialize();
-			resourceDecrypter.decrypt();
+			resourceDecrypter.Initialize();
+			resourceDecrypter.Decrypt();
 			if (resourceDecrypter.CanRemoveTypes) {
-				addTypeToBeRemoved(resourceDecrypter.ResourceFlagsType, "Obfuscator ResourceFlags type");
-				addTypeToBeRemoved(resourceDecrypter.ResType, "Obfuscator Res type");
-				addTypeToBeRemoved(resourceDecrypter.ResourceEnumeratorType, "Obfuscator ResourceEnumerator type");
-				addTypeToBeRemoved(resourceDecrypter.EncryptedResourceReaderType, "Obfuscator EncryptedResourceReader type");
-				addTypeToBeRemoved(resourceDecrypter.EncryptedResourceSetType, "Obfuscator EncryptedResourceSet type");
-				addTypeToBeRemoved(resourceDecrypter.EncryptedResourceStreamType, "Obfuscator EncryptedResourceStream type");
+				AddTypeToBeRemoved(resourceDecrypter.ResourceFlagsType, "Obfuscator ResourceFlags type");
+				AddTypeToBeRemoved(resourceDecrypter.ResType, "Obfuscator Res type");
+				AddTypeToBeRemoved(resourceDecrypter.ResourceEnumeratorType, "Obfuscator ResourceEnumerator type");
+				AddTypeToBeRemoved(resourceDecrypter.EncryptedResourceReaderType, "Obfuscator EncryptedResourceReader type");
+				AddTypeToBeRemoved(resourceDecrypter.EncryptedResourceSetType, "Obfuscator EncryptedResourceSet type");
+				AddTypeToBeRemoved(resourceDecrypter.EncryptedResourceStreamType, "Obfuscator EncryptedResourceStream type");
 			}
 		}
 
-		void removeTamperDetection() {
+		void RemoveTamperDetection() {
 			var tamperDetection = new TamperDetection(module, mainType);
-			tamperDetection.initialize();
+			tamperDetection.Initialize();
 			foreach (var tamperDetectionMethod in tamperDetection.Methods)
-				addCctorInitCallToBeRemoved(tamperDetectionMethod);
-			addTypeToBeRemoved(tamperDetection.Type, "Tamper detection type");
+				AddCctorInitCallToBeRemoved(tamperDetectionMethod);
+			AddTypeToBeRemoved(tamperDetection.Type, "Tamper detection type");
 		}
 
-		void dumpEmbeddedAssemblies() {
+		void DumpEmbeddedAssemblies() {
 			foreach (var info in assemblyResolver.AssemblyInfos)
-				DeobfuscatedFile.createAssemblyFile(info.data, info.simpleName, info.extension);
-			addResourceToBeRemoved(assemblyResolver.BundleDataResource, "Embedded assemblies resource");
-			addResourceToBeRemoved(assemblyResolver.BundleXmlFileResource, "Embedded assemblies XML file resource");
-			addTypesToBeRemoved(assemblyResolver.BundleTypes, "Obfuscator assembly bundle types");
+				DeobfuscatedFile.CreateAssemblyFile(info.data, info.simpleName, info.extension);
+			AddResourceToBeRemoved(assemblyResolver.BundleDataResource, "Embedded assemblies resource");
+			AddResourceToBeRemoved(assemblyResolver.BundleXmlFileResource, "Embedded assemblies XML file resource");
+			AddTypesToBeRemoved(assemblyResolver.BundleTypes, "Obfuscator assembly bundle types");
 		}
 
-		public override void deobfuscateMethodBegin(Blocks blocks) {
-			proxyCallFixer.deobfuscate(blocks);
-			base.deobfuscateMethodBegin(blocks);
+		public override void DeobfuscateMethodBegin(Blocks blocks) {
+			proxyCallFixer.Deobfuscate(blocks);
+			base.DeobfuscateMethodBegin(blocks);
 		}
 
-		public override void deobfuscateMethodEnd(Blocks blocks) {
-			mainType.removeInitCall(blocks);
-			resourceDecrypter.deobfuscate(blocks);
-			base.deobfuscateMethodEnd(blocks);
+		public override void DeobfuscateMethodEnd(Blocks blocks) {
+			mainType.RemoveInitCall(blocks);
+			resourceDecrypter.Deobfuscate(blocks);
+			base.DeobfuscateMethodEnd(blocks);
 		}
 
-		public override void deobfuscateEnd() {
+		public override void DeobfuscateEnd() {
 			bool canRemoveProxyTypes = proxyCallFixer.CanRemoveTypes;
 
 			if (CanRemoveStringDecrypterType)
-				addTypeToBeRemoved(stringDecrypter.Type, "String decrypter type");
+				AddTypeToBeRemoved(stringDecrypter.Type, "String decrypter type");
 
 			if (!mainType.Detected) {
 			}
 			else if (mainType.Version >= ObfuscatorVersion.V5_0) {
 				if (!proxyCallFixer.FoundProxyType || canRemoveProxyTypes)
-					addTypeToBeRemoved(mainType.Type, "Main CV type");
+					AddTypeToBeRemoved(mainType.Type, "Main CV type");
 			}
 			else {
 				var type = mainType.Type;
 				if (!type.HasNestedTypes && !type.HasProperties && !type.HasEvents && !type.HasFields)
-					addTypeToBeRemoved(type, "Main CV type");
+					AddTypeToBeRemoved(type, "Main CV type");
 				else {
 					foreach (var method in type.Methods)
-						addMethodToBeRemoved(method, "CV main type method");
+						AddMethodToBeRemoved(method, "CV main type method");
 				}
 			}
 
-			removeProxyDelegates(proxyCallFixer, canRemoveProxyTypes);
+			RemoveProxyDelegates(proxyCallFixer, canRemoveProxyTypes);
 			if (canRemoveProxyTypes) {
-				addTypeToBeRemoved(proxyCallFixer.IlGeneratorType, "Obfuscator proxy method ILGenerator type");
-				addTypeToBeRemoved(proxyCallFixer.FieldInfoType, "Obfuscator proxy method FieldInfo type");
-				addTypeToBeRemoved(proxyCallFixer.MethodInfoType, "Obfuscator proxy method MethodInfo type");
+				AddTypeToBeRemoved(proxyCallFixer.IlGeneratorType, "Obfuscator proxy method ILGenerator type");
+				AddTypeToBeRemoved(proxyCallFixer.FieldInfoType, "Obfuscator proxy method FieldInfo type");
+				AddTypeToBeRemoved(proxyCallFixer.MethodInfoType, "Obfuscator proxy method MethodInfo type");
 			}
 
-			addMethodsToBeRemoved(InvalidMethodsFinder.findAll(module), "Anti-reflection method");
+			AddMethodsToBeRemoved(InvalidMethodsFinder.FindAll(module), "Anti-reflection method");
 
-			base.deobfuscateEnd();
+			base.DeobfuscateEnd();
 		}
 
-		public override IEnumerable<int> getStringDecrypterMethods() {
+		public override IEnumerable<int> GetStringDecrypterMethods() {
 			var list = new List<int>();
 			if (stringDecrypter.DecryptMethod != null)
 				list.Add(stringDecrypter.DecryptMethod.MDToken.ToInt32());
diff --git a/de4dot.code/deobfuscators/CodeVeil/ErexResourceReader.cs b/de4dot.code/deobfuscators/CodeVeil/ErexResourceReader.cs
index c6842373..e2ce48cf 100644
--- a/de4dot.code/deobfuscators/CodeVeil/ErexResourceReader.cs
+++ b/de4dot.code/deobfuscators/CodeVeil/ErexResourceReader.cs
@@ -30,7 +30,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			this.reader = reader;
 		}
 
-		public byte[] decrypt() {
+		public byte[] Decrypt() {
 			if (reader.ReadUInt32() != 0x58455245)
 				throw new InvalidDataException("Invalid EREX sig");
 			if (reader.ReadInt32() > 1)
@@ -45,29 +45,29 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 				throw new ApplicationException("Invalid length");
 
 			if (isEncrypted)
-				readKey();
+				ReadKey();
 
 			if (isDeflated)
-				reader = inflate(length);
+				reader = Inflate(length);
 
 			if (isEncrypted)
-				reader = decrypt(length);
+				reader = Decrypt(length);
 
 			return reader.ReadBytes(length);
 		}
 
-		void readKey() {
+		void ReadKey() {
 			key = new uint[reader.ReadByte()];
 			for (int i = 0; i < key.Length; i++)
 				key[i] = reader.ReadUInt32();
 		}
 
-		IBinaryReader inflate(int length) {
+		IBinaryReader Inflate(int length) {
 			var data = reader.ReadRemainingBytes();
-			return MemoryImageStream.Create(DeobUtils.inflate(data, true));
+			return MemoryImageStream.Create(DeobUtils.Inflate(data, true));
 		}
 
-		IBinaryReader decrypt(int length) {
+		IBinaryReader Decrypt(int length) {
 			var block = new uint[4];
 			var decrypted = new byte[16];
 
@@ -77,7 +77,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 				block[1] = reader.ReadUInt32();
 				block[2] = reader.ReadUInt32();
 				block[3] = reader.ReadUInt32();
-				DeobUtils.xxteaDecrypt(block, key);
+				DeobUtils.XxteaDecrypt(block, key);
 				Buffer.BlockCopy(block, 0, decrypted, 0, decrypted.Length);
 				outStream.Write(decrypted, 0, decrypted.Length);
 			}
diff --git a/de4dot.code/deobfuscators/CodeVeil/InvalidMethodsFinder.cs b/de4dot.code/deobfuscators/CodeVeil/InvalidMethodsFinder.cs
index a44df4fd..fba61b40 100644
--- a/de4dot.code/deobfuscators/CodeVeil/InvalidMethodsFinder.cs
+++ b/de4dot.code/deobfuscators/CodeVeil/InvalidMethodsFinder.cs
@@ -22,18 +22,18 @@ using dnlib.DotNet;
 
 namespace de4dot.code.deobfuscators.CodeVeil {
 	class InvalidMethodsFinder {
-		public static List<MethodDef> findAll(ModuleDefMD module) {
+		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))
+					if (IsInvalidMethod(method))
 						list.Add(method);
 				}
 			}
 			return list;
 		}
 
-		public static bool isInvalidMethod(MethodDef method) {
+		public static bool IsInvalidMethod(MethodDef method) {
 			if (method == null || method.IsStatic)
 				return false;
 			var sig = method.MethodSig;
diff --git a/de4dot.code/deobfuscators/CodeVeil/MainType.cs b/de4dot.code/deobfuscators/CodeVeil/MainType.cs
index 93b5fd2f..870a7155 100644
--- a/de4dot.code/deobfuscators/CodeVeil/MainType.cs
+++ b/de4dot.code/deobfuscators/CodeVeil/MainType.cs
@@ -67,21 +67,21 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 
 		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");
-			this.tamperCheckMethod = lookup(oldOne.tamperCheckMethod, "Could not find tamper detection method");
+			this.theType = Lookup(oldOne.theType, "Could not find main type");
+			this.initMethod = Lookup(oldOne.initMethod, "Could not find main type init method");
+			this.tamperCheckMethod = Lookup(oldOne.tamperCheckMethod, "Could not find tamper detection method");
 			this.obfuscatorVersion = oldOne.obfuscatorVersion;
 			this.rvas = oldOne.rvas;
 			foreach (var otherInitMethod in otherInitMethods)
-				otherInitMethods.Add(lookup(otherInitMethod, "Could not find otherInitMethod"));
+				otherInitMethods.Add(Lookup(otherInitMethod, "Could not find otherInitMethod"));
 		}
 
-		T lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
-			return DeobUtils.lookup(module, def, errorMessage);
+		T Lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
+			return DeobUtils.Lookup(module, def, errorMessage);
 		}
 
-		public void find() {
-			var cctor = DotNetUtils.getModuleTypeCctor(module);
+		public void Find() {
+			var cctor = DotNetUtils.GetModuleTypeCctor(module);
 			if (cctor == null)
 				return;
 
@@ -100,9 +100,9 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 					continue;
 				var initMethodTmp = call.Operand as MethodDef;
 				ObfuscatorVersion obfuscatorVersionTmp;
-				if (!checkInitMethod(initMethodTmp, out obfuscatorVersionTmp))
+				if (!CheckInitMethod(initMethodTmp, out obfuscatorVersionTmp))
 					continue;
-				if (!checkMethodsType(initMethodTmp.DeclaringType))
+				if (!CheckMethodsType(initMethodTmp.DeclaringType))
 					continue;
 
 				obfuscatorVersion = obfuscatorVersionTmp;
@@ -117,7 +117,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			"System.Collections.Generic.List`1<System.Delegate>",
 			"System.Runtime.InteropServices.GCHandle",
 		};
-		bool checkInitMethod(MethodDef initMethod, out ObfuscatorVersion obfuscatorVersionTmp) {
+		bool CheckInitMethod(MethodDef initMethod, out ObfuscatorVersion obfuscatorVersionTmp) {
 			obfuscatorVersionTmp = ObfuscatorVersion.Unknown;
 
 			if (initMethod == null)
@@ -126,18 +126,18 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 				return false;
 			if (!initMethod.IsStatic)
 				return false;
-			if (!DotNetUtils.isMethod(initMethod, "System.Void", "(System.Boolean,System.Boolean)"))
+			if (!DotNetUtils.IsMethod(initMethod, "System.Void", "(System.Boolean,System.Boolean)"))
 				return false;
 
-			if (hasCodeString(initMethod, "E_FullTrust")) {
-				if (DotNetUtils.getPInvokeMethod(initMethod.DeclaringType, "user32", "CallWindowProcW") != null)
+			if (HasCodeString(initMethod, "E_FullTrust")) {
+				if (DotNetUtils.GetPInvokeMethod(initMethod.DeclaringType, "user32", "CallWindowProcW") != null)
 					obfuscatorVersionTmp = ObfuscatorVersion.V4_1;
 				else
 					obfuscatorVersionTmp = ObfuscatorVersion.V4_0;
 			}
-			else if (hasCodeString(initMethod, "Full Trust Required"))
+			else if (HasCodeString(initMethod, "Full Trust Required"))
 				obfuscatorVersionTmp = ObfuscatorVersion.V3;
-			else if (initMethod.DeclaringType.HasNestedTypes && new FieldTypes(initMethod.DeclaringType).all(fieldTypesV5))
+			else if (initMethod.DeclaringType.HasNestedTypes && new FieldTypes(initMethod.DeclaringType).All(fieldTypesV5))
 				obfuscatorVersionTmp = ObfuscatorVersion.V5_0;
 			else
 				return false;
@@ -145,18 +145,18 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return true;
 		}
 
-		static bool hasCodeString(MethodDef method, string str) {
-			foreach (var s in DotNetUtils.getCodeStrings(method)) {
+		static bool HasCodeString(MethodDef method, string str) {
+			foreach (var s in DotNetUtils.GetCodeStrings(method)) {
 				if (s == str)
 					return true;
 			}
 			return false;
 		}
 
-		bool checkMethodsType(TypeDef type) {
+		bool CheckMethodsType(TypeDef type) {
 			rvas = new List<uint>();
 
-			var fields = getRvaFields(type);
+			var fields = GetRvaFields(type);
 			if (fields.Count < 2)	// RVAs for executive and stub are always present if encrypted methods
 				return true;
 
@@ -165,7 +165,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return true;
 		}
 
-		static List<FieldDef> getRvaFields(TypeDef type) {
+		static List<FieldDef> GetRvaFields(TypeDef type) {
 			var fields = new List<FieldDef>();
 			foreach (var field in type.Fields) {
 				var etype = field.FieldSig.GetFieldType().GetElementType();
@@ -179,19 +179,19 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return fields;
 		}
 
-		public void initialize() {
+		public void Initialize() {
 			if (theType == null)
 				return;
 
-			tamperCheckMethod = findTamperCheckMethod();
-			otherInitMethods = findOtherInitMethods();
+			tamperCheckMethod = FindTamperCheckMethod();
+			otherInitMethods = FindOtherInitMethods();
 		}
 
-		MethodDef findTamperCheckMethod() {
+		MethodDef FindTamperCheckMethod() {
 			foreach (var method in theType.Methods) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
-				if (!DotNetUtils.isMethod(method, "System.Void", "(System.Reflection.Assembly,System.UInt64)"))
+				if (!DotNetUtils.IsMethod(method, "System.Void", "(System.Reflection.Assembly,System.UInt64)"))
 					continue;
 
 				return method;
@@ -200,14 +200,14 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return null;
 		}
 
-		List<MethodDef> findOtherInitMethods() {
+		List<MethodDef> FindOtherInitMethods() {
 			var list = new List<MethodDef>();
 			foreach (var method in theType.Methods) {
 				if (!method.IsStatic)
 					continue;
 				if (method.Name == ".cctor")
 					continue;
-				if (!DotNetUtils.isMethod(method, "System.Void", "()"))
+				if (!DotNetUtils.IsMethod(method, "System.Void", "()"))
 					continue;
 
 				list.Add(method);
@@ -215,7 +215,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return list;
 		}
 
-		public MethodDef getInitStringDecrypterMethod(MethodDef stringDecrypterInitMethod) {
+		public MethodDef GetInitStringDecrypterMethod(MethodDef stringDecrypterInitMethod) {
 			if (stringDecrypterInitMethod == null)
 				return null;
 			if (theType == null)
@@ -224,34 +224,34 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			foreach (var method in theType.Methods) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
-				if (callsMethod(method, stringDecrypterInitMethod))
+				if (CallsMethod(method, stringDecrypterInitMethod))
 					return method;
 			}
 			return null;
 		}
 
-		bool callsMethod(MethodDef methodToCheck, MethodDef calledMethod) {
-			foreach (var method in DotNetUtils.getCalledMethods(module, methodToCheck)) {
+		bool CallsMethod(MethodDef methodToCheck, MethodDef calledMethod) {
+			foreach (var method in DotNetUtils.GetCalledMethods(module, methodToCheck)) {
 				if (method == calledMethod)
 					return true;
 			}
 			return false;
 		}
 
-		public void removeInitCall(Blocks blocks) {
+		public void RemoveInitCall(Blocks blocks) {
 			if (initMethod == null || theType == null)
 				return;
 			if (blocks.Method.Name != ".cctor")
 				return;
-			if (blocks.Method.DeclaringType != DotNetUtils.getModuleType(module))
+			if (blocks.Method.DeclaringType != DotNetUtils.GetModuleType(module))
 				return;
 
-			foreach (var block in blocks.MethodBlocks.getAllBlocks()) {
+			foreach (var block in blocks.MethodBlocks.GetAllBlocks()) {
 				var instrs = block.Instructions;
 				for (int i = 0; i < instrs.Count - 2; i++) {
-					if (!instrs[i].isLdcI4())
+					if (!instrs[i].IsLdcI4())
 						continue;
-					if (!instrs[i + 1].isLdcI4())
+					if (!instrs[i + 1].IsLdcI4())
 						continue;
 					var call = instrs[i + 2];
 					if (call.OpCode.Code != Code.Call)
@@ -259,7 +259,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 					if (call.Operand != initMethod)
 						continue;
 
-					block.remove(i, 3);
+					block.Remove(i, 3);
 					return;
 				}
 			}
diff --git a/de4dot.code/deobfuscators/CodeVeil/MethodsDecrypter.cs b/de4dot.code/deobfuscators/CodeVeil/MethodsDecrypter.cs
index 3537cb9a..58df9d4f 100644
--- a/de4dot.code/deobfuscators/CodeVeil/MethodsDecrypter.cs
+++ b/de4dot.code/deobfuscators/CodeVeil/MethodsDecrypter.cs
@@ -30,18 +30,18 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 		IDecrypter decrypter;
 
 		interface IDecrypter {
-			void initialize(byte[] methodsData);
-			bool decrypt(IBinaryReader fileDataReader, DumpedMethod dm);
+			void Initialize(byte[] methodsData);
+			bool Decrypt(IBinaryReader fileDataReader, DumpedMethod dm);
 		}
 
 		class Decrypter : IDecrypter {
 			IBinaryReader methodsDataReader;
 
-			public virtual void initialize(byte[] methodsData) {
+			public virtual void Initialize(byte[] methodsData) {
 				methodsDataReader = MemoryImageStream.Create(methodsData);
 			}
 
-			public virtual bool decrypt(IBinaryReader fileDataReader, DumpedMethod dm) {
+			public virtual bool Decrypt(IBinaryReader fileDataReader, DumpedMethod dm) {
 				if (fileDataReader.ReadByte() != 0x2A)
 					return false;	// Not a RET
 				methodsDataReader.Position = fileDataReader.ReadCompressedUInt32();
@@ -49,15 +49,15 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 				dm.mhCodeSize = methodsDataReader.ReadCompressedUInt32();
 				dm.code = methodsDataReader.ReadBytes((int)dm.mhCodeSize);
 				if ((dm.mhFlags & 8) != 0)
-					dm.extraSections = MethodBodyParser.readExtraSections(methodsDataReader);
+					dm.extraSections = MethodBodyParser.ReadExtraSections(methodsDataReader);
 
-				if (!decryptCode(dm))
+				if (!DecryptCode(dm))
 					return false;
 
 				return true;
 			}
 
-			protected virtual bool decryptCode(DumpedMethod dm) {
+			protected virtual bool DecryptCode(DumpedMethod dm) {
 				return true;
 			}
 		}
@@ -65,16 +65,16 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 		class DecrypterV5 : Decrypter {
 			byte[] decryptKey;
 
-			public override void initialize(byte[] methodsData) {
-				var data = DeobUtils.inflate(methodsData, true);
+			public override void Initialize(byte[] methodsData) {
+				var data = DeobUtils.Inflate(methodsData, true);
 				decryptKey = BitConverter.GetBytes(BitConverter.ToUInt32(data, 0));
 
 				var newMethodsData = new byte[data.Length - 4];
 				Array.Copy(data, 4, newMethodsData, 0, newMethodsData.Length);
-				base.initialize(newMethodsData);
+				base.Initialize(newMethodsData);
 			}
 
-			protected override bool decryptCode(DumpedMethod dm) {
+			protected override bool DecryptCode(DumpedMethod dm) {
 				var code = dm.code;
 				for (int i = 0; i < code.Length; i++) {
 					for (int j = 0; j < 4 && i + j < code.Length; j++)
@@ -97,7 +97,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			this.mainType = mainType;
 		}
 
-		public void find() {
+		public void Find() {
 			if (!mainType.Detected)
 				return;
 
@@ -120,7 +120,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			}
 		}
 
-		public bool decrypt(byte[] fileData, ref DumpedMethods dumpedMethods) {
+		public bool Decrypt(byte[] fileData, ref DumpedMethods dumpedMethods) {
 			if (decrypter == null)
 				return false;
 
@@ -128,13 +128,13 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 				if (peImage.Sections.Count <= 0)
 					return false;
 
-				var methodsData = findMethodsData(peImage, fileData);
+				var methodsData = FindMethodsData(peImage, fileData);
 				if (methodsData == null)
 					return false;
 
-				decrypter.initialize(methodsData);
+				decrypter.Initialize(methodsData);
 
-				dumpedMethods = createDumpedMethods(peImage, fileData, methodsData);
+				dumpedMethods = CreateDumpedMethods(peImage, fileData, methodsData);
 				if (dumpedMethods == null)
 					return false;
 			}
@@ -142,7 +142,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return true;
 		}
 
-		DumpedMethods createDumpedMethods(MyPEImage peImage, byte[] fileData, byte[] methodsData) {
+		DumpedMethods CreateDumpedMethods(MyPEImage peImage, byte[] fileData, byte[] methodsData) {
 			var dumpedMethods = new DumpedMethods();
 
 			var methodsDataReader = MemoryImageStream.Create(methodsData);
@@ -152,12 +152,12 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			for (uint rid = 1; rid <= methodDef.Rows; rid++) {
 				var dm = new DumpedMethod();
 
-				peImage.readMethodTableRowTo(dm, rid);
+				peImage.ReadMethodTableRowTo(dm, rid);
 				if (dm.mdRVA == 0)
 					continue;
-				uint bodyOffset = peImage.rvaToOffset(dm.mdRVA);
+				uint bodyOffset = peImage.RvaToOffset(dm.mdRVA);
 
-				byte b = peImage.offsetReadByte(bodyOffset);
+				byte b = peImage.OffsetReadByte(bodyOffset);
 				uint codeOffset;
 				if ((b & 3) == 2) {
 					if (b != 2)
@@ -169,20 +169,20 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 					codeOffset = bodyOffset + 1;
 				}
 				else {
-					if (peImage.offsetReadUInt32(bodyOffset + 4) != 0)
+					if (peImage.OffsetReadUInt32(bodyOffset + 4) != 0)
 						continue;	// not zero byte code size
 
-					dm.mhFlags = peImage.offsetReadUInt16(bodyOffset);
-					dm.mhMaxStack = peImage.offsetReadUInt16(bodyOffset + 2);
-					dm.mhLocalVarSigTok = peImage.offsetReadUInt32(bodyOffset + 8);
+					dm.mhFlags = peImage.OffsetReadUInt16(bodyOffset);
+					dm.mhMaxStack = peImage.OffsetReadUInt16(bodyOffset + 2);
+					dm.mhLocalVarSigTok = peImage.OffsetReadUInt32(bodyOffset + 8);
 					codeOffset = bodyOffset + (uint)(dm.mhFlags >> 12) * 4;
 				}
 				fileDataReader.Position = codeOffset;
 
-				if (!decrypter.decrypt(fileDataReader, dm))
+				if (!decrypter.Decrypt(fileDataReader, dm))
 					continue;
 
-				dumpedMethods.add(dm);
+				dumpedMethods.Add(dm);
 			}
 
 			return dumpedMethods;
@@ -192,7 +192,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 		static byte[] initializeMethodEnd = new byte[] {
 			0x33, 0xC0, 0x40, 0x5E, 0x5F, 0x5A, 0x59, 0x5B, 0xC9, 0xC2,
 		};
-		byte[] findMethodsData(MyPEImage peImage, byte[] fileData) {
+		byte[] FindMethodsData(MyPEImage peImage, byte[] fileData) {
 			var section = peImage.Sections[0];
 
 			var reader = MemoryImageStream.Create(fileData);
@@ -200,8 +200,8 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			const int RVA_EXECUTIVE_OFFSET = 1 * 4;
 			const int ENC_CODE_OFFSET = 6 * 4;
 			int lastOffset = Math.Min(fileData.Length, (int)(section.PointerToRawData + section.SizeOfRawData));
-			for (int offset = getStartOffset(peImage); offset < lastOffset; ) {
-				offset = findSig(fileData, offset, lastOffset, initializeMethodEnd);
+			for (int offset = GetStartOffset(peImage); offset < lastOffset; ) {
+				offset = FindSig(fileData, offset, lastOffset, initializeMethodEnd);
 				if (offset < 0)
 					return null;
 				offset += initializeMethodEnd.Length;
@@ -234,27 +234,27 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return null;
 		}
 
-		int getStartOffset(MyPEImage peImage) {
+		int GetStartOffset(MyPEImage peImage) {
 			int minOffset = int.MaxValue;
 			foreach (var rva in mainType.Rvas) {
-				int rvaOffs = (int)peImage.rvaToOffset((uint)rva);
+				int rvaOffs = (int)peImage.RvaToOffset((uint)rva);
 				if (rvaOffs < minOffset)
 					minOffset = rvaOffs;
 			}
 			return minOffset == int.MaxValue ? 0 : minOffset;
 		}
 
-		static int findSig(byte[] fileData, int offset, int lastOffset, byte[] sig) {
+		static int FindSig(byte[] fileData, int offset, int lastOffset, byte[] sig) {
 			for (int i = offset; i < lastOffset - sig.Length + 1; i++) {
 				if (fileData[i] != sig[0])
 					continue;
-				if (compare(fileData, i + 1, sig, 1, sig.Length - 1))
+				if (Compare(fileData, i + 1, sig, 1, sig.Length - 1))
 					return i;
 			}
 			return -1;
 		}
 
-		static bool compare(byte[] a1, int i1, byte[] a2, int i2, int len) {
+		static bool Compare(byte[] a1, int i1, byte[] a2, int i2, int len) {
 			for (int i = 0; i < len; i++) {
 				if (a1[i1++] != a2[i2++])
 					return false;
diff --git a/de4dot.code/deobfuscators/CodeVeil/ProxyCallFixer.cs b/de4dot.code/deobfuscators/CodeVeil/ProxyCallFixer.cs
index 9d8096a7..2725afe9 100644
--- a/de4dot.code/deobfuscators/CodeVeil/ProxyCallFixer.cs
+++ b/de4dot.code/deobfuscators/CodeVeil/ProxyCallFixer.cs
@@ -81,15 +81,15 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 		public ProxyCallFixer(ModuleDefMD module, MainType mainType, ProxyCallFixer oldOne)
 			: base(module, oldOne) {
 			this.mainType = mainType;
-			info.proxyType = lookup(oldOne.info.proxyType, "Could not find proxyType");
-			info.initMethod = lookup(oldOne.info.initMethod, "Could not find initMethod");
-			info.dataField = lookup(oldOne.info.dataField, "Could not find dataField");
-			info.ilgeneratorType = lookup(oldOne.info.ilgeneratorType, "Could not find ilgeneratorType");
-			info.fieldInfoType = lookup(oldOne.info.fieldInfoType, "Could not find fieldInfoType");
-			info.methodInfoType = lookup(oldOne.info.methodInfoType, "Could not find methodInfoType");
+			info.proxyType = Lookup(oldOne.info.proxyType, "Could not find proxyType");
+			info.initMethod = Lookup(oldOne.info.initMethod, "Could not find initMethod");
+			info.dataField = Lookup(oldOne.info.dataField, "Could not find dataField");
+			info.ilgeneratorType = Lookup(oldOne.info.ilgeneratorType, "Could not find ilgeneratorType");
+			info.fieldInfoType = Lookup(oldOne.info.fieldInfoType, "Could not find fieldInfoType");
+			info.methodInfoType = Lookup(oldOne.info.methodInfoType, "Could not find methodInfoType");
 		}
 
-		protected override object checkCctor(ref TypeDef type, MethodDef 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];
@@ -112,7 +112,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return null;
 		}
 
-		protected override void getCallInfo(object context, FieldDef field, out IMethod 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) + (int)reader.ReadCompressedUInt32();
@@ -126,24 +126,24 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 				throw new ApplicationException("Invalid declaring type token");
 		}
 
-		public void findDelegateCreator() {
+		public void FindDelegateCreator() {
 			if (!mainType.Detected)
 				return;
 
 			var infoTmp = new Info();
-			if (!initializeInfo(infoTmp, mainType.Type))
+			if (!InitializeInfo(infoTmp, mainType.Type))
 				return;
 
 			info = infoTmp;
-			setDelegateCreatorMethod(info.initMethod);
+			SetDelegateCreatorMethod(info.initMethod);
 		}
 
-		bool initializeInfo(Info infoTmp, TypeDef type) {
+		bool InitializeInfo(Info infoTmp, TypeDef type) {
 			foreach (var dtype in type.NestedTypes) {
 				var cctor = dtype.FindMethod(".cctor");
 				if (cctor == null)
 					continue;
-				if (!initProxyType(infoTmp, cctor))
+				if (!InitProxyType(infoTmp, cctor))
 					continue;
 
 				return true;
@@ -152,13 +152,13 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return false;
 		}
 
-		bool initProxyType(Info infoTmp, MethodDef method) {
-			foreach (var calledMethod in DotNetUtils.getCalledMethods(module, method)) {
+		bool InitProxyType(Info infoTmp, MethodDef method) {
+			foreach (var calledMethod in DotNetUtils.GetCalledMethods(module, method)) {
 				if (!calledMethod.IsStatic)
 					continue;
-				if (!DotNetUtils.isMethod(calledMethod, "System.Void", "(System.Int32)"))
+				if (!DotNetUtils.IsMethod(calledMethod, "System.Void", "(System.Int32)"))
 					continue;
-				if (!checkProxyType(infoTmp, calledMethod.DeclaringType))
+				if (!CheckProxyType(infoTmp, calledMethod.DeclaringType))
 					continue;
 
 				infoTmp.proxyType = calledMethod.DeclaringType;
@@ -175,18 +175,18 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			"System.Reflection.Emit.OpCode",
 			"System.Reflection.Emit.OpCode[]",
 		};
-		bool checkProxyType(Info infoTmp, TypeDef type) {
+		bool CheckProxyType(Info infoTmp, TypeDef type) {
 			if (type.NestedTypes.Count != 1)
 				return false;
 
-			if (!new FieldTypes(type).all(requiredFields))
+			if (!new FieldTypes(type).All(requiredFields))
 				return false;
 
-			var fields = getRvaFields(type);
+			var fields = GetRvaFields(type);
 			if (fields.Count != 1)
 				return false;
 			var field = fields[0];
-			var fieldType = DotNetUtils.getType(module, field.FieldSig.GetFieldType());
+			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,7 +196,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return true;
 		}
 
-		static List<FieldDef> getRvaFields(TypeDef type) {
+		static List<FieldDef> GetRvaFields(TypeDef type) {
 			var fields = new List<FieldDef>();
 			foreach (var field in type.Fields) {
 				if (field.RVA != 0)
@@ -205,26 +205,26 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return fields;
 		}
 
-		protected override IEnumerable<TypeDef> getDelegateTypes() {
+		protected override IEnumerable<TypeDef> GetDelegateTypes() {
 			if (!mainType.Detected)
 				return new List<TypeDef>();
 			return mainType.Type.NestedTypes;
 		}
 
-		public void initialize() {
+		public void Initialize() {
 			if (info.dataField == null)
 				return;
 
-			findOtherTypes();
+			FindOtherTypes();
 
-			var decompressed = DeobUtils.inflate(info.dataField.InitialValue, true);
+			var decompressed = DeobUtils.Inflate(info.dataField.InitialValue, true);
 			reader = MemoryImageStream.Create(decompressed);
 			info.dataField.FieldSig.Type = module.CorLibTypes.Byte;
 			info.dataField.InitialValue = new byte[1];
 			info.dataField.RVA = 0;
 		}
 
-		void findOtherTypes() {
+		void FindOtherTypes() {
 			if (info.proxyType == null)
 				return;
 
@@ -238,11 +238,11 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 				var methodType = sig.Params[0].TryGetTypeDef();
 				var fieldType = sig.Params[1].TryGetTypeDef();
 				var ilgType = sig.Params[3].TryGetTypeDef();
-				if (!checkMethodType(methodType))
+				if (!CheckMethodType(methodType))
 					continue;
-				if (!checkFieldType(fieldType))
+				if (!CheckFieldType(fieldType))
 					continue;
-				if (!checkIlGeneratorType(ilgType))
+				if (!CheckIlGeneratorType(ilgType))
 					continue;
 
 				info.ilgeneratorType = ilgType;
@@ -251,32 +251,32 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			}
 		}
 
-		bool checkMethodType(TypeDef type) {
+		bool CheckMethodType(TypeDef type) {
 			if (type == null || type.BaseType == null || type.BaseType.FullName != "System.Object")
 				return false;
 			if (type.Fields.Count != 1)
 				return false;
-			if (DotNetUtils.getField(type, "System.Reflection.MethodInfo") == null)
+			if (DotNetUtils.GetField(type, "System.Reflection.MethodInfo") == null)
 				return false;
 
 			return true;
 		}
 
-		bool checkFieldType(TypeDef type) {
+		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)
+			if (DotNetUtils.GetField(type, "System.Reflection.FieldInfo") == null)
 				return false;
 
 			return true;
 		}
 
-		bool checkIlGeneratorType(TypeDef type) {
+		bool CheckIlGeneratorType(TypeDef type) {
 			if (type == null || type.BaseType == null || type.BaseType.FullName != "System.Object")
 				return false;
 			if (type.Fields.Count != 1)
 				return false;
-			if (DotNetUtils.getField(type, "System.Reflection.Emit.ILGenerator") == null)
+			if (DotNetUtils.GetField(type, "System.Reflection.Emit.ILGenerator") == null)
 				return false;
 
 			return true;
diff --git a/de4dot.code/deobfuscators/CodeVeil/ResourceConverter.cs b/de4dot.code/deobfuscators/CodeVeil/ResourceConverter.cs
index 0a65d81e..ca0fd414 100644
--- a/de4dot.code/deobfuscators/CodeVeil/ResourceConverter.cs
+++ b/de4dot.code/deobfuscators/CodeVeil/ResourceConverter.cs
@@ -35,17 +35,17 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			this.infos = infos;
 		}
 
-		public byte[] convert() {
+		public byte[] Convert() {
 			var resources = new ResourceElementSet();
 			foreach (var info in infos)
-				resources.add(convert(info));
+				resources.Add(Convert(info));
 
 			var memStream = new MemoryStream();
-			ResourceWriter.write(module, memStream, resources);
+			ResourceWriter.Write(module, memStream, resources);
 			return memStream.ToArray();
 		}
 
-		ResourceElement convert(ResourceInfo info) {
+		ResourceElement Convert(ResourceInfo info) {
 			var reader = info.dataReader;
 			reader.Position = info.offset;
 
@@ -53,87 +53,87 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			int type = (info.flags & 0x7F);
 			switch (type) {
 			case 1:		// bool
-				resourceData = dataCreator.create(reader.ReadBoolean());
+				resourceData = dataCreator.Create(reader.ReadBoolean());
 				break;
 
 			case 2:		// byte
-				resourceData = dataCreator.create(reader.ReadByte());
+				resourceData = dataCreator.Create(reader.ReadByte());
 				break;
 
 			case 3:		// byte[]
-				resourceData = dataCreator.create(reader.ReadBytes(info.length));
+				resourceData = dataCreator.Create(reader.ReadBytes(info.length));
 				break;
 
 			case 4:		// char[]
-				resourceData = dataCreator.create(reader.ReadChars(info.length));
+				resourceData = dataCreator.Create(reader.ReadChars(info.length));
 				break;
 
 			case 5:		// sbyte
-				resourceData = dataCreator.create(reader.ReadSByte());
+				resourceData = dataCreator.Create(reader.ReadSByte());
 				break;
 
 			case 6:		// char
-				resourceData = dataCreator.create(reader.ReadChar());
+				resourceData = dataCreator.Create(reader.ReadChar());
 				break;
 
 			case 7:		// decimal
-				resourceData = dataCreator.create(reader.ReadDecimal());
+				resourceData = dataCreator.Create(reader.ReadDecimal());
 				break;
 
 			case 8:		// double
-				resourceData = dataCreator.create(reader.ReadDouble());
+				resourceData = dataCreator.Create(reader.ReadDouble());
 				break;
 
 			case 9:		// short
-				resourceData = dataCreator.create(reader.ReadInt16());
+				resourceData = dataCreator.Create(reader.ReadInt16());
 				break;
 
 			case 10:	// int
-				resourceData = dataCreator.create(reader.ReadInt32());
+				resourceData = dataCreator.Create(reader.ReadInt32());
 				break;
 
 			case 11:	// long
-				resourceData = dataCreator.create(reader.ReadInt64());
+				resourceData = dataCreator.Create(reader.ReadInt64());
 				break;
 
 			case 12:	// float
-				resourceData = dataCreator.create(reader.ReadSingle());
+				resourceData = dataCreator.Create(reader.ReadSingle());
 				break;
 
 			case 13:	// string
-				resourceData = dataCreator.create(reader.ReadString());
+				resourceData = dataCreator.Create(reader.ReadString());
 				break;
 
 			case 14:	// ushort
-				resourceData = dataCreator.create(reader.ReadUInt16());
+				resourceData = dataCreator.Create(reader.ReadUInt16());
 				break;
 
 			case 15:	// uint
-				resourceData = dataCreator.create(reader.ReadUInt32());
+				resourceData = dataCreator.Create(reader.ReadUInt32());
 				break;
 
 			case 16:	// ulong
-				resourceData = dataCreator.create(reader.ReadUInt64());
+				resourceData = dataCreator.Create(reader.ReadUInt64());
 				break;
 
 			case 17:	// DateTime
-				resourceData = dataCreator.create(DateTime.FromBinary(reader.ReadInt64()));
+				resourceData = dataCreator.Create(DateTime.FromBinary(reader.ReadInt64()));
 				break;
 
 			case 18:	// TimeSpan
-				resourceData = dataCreator.create(TimeSpan.FromTicks(reader.ReadInt64()));
+				resourceData = dataCreator.Create(TimeSpan.FromTicks(reader.ReadInt64()));
 				break;
 
 			case 19:	// Icon
-				resourceData = dataCreator.createIcon(reader.ReadBytes(info.length));
+				resourceData = dataCreator.CreateIcon(reader.ReadBytes(info.length));
 				break;
 
 			case 20:	// Image
-				resourceData = dataCreator.createImage(reader.ReadBytes(info.length));
+				resourceData = dataCreator.CreateImage(reader.ReadBytes(info.length));
 				break;
 
 			case 31:	// binary
-				resourceData = dataCreator.createSerialized(reader.ReadBytes(info.length));
+				resourceData = dataCreator.CreateSerialized(reader.ReadBytes(info.length));
 				break;
 
 			case 21:	// Point (CV doesn't restore this type)
diff --git a/de4dot.code/deobfuscators/CodeVeil/ResourceDecrypter.cs b/de4dot.code/deobfuscators/CodeVeil/ResourceDecrypter.cs
index 5332c7e2..4a9bc10e 100644
--- a/de4dot.code/deobfuscators/CodeVeil/ResourceDecrypter.cs
+++ b/de4dot.code/deobfuscators/CodeVeil/ResourceDecrypter.cs
@@ -77,17 +77,17 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			this.module = module;
 		}
 
-		public void initialize() {
+		public void Initialize() {
 			methodsRestorer = new MethodCallRestorerBase(module);
-			findEncryptedResourceStreamType();
-			findEncryptedResourceSet();
-			findEncryptedResourceReader();
-			findResType();
-			findResourceFlags();
-			findResourceEnumerator();
+			FindEncryptedResourceStreamType();
+			FindEncryptedResourceSet();
+			FindEncryptedResourceReader();
+			FindResType();
+			FindResourceFlags();
+			FindResourceEnumerator();
 		}
 
-		void findResourceEnumerator() {
+		void FindResourceEnumerator() {
 			if (encryptedResourceReaderType == null)
 				return;
 
@@ -102,9 +102,9 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 					continue;
 				if (type.BaseType == null || type.BaseType.FullName != "System.Object")
 					continue;
-				if (!hasInterface(type, "System.Collections.IDictionaryEnumerator"))
+				if (!HasInterface(type, "System.Collections.IDictionaryEnumerator"))
 					continue;
-				if (!new FieldTypes(type).all(resourceEnumeratorType_fields))
+				if (!new FieldTypes(type).All(resourceEnumeratorType_fields))
 					continue;
 				var ctor = type.FindMethod(".ctor");
 				if (ctor == null)
@@ -120,7 +120,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			}
 		}
 
-		void findResourceFlags() {
+		void FindResourceFlags() {
 			if (resTypeCtor == null)
 				return;
 			var sig = resTypeCtor.MethodSig;
@@ -138,7 +138,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			"System.Object",
 			"System.String",
 		};
-		void findResType() {
+		void FindResType() {
 			if (encryptedResourceReaderTypeDict == null)
 				return;
 			var type = encryptedResourceReaderTypeDict.GenericArguments[1].TryGetTypeDef();
@@ -164,25 +164,25 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			"System.IO.BinaryReader",
 			"System.Runtime.Serialization.Formatters.Binary.BinaryFormatter",
 		};
-		void findEncryptedResourceReader() {
-			var type = getTypeFromCode(encryptedResourceSet_GetDefaultReader);
+		void FindEncryptedResourceReader() {
+			var type = GetTypeFromCode(encryptedResourceSet_GetDefaultReader);
 			if (type == null)
 				return;
-			if (type.BaseType == null || !hasInterface(type, "System.Resources.IResourceReader"))
+			if (type.BaseType == null || !HasInterface(type, "System.Resources.IResourceReader"))
 				return;
-			if (!new FieldTypes(type).all(encryptedResourceReaderType_fields))
+			if (!new FieldTypes(type).All(encryptedResourceReaderType_fields))
 				return;
-			var dictType = getDlxResDict(type);
+			var dictType = GetDlxResDict(type);
 			if (dictType == null)
 				return;
-			if (findXxteaMethod(type) == null)
+			if (FindXxteaMethod(type) == null)
 				return;
 
 			encryptedResourceReaderType = type;
 			encryptedResourceReaderTypeDict = dictType;
 		}
 
-		static bool hasInterface(TypeDef type, string interfaceFullName) {
+		static bool HasInterface(TypeDef type, string interfaceFullName) {
 			foreach (var iface in type.Interfaces) {
 				if (iface.Interface.FullName == interfaceFullName)
 					return true;
@@ -190,7 +190,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return false;
 		}
 
-		static GenericInstSig getDlxResDict(TypeDef type) {
+		static GenericInstSig GetDlxResDict(TypeDef type) {
 			foreach (var field in type.Fields) {
 				var fieldType = field.FieldSig.GetFieldType().ToGenericInstSig();
 				if (fieldType == null)
@@ -208,7 +208,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return null;
 		}
 
-		static TypeDef getTypeFromCode(MethodDef method) {
+		static TypeDef GetTypeFromCode(MethodDef method) {
 			if (method == null || method.Body == null)
 				return null;
 			foreach (var instr in method.Body.Instructions) {
@@ -222,17 +222,17 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return null;
 		}
 
-		void findEncryptedResourceSet() {
+		void FindEncryptedResourceSet() {
 			foreach (var type in module.Types) {
 				if (type.Namespace != "")
 					continue;
 				if (type.BaseType == null || type.BaseType.FullName != "System.Resources.ResourceSet")
 					continue;
 				var ctor = type.FindMethod(".ctor");
-				if (!DotNetUtils.isMethod(ctor, "System.Void", "(System.Resources.IResourceReader)"))
+				if (!DotNetUtils.IsMethod(ctor, "System.Void", "(System.Resources.IResourceReader)"))
 					continue;
 				var method = type.FindMethod("GetDefaultReader");
-				if (!DotNetUtils.isMethod(method, "System.Type", "()"))
+				if (!DotNetUtils.IsMethod(method, "System.Type", "()"))
 					continue;
 				if (method.Body == null || method.IsStatic || !method.IsVirtual)
 					continue;
@@ -253,45 +253,45 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			"System.IO.Stream",
 			"System.UInt32[]",
 		};
-		void findEncryptedResourceStreamType() {
+		void FindEncryptedResourceStreamType() {
 			foreach (var type in module.Types) {
 				if (type.Namespace != "")
 					continue;
 				if (type.BaseType == null || type.BaseType.FullName != "System.IO.Stream")
 					continue;
 				var ctor = type.FindMethod(".ctor");
-				if (!DotNetUtils.isMethod(ctor, "System.Void", "(System.IO.Stream)"))
+				if (!DotNetUtils.IsMethod(ctor, "System.Void", "(System.IO.Stream)"))
 					continue;
-				if (!new FieldTypes(type).all(encryptedResourceStreamType_fields))
+				if (!new FieldTypes(type).All(encryptedResourceStreamType_fields))
 					continue;
-				if (findXxteaMethod(type) == null)
+				if (FindXxteaMethod(type) == null)
 					continue;
 
 				MethodDef getManifestResourceStreamMethodTmp1, getManifestResourceStreamMethodTmp2;
-				if (!findManifestResourceStreamMethods(type, out getManifestResourceStreamMethodTmp1, out getManifestResourceStreamMethodTmp2))
+				if (!FindManifestResourceStreamMethods(type, out getManifestResourceStreamMethodTmp1, out getManifestResourceStreamMethodTmp2))
 					continue;
 
-				methodsRestorer.createGetManifestResourceStream1(getManifestResourceStreamMethodTmp1);
-				methodsRestorer.createGetManifestResourceStream2(getManifestResourceStreamMethodTmp2);
+				methodsRestorer.CreateGetManifestResourceStream1(getManifestResourceStreamMethodTmp1);
+				methodsRestorer.CreateGetManifestResourceStream2(getManifestResourceStreamMethodTmp2);
 				encryptedResourceStreamType = type;
 				return;
 			}
 		}
 
-		static MethodDef findXxteaMethod(TypeDef type) {
+		static MethodDef FindXxteaMethod(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (!method.IsPrivate || method.IsStatic || method.Body == null)
 					continue;
-				if (DotNetUtils.isMethod(method, "System.Void", "(System.UInt32[],System.UInt32[])")) {
-					if (!DeobUtils.hasInteger(method, 0x9E3779B9))
+				if (DotNetUtils.IsMethod(method, "System.Void", "(System.UInt32[],System.UInt32[])")) {
+					if (!DeobUtils.HasInteger(method, 0x9E3779B9))
 						continue;
 				}
-				else if (DotNetUtils.isMethod(method, "System.Void", "(System.UInt32[],System.UInt32[],System.UInt32,System.UInt32,System.UInt32,System.UInt32,System.UInt32,System.UInt32,System.UInt32,System.UInt32,System.UInt32)")) {
+				else if (DotNetUtils.IsMethod(method, "System.Void", "(System.UInt32[],System.UInt32[],System.UInt32,System.UInt32,System.UInt32,System.UInt32,System.UInt32,System.UInt32,System.UInt32,System.UInt32,System.UInt32)")) {
 					// Here if 5.0. 0x9E3779B9 is passed to it as the last arg.
 				}
 				else
 					continue;
-				if (!DeobUtils.hasInteger(method, 52))
+				if (!DeobUtils.HasInteger(method, 52))
 					continue;
 
 				return method;
@@ -299,44 +299,44 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return null;
 		}
 
-		static bool findManifestResourceStreamMethods(TypeDef type, out MethodDef getManifestResourceStreamMethodTmp1, out MethodDef getManifestResourceStreamMethodTmp2) {
+		static bool FindManifestResourceStreamMethods(TypeDef type, out MethodDef getManifestResourceStreamMethodTmp1, out MethodDef getManifestResourceStreamMethodTmp2) {
 			getManifestResourceStreamMethodTmp1 = null;
 			getManifestResourceStreamMethodTmp2 = null;
 			foreach (var method in type.Methods) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
-				if (DotNetUtils.isMethod(method, "System.IO.Stream", "(System.Reflection.Assembly,System.String)"))
+				if (DotNetUtils.IsMethod(method, "System.IO.Stream", "(System.Reflection.Assembly,System.String)"))
 					getManifestResourceStreamMethodTmp1 = method;
-				else if (DotNetUtils.isMethod(method, "System.IO.Stream", "(System.Reflection.Assembly,System.Type,System.String)"))
+				else if (DotNetUtils.IsMethod(method, "System.IO.Stream", "(System.Reflection.Assembly,System.Type,System.String)"))
 					getManifestResourceStreamMethodTmp2 = method;
 			}
 			return getManifestResourceStreamMethodTmp1 != null && getManifestResourceStreamMethodTmp2 != null;
 		}
 
-		public void decrypt() {
+		public void Decrypt() {
 			for (int i = 0; i < module.Resources.Count; i++) {
 				var resource = module.Resources[i] as EmbeddedResource;
 				if (resource == null)
 					continue;
 
-				var decrypted = decrypt(resource.Data);
+				var decrypted = Decrypt(resource.Data);
 				if (decrypted == null)
 					continue;
 
-				Logger.v("Decrypted resource {0}", Utils.toCsharpString(resource.Name));
+				Logger.v("Decrypted resource {0}", Utils.ToCsharpString(resource.Name));
 				module.Resources[i] = new EmbeddedResource(resource.Name, decrypted, resource.Attributes);
 			}
 		}
 
-		byte[] decrypt(IBinaryReader reader) {
+		byte[] Decrypt(IBinaryReader reader) {
 			try {
 				reader.Position = 0;
 				uint sig = reader.ReadUInt32();
 				reader.Position = 0;
 				if (sig == 0xBEEFCACE)
-					return decryptBeefcace(reader);
+					return DecryptBeefcace(reader);
 				if (sig == 0x58455245)
-					return decryptErex(reader);
+					return DecryptErex(reader);
 				return null;
 			}
 			catch (InvalidDataException) {
@@ -348,20 +348,20 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			}
 		}
 
-		byte[] decryptBeefcace(IBinaryReader reader) {
+		byte[] DecryptBeefcace(IBinaryReader reader) {
 			var resourceReader = new ResourceReader(reader);
-			return new ResourceConverter(module, resourceReader.read()).convert();
+			return new ResourceConverter(module, resourceReader.Read()).Convert();
 		}
 
-		byte[] decryptErex(IBinaryReader reader) {
-			return new ErexResourceReader(reader).decrypt();
+		byte[] DecryptErex(IBinaryReader reader) {
+			return new ErexResourceReader(reader).Decrypt();
 		}
 
-		public void deobfuscate(Blocks blocks) {
+		public void Deobfuscate(Blocks blocks) {
 			if (encryptedResourceStreamType == null)
 				return;
 
-			methodsRestorer.deobfuscate(blocks);
+			methodsRestorer.Deobfuscate(blocks);
 		}
 	}
 }
diff --git a/de4dot.code/deobfuscators/CodeVeil/ResourceReader.cs b/de4dot.code/deobfuscators/CodeVeil/ResourceReader.cs
index 1d90779d..c06f3c07 100644
--- a/de4dot.code/deobfuscators/CodeVeil/ResourceReader.cs
+++ b/de4dot.code/deobfuscators/CodeVeil/ResourceReader.cs
@@ -41,7 +41,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			this.reader = reader;
 		}
 
-		public ResourceInfo[] read() {
+		public ResourceInfo[] Read() {
 			if (reader.ReadUInt32() != 0xBEEFCACE)
 				throw new InvalidDataException("Invalid magic");
 			if (reader.ReadUInt32() <= 0)
@@ -66,7 +66,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 
 			var infos = new ResourceInfo[numResources];
 			for (int i = 0; i < numResources; i++) {
-				var resourceName = readResourceName(reader, encrypted);
+				var resourceName = ReadResourceName(reader, encrypted);
 				int offset = reader.ReadInt32();
 				byte resourceFlags = reader.ReadByte();
 				int resourceLength = (resourceFlags & 0x80) == 0 ? -1 : reader.ReadInt32();
@@ -86,7 +86,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 					encryptedData[i] = dataReader.ReadUInt32();
 				key[2] = dataReader.ReadUInt32();
 				key[3] = dataReader.ReadUInt32();
-				DeobUtils.xxteaDecrypt(encryptedData, key);
+				DeobUtils.XxteaDecrypt(encryptedData, key);
 				byte[] decryptedData = new byte[encryptedData.Length * 4];
 				Buffer.BlockCopy(encryptedData, 0, decryptedData, 0, decryptedData.Length);
 				dataReader = MemoryImageStream.Create(decryptedData);
@@ -94,7 +94,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 
 			if (inflateData) {
 				var data = dataReader.ReadRemainingBytes();
-				data = DeobUtils.inflate(data, true);
+				data = DeobUtils.Inflate(data, true);
 				dataReader = MemoryImageStream.Create(data);
 			}
 
@@ -104,7 +104,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return infos;
 		}
 
-		static string readResourceName(IBinaryReader reader, bool encrypted) {
+		static string ReadResourceName(IBinaryReader reader, bool encrypted) {
 			if (!encrypted)
 				return reader.ReadString();
 
@@ -113,11 +113,11 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 				throw new ApplicationException("Invalid string length");
 			var sb = new StringBuilder(len);
 			for (int i = 0; i < len; i++)
-				sb.Append((char)rol3(reader.ReadChar()));
+				sb.Append((char)Rol3(reader.ReadChar()));
 			return sb.ToString();
 		}
 
-		static char rol3(char c) {
+		static char Rol3(char c) {
 			ushort s = (ushort)c;
 			return (char)((s << 3) | (s >> (16 - 3)));
 		}
diff --git a/de4dot.code/deobfuscators/CodeVeil/StringDecrypter.cs b/de4dot.code/deobfuscators/CodeVeil/StringDecrypter.cs
index 79d92b73..28be23b4 100644
--- a/de4dot.code/deobfuscators/CodeVeil/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/CodeVeil/StringDecrypter.cs
@@ -58,29 +58,29 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 		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");
-			this.stringDataField = lookup(oldOne.stringDataField, "Could not find string data field");
-			this.initMethod = lookup(oldOne.initMethod, "Could not find string decrypter init method");
-			this.decrypterMethod = lookup(oldOne.decrypterMethod, "Could not find string decrypter method");
+			this.decrypterType = Lookup(oldOne.decrypterType, "Could not find string decrypter type");
+			this.stringDataField = Lookup(oldOne.stringDataField, "Could not find string data field");
+			this.initMethod = Lookup(oldOne.initMethod, "Could not find string decrypter init method");
+			this.decrypterMethod = Lookup(oldOne.decrypterMethod, "Could not find string decrypter method");
 		}
 
-		T lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
-			return DeobUtils.lookup(module, def, errorMessage);
+		T Lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
+			return DeobUtils.Lookup(module, def, errorMessage);
 		}
 
-		public void find() {
-			var cctor = DotNetUtils.getModuleTypeCctor(module);
+		public void Find() {
+			var cctor = DotNetUtils.GetModuleTypeCctor(module);
 			if (cctor == null)
 				return;
 
 			// V3-V4 calls string decrypter init method in <Module>::.cctor().
-			if (find(cctor))
+			if (Find(cctor))
 				return;
 
-			findV5(cctor);
+			FindV5(cctor);
 		}
 
-		bool find(MethodDef method) {
+		bool Find(MethodDef method) {
 			if (method == null || method.Body == null || !method.IsStatic)
 				return false;
 
@@ -92,9 +92,9 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 				var initMethodTmp = call.Operand as MethodDef;
 				if (initMethodTmp == null || initMethodTmp.Body == null || !initMethodTmp.IsStatic)
 					continue;
-				if (!DotNetUtils.isMethod(initMethodTmp, "System.Void", "()"))
+				if (!DotNetUtils.IsMethod(initMethodTmp, "System.Void", "()"))
 					continue;
-				if (!checkType(initMethodTmp.DeclaringType))
+				if (!CheckType(initMethodTmp.DeclaringType))
 					continue;
 
 				decrypterType = initMethodTmp.DeclaringType;
@@ -106,27 +106,27 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 		}
 
 		// The main decrypter type calls the string decrypter init method inside its init method
-		void findV5(MethodDef method) {
+		void FindV5(MethodDef method) {
 			if (!mainType.Detected)
 				return;
-			foreach (var calledMethod in DotNetUtils.getCalledMethods(module, mainType.InitMethod)) {
-				if (find(calledMethod))
+			foreach (var calledMethod in DotNetUtils.GetCalledMethods(module, mainType.InitMethod)) {
+				if (Find(calledMethod))
 					return;
 			}
 		}
 
-		bool checkType(TypeDef type) {
+		bool CheckType(TypeDef type) {
 			if (!type.HasNestedTypes)
 				return false;
 
-			var stringDataFieldTmp = checkFields(type);
+			var stringDataFieldTmp = CheckFields(type);
 			if (stringDataFieldTmp == null)
 				return false;
-			var fieldType = DotNetUtils.getType(module, stringDataFieldTmp.FieldSig.GetFieldType());
+			var fieldType = DotNetUtils.GetType(module, stringDataFieldTmp.FieldSig.GetFieldType());
 			if (fieldType == null || type.NestedTypes.IndexOf(fieldType) < 0)
 				return false;
 
-			var decrypterMethodTmp = getDecrypterMethod(type);
+			var decrypterMethodTmp = GetDecrypterMethod(type);
 			if (decrypterMethodTmp == null)
 				return false;
 
@@ -135,12 +135,12 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return true;
 		}
 
-		static MethodDef getDecrypterMethod(TypeDef type) {
+		static MethodDef GetDecrypterMethod(TypeDef type) {
 			MethodDef foundMethod = null;
 			foreach (var method in type.Methods) {
 				if (method.Body == null || !method.IsStatic)
 					continue;
-				if (!DotNetUtils.isMethod(method, "System.String", "(System.Int32)"))
+				if (!DotNetUtils.IsMethod(method, "System.String", "(System.Int32)"))
 					continue;
 				if (foundMethod != null)
 					return null;
@@ -156,8 +156,8 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			"System.String[]",
 			"System.UInt32[]",
 		};
-		FieldDef checkFields(TypeDef type) {
-			if (!new FieldTypes(type).all(requiredFields))
+		FieldDef CheckFields(TypeDef type) {
+			if (!new FieldTypes(type).All(requiredFields))
 				return null;
 
 			FieldDef stringData = null;
@@ -180,22 +180,22 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return stringData;
 		}
 
-		public void initialize() {
+		public void Initialize() {
 			if (initMethod == null || stringDataField == null)
 				return;
 
-			var key = getKey(initMethod);
+			var key = GetKey(initMethod);
 			if (key == null)
 				throw new ApplicationException("Could not find string decrypter key");
 
-			decryptStrings(key);
+			DecryptStrings(key);
 
 			stringDataField.FieldSig.Type = module.CorLibTypes.Byte;
 			stringDataField.InitialValue = new byte[1];
 			stringDataField.RVA = 0;
 		}
 
-		static uint[] getKey(MethodDef method) {
+		static uint[] GetKey(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 1; i++) {
 				var ldci4 = instrs[i];
@@ -208,7 +208,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 					continue;
 
 				i++;
-				var key = ArrayFinder.getInitializedUInt32Array(4, method, ref i);
+				var key = ArrayFinder.GetInitializedUInt32Array(4, method, ref i);
 				if (key == null)
 					continue;
 
@@ -217,16 +217,16 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return null;
 		}
 
-		void decryptStrings(uint[] key) {
+		void DecryptStrings(uint[] key) {
 			var data = stringDataField.InitialValue;
 
 			var encryptedData = new uint[data.Length / 4];
 			Buffer.BlockCopy(data, 0, encryptedData, 0, data.Length);
-			DeobUtils.xxteaDecrypt(encryptedData, key);
+			DeobUtils.XxteaDecrypt(encryptedData, key);
 			var decryptedData = new byte[data.Length];
 			Buffer.BlockCopy(encryptedData, 0, decryptedData, 0, data.Length);
 
-			var inflated = DeobUtils.inflate(decryptedData, 0, decryptedData.Length, true);
+			var inflated = DeobUtils.Inflate(decryptedData, 0, decryptedData.Length, true);
 			var reader = MemoryImageStream.Create(inflated);
 			int deflatedLength = (int)reader.ReadCompressedUInt32();
 			int numStrings = (int)reader.ReadCompressedUInt32();
@@ -241,7 +241,7 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			}
 		}
 
-		public string decrypt(int index) {
+		public string Decrypt(int index) {
 			return decryptedStrings[index];
 		}
 	}
diff --git a/de4dot.code/deobfuscators/CodeVeil/TamperDetection.cs b/de4dot.code/deobfuscators/CodeVeil/TamperDetection.cs
index 740bbd17..d80c1589 100644
--- a/de4dot.code/deobfuscators/CodeVeil/TamperDetection.cs
+++ b/de4dot.code/deobfuscators/CodeVeil/TamperDetection.cs
@@ -42,54 +42,54 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			this.mainType = mainType;
 		}
 
-		public void initialize() {
+		public void Initialize() {
 			if (!mainType.Detected)
 				return;
 
 			if (mainType.TamperCheckMethod == null)
 				return;
 
-			findTamperDetectionTypes();
+			FindTamperDetectionTypes();
 		}
 
-		void findTamperDetectionTypes() {
+		void FindTamperDetectionTypes() {
 			foreach (var type in module.Types) {
 				if (!type.HasNestedTypes)
 					continue;
 				if ((type.Attributes & ~TypeAttributes.Sealed) != 0)
 					continue;
 
-				if (!checkTamperDetectionClasses(type.NestedTypes))
+				if (!CheckTamperDetectionClasses(type.NestedTypes))
 					continue;
 
 				tamperDetectionType = type;
-				findTamperDetectionMethods();
+				FindTamperDetectionMethods();
 				return;
 			}
 		}
 
-		void findTamperDetectionMethods() {
+		void FindTamperDetectionMethods() {
 			foreach (var type in tamperDetectionType.NestedTypes) {
 				foreach (var method in type.Methods) {
 					if (!method.IsStatic || method.Body == null)
 						continue;
 					if (method.Name == ".cctor")
 						continue;
-					if (DotNetUtils.isMethod(method, "System.Void", "()"))
+					if (DotNetUtils.IsMethod(method, "System.Void", "()"))
 						tamperDetectionMethods.Add(method);
 				}
 			}
 		}
 
-		bool checkTamperDetectionClasses(IEnumerable<TypeDef> types) {
+		bool CheckTamperDetectionClasses(IEnumerable<TypeDef> types) {
 			foreach (var type in types) {
-				if (!isTamperDetectionClass(type))
+				if (!IsTamperDetectionClass(type))
 					return false;
 			}
 			return true;
 		}
 
-		bool isTamperDetectionClass(TypeDef type) {
+		bool IsTamperDetectionClass(TypeDef type) {
 			if (type.BaseType == null || type.BaseType.FullName != "System.Object")
 				return false;
 			if ((type.Attributes & ~TypeAttributes.Sealed) != TypeAttributes.NestedAssembly)
@@ -97,41 +97,41 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 
 			MethodDef cctor = null, initMethod = null;
 			foreach (var method in type.Methods) {
-				if (InvalidMethodsFinder.isInvalidMethod(method))
+				if (InvalidMethodsFinder.IsInvalidMethod(method))
 					continue;
 				if (!method.IsStatic || method.Body == null)
 					return false;
 				if (method.Name == ".cctor")
 					cctor = method;
-				else if (DotNetUtils.isMethod(method, "System.Void", "()"))
+				else if (DotNetUtils.IsMethod(method, "System.Void", "()"))
 					initMethod = method;
 			}
 			if (cctor == null || initMethod == null)
 				return false;
 
-			if (!callsMainTypeTamperCheckMethod(cctor))
+			if (!CallsMainTypeTamperCheckMethod(cctor))
 				return false;
 
 			return true;
 		}
 
-		bool callsMainTypeTamperCheckMethod(MethodDef method) {
-			foreach (var calledMethod in DotNetUtils.getCalledMethods(module, method)) {
+		bool CallsMainTypeTamperCheckMethod(MethodDef method) {
+			foreach (var calledMethod in DotNetUtils.GetCalledMethods(module, method)) {
 				if (calledMethod == mainType.TamperCheckMethod)
 					return true;
 			}
 
 			var instructions = method.Body.Instructions;
 			for (int i = 0; i < instructions.Count; i++) {
-				var instrs = DotNetUtils.getInstructions(instructions, i, OpCodes.Ldtoken, OpCodes.Call, OpCodes.Call, OpCodes.Ldc_I8, OpCodes.Call);
+				var instrs = DotNetUtils.GetInstructions(instructions, i, OpCodes.Ldtoken, OpCodes.Call, OpCodes.Call, OpCodes.Ldc_I8, OpCodes.Call);
 				if (instrs == null)
 					continue;
 
-				if (!checkInvokeCall(instrs[1], "System.Type", "(System.RuntimeTypeHandle)"))
+				if (!CheckInvokeCall(instrs[1], "System.Type", "(System.RuntimeTypeHandle)"))
 					continue;
-				if (!checkInvokeCall(instrs[2], "System.Reflection.Assembly", "(System.Object)"))
+				if (!CheckInvokeCall(instrs[2], "System.Reflection.Assembly", "(System.Object)"))
 					continue;
-				if (!checkInvokeCall(instrs[4], "System.Void", "(System.Reflection.Assembly,System.UInt64)"))
+				if (!CheckInvokeCall(instrs[4], "System.Void", "(System.Reflection.Assembly,System.UInt64)"))
 					continue;
 
 				return true;
@@ -140,13 +140,13 @@ namespace de4dot.code.deobfuscators.CodeVeil {
 			return false;
 		}
 
-		static bool checkInvokeCall(Instruction instr, string returnType, string parameters) {
+		static bool CheckInvokeCall(Instruction instr, string returnType, string parameters) {
 			var method = instr.Operand as MethodDef;
 			if (method == null)
 				return false;
 			if (method.Name != "Invoke")
 				return false;
-			return DotNetUtils.isMethod(method, returnType, parameters);
+			return DotNetUtils.IsMethod(method, returnType, parameters);
 		}
 	}
 }
diff --git a/de4dot.code/deobfuscators/CodeWall/AssemblyDecrypter.cs b/de4dot.code/deobfuscators/CodeWall/AssemblyDecrypter.cs
index 5b530137..970d28a5 100644
--- a/de4dot.code/deobfuscators/CodeWall/AssemblyDecrypter.cs
+++ b/de4dot.code/deobfuscators/CodeWall/AssemblyDecrypter.cs
@@ -69,23 +69,23 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			this.deob = deob;
 		}
 
-		public void find() {
+		public void Find() {
 			var method = module.EntryPoint;
-			if (!checkEntryPoint(method))
+			if (!CheckEntryPoint(method))
 				return;
 
 			MethodDef decryptAssemblyMethod;
-			var mainKey = getMainResourceKey(method, out decryptAssemblyMethod);
+			var mainKey = GetMainResourceKey(method, out decryptAssemblyMethod);
 			if (mainKey == null)
 				return;
 
-			deobfuscateAll(decryptAssemblyMethod);
+			DeobfuscateAll(decryptAssemblyMethod);
 			ModuleDefMD theResourceModule;
-			var resource = getResource(decryptAssemblyMethod, out theResourceModule);
+			var resource = GetResource(decryptAssemblyMethod, out theResourceModule);
 			if (resource == null)
 				return;
 			string password, salt;
-			if (!getPassword(decryptAssemblyMethod, out password, out salt))
+			if (!GetPassword(decryptAssemblyMethod, out password, out salt))
 				return;
 
 			entryPointAssemblyKey = mainKey;
@@ -93,39 +93,39 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			resourceSalt = salt;
 			assemblyResource = resource;
 			resourceModule = theResourceModule;
-			decryptAllAssemblies();
+			DecryptAllAssemblies();
 		}
 
 		static readonly string[] requiredLocals = new string[] {
 			"System.AppDomain",
 			"System.DateTime",
 		};
-		bool checkEntryPoint(MethodDef method) {
+		bool CheckEntryPoint(MethodDef method) {
 			if (method == null)
 				return false;
-			if (!new LocalTypes(method).all(requiredLocals))
+			if (!new LocalTypes(method).All(requiredLocals))
 				return false;
-			var handlers = DeobUtils.getAllResolveHandlers(method);
+			var handlers = DeobUtils.GetAllResolveHandlers(method);
 			if (handlers.Count != 1)
 				return false;
 
 			return true;
 		}
 
-		void deobfuscateAll(MethodDef method) {
-			simpleDeobfuscator.deobfuscate(method);
-			simpleDeobfuscator.decryptStrings(method, deob);
+		void DeobfuscateAll(MethodDef method) {
+			simpleDeobfuscator.Deobfuscate(method);
+			simpleDeobfuscator.DecryptStrings(method, deob);
 		}
 
-		string getMainResourceKey(MethodDef method, out MethodDef decryptAssemblyMethod) {
-			foreach (var calledMethod in DotNetUtils.getCalledMethods(module, method)) {
+		string GetMainResourceKey(MethodDef method, out MethodDef decryptAssemblyMethod) {
+			foreach (var calledMethod in DotNetUtils.GetCalledMethods(module, method)) {
 				if (!calledMethod.IsStatic || calledMethod.Body == null)
 					continue;
-				if (!DotNetUtils.isMethod(calledMethod, "System.Void", "(System.String[])"))
+				if (!DotNetUtils.IsMethod(calledMethod, "System.Void", "(System.String[])"))
 					continue;
 
-				deobfuscateAll(calledMethod);
-				string keyInfo = getMainResourceKeyInfo(calledMethod, out decryptAssemblyMethod);
+				DeobfuscateAll(calledMethod);
+				string keyInfo = GetMainResourceKeyInfo(calledMethod, out decryptAssemblyMethod);
 				if (keyInfo == null)
 					continue;
 				return BitConverter.ToString(new MD5CryptoServiceProvider().ComputeHash(new ASCIIEncoding().GetBytes(keyInfo))).Replace("-", "");
@@ -135,7 +135,7 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			return null;
 		}
 
-		string getMainResourceKeyInfo(MethodDef method, out MethodDef 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];
@@ -155,13 +155,13 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			return null;
 		}
 
-		EmbeddedResource getResource(MethodDef method, out ModuleDefMD theResourceModule) {
+		EmbeddedResource GetResource(MethodDef method, out ModuleDefMD theResourceModule) {
 			string resourceDllFileName = null;
 			theResourceModule = module;
-			foreach (var s in DotNetUtils.getCodeStrings(method)) {
+			foreach (var s in DotNetUtils.GetCodeStrings(method)) {
 				if (s.Length > 0 && s[0] == '\\')
 					resourceDllFileName = s;
-				var resource = DotNetUtils.getResource(theResourceModule, s + ".resources") as EmbeddedResource;
+				var resource = DotNetUtils.GetResource(theResourceModule, s + ".resources") as EmbeddedResource;
 				if (resource != null)
 					return resource;
 			}
@@ -169,11 +169,11 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			if (resourceDllFileName == null)
 				return null;
 			// Here if CW 2.x
-			theResourceModule = getResourceModule(resourceDllFileName);
+			theResourceModule = GetResourceModule(resourceDllFileName);
 			if (theResourceModule == null)
 				return null;
-			foreach (var s in DotNetUtils.getCodeStrings(method)) {
-				var resource = DotNetUtils.getResource(theResourceModule, s + ".resources") as EmbeddedResource;
+			foreach (var s in DotNetUtils.GetCodeStrings(method)) {
+				var resource = DotNetUtils.GetResource(theResourceModule, s + ".resources") as EmbeddedResource;
 				if (resource != null)
 					return resource;
 			}
@@ -182,7 +182,7 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			return null;
 		}
 
-		ModuleDefMD getResourceModule(string name) {
+		ModuleDefMD GetResourceModule(string name) {
 			try {
 				var resourceDllFileName = Path.Combine(Path.GetDirectoryName(module.Location), name.Substring(1));
 				return ModuleDefMD.Load(resourceDllFileName);
@@ -192,7 +192,7 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			}
 		}
 
-		bool getPassword(MethodDef 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];
@@ -214,28 +214,28 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			return false;
 		}
 
-		void decryptAllAssemblies() {
+		void DecryptAllAssemblies() {
 			if (assemblyResource == null)
 				return;
 			assemblyResource.Data.Position = 0;
-			var resourceSet = ResourceReader.read(resourceModule, assemblyResource.Data);
+			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 assemblyData = Decrypt((byte[])resourceData.Data);
 				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.String, isMain));
+				assemblyInfos.Add(new AssemblyInfo(assemblyData, DeobUtils.GetExtension(theModule.Kind), theModule.Assembly.FullName, theModule.Assembly.Name.String, isMain));
 			}
 		}
 
-		byte[] decrypt(byte[] encrypted) {
+		byte[] Decrypt(byte[] encrypted) {
 			var keyGenerator = new PasswordDeriveBytes(resourcePassword, Encoding.ASCII.GetBytes(resourceSalt));
-			return DeobUtils.inflate(DeobUtils.aesDecrypt(encrypted, keyGenerator.GetBytes(32), keyGenerator.GetBytes(16)), false);
+			return DeobUtils.Inflate(DeobUtils.AesDecrypt(encrypted, keyGenerator.GetBytes(32), keyGenerator.GetBytes(16)), false);
 		}
 
-		public AssemblyInfo findMain(string asmFullName) {
+		public AssemblyInfo FindMain(string asmFullName) {
 			foreach (var asmInfo in assemblyInfos) {
 				if (asmInfo.isEntryPointAssembly && asmInfo.assemblyFullName == asmFullName)
 					return asmInfo;
@@ -243,7 +243,7 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			return null;
 		}
 
-		public AssemblyInfo findMain() {
+		public AssemblyInfo FindMain() {
 			foreach (var asmInfo in assemblyInfos) {
 				if (asmInfo.isEntryPointAssembly)
 					return asmInfo;
@@ -251,7 +251,7 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			return null;
 		}
 
-		public void remove(AssemblyInfo asmInfo) {
+		public void Remove(AssemblyInfo asmInfo) {
 			assemblyInfos.Remove(asmInfo);
 		}
 	}
diff --git a/de4dot.code/deobfuscators/CodeWall/Deobfuscator.cs b/de4dot.code/deobfuscators/CodeWall/Deobfuscator.cs
index ce1fad71..06f7f967 100644
--- a/de4dot.code/deobfuscators/CodeWall/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/CodeWall/Deobfuscator.cs
@@ -32,8 +32,8 @@ namespace de4dot.code.deobfuscators.CodeWall {
 
 		public DeobfuscatorInfo()
 			: base(DEFAULT_REGEX) {
-			dumpEmbeddedAssemblies = new BoolOption(null, makeArgName("embedded"), "Dump embedded assemblies", true);
-			decryptMainAsm = new BoolOption(null, makeArgName("decrypt-main"), "Decrypt main embedded assembly", true);
+			dumpEmbeddedAssemblies = new BoolOption(null, MakeArgName("embedded"), "Dump embedded assemblies", true);
+			decryptMainAsm = new BoolOption(null, MakeArgName("decrypt-main"), "Decrypt main embedded assembly", true);
 		}
 
 		public override string Name {
@@ -44,7 +44,7 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			get { return THE_TYPE; }
 		}
 
-		public override IDeobfuscator createDeobfuscator() {
+		public override IDeobfuscator CreateDeobfuscator() {
 			return new Deobfuscator(new Deobfuscator.Options {
 				ValidNameRegex = validNameRegex.get(),
 				DumpEmbeddedAssemblies = dumpEmbeddedAssemblies.get(),
@@ -52,7 +52,7 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			});
 		}
 
-		protected override IEnumerable<Option> getOptionsInternal() {
+		protected override IEnumerable<Option> GetOptionsInternal() {
 			return new List<Option>() {
 				dumpEmbeddedAssemblies,
 				decryptMainAsm,
@@ -89,11 +89,11 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			this.options = options;
 		}
 
-		protected override int detectInternal() {
+		protected override int DetectInternal() {
 			int val = 0;
 
-			int sum = toInt32(methodsDecrypter.Detected) +
-					toInt32(stringDecrypter.Detected);
+			int sum = ToInt32(methodsDecrypter.Detected) +
+					ToInt32(stringDecrypter.Detected);
 			if (sum > 0)
 				val += 100 + 10 * (sum - 1);
 
@@ -106,17 +106,17 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			return val;
 		}
 
-		protected override void scanForObfuscator() {
+		protected override void ScanForObfuscator() {
 			methodsDecrypter = new MethodsDecrypter(module);
-			methodsDecrypter.find();
+			methodsDecrypter.Find();
 			stringDecrypter = new StringDecrypter(module);
-			stringDecrypter.find();
-			var version = detectVersion();
+			stringDecrypter.Find();
+			var version = DetectVersion();
 			if (version != null)
 				obfuscatorName = DeobfuscatorInfo.THE_NAME + " " + version;
 		}
 
-		string detectVersion() {
+		string DetectVersion() {
 			if (stringDecrypter.Detected) {
 				switch (stringDecrypter.TheVersion) {
 				case StringDecrypter.Version.V30: return "v3.0 - v3.5";
@@ -136,9 +136,9 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			CanGetMainAssembly = 2,
 		}
 		DecryptState decryptState = DecryptState.CanDecryptMethods | DecryptState.CanGetMainAssembly;
-		public override bool getDecryptedModule(int count, ref byte[] newFileData, ref DumpedMethods dumpedMethods) {
+		public override bool GetDecryptedModule(int count, ref byte[] newFileData, ref DumpedMethods dumpedMethods) {
 			if ((decryptState & DecryptState.CanDecryptMethods) != 0) {
-				if (decryptModule(ref newFileData, ref dumpedMethods)) {
+				if (DecryptModule(ref newFileData, ref dumpedMethods)) {
 					ModuleBytes = newFileData;
 					decryptState &= ~DecryptState.CanDecryptMethods;
 					return true;
@@ -146,7 +146,7 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			}
 
 			if (options.DecryptMainAsm && (decryptState & DecryptState.CanGetMainAssembly) != 0) {
-				newFileData = getMainAssemblyBytes();
+				newFileData = GetMainAssemblyBytes();
 				if (newFileData != null) {
 					ModuleBytes = newFileData;
 					decryptState &= ~DecryptState.CanGetMainAssembly;
@@ -158,13 +158,13 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			return false;
 		}
 
-		bool decryptModule(ref byte[] newFileData, ref DumpedMethods dumpedMethods) {
+		bool DecryptModule(ref byte[] newFileData, ref DumpedMethods dumpedMethods) {
 			if (!methodsDecrypter.Detected)
 				return false;
 
-			byte[] fileData = ModuleBytes ?? DeobUtils.readModule(module);
+			byte[] fileData = ModuleBytes ?? DeobUtils.ReadModule(module);
 			using (var peImage = new MyPEImage(fileData)) {
-				if (!methodsDecrypter.decrypt(peImage, ref dumpedMethods))
+				if (!methodsDecrypter.Decrypt(peImage, ref dumpedMethods))
 					return false;
 			}
 
@@ -172,10 +172,10 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			return true;
 		}
 
-		byte[] getMainAssemblyBytes() {
+		byte[] GetMainAssemblyBytes() {
 			try {
-				initializeStringDecrypter();
-				initializeAssemblyDecrypter();
+				InitializeStringDecrypter();
+				InitializeAssemblyDecrypter();
 			}
 			catch {
 				return null;
@@ -184,80 +184,80 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			var asm = module.Assembly;
 			if (asm == null || assemblyDecrypter == null)
 				return null;
-			var asmInfo = assemblyDecrypter.findMain(asm.FullName) ?? assemblyDecrypter.findMain();
+			var asmInfo = assemblyDecrypter.FindMain(asm.FullName) ?? assemblyDecrypter.FindMain();
 			if (asmInfo == null)
 				return null;
 
-			assemblyDecrypter.remove(asmInfo);
+			assemblyDecrypter.Remove(asmInfo);
 			return asmInfo.data;
 		}
 
-		public override IDeobfuscator moduleReloaded(ModuleDefMD module) {
+		public override IDeobfuscator ModuleReloaded(ModuleDefMD module) {
 			var newOne = new Deobfuscator(options);
-			newOne.setModule(module);
+			newOne.SetModule(module);
 			newOne.methodsDecrypter = new MethodsDecrypter(module);
-			newOne.methodsDecrypter.find();
+			newOne.methodsDecrypter.Find();
 			newOne.stringDecrypter = new StringDecrypter(module);
-			newOne.stringDecrypter.find();
+			newOne.stringDecrypter.Find();
 			newOne.assemblyDecrypter = assemblyDecrypter;
 			newOne.ModuleBytes = ModuleBytes;
 			newOne.decryptState = decryptState;
 			return newOne;
 		}
 
-		public override void deobfuscateBegin() {
-			base.deobfuscateBegin();
+		public override void DeobfuscateBegin() {
+			base.DeobfuscateBegin();
 
-			initializeStringDecrypter();
-			initializeAssemblyDecrypter();
-			dumpEmbeddedAssemblies();
+			InitializeStringDecrypter();
+			InitializeAssemblyDecrypter();
+			DumpEmbeddedAssemblies();
 		}
 
 		bool hasInitializedStringDecrypter = false;
-		void initializeStringDecrypter() {
+		void InitializeStringDecrypter() {
 			if (hasInitializedStringDecrypter)
 				return;
-			stringDecrypter.initialize(DeobfuscatedFile);
+			stringDecrypter.Initialize(DeobfuscatedFile);
 			foreach (var info in stringDecrypter.Infos)
-				staticStringInliner.add(info.Method, (method, gim, args) => stringDecrypter.decrypt(method, (int)args[0], (int)args[1], (int)args[2]));
-			DeobfuscatedFile.stringDecryptersAdded();
+				staticStringInliner.Add(info.Method, (method, gim, args) => stringDecrypter.Decrypt(method, (int)args[0], (int)args[1], (int)args[2]));
+			DeobfuscatedFile.StringDecryptersAdded();
 			hasInitializedStringDecrypter = true;
 		}
 
-		void initializeAssemblyDecrypter() {
+		void InitializeAssemblyDecrypter() {
 			if (!options.DumpEmbeddedAssemblies || assemblyDecrypter != null)
 				return;
 			assemblyDecrypter = new AssemblyDecrypter(module, DeobfuscatedFile, this);
-			assemblyDecrypter.find();
+			assemblyDecrypter.Find();
 		}
 
-		void dumpEmbeddedAssemblies() {
+		void DumpEmbeddedAssemblies() {
 			if (assemblyDecrypter == null)
 				return;
 			foreach (var info in assemblyDecrypter.AssemblyInfos) {
 				var asmName = info.assemblySimpleName;
 				if (info.isEntryPointAssembly)
 					asmName += "_real";
-				DeobfuscatedFile.createAssemblyFile(info.data, asmName, info.extension);
+				DeobfuscatedFile.CreateAssemblyFile(info.data, asmName, info.extension);
 			}
 		}
 
-		public override void deobfuscateMethodEnd(Blocks blocks) {
-			methodsDecrypter.deobfuscate(blocks);
-			base.deobfuscateMethodEnd(blocks);
+		public override void DeobfuscateMethodEnd(Blocks blocks) {
+			methodsDecrypter.Deobfuscate(blocks);
+			base.DeobfuscateMethodEnd(blocks);
 		}
 
-		public override void deobfuscateEnd() {
+		public override void DeobfuscateEnd() {
 			if (CanRemoveStringDecrypterType) {
 				foreach (var info in stringDecrypter.Infos) {
-					addResourceToBeRemoved(info.Resource, "Encrypted strings");
-					addTypeToBeRemoved(info.Type, "String decrypter type");
+					AddResourceToBeRemoved(info.Resource, "Encrypted strings");
+					AddTypeToBeRemoved(info.Type, "String decrypter type");
 				}
 			}
-			base.deobfuscateEnd();
+			base.DeobfuscateEnd();
 		}
 
-		public override IEnumerable<int> getStringDecrypterMethods() {
+		public override IEnumerable<int> GetStringDecrypterMethods() {
 			var list = new List<int>();
 			foreach (var info in stringDecrypter.Infos)
 				list.Add(info.Method.MDToken.ToInt32());
diff --git a/de4dot.code/deobfuscators/CodeWall/KeyGenerator.cs b/de4dot.code/deobfuscators/CodeWall/KeyGenerator.cs
index c69e1f2d..7db36dbb 100644
--- a/de4dot.code/deobfuscators/CodeWall/KeyGenerator.cs
+++ b/de4dot.code/deobfuscators/CodeWall/KeyGenerator.cs
@@ -30,14 +30,14 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			mother = new CRandomMother(seed);
 		}
 
-		uint random() {
+		uint Random() {
 			return (mersenne.BRandom() >> 1) ^ (uint)Math.Abs((int)(mother.Random() * int.MinValue));
 		}
 
-		public byte[] generate(int size) {
+		public byte[] Generate(int size) {
 			var key = new byte[size];
 			for (int i = 0; i < size; i++)
-				key[i] = (byte)random();
+				key[i] = (byte)Random();
 			return key;
 		}
 	}
diff --git a/de4dot.code/deobfuscators/CodeWall/MethodsDecrypter.cs b/de4dot.code/deobfuscators/CodeWall/MethodsDecrypter.cs
index 31b93152..025fc0eb 100644
--- a/de4dot.code/deobfuscators/CodeWall/MethodsDecrypter.cs
+++ b/de4dot.code/deobfuscators/CodeWall/MethodsDecrypter.cs
@@ -38,14 +38,14 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			this.module = module;
 		}
 
-		public void find() {
-			foreach (var cctor in DeobUtils.getInitCctors(module, 3)) {
-				if (checkCctor(cctor))
+		public void Find() {
+			foreach (var cctor in DeobUtils.GetInitCctors(module, 3)) {
+				if (CheckCctor(cctor))
 					return;
 			}
 		}
 
-		bool checkCctor(MethodDef method) {
+		bool CheckCctor(MethodDef method) {
 			if (method == null || method.Body == null)
 				return false;
 
@@ -66,7 +66,7 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			return false;
 		}
 
-		public bool decrypt(MyPEImage peImage, ref DumpedMethods dumpedMethods) {
+		public bool Decrypt(MyPEImage peImage, ref DumpedMethods dumpedMethods) {
 			dumpedMethods = new DumpedMethods();
 
 			bool decrypted = false;
@@ -74,15 +74,15 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			var methodDef = peImage.DotNetFile.MetaData.TablesStream.MethodTable;
 			for (uint rid = 1; rid <= methodDef.Rows; rid++) {
 				var dm = new DumpedMethod();
-				peImage.readMethodTableRowTo(dm, rid);
+				peImage.ReadMethodTableRowTo(dm, rid);
 
 				if (dm.mdRVA == 0)
 					continue;
-				uint bodyOffset = peImage.rvaToOffset(dm.mdRVA);
+				uint bodyOffset = peImage.RvaToOffset(dm.mdRVA);
 
 				peImage.Reader.Position = bodyOffset;
-				var mbHeader = MethodBodyParser.parseMethodBody(peImage.Reader, out dm.code, out dm.extraSections);
-				peImage.updateMethodHeaderInfo(dm, mbHeader);
+				var mbHeader = MethodBodyParser.ParseMethodBody(peImage.Reader, out dm.code, out dm.extraSections);
+				peImage.UpdateMethodHeaderInfo(dm, mbHeader);
 
 				if (dm.code.Length < 6 || dm.code[0] != 0x2A || dm.code[1] != 0x2A)
 					continue;
@@ -90,35 +90,35 @@ namespace de4dot.code.deobfuscators.CodeWall {
 				int seed = BitConverter.ToInt32(dm.code, 2);
 				Array.Copy(newCodeHeader, dm.code, newCodeHeader.Length);
 				if (seed == 0)
-					decrypt(dm.code);
+					Decrypt(dm.code);
 				else
-					decrypt(dm.code, seed);
+					Decrypt(dm.code, seed);
 
-				dumpedMethods.add(dm);
+				dumpedMethods.Add(dm);
 				decrypted = true;
 			}
 
 			return decrypted;
 		}
 
-		void decrypt(byte[] data) {
+		void Decrypt(byte[] data) {
 			for (int i = 6; i < data.Length; i++)
 				data[i] ^= decryptKey[i % decryptKey.Length];
 		}
 
-		void decrypt(byte[] data, int seed) {
-			var key = new KeyGenerator(seed).generate(data.Length);
+		void Decrypt(byte[] data, int seed) {
+			var key = new KeyGenerator(seed).Generate(data.Length);
 			for (int i = 6; i < data.Length; i++)
 				data[i] ^= key[i];
 		}
 
-		public void deobfuscate(Blocks blocks) {
+		public void Deobfuscate(Blocks blocks) {
 			if (initMethod == null)
 				return;
 			if (blocks.Method.Name != ".cctor")
 				return;
 
-			foreach (var block in blocks.MethodBlocks.getAllBlocks()) {
+			foreach (var block in blocks.MethodBlocks.GetAllBlocks()) {
 				var instrs = block.Instructions;
 				for (int i = 0; i < instrs.Count; i++) {
 					var instr = instrs[i];
@@ -127,7 +127,7 @@ namespace de4dot.code.deobfuscators.CodeWall {
 					var calledMethod = instr.Operand as IMethod;
 					if (!MethodEqualityComparer.CompareDeclaringTypes.Equals(calledMethod, initMethod))
 						continue;
-					block.remove(i, 1);
+					block.Remove(i, 1);
 					i--;
 				}
 			}
diff --git a/de4dot.code/deobfuscators/CodeWall/StringDecrypter.cs b/de4dot.code/deobfuscators/CodeWall/StringDecrypter.cs
index b4a7a6a0..ff1dea7e 100644
--- a/de4dot.code/deobfuscators/CodeWall/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/CodeWall/StringDecrypter.cs
@@ -59,32 +59,32 @@ namespace de4dot.code.deobfuscators.CodeWall {
 				this.method = method;
 			}
 
-			public string decrypt(int magic1, int magic2, int magic3) {
+			public string Decrypt(int magic1, int magic2, int magic3) {
 				int dataLen = magic3 ^ Magic3;
-				var key = getKey(magic1 ^ Magic1, dataLen);
-				Reader.Position = getDataOffset(magic2);
+				var key = GetKey(magic1 ^ Magic1, dataLen);
+				Reader.Position = GetDataOffset(magic2);
 				var data = Reader.ReadBytes(dataLen);
 				for (int i = 0; i < dataLen; i++)
 					data[i] ^= key[i];
 				return Encoding.Unicode.GetString(data);
 			}
 
-			byte[] getKey(int seed, int keyLen) {
+			byte[] GetKey(int seed, int keyLen) {
 				var random = new Random(seed);
 				var key = new byte[keyLen];
 				random.NextBytes(key);
 				return key;
 			}
 
-			int getDataOffset(int magic2) {
-				var pkt = getPublicKeyToken();
+			int GetDataOffset(int magic2) {
+				var pkt = GetPublicKeyToken();
 				if (pkt == null)
 					return magic2 ^ Magic2;
 				else
 					return magic2 ^ BitConverter.ToInt32(pkt, 0) ^ BitConverter.ToInt32(pkt, 4);
 			}
 
-			byte[] getPublicKeyToken() {
+			byte[] GetPublicKeyToken() {
 				var module = method.Module;
 				if (module.Assembly == null || PublicKeyBase.IsNullOrEmpty2(module.Assembly.PublicKey))
 					return null;
@@ -109,7 +109,7 @@ namespace de4dot.code.deobfuscators.CodeWall {
 		public IEnumerable<StringEncrypterInfo> Infos {
 			get {
 				var list = new List<StringEncrypterInfo>();
-				foreach (var info in stringEncrypterInfos.getValues()) {
+				foreach (var info in stringEncrypterInfos.GetValues()) {
 					if (info.Resource != null)
 						list.Add(info);
 				}
@@ -121,26 +121,26 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			this.module = module;
 		}
 
-		public void find() {
+		public void Find() {
 			foreach (var type in module.Types) {
 				MethodDef decrypterMethod;
-				var decrypterVersion = checkType(type, out decrypterMethod);
+				var decrypterVersion = CheckType(type, out decrypterMethod);
 				if (decrypterVersion == Version.Unknown)
 					continue;
 				version = decrypterVersion;
-				stringEncrypterInfos.add(decrypterMethod, new StringEncrypterInfo(decrypterMethod));
+				stringEncrypterInfos.Add(decrypterMethod, new StringEncrypterInfo(decrypterMethod));
 			}
 		}
 
-		Version checkType(TypeDef type, out MethodDef decrypterMethod) {
+		Version CheckType(TypeDef type, out MethodDef decrypterMethod) {
 			MethodDef method;
 
-			if ((method = checkType_v30(type)) != null) {
+			if ((method = CheckTypeV30(type)) != null) {
 				decrypterMethod = method;
 				return Version.V30;
 			}
 
-			if ((method = checkType_v36(type)) != null) {
+			if ((method = CheckTypeV36(type)) != null) {
 				decrypterMethod = method;
 				return Version.V36;
 			}
@@ -160,19 +160,19 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			"System.Random",
 			"System.String",
 		};
-		MethodDef checkType_v30(TypeDef type) {
-			MethodDef decrypterMethod = checkMethods_v30(type);
+		MethodDef CheckTypeV30(TypeDef type) {
+			MethodDef decrypterMethod = CheckMethodsV30(type);
 			if (decrypterMethod == null)
 				return null;
-			if (!new FieldTypes(type).exactly(requiredTypes_v30))
+			if (!new FieldTypes(type).Exactly(requiredTypes_v30))
 				return null;
-			if (!new LocalTypes(decrypterMethod).exactly(requiredLocals_v30))
+			if (!new LocalTypes(decrypterMethod).Exactly(requiredLocals_v30))
 				return null;
 
 			return decrypterMethod;
 		}
 
-		static MethodDef checkMethods_v30(TypeDef type) {
+		static MethodDef CheckMethodsV30(TypeDef type) {
 			if (type.Methods.Count < 1 || type.Methods.Count > 2)
 				return null;
 
@@ -185,7 +185,7 @@ namespace de4dot.code.deobfuscators.CodeWall {
 				}
 				if (decrypterMethod != null)
 					return null;
-				if (!DotNetUtils.isMethod(method, "System.String", "(System.Int32,System.Int32,System.Int32)"))
+				if (!DotNetUtils.IsMethod(method, "System.String", "(System.Int32,System.Int32,System.Int32)"))
 					return null;
 				decrypterMethod = method;
 			}
@@ -207,19 +207,19 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			"System.String",
 			"System.Object",
 		};
-		MethodDef checkType_v36(TypeDef type) {
-			MethodDef decrypterMethod = checkMethods_v36(type);
+		MethodDef CheckTypeV36(TypeDef type) {
+			MethodDef decrypterMethod = CheckMethodsV36(type);
 			if (decrypterMethod == null)
 				return null;
-			if (!new FieldTypes(type).exactly(requiredTypes_v36))
+			if (!new FieldTypes(type).Exactly(requiredTypes_v36))
 				return null;
-			if (!new LocalTypes(decrypterMethod).exactly(requiredLocals_v36))
+			if (!new LocalTypes(decrypterMethod).Exactly(requiredLocals_v36))
 				return null;
 
 			return decrypterMethod;
 		}
 
-		static MethodDef checkMethods_v36(TypeDef type) {
+		static MethodDef CheckMethodsV36(TypeDef type) {
 			if (type.Methods.Count != 2)
 				return null;
 
@@ -232,7 +232,7 @@ namespace de4dot.code.deobfuscators.CodeWall {
 				}
 				if (decrypterMethod != null)
 					return null;
-				if (!DotNetUtils.isMethod(method, "System.String", "(System.Int32,System.Int32,System.Int32)"))
+				if (!DotNetUtils.IsMethod(method, "System.String", "(System.Int32,System.Int32,System.Int32)"))
 					return null;
 				decrypterMethod = method;
 			}
@@ -243,27 +243,27 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			return decrypterMethod;
 		}
 
-		public void initialize(ISimpleDeobfuscator simpleDeobfuscator) {
-			foreach (var info in stringEncrypterInfos.getValues()) {
-				simpleDeobfuscator.deobfuscate(info.Method);
-				info.Resource = findResource(info.Method);
+		public void Initialize(ISimpleDeobfuscator simpleDeobfuscator) {
+			foreach (var info in stringEncrypterInfos.GetValues()) {
+				simpleDeobfuscator.Deobfuscate(info.Method);
+				info.Resource = FindResource(info.Method);
 				if (info.Resource == null) {
 					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.Magic1 = FindMagic1(info.Method);
+				info.Magic2 = FindMagic2(info.Method);
+				info.Magic3 = FindMagic3(info.Method);
 				info.Reader = info.Resource.Data;
 				info.Reader.Position = 0;
 			}
 		}
 
-		EmbeddedResource findResource(MethodDef method) {
-			return DotNetUtils.getResource(module, DotNetUtils.getCodeStrings(method)) as EmbeddedResource;
+		EmbeddedResource FindResource(MethodDef method) {
+			return DotNetUtils.GetResource(module, DotNetUtils.GetCodeStrings(method)) as EmbeddedResource;
 		}
 
-		static int findMagic1(MethodDef method) {
+		static int FindMagic1(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 2; i++) {
 				var ldarg = instrs[i];
@@ -279,7 +279,7 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			throw new ApplicationException("Could not find magic1");
 		}
 
-		static int findMagic2(MethodDef method) {
+		static int FindMagic2(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 2; i++) {
 				var ldloc = instrs[i];
@@ -295,7 +295,7 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			throw new ApplicationException("Could not find magic2");
 		}
 
-		static int findMagic3(MethodDef method) {
+		static int FindMagic3(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 2; i++) {
 				var ldarg = instrs[i];
@@ -311,9 +311,9 @@ namespace de4dot.code.deobfuscators.CodeWall {
 			throw new ApplicationException("Could not find magic3");
 		}
 
-		public string decrypt(MethodDef method, int magic1, int magic2, int magic3) {
-			var info = stringEncrypterInfos.find(method);
-			return info.decrypt(magic1, magic2, 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 ad626104..ab5f97f6 100644
--- a/de4dot.code/deobfuscators/ConstantsReader.cs
+++ b/de4dot.code/deobfuscators/ConstantsReader.cs
@@ -120,84 +120,84 @@ namespace de4dot.code.deobfuscators {
 			this.locals = locals;
 		}
 
-		public void setConstantInt32(Local local, int value) {
+		public void SetConstantInt32(Local local, int value) {
 			localsValuesInt32[local] = value;
 		}
 
-		public void setConstantInt32(Local local, uint value) {
-			setConstantInt32(local, (int)value);
+		public void SetConstantInt32(Local local, uint value) {
+			SetConstantInt32(local, (int)value);
 		}
 
-		public void setConstantInt64(Local local, long value) {
+		public void SetConstantInt64(Local local, long value) {
 			localsValuesInt64[local] = value;
 		}
 
-		public void setConstantInt64(Local local, ulong value) {
-			setConstantInt64(local, (long)value);
+		public void SetConstantInt64(Local local, ulong value) {
+			SetConstantInt64(local, (long)value);
 		}
 
-		public void setConstantDouble(Local local, double value) {
+		public void SetConstantDouble(Local local, double value) {
 			localsValuesDouble[local] = value;
 		}
 
-		public bool getNextInt32(ref int index, out int val) {
+		public bool GetNextInt32(ref int index, out int val) {
 			for (; index < instructions.Count; index++) {
 				var instr = instructions[index];
-				if (!isLoadConstantInt32(instr))
+				if (!IsLoadConstantInt32(instr))
 					continue;
 
-				return getInt32(ref index, out val);
+				return GetInt32(ref index, out val);
 			}
 
 			val = 0;
 			return false;
 		}
 
-		public bool isLoadConstantInt32(Instruction instr) {
+		public bool IsLoadConstantInt32(Instruction instr) {
 			if (instr.IsLdcI4())
 				return true;
 			if (instr.IsLdloc()) {
 				int tmp;
-				return getLocalConstantInt32(instr, out tmp);
+				return GetLocalConstantInt32(instr, out tmp);
 			}
 			if (instr.IsLdarg()) {
 				int tmp;
-				return getArgConstantInt32(instr, out tmp);
+				return GetArgConstantInt32(instr, out tmp);
 			}
 			return false;
 		}
 
-		public bool isLoadConstantInt64(Instruction instr) {
+		public bool IsLoadConstantInt64(Instruction instr) {
 			if (instr.OpCode.Code == Code.Ldc_I8)
 				return true;
 			if (instr.IsLdloc()) {
 				long tmp;
-				return getLocalConstantInt64(instr, out tmp);
+				return GetLocalConstantInt64(instr, out tmp);
 			}
 			if (instr.IsLdarg()) {
 				long tmp;
-				return getArgConstantInt64(instr, out tmp);
+				return GetArgConstantInt64(instr, out tmp);
 			}
 			return false;
 		}
 
-		public bool isLoadConstantDouble(Instruction instr) {
+		public bool IsLoadConstantDouble(Instruction instr) {
 			if (instr.OpCode.Code == Code.Ldc_R8)
 				return true;
 			if (instr.IsLdloc()) {
 				double tmp;
-				return getLocalConstantDouble(instr, out tmp);
+				return GetLocalConstantDouble(instr, out tmp);
 			}
 			if (instr.IsLdarg()) {
 				double tmp;
-				return getArgConstantDouble(instr, out tmp);
+				return GetArgConstantDouble(instr, out tmp);
 			}
 			return false;
 		}
 
-		public bool getInt16(ref int index, out short val) {
+		public bool GetInt16(ref int index, out short val) {
 			int tmp;
-			if (!getInt32(ref index, out tmp)) {
+			if (!GetInt32(ref index, out tmp)) {
 				val = 0;
 				return false;
 			}
@@ -215,19 +215,19 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		protected virtual bool processInstructionInt32(ref int index, Stack<ConstantInfo<int>> stack) {
+		protected virtual bool ProcessInstructionInt32(ref int index, Stack<ConstantInfo<int>> stack) {
 			return false;
 		}
 
-		protected virtual bool processInstructionInt64(ref int index, Stack<ConstantInfo<long>> stack) {
+		protected virtual bool ProcessInstructionInt64(ref int index, Stack<ConstantInfo<long>> stack) {
 			return false;
 		}
 
-		protected virtual bool processInstructionDouble(ref int index, Stack<ConstantInfo<double>> stack) {
+		protected virtual bool ProcessInstructionDouble(ref int index, Stack<ConstantInfo<double>> stack) {
 			return false;
 		}
 
-		public bool getInt32(ref int index, out int val) {
+		public bool GetInt32(ref int index, out int val) {
 			val = 0;
 			if (index >= instructions.Count)
 				return false;
@@ -237,7 +237,7 @@ namespace de4dot.code.deobfuscators {
 			int op1;
 			ConstantInfo<int> info1, info2;
 			for (; index < instructions.Count; index++) {
-				if (processInstructionInt32(ref index, stack)) {
+				if (ProcessInstructionInt32(ref index, stack)) {
 					index--;
 					continue;
 				}
@@ -292,7 +292,7 @@ namespace de4dot.code.deobfuscators {
 				case Code.Ldloc_1:
 				case Code.Ldloc_2:
 				case Code.Ldloc_3:
-					if (!getLocalConstantInt32(instr, out op1))
+					if (!GetLocalConstantInt32(instr, out op1))
 						goto done;
 					stack.Push(new ConstantInfo<int>(index, op1));
 					break;
@@ -303,7 +303,7 @@ namespace de4dot.code.deobfuscators {
 				case Code.Ldarg_1:
 				case Code.Ldarg_2:
 				case Code.Ldarg_3:
-					if (!getArgConstantInt32(instr, out op1))
+					if (!GetArgConstantInt32(instr, out op1))
 						goto done;
 					stack.Push(new ConstantInfo<int>(index, op1));
 					break;
@@ -406,7 +406,7 @@ done:
 			return true;
 		}
 
-		public bool getInt64(ref int index, out long val) {
+		public bool GetInt64(ref int index, out long val) {
 			val = 0;
 			if (index >= instructions.Count)
 				return false;
@@ -416,7 +416,7 @@ done:
 			long op1;
 			ConstantInfo<long> info1, info2;
 			for (; index < instructions.Count; index++) {
-				if (processInstructionInt64(ref index, stack)) {
+				if (ProcessInstructionInt64(ref index, stack)) {
 					index--;
 					continue;
 				}
@@ -483,7 +483,7 @@ done:
 				case Code.Ldloc_1:
 				case Code.Ldloc_2:
 				case Code.Ldloc_3:
-					if (!getLocalConstantInt64(instr, out op1))
+					if (!GetLocalConstantInt64(instr, out op1))
 						goto done;
 					stack.Push(new ConstantInfo<long>(index, op1));
 					break;
@@ -494,7 +494,7 @@ done:
 				case Code.Ldarg_1:
 				case Code.Ldarg_2:
 				case Code.Ldarg_3:
-					if (!getArgConstantInt64(instr, out op1))
+					if (!GetArgConstantInt64(instr, out op1))
 						goto done;
 					stack.Push(new ConstantInfo<long>(index, op1));
 					break;
@@ -586,7 +586,7 @@ done:
 			return true;
 		}
 
-		public bool getDouble(ref int index, out double val) {
+		public bool GetDouble(ref int index, out double val) {
 			val = 0;
 			if (index >= instructions.Count)
 				return false;
@@ -596,7 +596,7 @@ done:
 			double op1;
 			ConstantInfo<double> info1, info2;
 			for (; index < instructions.Count; index++) {
-				if (processInstructionDouble(ref index, stack)) {
+				if (ProcessInstructionDouble(ref index, stack)) {
 					index--;
 					continue;
 				}
@@ -626,7 +626,7 @@ done:
 				case Code.Ldloc_1:
 				case Code.Ldloc_2:
 				case Code.Ldloc_3:
-					if (!getLocalConstantDouble(instr, out op1))
+					if (!GetLocalConstantDouble(instr, out op1))
 						goto done;
 					stack.Push(new ConstantInfo<double>(index, op1));
 					break;
@@ -637,7 +637,7 @@ done:
 				case Code.Ldarg_1:
 				case Code.Ldarg_2:
 				case Code.Ldarg_3:
-					if (!getArgConstantDouble(instr, out op1))
+					if (!GetArgConstantDouble(instr, out op1))
 						goto done;
 					stack.Push(new ConstantInfo<double>(index, op1));
 					break;
@@ -705,7 +705,7 @@ done:
 			return true;
 		}
 
-		protected virtual bool getLocalConstantInt32(Instruction instr, out int value) {
+		protected virtual bool GetLocalConstantInt32(Instruction instr, out int value) {
 			value = 0;
 			if (locals == null)
 				return false;
@@ -717,12 +717,12 @@ done:
 			return localsValuesInt32.TryGetValue(local, out value);
 		}
 
-		protected virtual bool getArgConstantInt32(Instruction instr, out int value) {
+		protected virtual bool GetArgConstantInt32(Instruction instr, out int value) {
 			value = 0;
 			return false;
 		}
 
-		protected virtual bool getLocalConstantInt64(Instruction instr, out long value) {
+		protected virtual bool GetLocalConstantInt64(Instruction instr, out long value) {
 			value = 0;
 			if (locals == null)
 				return false;
@@ -734,12 +734,12 @@ done:
 			return localsValuesInt64.TryGetValue(local, out value);
 		}
 
-		protected virtual bool getArgConstantInt64(Instruction instr, out long value) {
+		protected virtual bool GetArgConstantInt64(Instruction instr, out long value) {
 			value = 0;
 			return false;
 		}
 
-		protected virtual bool getLocalConstantDouble(Instruction instr, out double value) {
+		protected virtual bool GetLocalConstantDouble(Instruction instr, out double value) {
 			value = 0;
 			if (locals == null)
 				return false;
@@ -751,7 +751,7 @@ done:
 			return localsValuesDouble.TryGetValue(local, out value);
 		}
 
-		protected virtual bool getArgConstantDouble(Instruction instr, out double value) {
+		protected virtual bool GetArgConstantDouble(Instruction instr, out double value) {
 			value = 0;
 			return false;
 		}
diff --git a/de4dot.code/deobfuscators/CryptoObfuscator/AntiDebugger.cs b/de4dot.code/deobfuscators/CryptoObfuscator/AntiDebugger.cs
index 4a8dfc67..5480bba8 100644
--- a/de4dot.code/deobfuscators/CryptoObfuscator/AntiDebugger.cs
+++ b/de4dot.code/deobfuscators/CryptoObfuscator/AntiDebugger.cs
@@ -42,33 +42,33 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			this.deob = deob;
 		}
 
-		public void find() {
-			if (find(module.EntryPoint))
+		public void Find() {
+			if (Find(module.EntryPoint))
 				return;
-			if (find(DotNetUtils.getModuleTypeCctor(module)))
+			if (Find(DotNetUtils.GetModuleTypeCctor(module)))
 				return;
 		}
 
-		bool find(MethodDef methodToCheck) {
+		bool Find(MethodDef methodToCheck) {
 			if (methodToCheck == null)
 				return false;
-			foreach (var method in DotNetUtils.getCalledMethods(module, methodToCheck)) {
+			foreach (var method in DotNetUtils.GetCalledMethods(module, methodToCheck)) {
 				var type = method.DeclaringType;
 
-				if (!method.IsStatic || !DotNetUtils.isMethod(method, "System.Void", "()"))
+				if (!method.IsStatic || !DotNetUtils.IsMethod(method, "System.Void", "()"))
 					continue;
-				if (DotNetUtils.getPInvokeMethod(type, "kernel32", "LoadLibrary") == null)
+				if (DotNetUtils.GetPInvokeMethod(type, "kernel32", "LoadLibrary") == null)
 					continue;
-				if (DotNetUtils.getPInvokeMethod(type, "kernel32", "GetProcAddress") == null)
+				if (DotNetUtils.GetPInvokeMethod(type, "kernel32", "GetProcAddress") == null)
 					continue;
-				deobfuscate(method);
-				if (!containsString(method, "debugger is activ") &&
-					!containsString(method, "debugger is running") &&
-					!containsString(method, "Debugger detected") &&
-					!containsString(method, "Debugger was detected") &&
-					!containsString(method, "{0} was detected") &&
-					!containsString(method, "run under") &&
-					!containsString(method, "run with"))
+				Deobfuscate(method);
+				if (!ContainsString(method, "debugger is activ") &&
+					!ContainsString(method, "debugger is running") &&
+					!ContainsString(method, "Debugger detected") &&
+					!ContainsString(method, "Debugger was detected") &&
+					!ContainsString(method, "{0} was detected") &&
+					!ContainsString(method, "run under") &&
+					!ContainsString(method, "run with"))
 					continue;
 
 				antiDebuggerType = type;
@@ -79,13 +79,13 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return false;
 		}
 
-		void deobfuscate(MethodDef method) {
-			simpleDeobfuscator.deobfuscate(method);
-			simpleDeobfuscator.decryptStrings(method, deob);
+		void Deobfuscate(MethodDef method) {
+			simpleDeobfuscator.Deobfuscate(method);
+			simpleDeobfuscator.DecryptStrings(method, deob);
 		}
 
-		bool containsString(MethodDef method, string part) {
-			foreach (var s in DotNetUtils.getCodeStrings(method)) {
+		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 ab67fc82..5b107767 100644
--- a/de4dot.code/deobfuscators/CryptoObfuscator/AssemblyResolver.cs
+++ b/de4dot.code/deobfuscators/CryptoObfuscator/AssemblyResolver.cs
@@ -66,30 +66,30 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			this.module = module;
 		}
 
-		public void find() {
-			var cctor = DotNetUtils.getModuleTypeCctor(module);
+		public void Find() {
+			var cctor = DotNetUtils.GetModuleTypeCctor(module);
 			if (cctor == null)
 				return;
 
-			foreach (var method in DotNetUtils.getCalledMethods(module, cctor)) {
+			foreach (var method in DotNetUtils.GetCalledMethods(module, cctor)) {
 				if (method.Name == ".cctor" || method.Name == ".ctor")
 					continue;
-				if (!method.IsStatic || !DotNetUtils.isMethod(method, "System.Void", "()"))
+				if (!method.IsStatic || !DotNetUtils.IsMethod(method, "System.Void", "()"))
 					continue;
-				if (checkType(method.DeclaringType, method))
+				if (CheckType(method.DeclaringType, method))
 					break;
 			}
 		}
 
-		bool checkType(TypeDef type, MethodDef initMethod) {
-			if (DotNetUtils.findFieldType(type, "System.Collections.Hashtable", true) == null)
+		bool CheckType(TypeDef type, MethodDef initMethod) {
+			if (DotNetUtils.FindFieldType(type, "System.Collections.Hashtable", true) == null)
 				return false;
-			if (!checkInitMethod(initMethod))
+			if (!CheckInitMethod(initMethod))
 				return false;
 
 			List<AssemblyInfo> newAssemblyInfos = null;
-			foreach (var s in DotNetUtils.getCodeStrings(initMethod)) {
-				newAssemblyInfos = initializeEmbeddedAssemblies(s);
+			foreach (var s in DotNetUtils.GetCodeStrings(initMethod)) {
+				newAssemblyInfos = InitializeEmbeddedAssemblies(s);
 				if (newAssemblyInfos != null)
 					break;
 			}
@@ -102,13 +102,13 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return true;
 		}
 
-		bool checkInitMethod(MethodDef initMethod) {
+		bool CheckInitMethod(MethodDef initMethod) {
 			if (!initMethod.HasBody)
 				return false;
 
 			var instructions = initMethod.Body.Instructions;
 			for (int i = 0; i < instructions.Count; i++) {
-				var instrs = DotNetUtils.getInstructions(instructions, i, OpCodes.Ldnull, OpCodes.Ldftn, OpCodes.Newobj);
+				var instrs = DotNetUtils.GetInstructions(instructions, i, OpCodes.Ldnull, OpCodes.Ldftn, OpCodes.Newobj);
 				if (instrs == null)
 					continue;
 
@@ -130,7 +130,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return false;
 		}
 
-		List<AssemblyInfo> initializeEmbeddedAssemblies(string s) {
+		List<AssemblyInfo> InitializeEmbeddedAssemblies(string s) {
 			var sb = new StringBuilder(s.Length);
 			foreach (var c in s)
 				sb.Append((char)~c);
@@ -142,8 +142,8 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			for (int i = 0; i < tmpAssemblyInfos.Length; i += 2) {
 				var assemblyName = tmpAssemblyInfos[i];
 				var resourceName = tmpAssemblyInfos[i + 1];
-				var resource = DotNetUtils.getResource(module, resourceName) as EmbeddedResource;
-				var symbolsResource = DotNetUtils.getResource(module, resourceName + "#") as EmbeddedResource;
+				var resource = DotNetUtils.GetResource(module, resourceName) as EmbeddedResource;
+				var symbolsResource = DotNetUtils.GetResource(module, resourceName + "#") as EmbeddedResource;
 				if (resource == null)
 					return null;
 				newAssemblyInfos.Add(new AssemblyInfo(assemblyName, resource, symbolsResource));
diff --git a/de4dot.code/deobfuscators/CryptoObfuscator/CoUtils.cs b/de4dot.code/deobfuscators/CryptoObfuscator/CoUtils.cs
index 61b77d48..96fb28c2 100644
--- a/de4dot.code/deobfuscators/CryptoObfuscator/CoUtils.cs
+++ b/de4dot.code/deobfuscators/CryptoObfuscator/CoUtils.cs
@@ -25,19 +25,19 @@ using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.CryptoObfuscator {
 	static class CoUtils {
-		public static EmbeddedResource getResource(ModuleDefMD module, MethodDef method) {
+		public static EmbeddedResource GetResource(ModuleDefMD module, MethodDef method) {
 			if (method == null || method.Body == null)
 				return null;
-			return getResource(module, DotNetUtils.getCodeStrings(method));
+			return GetResource(module, DotNetUtils.GetCodeStrings(method));
 		}
 
-		public static EmbeddedResource getResource(ModuleDefMD 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;
+				var resource = DotNetUtils.GetResource(module, name) as EmbeddedResource;
 				if (resource != null)
 					return resource;
 				try {
-					resource = DotNetUtils.getResource(module, Encoding.UTF8.GetString(Convert.FromBase64String(name))) as EmbeddedResource;
+					resource = DotNetUtils.GetResource(module, Encoding.UTF8.GetString(Convert.FromBase64String(name))) as EmbeddedResource;
 					if (resource != null)
 						return resource;
 				}
diff --git a/de4dot.code/deobfuscators/CryptoObfuscator/ConstantsDecrypter.cs b/de4dot.code/deobfuscators/CryptoObfuscator/ConstantsDecrypter.cs
index 3a4a89ed..295659f1 100644
--- a/de4dot.code/deobfuscators/CryptoObfuscator/ConstantsDecrypter.cs
+++ b/de4dot.code/deobfuscators/CryptoObfuscator/ConstantsDecrypter.cs
@@ -67,9 +67,9 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			this.module = module;
 		}
 
-		public void find() {
+		public void Find() {
 			foreach (var type in module.Types) {
-				if (!checkType(type))
+				if (!CheckType(type))
 					continue;
 
 				decrypterType = type;
@@ -80,51 +80,51 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 		static readonly string[] requiredTypes = new string[] {
 			"System.Byte[]",
 		};
-		bool checkType(TypeDef type) {
+		bool CheckType(TypeDef type) {
 			if (type.Methods.Count != 7)
 				return false;
 			if (type.Fields.Count < 1 || type.Fields.Count > 2)
 				return false;
-			if (!new FieldTypes(type).all(requiredTypes))
+			if (!new FieldTypes(type).All(requiredTypes))
 				return false;
-			if (!checkMethods(type))
+			if (!CheckMethods(type))
 				return false;
 
 			return true;
 		}
 
-		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)");
-			methodR8 = DotNetUtils.getMethod(type, "System.Double", "(System.Int32)");
+		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)");
+			methodR8 = DotNetUtils.GetMethod(type, "System.Double", "(System.Int32)");
 
 			return methodI4 != null && methodI8 != null &&
 				methodR4 != null && methodR8 != null;
 		}
 
-		public void init(ResourceDecrypter resourceDecrypter) {
+		public void Initialize(ResourceDecrypter resourceDecrypter) {
 			if (decrypterType == null)
 				return;
 
-			encryptedResource = CoUtils.getResource(module, DotNetUtils.getCodeStrings(decrypterType.FindStaticConstructor()));
+			encryptedResource = CoUtils.GetResource(module, DotNetUtils.GetCodeStrings(decrypterType.FindStaticConstructor()));
 			encryptedResource.Data.Position = 0;
-			constantsData = resourceDecrypter.decrypt(encryptedResource.Data.CreateStream());
+			constantsData = resourceDecrypter.Decrypt(encryptedResource.Data.CreateStream());
 		}
 
-		public int decryptInt32(int index) {
+		public int DecryptInt32(int index) {
 			return BitConverter.ToInt32(constantsData, index);
 		}
 
-		public long decryptInt64(int index) {
+		public long DecryptInt64(int index) {
 			return BitConverter.ToInt64(constantsData, index);
 		}
 
-		public float decryptSingle(int index) {
+		public float DecryptSingle(int index) {
 			return BitConverter.ToSingle(constantsData, index);
 		}
 
-		public double decryptDouble(int index) {
+		public double DecryptDouble(int index) {
 			return BitConverter.ToDouble(constantsData, index);
 		}
 	}
diff --git a/de4dot.code/deobfuscators/CryptoObfuscator/Deobfuscator.cs b/de4dot.code/deobfuscators/CryptoObfuscator/Deobfuscator.cs
index 07484d7e..1a9b8754 100644
--- a/de4dot.code/deobfuscators/CryptoObfuscator/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/CryptoObfuscator/Deobfuscator.cs
@@ -33,8 +33,8 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 
 		public DeobfuscatorInfo()
 			: base(DEFAULT_REGEX) {
-			removeTamperProtection = new BoolOption(null, makeArgName("tamper"), "Remove tamper protection code", true);
-			decryptConstants = new BoolOption(null, makeArgName("consts"), "Decrypt constants", true);
+			removeTamperProtection = new BoolOption(null, MakeArgName("tamper"), "Remove tamper protection code", true);
+			decryptConstants = new BoolOption(null, MakeArgName("consts"), "Decrypt constants", true);
 		}
 
 		public override string Name {
@@ -45,7 +45,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			get { return THE_TYPE; }
 		}
 
-		public override IDeobfuscator createDeobfuscator() {
+		public override IDeobfuscator CreateDeobfuscator() {
 			return new Deobfuscator(new Deobfuscator.Options {
 				ValidNameRegex = validNameRegex.get(),
 				RemoveTamperProtection = removeTamperProtection.get(),
@@ -53,7 +53,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			});
 		}
 
-		protected override IEnumerable<Option> getOptionsInternal() {
+		protected override IEnumerable<Option> GetOptionsInternal() {
 			return new List<Option>() {
 				removeTamperProtection,
 				decryptConstants,
@@ -105,18 +105,18 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			StringFeatures = StringFeatures.AllowStaticDecryption | StringFeatures.AllowDynamicDecryption;
 		}
 
-		public override void init(ModuleDefMD module) {
-			base.init(module);
+		public override void Initialize(ModuleDefMD module) {
+			base.Initialize(module);
 		}
 
-		protected override int detectInternal() {
+		protected override int DetectInternal() {
 			int val = 0;
 
-			int sum = toInt32(methodsDecrypter.Detected) +
-					toInt32(stringDecrypter.Detected) +
-					toInt32(tamperDetection.Detected) +
-					toInt32(proxyCallFixer.Detected) +
-					toInt32(constantsDecrypter.Detected);
+			int sum = ToInt32(methodsDecrypter.Detected) +
+					ToInt32(stringDecrypter.Detected) +
+					ToInt32(tamperDetection.Detected) +
+					ToInt32(proxyCallFixer.Detected) +
+					ToInt32(constantsDecrypter.Detected);
 			if (sum > 0)
 				val += 100 + 10 * (sum - 1);
 			if (foundCryptoObfuscatorAttribute || foundObfuscatedSymbols || foundObfuscatorUserString)
@@ -125,32 +125,32 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return val;
 		}
 
-		protected override void scanForObfuscator() {
+		protected override void ScanForObfuscator() {
 			foreach (var type in module.Types) {
 				if (type.FullName == "CryptoObfuscator.ProtectedWithCryptoObfuscatorAttribute") {
 					foundCryptoObfuscatorAttribute = true;
-					addAttributeToBeRemoved(type, "Obfuscator attribute");
-					initializeVersion(type);
+					AddAttributeToBeRemoved(type, "Obfuscator attribute");
+					InitializeVersion(type);
 				}
 			}
-			if (checkCryptoObfuscator())
+			if (CheckCryptoObfuscator())
 				foundObfuscatedSymbols = true;
 
 			methodsDecrypter = new MethodsDecrypter(module);
-			methodsDecrypter.find();
+			methodsDecrypter.Find();
 			proxyCallFixer = new ProxyCallFixer(module);
-			proxyCallFixer.findDelegateCreator();
+			proxyCallFixer.FindDelegateCreator();
 			stringDecrypter = new StringDecrypter(module);
-			stringDecrypter.find();
+			stringDecrypter.Find();
 			tamperDetection = new TamperDetection(module);
-			tamperDetection.find();
+			tamperDetection.Find();
 			constantsDecrypter = new ConstantsDecrypter(module);
-			constantsDecrypter.find();
+			constantsDecrypter.Find();
 			foundObfuscatorUserString = Utils.StartsWith(module.ReadUserString(0x70000001), "\u0011\"3D9B94A98B-76A8-4810-B1A0-4BE7C4F9C98D", StringComparison.Ordinal);
 		}
 
-		void initializeVersion(TypeDef attr) {
-			var s = DotNetUtils.getCustomArgAsString(getAssemblyAttribute(attr), 0);
+		void InitializeVersion(TypeDef attr) {
+			var s = DotNetUtils.GetCustomArgAsString(GetAssemblyAttribute(attr), 0);
 			if (s == null)
 				return;
 
@@ -161,7 +161,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return;
 		}
 
-		bool checkCryptoObfuscator() {
+		bool CheckCryptoObfuscator() {
 			int matched = 0;
 			foreach (var type in module.Types) {
 				if (type.Namespace != "A")
@@ -176,110 +176,110 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return false;
 		}
 
-		public override void deobfuscateBegin() {
-			base.deobfuscateBegin();
+		public override void DeobfuscateBegin() {
+			base.DeobfuscateBegin();
 
 			resourceDecrypter = new ResourceDecrypter(module, DeobfuscatedFile);
 			resourceResolver = new ResourceResolver(module, resourceDecrypter);
 			assemblyResolver = new AssemblyResolver(module);
-			resourceResolver.find();
-			assemblyResolver.find();
+			resourceResolver.Find();
+			assemblyResolver.Find();
 
-			decryptResources();
-			stringDecrypter.init(resourceDecrypter);
+			DecryptResources();
+			stringDecrypter.Initialize(resourceDecrypter);
 			if (stringDecrypter.Method != null) {
-				staticStringInliner.add(stringDecrypter.Method, (method, gim, args) => {
-					return stringDecrypter.decrypt((int)args[0]);
+				staticStringInliner.Add(stringDecrypter.Method, (method, gim, args) => {
+					return stringDecrypter.Decrypt((int)args[0]);
 				});
-				DeobfuscatedFile.stringDecryptersAdded();
+				DeobfuscatedFile.StringDecryptersAdded();
 			}
 
-			methodsDecrypter.decrypt(resourceDecrypter);
+			methodsDecrypter.Decrypt(resourceDecrypter);
 
 			if (methodsDecrypter.Detected) {
 				if (!assemblyResolver.Detected)
-					assemblyResolver.find();
+					assemblyResolver.Find();
 				if (!tamperDetection.Detected)
-					tamperDetection.find();
+					tamperDetection.Find();
 			}
 			antiDebugger = new AntiDebugger(module, DeobfuscatedFile, this);
-			antiDebugger.find();
+			antiDebugger.Find();
 
 			if (options.DecryptConstants) {
-				constantsDecrypter.init(resourceDecrypter);
+				constantsDecrypter.Initialize(resourceDecrypter);
 				int32ValueInliner = new Int32ValueInliner();
-				int32ValueInliner.add(constantsDecrypter.Int32Decrypter, (method, gim, args) => constantsDecrypter.decryptInt32((int)args[0]));
+				int32ValueInliner.Add(constantsDecrypter.Int32Decrypter, (method, gim, args) => constantsDecrypter.DecryptInt32((int)args[0]));
 				int64ValueInliner = new Int64ValueInliner();
-				int64ValueInliner.add(constantsDecrypter.Int64Decrypter, (method, gim, args) => constantsDecrypter.decryptInt64((int)args[0]));
+				int64ValueInliner.Add(constantsDecrypter.Int64Decrypter, (method, gim, args) => constantsDecrypter.DecryptInt64((int)args[0]));
 				singleValueInliner = new SingleValueInliner();
-				singleValueInliner.add(constantsDecrypter.SingleDecrypter, (method, gim, args) => constantsDecrypter.decryptSingle((int)args[0]));
+				singleValueInliner.Add(constantsDecrypter.SingleDecrypter, (method, gim, args) => constantsDecrypter.DecryptSingle((int)args[0]));
 				doubleValueInliner = new DoubleValueInliner();
-				doubleValueInliner.add(constantsDecrypter.DoubleDecrypter, (method, gim, args) => constantsDecrypter.decryptDouble((int)args[0]));
-				addTypeToBeRemoved(constantsDecrypter.Type, "Constants decrypter type");
-				addResourceToBeRemoved(constantsDecrypter.Resource, "Encrypted constants");
+				doubleValueInliner.Add(constantsDecrypter.DoubleDecrypter, (method, gim, args) => constantsDecrypter.DecryptDouble((int)args[0]));
+				AddTypeToBeRemoved(constantsDecrypter.Type, "Constants decrypter type");
+				AddResourceToBeRemoved(constantsDecrypter.Resource, "Encrypted constants");
 			}
 
-			addModuleCctorInitCallToBeRemoved(resourceResolver.Method);
-			addModuleCctorInitCallToBeRemoved(assemblyResolver.Method);
-			addCallToBeRemoved(module.EntryPoint, tamperDetection.Method);
-			addModuleCctorInitCallToBeRemoved(tamperDetection.Method);
-			addCallToBeRemoved(module.EntryPoint, antiDebugger.Method);
-			addModuleCctorInitCallToBeRemoved(antiDebugger.Method);
-			addTypeToBeRemoved(resourceResolver.Type, "Resource resolver type");
-			addTypeToBeRemoved(assemblyResolver.Type, "Assembly resolver type");
-			addTypeToBeRemoved(tamperDetection.Type, "Tamper detection type");
-			addTypeToBeRemoved(antiDebugger.Type, "Anti-debugger type");
-			addTypeToBeRemoved(methodsDecrypter.Type, "Methods decrypter type");
-			addTypesToBeRemoved(methodsDecrypter.DelegateTypes, "Methods decrypter delegate type");
-			addResourceToBeRemoved(methodsDecrypter.Resource, "Encrypted methods");
+			AddModuleCctorInitCallToBeRemoved(resourceResolver.Method);
+			AddModuleCctorInitCallToBeRemoved(assemblyResolver.Method);
+			AddCallToBeRemoved(module.EntryPoint, tamperDetection.Method);
+			AddModuleCctorInitCallToBeRemoved(tamperDetection.Method);
+			AddCallToBeRemoved(module.EntryPoint, antiDebugger.Method);
+			AddModuleCctorInitCallToBeRemoved(antiDebugger.Method);
+			AddTypeToBeRemoved(resourceResolver.Type, "Resource resolver type");
+			AddTypeToBeRemoved(assemblyResolver.Type, "Assembly resolver type");
+			AddTypeToBeRemoved(tamperDetection.Type, "Tamper detection type");
+			AddTypeToBeRemoved(antiDebugger.Type, "Anti-debugger type");
+			AddTypeToBeRemoved(methodsDecrypter.Type, "Methods decrypter type");
+			AddTypesToBeRemoved(methodsDecrypter.DelegateTypes, "Methods decrypter delegate type");
+			AddResourceToBeRemoved(methodsDecrypter.Resource, "Encrypted methods");
 
-			proxyCallFixer.find();
+			proxyCallFixer.Find();
 
-			dumpEmbeddedAssemblies();
+			DumpEmbeddedAssemblies();
 		}
 
-		public override void deobfuscateMethodEnd(Blocks blocks) {
-			proxyCallFixer.deobfuscate(blocks);
+		public override void DeobfuscateMethodEnd(Blocks blocks) {
+			proxyCallFixer.Deobfuscate(blocks);
 			if (options.DecryptConstants) {
-				int32ValueInliner.decrypt(blocks);
-				int64ValueInliner.decrypt(blocks);
-				singleValueInliner.decrypt(blocks);
-				doubleValueInliner.decrypt(blocks);
+				int32ValueInliner.Decrypt(blocks);
+				int64ValueInliner.Decrypt(blocks);
+				singleValueInliner.Decrypt(blocks);
+				doubleValueInliner.Decrypt(blocks);
 			}
-			base.deobfuscateMethodEnd(blocks);
+			base.DeobfuscateMethodEnd(blocks);
 		}
 
-		public override void deobfuscateEnd() {
-			removeProxyDelegates(proxyCallFixer);
+		public override void DeobfuscateEnd() {
+			RemoveProxyDelegates(proxyCallFixer);
 			if (CanRemoveStringDecrypterType) {
-				addResourceToBeRemoved(stringDecrypter.Resource, "Encrypted strings");
-				addTypeToBeRemoved(stringDecrypter.Type, "String decrypter type");
+				AddResourceToBeRemoved(stringDecrypter.Resource, "Encrypted strings");
+				AddTypeToBeRemoved(stringDecrypter.Type, "String decrypter type");
 			}
-			base.deobfuscateEnd();
+			base.DeobfuscateEnd();
 		}
 
-		void decryptResources() {
-			var rsrc = resourceResolver.mergeResources();
+		void DecryptResources() {
+			var rsrc = resourceResolver.MergeResources();
 			if (rsrc == null)
 				return;
-			addResourceToBeRemoved(rsrc, "Encrypted resources");
+			AddResourceToBeRemoved(rsrc, "Encrypted resources");
 		}
 
-		void dumpEmbeddedAssemblies() {
+		void DumpEmbeddedAssemblies() {
 			foreach (var info in assemblyResolver.AssemblyInfos) {
-				dumpEmbeddedFile(info.resource, info.assemblyName, ".dll", string.Format("Embedded assembly: {0}", info.assemblyName));
+				DumpEmbeddedFile(info.resource, info.assemblyName, ".dll", string.Format("Embedded assembly: {0}", info.assemblyName));
 
 				if (info.symbolsResource != null)
-					dumpEmbeddedFile(info.symbolsResource, info.assemblyName, ".pdb", string.Format("Embedded pdb: {0}", info.assemblyName));
+					DumpEmbeddedFile(info.symbolsResource, info.assemblyName, ".pdb", string.Format("Embedded pdb: {0}", info.assemblyName));
 			}
 		}
 
-		void dumpEmbeddedFile(EmbeddedResource resource, string assemblyName, string extension, string reason) {
-			DeobfuscatedFile.createAssemblyFile(resourceDecrypter.decrypt(resource.GetResourceStream()), Utils.getAssemblySimpleName(assemblyName), extension);
-			addResourceToBeRemoved(resource, reason);
+		void DumpEmbeddedFile(EmbeddedResource resource, string assemblyName, string extension, string reason) {
+			DeobfuscatedFile.CreateAssemblyFile(resourceDecrypter.Decrypt(resource.GetResourceStream()), Utils.GetAssemblySimpleName(assemblyName), extension);
+			AddResourceToBeRemoved(resource, reason);
 		}
 
-		public override IEnumerable<int> getStringDecrypterMethods() {
+		public override IEnumerable<int> GetStringDecrypterMethods() {
 			var list = new List<int>();
 			if (stringDecrypter.Method != null)
 				list.Add(stringDecrypter.Method.MDToken.ToInt32());
diff --git a/de4dot.code/deobfuscators/CryptoObfuscator/MethodBodyReader.cs b/de4dot.code/deobfuscators/CryptoObfuscator/MethodBodyReader.cs
index e928dd2f..72c4e377 100644
--- a/de4dot.code/deobfuscators/CryptoObfuscator/MethodBodyReader.cs
+++ b/de4dot.code/deobfuscators/CryptoObfuscator/MethodBodyReader.cs
@@ -34,24 +34,24 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			this.module = module;
 		}
 
-		public void read(MethodDef method) {
+		public void Read(MethodDef method) {
 			this.parameters = method.Parameters;
-			SetLocals(getLocals(method));
+			SetLocals(GetLocals(method));
 
 			maxStackSize = (ushort)reader.ReadInt32();
 			ReadInstructionsNumBytes(reader.ReadUInt32());
-			readExceptionHandlers();
+			ReadExceptionHandlers();
 		}
 
-		void readExceptionHandlers() {
+		void ReadExceptionHandlers() {
 			int totalSize = reader.ReadInt32();
 			if (totalSize == 0)
 				return;
 			reader.ReadInt32();
-			readExceptionHandlers((totalSize - 4) / 24);
+			ReadExceptionHandlers((totalSize - 4) / 24);
 		}
 
-		static IList<Local> getLocals(MethodDef method) {
+		static IList<Local> GetLocals(MethodDef method) {
 			if (method.Body == null)
 				return new List<Local>();
 			return method.Body.Variables;
@@ -82,13 +82,13 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return module.ResolveToken(reader.ReadUInt32()) as ITypeDefOrRef;
 		}
 
-		void readExceptionHandlers(int numExceptionHandlers) {
+		void ReadExceptionHandlers(int numExceptionHandlers) {
 			exceptionHandlers = new ExceptionHandler[numExceptionHandlers];
 			for (int i = 0; i < exceptionHandlers.Count; i++)
-				exceptionHandlers[i] = readExceptionHandler();
+				exceptionHandlers[i] = ReadExceptionHandler();
 		}
 
-		ExceptionHandler readExceptionHandler() {
+		ExceptionHandler ReadExceptionHandler() {
 			var eh = new ExceptionHandler((ExceptionHandlerType)reader.ReadUInt32());
 
 			uint tryOffset = reader.ReadUInt32();
diff --git a/de4dot.code/deobfuscators/CryptoObfuscator/MethodsDecrypter.cs b/de4dot.code/deobfuscators/CryptoObfuscator/MethodsDecrypter.cs
index b5b095c6..ceb3c994 100644
--- a/de4dot.code/deobfuscators/CryptoObfuscator/MethodsDecrypter.cs
+++ b/de4dot.code/deobfuscators/CryptoObfuscator/MethodsDecrypter.cs
@@ -53,9 +53,9 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			this.module = module;
 		}
 
-		public void find() {
+		public void Find() {
 			foreach (var type in module.Types) {
-				if (check(type))
+				if (Check(type))
 					break;
 			}
 		}
@@ -65,18 +65,18 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			"System.Collections.Generic.Dictionary`2<System.Int32,System.Int32>",
 			"System.ModuleHandle",
 		};
-		bool check(TypeDef type) {
+		bool Check(TypeDef type) {
 			if (type.NestedTypes.Count != 1)
 				return false;
 			if (type.Fields.Count != 3)
 				return false;
-			if (!new FieldTypes(type).all(requiredFields))
+			if (!new FieldTypes(type).All(requiredFields))
 				return false;
 
 			var cctor = type.FindStaticConstructor();
 			if (cctor == null)
 				return false;
-			var decryptMethodTmp = findDecryptMethod(type);
+			var decryptMethodTmp = FindDecryptMethod(type);
 			if (decryptMethodTmp == null)
 				return false;
 
@@ -98,13 +98,13 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			"System.Type",
 			"System.Type[]",
 		};
-		static MethodDef findDecryptMethod(TypeDef type) {
+		static MethodDef FindDecryptMethod(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
-				if (!new LocalTypes(method).all(requiredLocals))
+				if (!new LocalTypes(method).All(requiredLocals))
 					continue;
-				if (!DotNetUtils.isMethod(method, "System.Void", "(System.Int32,System.Int32,System.Int32)"))
+				if (!DotNetUtils.IsMethod(method, "System.Void", "(System.Int32,System.Int32,System.Int32)"))
 					continue;
 
 				return method;
@@ -112,36 +112,36 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return null;
 		}
 
-		public void decrypt(ResourceDecrypter resourceDecrypter) {
+		public void Decrypt(ResourceDecrypter resourceDecrypter) {
 			if (decryptMethod == null)
 				return;
 
-			resource = CoUtils.getResource(module, decrypterCctor);
+			resource = CoUtils.GetResource(module, decrypterCctor);
 			if (resource == null)
 				return;
-			var decrypted = resourceDecrypter.decrypt(resource.GetResourceStream());
+			var decrypted = resourceDecrypter.Decrypt(resource.GetResourceStream());
 			var reader = MemoryImageStream.Create(decrypted);
 			int numEncrypted = reader.ReadInt32();
 			Logger.v("Restoring {0} encrypted methods", numEncrypted);
-			Logger.Instance.indent();
+			Logger.Instance.Indent();
 			for (int i = 0; i < numEncrypted; i++) {
 				int delegateTypeToken = reader.ReadInt32();
 				uint codeOffset = reader.ReadUInt32();
 				var origOffset = reader.Position;
 				reader.Position = codeOffset;
-				decrypt(reader, delegateTypeToken);
+				Decrypt(reader, delegateTypeToken);
 				reader.Position = origOffset;
 			}
-			Logger.Instance.deIndent();
+			Logger.Instance.DeIndent();
 		}
 
-		void decrypt(IBinaryReader reader, int delegateTypeToken) {
+		void Decrypt(IBinaryReader reader, int delegateTypeToken) {
 			var delegateType = module.ResolveToken(delegateTypeToken) as TypeDef;
 			if (delegateType == null)
 				throw new ApplicationException("Couldn't find delegate type");
 
 			int delToken, encMethToken, encDeclToken;
-			if (!getTokens(delegateType, out delToken, out encMethToken, out encDeclToken))
+			if (!GetTokens(delegateType, out delToken, out encMethToken, out encDeclToken))
 				throw new ApplicationException("Could not find encrypted method tokens");
 			if (delToken != delegateTypeToken)
 				throw new ApplicationException("Invalid delegate type token");
@@ -153,10 +153,10 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 				throw new ApplicationException("Invalid encrypted method token");
 
 			var bodyReader = new MethodBodyReader(module, reader);
-			bodyReader.read(encMethod);
+			bodyReader.Read(encMethod);
 			bodyReader.RestoreMethod(encMethod);
 			Logger.v("Restored method {0} ({1:X8}). Instrs:{2}, Locals:{3}, Exceptions:{4}",
-					Utils.removeNewlines(encMethod.FullName),
+					Utils.RemoveNewlines(encMethod.FullName),
 					encMethod.MDToken.ToInt32(),
 					encMethod.Body.Instructions.Count,
 					encMethod.Body.Variables.Count,
@@ -164,7 +164,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			delegateTypes.Add(delegateType);
 		}
 
-		bool getTokens(TypeDef 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;
diff --git a/de4dot.code/deobfuscators/CryptoObfuscator/ProxyCallFixer.cs b/de4dot.code/deobfuscators/CryptoObfuscator/ProxyCallFixer.cs
index f95e394a..26bd02a8 100644
--- a/de4dot.code/deobfuscators/CryptoObfuscator/ProxyCallFixer.cs
+++ b/de4dot.code/deobfuscators/CryptoObfuscator/ProxyCallFixer.cs
@@ -51,10 +51,10 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			}
 		}
 
-		protected override object checkCctor(TypeDef type, MethodDef 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);
+				var instrs = DotNetUtils.GetInstructions(instructions, i, OpCodes.Ldc_I4, OpCodes.Ldc_I4, OpCodes.Ldc_I4, OpCodes.Call);
 				if (instrs == null)
 					continue;
 
@@ -73,7 +73,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return null;
 		}
 
-		protected override void getCallInfo(object context, FieldDef field, out IMethod 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) {
@@ -93,22 +93,22 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			calledMethod = module.ResolveToken(ctx.methodToken) as IMethod;
 		}
 
-		public void findDelegateCreator() {
+		public void FindDelegateCreator() {
 			foreach (var type in module.Types) {
-				var createMethod = getProxyCreateMethod(type);
+				var createMethod = GetProxyCreateMethod(type);
 				if (createMethod == null)
 					continue;
 
-				var proxyCreatorType = getProxyCreatorType(type, createMethod);
+				var proxyCreatorType = GetProxyCreatorType(type, createMethod);
 				if (proxyCreatorType == ProxyCreatorType.None)
 					continue;
 				methodToType[createMethod] = proxyCreatorType;
-				setDelegateCreatorMethod(createMethod);
+				SetDelegateCreatorMethod(createMethod);
 			}
 		}
 
-		MethodDef getProxyCreateMethod(TypeDef type) {
-			if (DotNetUtils.findFieldType(type, "System.ModuleHandle", true) == null)
+		MethodDef GetProxyCreateMethod(TypeDef type) {
+			if (DotNetUtils.FindFieldType(type, "System.ModuleHandle", true) == null)
 				return null;
 			if (type.Fields.Count < 1 || type.Fields.Count > 16)
 				return null;
@@ -117,7 +117,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			foreach (var m in type.Methods) {
 				if (m.Name == ".ctor" || m.Name == ".cctor")
 					continue;
-				if (createMethod == null && DotNetUtils.isMethod(m, "System.Void", "(System.Int32,System.Int32,System.Int32)")) {
+				if (createMethod == null && DotNetUtils.IsMethod(m, "System.Void", "(System.Int32,System.Int32,System.Int32)")) {
 					createMethod = m;
 					continue;
 				}
@@ -125,13 +125,13 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			}
 			if (createMethod == null || !createMethod.HasBody)
 				return null;
-			if (!DeobUtils.hasInteger(createMethod, 0xFFFFFF))
+			if (!DeobUtils.HasInteger(createMethod, 0xFFFFFF))
 				return null;
 
 			return createMethod;
 		}
 
-		ProxyCreatorType getProxyCreatorType(TypeDef type, MethodDef 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)
diff --git a/de4dot.code/deobfuscators/CryptoObfuscator/ResourceDecrypter.cs b/de4dot.code/deobfuscators/CryptoObfuscator/ResourceDecrypter.cs
index 9200ad89..6028166e 100644
--- a/de4dot.code/deobfuscators/CryptoObfuscator/ResourceDecrypter.cs
+++ b/de4dot.code/deobfuscators/CryptoObfuscator/ResourceDecrypter.cs
@@ -42,33 +42,33 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 
 		public ResourceDecrypter(ModuleDefMD module, ISimpleDeobfuscator simpleDeobfuscator) {
 			this.module = module;
-			frameworkType = DotNetUtils.getFrameworkType(module);
-			find(simpleDeobfuscator);
+			frameworkType = DotNetUtils.GetFrameworkType(module);
+			Find(simpleDeobfuscator);
 		}
 
-		void find(ISimpleDeobfuscator simpleDeobfuscator) {
+		void Find(ISimpleDeobfuscator simpleDeobfuscator) {
 			switch (frameworkType) {
 			case FrameworkType.Desktop:
 				if (!module.IsClr1x)
-					findDesktopOrCompactFramework();
+					FindDesktopOrCompactFramework();
 				else
-					findDesktopOrCompactFrameworkV1();
+					FindDesktopOrCompactFrameworkV1();
 				break;
 
 			case FrameworkType.Silverlight:
-				findSilverlight();
+				FindSilverlight();
 				break;
 
 			case FrameworkType.CompactFramework:
 				if (!module.IsClr1x) {
-					if (findDesktopOrCompactFramework())
+					if (FindDesktopOrCompactFramework())
 						break;
 				}
-				findDesktopOrCompactFrameworkV1();
+				FindDesktopOrCompactFrameworkV1();
 				break;
 			}
 
-			initializeHeaderInfo(simpleDeobfuscator);
+			InitializeHeaderInfo(simpleDeobfuscator);
 		}
 
 		static string[] requiredTypes = new string[] {
@@ -76,19 +76,19 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			"System.Object",
 			"System.Int32",
 		};
-		bool findDesktopOrCompactFramework() {
+		bool FindDesktopOrCompactFramework() {
 			resourceDecrypterType = null;
 			foreach (var type in module.Types) {
 				if (type.Fields.Count < 5)
 					continue;
-				if (!new FieldTypes(type).all(requiredTypes))
+				if (!new FieldTypes(type).All(requiredTypes))
 					continue;
 
 				var cctor = type.FindStaticConstructor();
 				if (cctor == null)
 					continue;
 
-				if (!checkCctor(cctor))
+				if (!CheckCctor(cctor))
 					continue;
 
 				resourceDecrypterType = type;
@@ -97,7 +97,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return false;
 		}
 
-		bool checkCctor(MethodDef cctor) {
+		bool CheckCctor(MethodDef cctor) {
 			if (cctor.Body == null)
 				return false;
 			int stsfldCount = 0;
@@ -119,26 +119,26 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			"System.Int32",
 			"System.Security.Cryptography.DESCryptoServiceProvider",
 		};
-		bool findDesktopOrCompactFrameworkV1() {
+		bool FindDesktopOrCompactFrameworkV1() {
 			resourceDecrypterType = null;
 			foreach (var type in module.Types) {
 				if (type.Fields.Count != 0)
 					continue;
 
-				foreach (var method in getDecrypterMethods(type)) {
+				foreach (var method in GetDecrypterMethods(type)) {
 					if (method == null)
 						continue;
-					if (!new LocalTypes(method).exactly(requiredLocals_v1))
+					if (!new LocalTypes(method).Exactly(requiredLocals_v1))
 						continue;
-					if (!DotNetUtils.callsMethod(method, "System.Int64", "()"))
+					if (!DotNetUtils.CallsMethod(method, "System.Int64", "()"))
 						continue;
-					if (!DotNetUtils.callsMethod(method, "System.Int32", "(System.Byte[],System.Int32,System.Int32)"))
+					if (!DotNetUtils.CallsMethod(method, "System.Int32", "(System.Byte[],System.Int32,System.Int32)"))
 						continue;
-					if (!DotNetUtils.callsMethod(method, "System.Void", "(System.Array,System.Int32,System.Array,System.Int32,System.Int32)"))
+					if (!DotNetUtils.CallsMethod(method, "System.Void", "(System.Array,System.Int32,System.Array,System.Int32,System.Int32)"))
 						continue;
-					if (!DotNetUtils.callsMethod(method, "System.Security.Cryptography.ICryptoTransform", "()"))
+					if (!DotNetUtils.CallsMethod(method, "System.Security.Cryptography.ICryptoTransform", "()"))
 						continue;
-					if (!DotNetUtils.callsMethod(method, "System.Byte[]", "(System.Byte[],System.Int32,System.Int32)"))
+					if (!DotNetUtils.CallsMethod(method, "System.Byte[]", "(System.Byte[],System.Int32,System.Int32)"))
 						continue;
 
 					resourceDecrypterType = type;
@@ -153,17 +153,17 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			"System.Byte[]",
 			"System.Int32",
 		};
-		void findSilverlight() {
+		void FindSilverlight() {
 			foreach (var type in module.Types) {
 				if (type.Fields.Count > 0)
 					continue;
 				if (type.HasNestedTypes || type.HasGenericParameters)
 					continue;
 
-				foreach (var method in getDecrypterMethods(type)) {
+				foreach (var method in GetDecrypterMethods(type)) {
 					if (method == null)
 						continue;
-					if (!new LocalTypes(method).exactly(requiredLocals_sl))
+					if (!new LocalTypes(method).Exactly(requiredLocals_sl))
 						continue;
 
 					resourceDecrypterType = type;
@@ -172,11 +172,11 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			}
 		}
 
-		void initializeHeaderInfo(ISimpleDeobfuscator simpleDeobfuscator) {
+		void InitializeHeaderInfo(ISimpleDeobfuscator simpleDeobfuscator) {
 			skipBytes = 0;
 
-			foreach (var method in getDecrypterMethods(resourceDecrypterType)) {
-				if (updateFlags(method, simpleDeobfuscator))
+			foreach (var method in GetDecrypterMethods(resourceDecrypterType)) {
+				if (UpdateFlags(method, simpleDeobfuscator))
 					return;
 			}
 
@@ -205,12 +205,12 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return false;
 		}
 
-		bool updateFlags(MethodDef method, ISimpleDeobfuscator simpleDeobfuscator) {
+		bool UpdateFlags(MethodDef method, ISimpleDeobfuscator simpleDeobfuscator) {
 			if (method == null || method.Body == null || method.Body.Variables.Count < 3)
 				return false;
 
 			var constants = new List<int>();
-			simpleDeobfuscator.deobfuscate(method);
+			simpleDeobfuscator.Deobfuscate(method);
 			var instructions = method.Body.Instructions;
 			for (int i = 2; i < instructions.Count; i++) {
 				var and = instructions[i];
@@ -220,7 +220,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 				if (!ldci4.IsLdcI4())
 					continue;
 				int flagValue = ldci4.GetLdcI4Value();
-				if (!isFlag(flagValue))
+				if (!IsFlag(flagValue))
 					continue;
 				var ldloc = instructions[i - 2];
 				if (!ldloc.IsLdloc())
@@ -232,7 +232,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			}
 
 			flipFlagsBits = checkFlipBits(method);
-			skipBytes = getHeaderSkipBytes(method);
+			skipBytes = GetHeaderSkipBytes(method);
 
 			switch (frameworkType) {
 			case FrameworkType.Desktop:
@@ -269,7 +269,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return false;
 		}
 
-		static int getHeaderSkipBytes(MethodDef method) {
+		static int GetHeaderSkipBytes(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 1; i++) {
 				var ldci4 = instrs[i];
@@ -286,7 +286,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return 0;
 		}
 
-		static bool isFlag(int value) {
+		static bool IsFlag(int value) {
 			for (uint tmp = (uint)value; tmp != 0; tmp >>= 1) {
 				if ((tmp & 1) != 0)
 					return tmp == 1;
@@ -294,32 +294,32 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return false;
 		}
 
-		static IEnumerable<MethodDef> getDecrypterMethods(TypeDef type) {
+		static IEnumerable<MethodDef> GetDecrypterMethods(TypeDef type) {
 			if (type == null)
 				yield break;
 			foreach (var method in type.Methods) {
-				if (DotNetUtils.isMethod(method, "System.Byte[]", "(System.IO.Stream)"))
+				if (DotNetUtils.IsMethod(method, "System.Byte[]", "(System.IO.Stream)"))
 					yield return method;
-				else if (DotNetUtils.isMethod(method, "System.Byte[]", "(System.Int64,System.IO.Stream)"))
+				else if (DotNetUtils.IsMethod(method, "System.Byte[]", "(System.Int64,System.IO.Stream)"))
 					yield return method;
-				else if (DotNetUtils.isMethod(method, "System.Byte[]", "(System.Int32,System.IO.Stream)"))
+				else if (DotNetUtils.IsMethod(method, "System.Byte[]", "(System.Int32,System.IO.Stream)"))
 					yield return method;
-				else if (DotNetUtils.isMethod(method, "System.Byte[]", "(System.Int16,System.IO.Stream)"))
+				else if (DotNetUtils.IsMethod(method, "System.Byte[]", "(System.Int16,System.IO.Stream)"))
 					yield return method;
-				else if (DotNetUtils.isMethod(method, "System.Byte[]", "(System.Byte,System.IO.Stream)"))
+				else if (DotNetUtils.IsMethod(method, "System.Byte[]", "(System.Byte,System.IO.Stream)"))
 					yield return method;
-				else if (DotNetUtils.isMethod(method, "System.Byte[]", "(System.SByte,System.IO.Stream)"))
+				else if (DotNetUtils.IsMethod(method, "System.Byte[]", "(System.SByte,System.IO.Stream)"))
 					yield return method;
-				else if (DotNetUtils.isMethod(method, "System.Byte[]", "(System.Byte,System.IO.Stream,System.Int32)"))
+				else if (DotNetUtils.IsMethod(method, "System.Byte[]", "(System.Byte,System.IO.Stream,System.Int32)"))
 					yield return method;
-				else if (DotNetUtils.isMethod(method, "System.Byte[]", "(System.SByte,System.IO.Stream,System.UInt32)"))
+				else if (DotNetUtils.IsMethod(method, "System.Byte[]", "(System.SByte,System.IO.Stream,System.UInt32)"))
 					yield return method;
-				else if (DotNetUtils.isMethod(method, "System.Byte[]", "(System.Char,System.IO.Stream)"))
+				else if (DotNetUtils.IsMethod(method, "System.Byte[]", "(System.Char,System.IO.Stream)"))
 					yield return method;
 			}
 		}
 
-		public byte[] decrypt(Stream resourceStream) {
+		public byte[] Decrypt(Stream resourceStream) {
 			byte flags = (byte)resourceStream.ReadByte();
 			if (flipFlagsBits)
 				flags = (byte)~flags;
@@ -340,7 +340,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 					var iv = new byte[8];
 					sourceStream.Read(iv, 0, 8);
 					provider.IV = iv;
-					provider.Key = getKey(sourceStream);
+					provider.Key = GetKey(sourceStream);
 
 					using (var transform = provider.CreateDecryptor()) {
 						while (true) {
@@ -399,7 +399,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			}
 		}
 
-		byte[] getKey(Stream resourceStream) {
+		byte[] GetKey(Stream resourceStream) {
 			byte[] key = new byte[8];
 			resourceStream.Read(key, 0, key.Length);
 			for (int i = 0; i < key.Length; i++) {
diff --git a/de4dot.code/deobfuscators/CryptoObfuscator/ResourceResolver.cs b/de4dot.code/deobfuscators/CryptoObfuscator/ResourceResolver.cs
index dd9d5d49..67c3eaa7 100644
--- a/de4dot.code/deobfuscators/CryptoObfuscator/ResourceResolver.cs
+++ b/de4dot.code/deobfuscators/CryptoObfuscator/ResourceResolver.cs
@@ -52,36 +52,36 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			this.resourceDecrypter = resourceDecrypter;
 		}
 
-		public void find() {
-			var cctor = DotNetUtils.getModuleTypeCctor(module);
+		public void Find() {
+			var cctor = DotNetUtils.GetModuleTypeCctor(module);
 			if (cctor == null)
 				return;
 
-			foreach (var method in DotNetUtils.getCalledMethods(module, cctor)) {
+			foreach (var method in DotNetUtils.GetCalledMethods(module, cctor)) {
 				if (method.Name == ".cctor" || method.Name == ".ctor")
 					continue;
-				if (!method.IsStatic || !DotNetUtils.isMethod(method, "System.Void", "()"))
+				if (!method.IsStatic || !DotNetUtils.IsMethod(method, "System.Void", "()"))
 					continue;
-				if (checkType(method))
+				if (CheckType(method))
 					break;
 			}
 		}
 
-		public EmbeddedResource mergeResources() {
+		public EmbeddedResource MergeResources() {
 			if (mergedIt)
 				return null;
 
-			var resource = DotNetUtils.getResource(module, getResourceNames()) as EmbeddedResource;
+			var resource = DotNetUtils.GetResource(module, GetResourceNames()) as EmbeddedResource;
 			if (resource == null)
 				return null;
 
 			resource.Data.Position = 0;
-			DeobUtils.decryptAndAddResources(module, resource.Name.String, () => resourceDecrypter.decrypt(resource.Data.CreateStream()));
+			DeobUtils.DecryptAndAddResources(module, resource.Name.String, () => resourceDecrypter.Decrypt(resource.Data.CreateStream()));
 			mergedIt = true;
 			return resource;
 		}
 
-		IEnumerable<string> getResourceNames() {
+		IEnumerable<string> GetResourceNames() {
 			var names = new List<string>();
 
 			switch (resolverVersion) {
@@ -101,15 +101,15 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return names;
 		}
 
-		bool checkType(MethodDef initMethod) {
+		bool CheckType(MethodDef initMethod) {
 			if (!initMethod.HasBody)
 				return false;
-			if (DotNetUtils.findFieldType(initMethod.DeclaringType, "System.Reflection.Assembly", true) == null)
+			if (DotNetUtils.FindFieldType(initMethod.DeclaringType, "System.Reflection.Assembly", true) == null)
 				return false;
 
-			resolverVersion = checkSetupMethod(initMethod);
+			resolverVersion = CheckSetupMethod(initMethod);
 			if (resolverVersion == ResolverVersion.None)
-				resolverVersion = checkSetupMethod(initMethod.DeclaringType.FindStaticConstructor());
+				resolverVersion = CheckSetupMethod(initMethod.DeclaringType.FindStaticConstructor());
 			if (resolverVersion == ResolverVersion.None)
 				return false;
 
@@ -118,11 +118,11 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return true;
 		}
 
-		ResolverVersion checkSetupMethod(MethodDef setupMethod) {
+		ResolverVersion CheckSetupMethod(MethodDef setupMethod) {
 			var instructions = setupMethod.Body.Instructions;
 			int foundCount = 0;
 			for (int i = 0; i < instructions.Count; i++) {
-				var instrs = DotNetUtils.getInstructions(instructions, i, OpCodes.Ldnull, OpCodes.Ldftn, OpCodes.Newobj);
+				var instrs = DotNetUtils.GetInstructions(instructions, i, OpCodes.Ldnull, OpCodes.Ldftn, OpCodes.Newobj);
 				if (instrs == null)
 					continue;
 
diff --git a/de4dot.code/deobfuscators/CryptoObfuscator/StringDecrypter.cs b/de4dot.code/deobfuscators/CryptoObfuscator/StringDecrypter.cs
index afe02be1..994fc845 100644
--- a/de4dot.code/deobfuscators/CryptoObfuscator/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/CryptoObfuscator/StringDecrypter.cs
@@ -50,38 +50,38 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			this.module = module;
 		}
 
-		public void find() {
+		public void Find() {
 			TypeDef type;
 			MethodDef method;
-			if (!findStringDecrypterType(out type, out method))
+			if (!FindStringDecrypterType(out type, out method))
 				return;
 
 			stringDecrypterType = type;
 			stringDecrypterMethod = method;
 		}
 
-		public void init(ResourceDecrypter resourceDecrypter) {
+		public void Initialize(ResourceDecrypter resourceDecrypter) {
 			if (decryptedData != null || stringDecrypterType == null)
 				return;
 
-			var resourceName = getResourceName();
-			stringResource = DotNetUtils.getResource(module, resourceName) as EmbeddedResource;
+			var resourceName = GetResourceName();
+			stringResource = DotNetUtils.GetResource(module, resourceName) as EmbeddedResource;
 			if (stringResource == null)
 				return;
-			Logger.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());
+			decryptedData = resourceDecrypter.Decrypt(stringResource.GetResourceStream());
 		}
 
-		string getResourceName() {
+		string GetResourceName() {
 			var defaultName = module.Assembly.Name.String + module.Assembly.Name.String;
 
 			var cctor = stringDecrypterType.FindStaticConstructor();
 			if (cctor == null)
 				return defaultName;
 
-			foreach (var s in DotNetUtils.getCodeStrings(cctor)) {
-				if (DotNetUtils.getResource(module, s) != null)
+			foreach (var s in DotNetUtils.GetCodeStrings(cctor)) {
+				if (DotNetUtils.GetResource(module, s) != null)
 					return s;
 				try {
 					return Encoding.UTF8.GetString(Convert.FromBase64String(s));
@@ -93,12 +93,12 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return defaultName;
 		}
 
-		public string decrypt(int index) {
-			int len = DeobUtils.readVariableLengthInt32(decryptedData, ref index);
+		public string Decrypt(int index) {
+			int len = DeobUtils.ReadVariableLengthInt32(decryptedData, ref index);
 			return Encoding.Unicode.GetString(decryptedData, index, len);
 		}
 
-		bool findStringDecrypterType(out TypeDef theType, out MethodDef theMethod) {
+		bool FindStringDecrypterType(out TypeDef theType, out MethodDef theMethod) {
 			theType = null;
 			theMethod = null;
 
@@ -107,7 +107,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 					continue;
 				if (type.Fields.Count != 1)
 					continue;
-				if (DotNetUtils.findFieldType(type, "System.Byte[]", true) == null)
+				if (DotNetUtils.FindFieldType(type, "System.Byte[]", true) == null)
 					continue;
 				if (type.Methods.Count != 2 && type.Methods.Count != 3)
 					continue;
@@ -118,7 +118,7 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 				foreach (var m in type.Methods) {
 					if (m.Name == ".ctor" || m.Name == ".cctor")
 						continue;
-					if (DotNetUtils.isMethod(m, "System.String", "(System.Int32)")) {
+					if (DotNetUtils.IsMethod(m, "System.String", "(System.Int32)")) {
 						method = m;
 						continue;
 					}
diff --git a/de4dot.code/deobfuscators/CryptoObfuscator/TamperDetection.cs b/de4dot.code/deobfuscators/CryptoObfuscator/TamperDetection.cs
index fc76ad37..79a5a6ff 100644
--- a/de4dot.code/deobfuscators/CryptoObfuscator/TamperDetection.cs
+++ b/de4dot.code/deobfuscators/CryptoObfuscator/TamperDetection.cs
@@ -41,31 +41,31 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 
 		public TamperDetection(ModuleDefMD module) {
 			this.module = module;
-			frameworkType = DotNetUtils.getFrameworkType(module);
+			frameworkType = DotNetUtils.GetFrameworkType(module);
 		}
 
-		public void find() {
-			if (find(module.EntryPoint))
+		public void Find() {
+			if (Find(module.EntryPoint))
 				return;
-			if (find(DotNetUtils.getModuleTypeCctor(module)))
+			if (Find(DotNetUtils.GetModuleTypeCctor(module)))
 				return;
 		}
 
-		bool find(MethodDef methodToCheck) {
+		bool Find(MethodDef methodToCheck) {
 			if (methodToCheck == null)
 				return false;
 
-			foreach (var method in DotNetUtils.getCalledMethods(module, methodToCheck)) {
+			foreach (var method in DotNetUtils.GetCalledMethods(module, methodToCheck)) {
 				bool result = false;
 				switch (frameworkType) {
 				case FrameworkType.Desktop:
-					result = findDesktop(method);
+					result = FindDesktop(method);
 					break;
 				case FrameworkType.Silverlight:
-					result = findSilverlight(method);
+					result = FindSilverlight(method);
 					break;
 				case FrameworkType.CompactFramework:
-					result = findCompactFramework(method);
+					result = FindCompactFramework(method);
 					break;
 				}
 				if (!result)
@@ -79,16 +79,16 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			return false;
 		}
 
-		bool findDesktop(MethodDef method) {
+		bool FindDesktop(MethodDef method) {
 			var type = method.DeclaringType;
 
-			if (!method.IsStatic || !DotNetUtils.isMethod(method, "System.Void", "()"))
+			if (!method.IsStatic || !DotNetUtils.IsMethod(method, "System.Void", "()"))
 				return false;
 			if (type.Methods.Count < 3 || type.Methods.Count > 24)
 				return false;
-			if (DotNetUtils.getPInvokeMethod(type, "mscoree", "StrongNameSignatureVerificationEx") != null) {
+			if (DotNetUtils.GetPInvokeMethod(type, "mscoree", "StrongNameSignatureVerificationEx") != null) {
 			}
-			else if (DotNetUtils.getPInvokeMethod(type, "mscoree", "CLRCreateInstance") != null) {
+			else if (DotNetUtils.GetPInvokeMethod(type, "mscoree", "CLRCreateInstance") != null) {
 				if (type.NestedTypes.Count != 3)
 					return false;
 				if (!type.NestedTypes[0].IsInterface || !type.NestedTypes[1].IsInterface || !type.NestedTypes[2].IsInterface)
@@ -107,22 +107,22 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			"System.Reflection.AssemblyName",
 			"System.String",
 		};
-		bool findSilverlight(MethodDef method) {
-			if (!new LocalTypes(method).exactly(requiredLocals_sl))
+		bool FindSilverlight(MethodDef method) {
+			if (!new LocalTypes(method).Exactly(requiredLocals_sl))
 				return false;
-			if (!DotNetUtils.callsMethod(method, "System.Int32 System.String::get_Length()"))
+			if (!DotNetUtils.CallsMethod(method, "System.Int32 System.String::get_Length()"))
 				return false;
-			if (!DotNetUtils.callsMethod(method, "System.Byte[] System.Convert::FromBase64String(System.String)"))
+			if (!DotNetUtils.CallsMethod(method, "System.Byte[] System.Convert::FromBase64String(System.String)"))
 				return false;
-			if (!DotNetUtils.callsMethod(method, "System.Reflection.Assembly System.Reflection.Assembly::GetExecutingAssembly()"))
+			if (!DotNetUtils.CallsMethod(method, "System.Reflection.Assembly System.Reflection.Assembly::GetExecutingAssembly()"))
 				return false;
-			if (!DotNetUtils.callsMethod(method, "System.String System.Reflection.Assembly::get_FullName()"))
+			if (!DotNetUtils.CallsMethod(method, "System.String System.Reflection.Assembly::get_FullName()"))
 				return false;
-			if (!DotNetUtils.callsMethod(method, "System.Byte[] System.Reflection.AssemblyName::GetPublicKeyToken()"))
+			if (!DotNetUtils.CallsMethod(method, "System.Byte[] System.Reflection.AssemblyName::GetPublicKeyToken()"))
 				return false;
-			if (DotNetUtils.callsMethod(method, "System.String", "(System.Reflection.Assembly)")) {
+			if (DotNetUtils.CallsMethod(method, "System.String", "(System.Reflection.Assembly)")) {
 			}
-			else if (DotNetUtils.callsMethod(method, "System.String System.Reflection.AssemblyName::get_Name()")) {
+			else if (DotNetUtils.CallsMethod(method, "System.String System.Reflection.AssemblyName::get_Name()")) {
 			}
 			else
 				return false;
@@ -136,21 +136,21 @@ namespace de4dot.code.deobfuscators.CryptoObfuscator {
 			"System.Int32",
 			"System.String",
 		};
-		bool findCompactFramework(MethodDef method) {
-			if (!new LocalTypes(method).exactly(requiredLocals_cf))
+		bool FindCompactFramework(MethodDef method) {
+			if (!new LocalTypes(method).Exactly(requiredLocals_cf))
 				return false;
-			if (!DotNetUtils.callsMethod(method, "System.Int32 System.String::get_Length()"))
+			if (!DotNetUtils.CallsMethod(method, "System.Int32 System.String::get_Length()"))
 				return false;
-			if (!DotNetUtils.callsMethod(method, "System.Byte[] System.Convert::FromBase64String(System.String)"))
+			if (!DotNetUtils.CallsMethod(method, "System.Byte[] System.Convert::FromBase64String(System.String)"))
 				return false;
-			if (!DotNetUtils.callsMethod(method, "System.Reflection.Assembly System.Reflection.Assembly::GetExecutingAssembly()"))
+			if (!DotNetUtils.CallsMethod(method, "System.Reflection.Assembly System.Reflection.Assembly::GetExecutingAssembly()"))
 				return false;
 
-			if (DotNetUtils.callsMethod(method, "System.Byte[]", "(System.Reflection.Assembly)") &&
-				DotNetUtils.callsMethod(method, "System.String", "(System.Reflection.Assembly)")) {
+			if (DotNetUtils.CallsMethod(method, "System.Byte[]", "(System.Reflection.Assembly)") &&
+				DotNetUtils.CallsMethod(method, "System.String", "(System.Reflection.Assembly)")) {
 			}
-			else if (DotNetUtils.callsMethod(method, "System.Reflection.AssemblyName System.Reflection.Assembly::GetName()") &&
-					DotNetUtils.callsMethod(method, "System.Byte[] System.Reflection.AssemblyName::GetPublicKeyToken()")) {
+			else if (DotNetUtils.CallsMethod(method, "System.Reflection.AssemblyName System.Reflection.Assembly::GetName()") &&
+					DotNetUtils.CallsMethod(method, "System.Byte[] System.Reflection.AssemblyName::GetPublicKeyToken()")) {
 			}
 			else
 				return false;
diff --git a/de4dot.code/deobfuscators/DeepSea/ArrayBlockDeobfuscator.cs b/de4dot.code/deobfuscators/DeepSea/ArrayBlockDeobfuscator.cs
index f152ee95..c9f72b9e 100644
--- a/de4dot.code/deobfuscators/DeepSea/ArrayBlockDeobfuscator.cs
+++ b/de4dot.code/deobfuscators/DeepSea/ArrayBlockDeobfuscator.cs
@@ -33,25 +33,25 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			this.arrayBlockState = arrayBlockState;
 		}
 
-		public override void deobfuscateBegin(Blocks blocks) {
-			base.deobfuscateBegin(blocks);
-			initLocalToInfo();
+		public override void DeobfuscateBegin(Blocks blocks) {
+			base.DeobfuscateBegin(blocks);
+			InitLocalToInfo();
 		}
 
-		void initLocalToInfo() {
+		void InitLocalToInfo() {
 			localToInfo.Clear();
 
-			foreach (var block in blocks.MethodBlocks.getAllBlocks()) {
+			foreach (var block in blocks.MethodBlocks.GetAllBlocks()) {
 				var instrs = block.Instructions;
 				for (int i = 0; i < instrs.Count - 1; i++) {
 					var ldsfld = instrs[i];
 					if (ldsfld.OpCode.Code != Code.Ldsfld)
 						continue;
 					var stloc = instrs[i + 1];
-					if (!stloc.isStloc())
+					if (!stloc.IsStloc())
 						continue;
 
-					var info = arrayBlockState.getFieldInfo((IField)ldsfld.Operand);
+					var info = arrayBlockState.GetFieldInfo((IField)ldsfld.Operand);
 					if (info == null)
 						continue;
 					var local = stloc.Instruction.GetLocal(blocks.Locals);
@@ -63,25 +63,25 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			}
 		}
 
-		protected override bool deobfuscate(Block block) {
+		protected override bool Deobfuscate(Block block) {
 			bool changed = false;
 
 			constantsReader = null;
 			var instrs = block.Instructions;
 			for (int i = 0; i < instrs.Count; i++) {
-				bool ch = deobfuscate1(block, i);
+				bool ch = Deobfuscate1(block, i);
 				if (ch) {
 					changed = true;
 					continue;
 				}
 
-				ch = deobfuscate2(block, i);
+				ch = Deobfuscate2(block, i);
 				if (ch) {
 					changed = true;
 					continue;
 				}
 
-				ch = deobfuscate3(block, i);
+				ch = Deobfuscate3(block, i);
 				if (ch) {
 					changed = true;
 					continue;
@@ -133,13 +133,13 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			}
 		}
 
-		bool deobfuscate1(Block block, int i) {
+		bool Deobfuscate1(Block block, int i) {
 			var instrs = block.Instructions;
 			if (i >= instrs.Count - 2)
 				return false;
 
 			var ldloc = instrs[i];
-			if (!ldloc.isLdloc())
+			if (!ldloc.IsLdloc())
 				return false;
 			var local = ldloc.Instruction.GetLocal(blocks.Locals);
 			if (local == null)
@@ -149,19 +149,19 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return false;
 
 			var ldci4 = instrs[i + 1];
-			if (!ldci4.isLdcI4())
+			if (!ldci4.IsLdcI4())
 				return false;
 
 			var ldelem = instrs[i + 2];
 			if (!IsLdelem(info, ldelem.OpCode.Code))
 				return false;
 
-			block.remove(i, 3 - 1);
-			instrs[i] = new Instr(Instruction.CreateLdcI4((int)info.readArrayElement(ldci4.getLdcI4Value())));
+			block.Remove(i, 3 - 1);
+			instrs[i] = new Instr(Instruction.CreateLdcI4((int)info.ReadArrayElement(ldci4.GetLdcI4Value())));
 			return true;
 		}
 
-		bool deobfuscate2(Block block, int i) {
+		bool Deobfuscate2(Block block, int i) {
 			var instrs = block.Instructions;
 			if (i >= instrs.Count - 2)
 				return false;
@@ -169,24 +169,24 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			var ldsfld = instrs[i];
 			if (ldsfld.OpCode.Code != Code.Ldsfld)
 				return false;
-			var info = arrayBlockState.getFieldInfo(ldsfld.Operand as IField);
+			var info = arrayBlockState.GetFieldInfo(ldsfld.Operand as IField);
 			if (info == null)
 				return false;
 
 			var ldci4 = instrs[i + 1];
-			if (!ldci4.isLdcI4())
+			if (!ldci4.IsLdcI4())
 				return false;
 
 			var ldelem = instrs[i + 2];
 			if (!IsLdelem(info, ldelem.OpCode.Code))
 				return false;
 
-			block.remove(i, 3 - 1);
-			instrs[i] = new Instr(Instruction.CreateLdcI4((int)info.readArrayElement(ldci4.getLdcI4Value())));
+			block.Remove(i, 3 - 1);
+			instrs[i] = new Instr(Instruction.CreateLdcI4((int)info.ReadArrayElement(ldci4.GetLdcI4Value())));
 			return true;
 		}
 
-		bool deobfuscate3(Block block, int i) {
+		bool Deobfuscate3(Block block, int i) {
 			var instrs = block.Instructions;
 			if (i + 1 >= instrs.Count)
 				return false;
@@ -195,17 +195,17 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			var ldsfld = instrs[i];
 			if (ldsfld.OpCode.Code != Code.Ldsfld)
 				return false;
-			var info = arrayBlockState.getFieldInfo(ldsfld.Operand as IField);
+			var info = arrayBlockState.GetFieldInfo(ldsfld.Operand as IField);
 			if (info == null)
 				return false;
 
-			if (!instrs[i + 1].isLdcI4())
+			if (!instrs[i + 1].IsLdcI4())
 				return false;
 
-			var constants = getConstantsReader(block);
+			var constants = GetConstantsReader(block);
 			int value;
 			i += 2;
-			if (!constants.getInt32(ref i, out value))
+			if (!constants.GetInt32(ref i, out value))
 				return false;
 
 			if (i >= instrs.Count)
@@ -214,11 +214,11 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			if (!IsStelem(info, stelem.OpCode.Code))
 				return false;
 
-			block.remove(start, i - start + 1);
+			block.Remove(start, i - start + 1);
 			return true;
 		}
 
-		DsConstantsReader getConstantsReader(Block block) {
+		DsConstantsReader GetConstantsReader(Block block) {
 			if (constantsReader != null)
 				return constantsReader;
 			return constantsReader = new DsConstantsReader(block.Instructions);
diff --git a/de4dot.code/deobfuscators/DeepSea/ArrayBlockState.cs b/de4dot.code/deobfuscators/DeepSea/ArrayBlockState.cs
index f5623484..3ce602dd 100644
--- a/de4dot.code/deobfuscators/DeepSea/ArrayBlockState.cs
+++ b/de4dot.code/deobfuscators/DeepSea/ArrayBlockState.cs
@@ -38,10 +38,10 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				this.field = field;
 				this.elementType = ((SZArraySig)field.FieldType).Next.GetElementType();
 				this.arrayInitField = arrayInitField;
-				this.array = createArray(elementType, arrayInitField.InitialValue);
+				this.array = CreateArray(elementType, arrayInitField.InitialValue);
 			}
 
-			static Array createArray(ElementType etype, byte[] data) {
+			static Array CreateArray(ElementType etype, byte[] data) {
 				switch (etype) {
 				case ElementType.Boolean:
 				case ElementType.I1:
@@ -66,7 +66,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				}
 			}
 
-			public uint readArrayElement(int index) {
+			public uint ReadArrayElement(int index) {
 				switch (elementType) {
 				case ElementType.Boolean:
 				case ElementType.I1:
@@ -96,27 +96,27 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			this.module = module;
 		}
 
-		public void init(ISimpleDeobfuscator simpleDeobfuscator) {
-			initializeArrays(simpleDeobfuscator, DotNetUtils.getModuleTypeCctor(module));
+		public void Initialize(ISimpleDeobfuscator simpleDeobfuscator) {
+			InitializeArrays(simpleDeobfuscator, DotNetUtils.GetModuleTypeCctor(module));
 		}
 
-		void initializeArrays(ISimpleDeobfuscator simpleDeobfuscator, MethodDef method) {
+		void InitializeArrays(ISimpleDeobfuscator simpleDeobfuscator, MethodDef method) {
 			if (method == null || method.Body == null)
 				return;
-			while (initializeArrays2(simpleDeobfuscator, method)) {
+			while (InitializeArrays2(simpleDeobfuscator, method)) {
 			}
 		}
 
-		bool initializeArrays2(ISimpleDeobfuscator simpleDeobfuscator, MethodDef method) {
+		bool InitializeArrays2(ISimpleDeobfuscator simpleDeobfuscator, MethodDef method) {
 			bool foundField = false;
-			simpleDeobfuscator.deobfuscate(method, true);
+			simpleDeobfuscator.Deobfuscate(method, true);
 			var instructions = method.Body.Instructions;
 			for (int i = 0; i < instructions.Count; i++) {
 				var ldci4 = instructions[i];
 				if (!ldci4.IsLdcI4())
 					continue;
 				i++;
-				var instrs = DotNetUtils.getInstructions(instructions, i, OpCodes.Newarr, OpCodes.Dup, OpCodes.Ldtoken, OpCodes.Call, OpCodes.Stsfld);
+				var instrs = DotNetUtils.GetInstructions(instructions, i, OpCodes.Newarr, OpCodes.Dup, OpCodes.Ldtoken, OpCodes.Call, OpCodes.Stsfld);
 				if (instrs == null)
 					continue;
 
@@ -135,32 +135,32 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				if (etype < ElementType.Boolean || etype > ElementType.U4)
 					continue;
 
-				if (fieldToInfo.find(targetField) == null) {
-					fieldToInfo.add(targetField, new FieldInfo(targetField, arrayInitField));
+				if (fieldToInfo.Find(targetField) == null) {
+					fieldToInfo.Add(targetField, new FieldInfo(targetField, arrayInitField));
 					foundField = true;
 				}
 			}
 			return foundField;
 		}
 
-		public FieldInfo getFieldInfo(IField fieldRef) {
+		public FieldInfo GetFieldInfo(IField fieldRef) {
 			if (fieldRef == null)
 				return null;
-			return fieldToInfo.find(fieldRef);
+			return fieldToInfo.Find(fieldRef);
 		}
 
-		public IEnumerable<FieldDef> cleanUp() {
+		public IEnumerable<FieldDef> CleanUp() {
 			var removedFields = new List<FieldDef>();
-			var moduleCctor = DotNetUtils.getModuleTypeCctor(module);
+			var moduleCctor = DotNetUtils.GetModuleTypeCctor(module);
 			if (moduleCctor == null)
 				return removedFields;
 			var moduleCctorBlocks = new Blocks(moduleCctor);
 
-			var keep = findFieldsToKeep();
-			foreach (var fieldInfo in fieldToInfo.getValues()) {
+			var keep = FindFieldsToKeep();
+			foreach (var fieldInfo in fieldToInfo.GetValues()) {
 				if (keep.ContainsKey(fieldInfo))
 					continue;
-				if (removeInitCode(moduleCctorBlocks, fieldInfo)) {
+				if (RemoveInitCode(moduleCctorBlocks, fieldInfo)) {
 					removedFields.Add(fieldInfo.field);
 					removedFields.Add(fieldInfo.arrayInitField);
 				}
@@ -171,18 +171,18 @@ namespace de4dot.code.deobfuscators.DeepSea {
 
 			IList<Instruction> allInstructions;
 			IList<ExceptionHandler> allExceptionHandlers;
-			moduleCctorBlocks.getCode(out allInstructions, out allExceptionHandlers);
-			DotNetUtils.restoreBody(moduleCctorBlocks.Method, allInstructions, allExceptionHandlers);
+			moduleCctorBlocks.GetCode(out allInstructions, out allExceptionHandlers);
+			DotNetUtils.RestoreBody(moduleCctorBlocks.Method, allInstructions, allExceptionHandlers);
 			return removedFields;
 		}
 
-		bool removeInitCode(Blocks blocks, FieldInfo info) {
+		bool RemoveInitCode(Blocks blocks, FieldInfo info) {
 			bool removedSomething = false;
-			foreach (var block in blocks.MethodBlocks.getAllBlocks()) {
+			foreach (var block in blocks.MethodBlocks.GetAllBlocks()) {
 				var instrs = block.Instructions;
 				for (int i = 0; i < instrs.Count - 5; i++) {
 					var ldci4 = instrs[i];
-					if (!ldci4.isLdcI4())
+					if (!ldci4.IsLdcI4())
 						continue;
 					if (instrs[i + 1].OpCode.Code != Code.Newarr)
 						continue;
@@ -204,7 +204,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 						continue;
 					if (stsfld.Operand != info.field)
 						continue;
-					block.remove(i, 6);
+					block.Remove(i, 6);
 					i--;
 					removedSomething = true;
 				}
@@ -212,11 +212,11 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return removedSomething;
 		}
 
-		Dictionary<FieldInfo, bool> findFieldsToKeep() {
+		Dictionary<FieldInfo, bool> FindFieldsToKeep() {
 			var keep = new Dictionary<FieldInfo, bool>();
 			foreach (var type in module.GetTypes()) {
 				foreach (var method in type.Methods) {
-					if (type == DotNetUtils.getModuleType(module) && method.Name == ".cctor")
+					if (type == DotNetUtils.GetModuleType(module) && method.Name == ".cctor")
 						continue;
 					if (method.Body == null)
 						continue;
@@ -225,7 +225,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 						var field = instr.Operand as IField;
 						if (field == null)
 							continue;
-						var fieldInfo = fieldToInfo.find(field);
+						var fieldInfo = fieldToInfo.Find(field);
 						if (fieldInfo == null)
 							continue;
 						keep[fieldInfo] = true;
diff --git a/de4dot.code/deobfuscators/DeepSea/AssemblyResolver.cs b/de4dot.code/deobfuscators/DeepSea/AssemblyResolver.cs
index 72cdd5dd..d42752b4 100644
--- a/de4dot.code/deobfuscators/DeepSea/AssemblyResolver.cs
+++ b/de4dot.code/deobfuscators/DeepSea/AssemblyResolver.cs
@@ -86,46 +86,46 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			"System.Security.Cryptography.SHA1Managed",
 			"System.Windows.AssemblyPart",
 		};
-		protected override bool checkResolverInitMethodSilverlight(MethodDef resolverInitMethod) {
+		protected override bool CheckResolverInitMethodSilverlight(MethodDef resolverInitMethod) {
 			if (resolverInitMethod.Body.ExceptionHandlers.Count != 1)
 				return false;
 
-			foreach (var method in DotNetUtils.getCalledMethods(module, resolverInitMethod)) {
+			foreach (var method in DotNetUtils.GetCalledMethods(module, resolverInitMethod)) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
 				if (!method.IsPublic || method.HasGenericParameters)
 					continue;
-				if (!DotNetUtils.isMethod(method, "System.Void", "(System.String)"))
+				if (!DotNetUtils.IsMethod(method, "System.Void", "(System.String)"))
 					continue;
-				simpleDeobfuscator.deobfuscate(method);
-				if (!new LocalTypes(method).all(requiredLocals_sl))
+				simpleDeobfuscator.Deobfuscate(method);
+				if (!new LocalTypes(method).All(requiredLocals_sl))
 					continue;
 
 				initMethod = resolverInitMethod;
 				resolveHandler = method;
-				updateVersion(resolveHandler);
+				UpdateVersion(resolveHandler);
 				return true;
 			}
 
 			return false;
 		}
 
-		void updateVersion(MethodDef handler) {
-			if (isV3Old(handler)) {
+		void UpdateVersion(MethodDef handler) {
+			if (IsV3Old(handler)) {
 				version = Version.V3Old;
 				return;
 			}
-			if (isV3SL(handler)) {
+			if (IsV3SL(handler)) {
 				version = Version.V3;	// 3.x-4.0.4
 				return;
 			}
-			if (isV41SL(handler)) {
+			if (IsV41SL(handler)) {
 				version = Version.V41SL;
 				return;
 			}
 		}
 
-		static bool isV3SL(MethodDef handler) {
+		static bool IsV3SL(MethodDef handler) {
 			var instrs = handler.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 3; i++) {
 				if (!instrs[i].IsLdloc())
@@ -141,7 +141,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return false;
 		}
 
-		static bool isV41SL(MethodDef handler) {
+		static bool IsV41SL(MethodDef handler) {
 			var instrs = handler.Body.Instructions;
 			for (int i = 0; i < instrs.Count; i++) {
 				if (!instrs[i].IsLdcI4() || instrs[i].GetLdcI4Value() != 5)
@@ -157,34 +157,34 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return false;
 		}
 
-		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()") &&
+		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)");
+				!DotNetUtils.CallsMethod(method, "System.Int32", "(System.IO.Stream,System.Int32,System.Int32)");
 		}
 
-		protected override bool checkResolverInitMethodInternal(MethodDef resolverInitMethod) {
-			return DotNetUtils.callsMethod(resolverInitMethod, "System.Void System.AppDomain::add_AssemblyResolve(System.ResolveEventHandler)");
+		protected override bool CheckResolverInitMethodInternal(MethodDef resolverInitMethod) {
+			return DotNetUtils.CallsMethod(resolverInitMethod, "System.Void System.AppDomain::add_AssemblyResolve(System.ResolveEventHandler)");
 		}
 
-		protected override bool checkHandlerMethodDesktopInternal(MethodDef handler) {
-			if (checkHandlerV3(handler) || checkHandlerSL(handler)) {
-				updateVersion(handler);
+		protected override bool CheckHandlerMethodDesktopInternal(MethodDef handler) {
+			if (CheckHandlerV3(handler) || checkHandlerSL(handler)) {
+				UpdateVersion(handler);
 				return true;
 			}
 
-			simpleDeobfuscator.deobfuscate(handler);
+			simpleDeobfuscator.Deobfuscate(handler);
 			List<FieldInfo> fieldInfosTmp;
 			MethodDef decryptMethodTmp;
-			if (checkHandlerV4(handler, out fieldInfosTmp, out decryptMethodTmp)) {
+			if (CheckHandlerV4(handler, out fieldInfosTmp, out decryptMethodTmp)) {
 				version = Version.V4;
 				fieldInfos = fieldInfosTmp;
 				decryptMethod = decryptMethodTmp;
 				return true;
 			}
 
-			Version versionTmp = checkHandlerV404_41(handler, out fieldInfosTmp, out decryptMethodTmp);
+			Version versionTmp = CheckHandlerV404_41(handler, out fieldInfosTmp, out decryptMethodTmp);
 			if (fieldInfosTmp.Count != 0) {
 				version = versionTmp;
 				fieldInfos = fieldInfosTmp;
@@ -204,8 +204,8 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			"System.Security.Cryptography.SHA1CryptoServiceProvider",
 			"System.String",
 		};
-		static bool checkHandlerV3(MethodDef handler) {
-			return new LocalTypes(handler).all(handlerLocalTypes_NET);
+		static bool CheckHandlerV3(MethodDef handler) {
+			return new LocalTypes(handler).All(handlerLocalTypes_NET);
 		}
 
 		static string[] handlerLocalTypes_SL = new string[] {
@@ -217,11 +217,11 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			"System.Windows.AssemblyPart",
 		};
 		static bool checkHandlerSL(MethodDef handler) {
-			return new LocalTypes(handler).all(handlerLocalTypes_SL);
+			return new LocalTypes(handler).All(handlerLocalTypes_SL);
 		}
 
 		// 4.0.1.18 .. 4.0.3
-		bool checkHandlerV4(MethodDef handler, out List<FieldInfo> fieldInfos, out MethodDef decryptMethod) {
+		bool CheckHandlerV4(MethodDef handler, out List<FieldInfo> fieldInfos, out MethodDef decryptMethod) {
 			fieldInfos = new List<FieldInfo>();
 			decryptMethod = null;
 
@@ -253,7 +253,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				if (call.OpCode.Code != Code.Call)
 					return false;
 				var decryptMethodTmp = call.Operand as MethodDef;
-				if (!DotNetUtils.isMethod(decryptMethodTmp, "System.Reflection.Assembly", "(System.RuntimeFieldHandle,System.Int32,System.Int32)"))
+				if (!DotNetUtils.IsMethod(decryptMethodTmp, "System.Reflection.Assembly", "(System.RuntimeFieldHandle,System.Int32,System.Int32)"))
 					return false;
 
 				decryptMethod = decryptMethodTmp;
@@ -264,7 +264,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 		}
 
 		// 4.0.4, 4.1+
-		Version checkHandlerV404_41(MethodDef handler, out List<FieldInfo> fieldInfos, out MethodDef decryptMethod) {
+		Version CheckHandlerV404_41(MethodDef handler, out List<FieldInfo> fieldInfos, out MethodDef decryptMethod) {
 			Version version = Version.Unknown;
 			fieldInfos = new List<FieldInfo>();
 			decryptMethod = null;
@@ -293,13 +293,13 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				var call1 = instrs[index++];
 				if (call1.OpCode.Code != Code.Call)
 					continue;
-				if (!DotNetUtils.isMethod(call1.Operand as IMethod, "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);
+				int callIndex = GetCallDecryptMethodIndex(instrs, index);
 				if (callIndex < 0)
 					continue;
-				var args = DsUtils.getArgValues(instrs, callIndex);
+				var args = DsUtils.GetArgValues(instrs, callIndex);
 				if (args == null)
 					continue;
 				var decryptMethodTmp = instrs[callIndex].Operand as MethodDef;
@@ -307,7 +307,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 					continue;
 				int magic;
 				Version versionTmp;
-				getMagic(decryptMethodTmp, args, out versionTmp, out magic);
+				GetMagic(decryptMethodTmp, args, out versionTmp, out magic);
 
 				version = versionTmp;
 				decryptMethod = decryptMethodTmp;
@@ -317,9 +317,9 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return version;
 		}
 
-		static bool getMagic(MethodDef 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);
+			int magicIndex = GetMagicIndex(method, out version);
 			if (magicIndex < 0 || magicIndex >= args.Count)
 				return false;
 			var val = args[magicIndex];
@@ -330,14 +330,14 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return true;
 		}
 
-		static int getMagicIndex(MethodDef method, out Version version) {
-			int magicIndex = getMagicIndex404(method);
+		static int GetMagicIndex(MethodDef method, out Version version) {
+			int magicIndex = GetMagicIndex404(method);
 			if (magicIndex >= 0) {
 				version = Version.V404;
 				return magicIndex;
 			}
 
-			magicIndex = getMagicIndex41Trial(method);
+			magicIndex = GetMagicIndex41Trial(method);
 			if (magicIndex >= 0) {
 				version = Version.V41;
 				return magicIndex;
@@ -347,7 +347,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return -1;
 		}
 
-		static int getMagicIndex404(MethodDef method) {
+		static int GetMagicIndex404(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 4; i++) {
 				int index = i;
@@ -368,7 +368,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return -1;
 		}
 
-		static int getMagicIndex41Trial(MethodDef method) {
+		static int GetMagicIndex41Trial(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 4; i++) {
 				int index = i;
@@ -389,13 +389,13 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return -1;
 		}
 
-		static int getCallDecryptMethodIndex(IList<Instruction> instrs, int index) {
-			index = getRetIndex(instrs, index);
+		static int GetCallDecryptMethodIndex(IList<Instruction> instrs, int index) {
+			index = GetRetIndex(instrs, index);
 			if (index < 0)
 				return -1;
 			for (int i = index - 1; i >= 0; i--) {
 				var instr = instrs[i];
-				if (!isCallOrNext(instr))
+				if (!IsCallOrNext(instr))
 					break;
 				if (instr.OpCode.Code != Code.Call)
 					continue;
@@ -408,18 +408,18 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return -1;
 		}
 
-		static int getRetIndex(IList<Instruction> instrs, int index) {
+		static int GetRetIndex(IList<Instruction> instrs, int index) {
 			for (int i = index; i < instrs.Count; i++) {
 				var instr = instrs[i];
 				if (instr.OpCode.Code == Code.Ret)
 					return i;
-				if (!isCallOrNext(instr))
+				if (!IsCallOrNext(instr))
 					break;
 			}
 			return -1;
 		}
 
-		static bool isCallOrNext(Instruction instr) {
+		static bool IsCallOrNext(Instruction instr) {
 			switch (instr.OpCode.FlowControl) {
 			case FlowControl.Call:
 			case FlowControl.Next:
@@ -429,28 +429,28 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			}
 		}
 
-		public IEnumerable<AssemblyInfo> getAssemblyInfos() {
+		public IEnumerable<AssemblyInfo> GetAssemblyInfos() {
 			if (!Detected)
 				return new List<AssemblyInfo>();
 
 			switch (version) {
 			case Version.V3Old:
-				return getAssemblyInfos(resource => decryptResourceV3Old(resource));
+				return GetAssemblyInfos(resource => DecryptResourceV3Old(resource));
 			case Version.V3:
-				return getAssemblyInfos(resource => decryptResourceV3(resource));
+				return GetAssemblyInfos(resource => DecryptResourceV3(resource));
 			case Version.V4:
 			case Version.V404:
-				return getAssemblyInfosV4();
+				return GetAssemblyInfosV4();
 			case Version.V41:
-				return getAssemblyInfosV41();
+				return GetAssemblyInfosV41();
 			case Version.V41SL:
-				return getAssemblyInfos(resource => decryptResourceV41SL(resource));
+				return GetAssemblyInfos(resource => DecryptResourceV41SL(resource));
 			default:
 				throw new ApplicationException("Unknown version");
 			}
 		}
 
-		IEnumerable<AssemblyInfo> getAssemblyInfos(Func<EmbeddedResource, byte[]> decrypter) {
+		IEnumerable<AssemblyInfo> GetAssemblyInfos(Func<EmbeddedResource, byte[]> decrypter) {
 			var infos = new List<AssemblyInfo>();
 
 			foreach (var tmp in module.Resources) {
@@ -459,7 +459,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 					continue;
 				if (!Regex.IsMatch(resource.Name.String, @"^[0-9A-F]{40}$"))
 					continue;
-				var info = getAssemblyInfo(resource, decrypter);
+				var info = GetAssemblyInfo(resource, decrypter);
 				if (info == null)
 					continue;
 				infos.Add(info);
@@ -468,25 +468,25 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return infos;
 		}
 
-		AssemblyInfo getAssemblyInfo(EmbeddedResource resource, Func<EmbeddedResource, byte[]> decrypter) {
+		AssemblyInfo GetAssemblyInfo(EmbeddedResource resource, Func<EmbeddedResource, byte[]> decrypter) {
 			try {
 				var decrypted = decrypter(resource);
-				return getAssemblyInfo(decrypted, resource);
+				return GetAssemblyInfo(decrypted, resource);
 			}
 			catch (Exception) {
 				return null;
 			}
 		}
 
-		AssemblyInfo getAssemblyInfo(byte[] decryptedData, EmbeddedResource resource) {
+		AssemblyInfo GetAssemblyInfo(byte[] decryptedData, EmbeddedResource resource) {
 			var asm = AssemblyDef.Load(decryptedData);
 			var fullName = asm.FullName;
 			var simpleName = asm.Name.String;
-			var extension = DeobUtils.getExtension(asm.Modules[0].Kind);
+			var extension = DeobUtils.GetExtension(asm.Modules[0].Kind);
 			return new AssemblyInfo(decryptedData, fullName, simpleName, extension, resource);
 		}
 
-		IEnumerable<AssemblyInfo> getAssemblyInfos(Func<byte[], int, byte[]> decrypter) {
+		IEnumerable<AssemblyInfo> GetAssemblyInfos(Func<byte[], int, byte[]> decrypter) {
 			var infos = new List<AssemblyInfo>();
 
 			if (fieldInfos == null)
@@ -494,7 +494,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 
 			foreach (var fieldInfo in fieldInfos) {
 				var decrypted = decrypter(fieldInfo.field.InitialValue, fieldInfo.magic);
-				infos.Add(getAssemblyInfo(decrypted, null));
+				infos.Add(GetAssemblyInfo(decrypted, null));
 				fieldInfo.field.InitialValue = new byte[1];
 				fieldInfo.field.FieldSig.Type = module.CorLibTypes.Byte;
 				fieldInfo.field.RVA = 0;
@@ -503,15 +503,15 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return infos;
 		}
 
-		IEnumerable<AssemblyInfo> getAssemblyInfosV4() {
-			return getAssemblyInfos((data, magic) => decryptResourceV4(data, magic));
+		IEnumerable<AssemblyInfo> GetAssemblyInfosV4() {
+			return GetAssemblyInfos((data, magic) => DecryptResourceV4(data, magic));
 		}
 
-		IEnumerable<AssemblyInfo> getAssemblyInfosV41() {
-			return getAssemblyInfos((data, magic) => inflateIfNeeded(decrypt41Trial(data, magic)));
+		IEnumerable<AssemblyInfo> GetAssemblyInfosV41() {
+			return GetAssemblyInfos((data, magic) => InflateIfNeeded(Decrypt41Trial(data, magic)));
 		}
 
-		static byte[] decrypt41Trial(byte[] data, int magic) {
+		static byte[] Decrypt41Trial(byte[] data, int magic) {
 			for (int i = 0; i < data.Length; i++)
 				data[i] ^= (byte)(i / 3 + magic);
 			return data;
diff --git a/de4dot.code/deobfuscators/DeepSea/CastDeobfuscator.cs b/de4dot.code/deobfuscators/DeepSea/CastDeobfuscator.cs
index 13120db9..c04c1c4a 100644
--- a/de4dot.code/deobfuscators/DeepSea/CastDeobfuscator.cs
+++ b/de4dot.code/deobfuscators/DeepSea/CastDeobfuscator.cs
@@ -75,12 +75,12 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			get { return true; }
 		}
 
-		public void deobfuscateBegin(Blocks blocks) {
+		public void DeobfuscateBegin(Blocks blocks) {
 			this.blocks = blocks;
 		}
 
-		public bool deobfuscate(List<Block> allBlocks) {
-			if (!init(allBlocks))
+		public bool Deobfuscate(List<Block> allBlocks) {
+			if (!Initialize(allBlocks))
 				return false;
 
 			bool changed = false;
@@ -97,7 +97,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 							continue;
 						localInfos[local].invalid();
 					}
-					else if (instr.isLdloc()) {
+					else if (instr.IsLdloc()) {
 						var local = instr.Instruction.GetLocal(blocks.Locals);
 						if (local == null)
 							continue;
@@ -105,14 +105,14 @@ namespace de4dot.code.deobfuscators.DeepSea {
 						var cast = instrs[i + 1];
 						if (localInfo.CastType == null)
 							continue;
-						if (!isCast(cast))
+						if (!IsCast(cast))
 							throw new ApplicationException("Not a cast instr");
 
 						indexesToRemove.Add(i + 1);
 					}
 				}
 				if (indexesToRemove.Count > 0) {
-					block.remove(indexesToRemove);
+					block.Remove(indexesToRemove);
 					changed = true;
 				}
 			}
@@ -136,19 +136,19 @@ namespace de4dot.code.deobfuscators.DeepSea {
 							instr = instrs[i - 1];
 						}
 
-						if (instr.isLdarg())
-							addCast(block, castIndex, i + 1, instr.Instruction.GetArgumentType(blocks.Method.MethodSig, blocks.Method.DeclaringType));
+						if (instr.IsLdarg())
+							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 IField;
 							if (field == null)
 								continue;
-							addCast(block, castIndex, i + 1, field.FieldSig.GetFieldType());
+							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 IMethod;
-							if (calledMethod == null || !DotNetUtils.hasReturnValue(calledMethod))
+							if (calledMethod == null || !DotNetUtils.HasReturnValue(calledMethod))
 								continue;
-							addCast(block, castIndex, i + 1, calledMethod.MethodSig.GetRetType());
+							AddCast(block, castIndex, i + 1, calledMethod.MethodSig.GetRetType());
 						}
 					}
 				}
@@ -157,13 +157,13 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return changed;
 		}
 
-		bool addCast(Block block, int castIndex, int index, TypeSig 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)
 				return false;
 			var stloc = block.Instructions[index];
-			if (!stloc.isStloc())
+			if (!stloc.IsStloc())
 				return false;
 			var local = stloc.Instruction.GetLocal(blocks.Locals);
 			if (local == null)
@@ -173,11 +173,11 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return false;
 
 			if (!new SigComparer().Equals(localInfo.CastType, type))
-				block.insert(castIndex, new Instruction(OpCodes.Castclass, localInfo.CastType));
+				block.Insert(castIndex, new Instruction(OpCodes.Castclass, localInfo.CastType));
 			return true;
 		}
 
-		bool init(List<Block> allBlocks) {
+		bool Initialize(List<Block> allBlocks) {
 			localInfos.Clear();
 			foreach (var local in blocks.Locals)
 				localInfos[local] = new LocalInfo(local);
@@ -188,24 +188,24 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				var instrs = block.Instructions;
 				for (int i = 0; i < instrs.Count - 1; i++) {
 					var ldloc = instrs[i];
-					if (!ldloc.isLdloc())
+					if (!ldloc.IsLdloc())
 						continue;
 					var local = ldloc.Instruction.GetLocal(blocks.Locals);
 					if (local == null)
 						continue;
 					var localInfo = localInfos[local];
-					localInfo.CastType = getCastType(instrs[i + 1]);
+					localInfo.CastType = GetCastType(instrs[i + 1]);
 				}
 			}
 			return true;
 		}
 
-		static bool isCast(Instr instr) {
+		static bool IsCast(Instr instr) {
 			return instr.OpCode.Code == Code.Castclass || instr.OpCode.Code == Code.Isinst;
 		}
 
-		static ITypeDefOrRef getCastType(Instr instr) {
-			if (!isCast(instr))
+		static ITypeDefOrRef GetCastType(Instr instr) {
+			if (!IsCast(instr))
 				return null;
 			return instr.Operand as ITypeDefOrRef;
 		}
diff --git a/de4dot.code/deobfuscators/DeepSea/Deobfuscator.cs b/de4dot.code/deobfuscators/DeepSea/Deobfuscator.cs
index c316e0ce..503fed61 100644
--- a/de4dot.code/deobfuscators/DeepSea/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/DeepSea/Deobfuscator.cs
@@ -36,13 +36,13 @@ namespace de4dot.code.deobfuscators.DeepSea {
 
 		public DeobfuscatorInfo()
 			: base() {
-			inlineMethods = new BoolOption(null, makeArgName("inline"), "Inline short methods", true);
-			removeInlinedMethods = new BoolOption(null, makeArgName("remove-inlined"), "Remove inlined methods", true);
-			decryptResources = new BoolOption(null, makeArgName("rsrc"), "Decrypt resources", true);
-			dumpEmbeddedAssemblies = new BoolOption(null, makeArgName("embedded"), "Dump embedded assemblies", true);
-			restoreFields = new BoolOption(null, makeArgName("fields"), "Restore fields", true);
-			renameResourceKeys = new BoolOption(null, makeArgName("keys"), "Rename resource keys", true);
-			castDeobfuscation = new BoolOption(null, makeArgName("casts"), "Deobfuscate casts", true);
+			inlineMethods = new BoolOption(null, MakeArgName("inline"), "Inline short methods", true);
+			removeInlinedMethods = new BoolOption(null, MakeArgName("remove-inlined"), "Remove inlined methods", true);
+			decryptResources = new BoolOption(null, MakeArgName("rsrc"), "Decrypt resources", true);
+			dumpEmbeddedAssemblies = new BoolOption(null, MakeArgName("embedded"), "Dump embedded assemblies", true);
+			restoreFields = new BoolOption(null, MakeArgName("fields"), "Restore fields", true);
+			renameResourceKeys = new BoolOption(null, MakeArgName("keys"), "Rename resource keys", true);
+			castDeobfuscation = new BoolOption(null, MakeArgName("casts"), "Deobfuscate casts", true);
 		}
 
 		public override string Name {
@@ -53,7 +53,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			get { return THE_TYPE; }
 		}
 
-		public override IDeobfuscator createDeobfuscator() {
+		public override IDeobfuscator CreateDeobfuscator() {
 			return new Deobfuscator(new Deobfuscator.Options {
 				ValidNameRegex = validNameRegex.get(),
 				InlineMethods = inlineMethods.get(),
@@ -66,7 +66,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			});
 		}
 
-		protected override IEnumerable<Option> getOptionsInternal() {
+		protected override IEnumerable<Option> GetOptionsInternal() {
 			return new List<Option>() {
 				inlineMethods,
 				removeInlinedMethods,
@@ -118,14 +118,14 @@ namespace de4dot.code.deobfuscators.DeepSea {
 
 		public override IEnumerable<IBlocksDeobfuscator> BlocksDeobfuscators {
 			get {
-				var list = new List<IBlocksDeobfuscator>(getBlocksDeobfuscators());
+				var list = new List<IBlocksDeobfuscator>(GetBlocksDeobfuscators());
 				if (CanInlineMethods)
-					list.Add(new DsMethodCallInliner(new CachedCflowDeobfuscator(getBlocksDeobfuscators())));
+					list.Add(new DsMethodCallInliner(new CachedCflowDeobfuscator(GetBlocksDeobfuscators())));
 				return list;
 			}
 		}
 
-		List<IBlocksDeobfuscator> getBlocksDeobfuscators() {
+		List<IBlocksDeobfuscator> GetBlocksDeobfuscators() {
 			var list = new List<IBlocksDeobfuscator>();
 			if (arrayBlockState != null && arrayBlockState.Detected)
 				list.Add(new ArrayBlockDeobfuscator(arrayBlockState));
@@ -144,35 +144,35 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				this.RenamingOptions &= ~RenamingOptions.RenameResourceKeys;
 		}
 
-		protected override int detectInternal() {
+		protected override int DetectInternal() {
 			int val = 0;
 
-			int sum = toInt32(stringDecrypter.Detected) +
-					toInt32(resourceResolver.Detected) +
-					toInt32(assemblyResolver.Detected);
+			int sum = ToInt32(stringDecrypter.Detected) +
+					ToInt32(resourceResolver.Detected) +
+					ToInt32(assemblyResolver.Detected);
 			if (sum > 0)
 				val += 100 + 10 * (sum - 1);
 
 			return val;
 		}
 
-		protected override void scanForObfuscator() {
+		protected override void ScanForObfuscator() {
 			staticStringInliner.UseUnknownArgs = true;
 			arrayBlockState = new ArrayBlockState(module);
-			arrayBlockState.init(DeobfuscatedFile);
+			arrayBlockState.Initialize(DeobfuscatedFile);
 			stringDecrypter = new StringDecrypter(module);
-			stringDecrypter.find(DeobfuscatedFile);
+			stringDecrypter.Find(DeobfuscatedFile);
 			resourceResolver = new ResourceResolver(module, DeobfuscatedFile, this);
-			resourceResolver.find();
+			resourceResolver.Find();
 			assemblyResolver = new AssemblyResolver(module, DeobfuscatedFile, this);
-			assemblyResolver.find();
-			obfuscatorName = detectVersion();
+			assemblyResolver.Find();
+			obfuscatorName = DetectVersion();
 		}
 
-		string detectVersion() {
+		string DetectVersion() {
 			switch (stringDecrypter.Version) {
 			case StringDecrypter.DecrypterVersion.V1_3:
-				if (detectMethodProxyObfuscation())
+				if (DetectMethodProxyObfuscation())
 					return DeobfuscatorInfo.THE_NAME + " 3.5";
 				return DeobfuscatorInfo.THE_NAME + " 1.x-3.x";
 			case StringDecrypter.DecrypterVersion.V4_0:
@@ -184,7 +184,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return DeobfuscatorInfo.THE_NAME;
 		}
 
-		bool detectMethodProxyObfuscation() {
+		bool DetectMethodProxyObfuscation() {
 			const int MIN_FOUND_PROXIES = 10;
 
 			int foundProxies = 0, checkedMethods = 0;
@@ -196,7 +196,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 						continue;
 					if (checkedMethods++ >= 1000)
 						goto done;
-					if (!DsMethodCallInliner.canInline(method))
+					if (!DsMethodCallInliner.CanInline(method))
 						continue;
 					foundProxies++;
 				}
@@ -205,91 +205,91 @@ done:
 			return foundProxies >= MIN_FOUND_PROXIES;
 		}
 
-		public override void deobfuscateBegin() {
-			base.deobfuscateBegin();
+		public override void DeobfuscateBegin() {
+			base.DeobfuscateBegin();
 
 			if (options.RestoreFields) {
 				fieldsRestorer = new FieldsRestorer(module);
-				fieldsRestorer.initialize();
+				fieldsRestorer.Initialize();
 			}
 
 			foreach (var method in stringDecrypter.DecrypterMethods) {
-				staticStringInliner.add(method, (method2, gim, args) => {
-					return stringDecrypter.decrypt(method2, args);
+				staticStringInliner.Add(method, (method2, gim, args) => {
+					return stringDecrypter.Decrypt(method2, args);
 				});
 			}
-			DeobfuscatedFile.stringDecryptersAdded();
+			DeobfuscatedFile.StringDecryptersAdded();
 
-			resourceResolver.initialize();
-			decryptResources();
+			resourceResolver.Initialize();
+			DecryptResources();
 
-			dumpEmbeddedAssemblies();
+			DumpEmbeddedAssemblies();
 
 			startedDeobfuscating = true;
 		}
 
-		void decryptResources() {
+		void DecryptResources() {
 			if (!options.DecryptResources)
 				return;
 			EmbeddedResource rsrc;
-			if (!resourceResolver.mergeResources(out rsrc))
+			if (!resourceResolver.MergeResources(out rsrc))
 				return;
-			addResourceToBeRemoved(rsrc, "Encrypted resources");
-			addCctorInitCallToBeRemoved(resourceResolver.InitMethod);
-			addCallToBeRemoved(module.EntryPoint, resourceResolver.InitMethod);
-			addMethodToBeRemoved(resourceResolver.InitMethod, "Resource resolver init method");
-			addMethodToBeRemoved(resourceResolver.InitMethod2, "Resource resolver init method #2");
-			addMethodToBeRemoved(resourceResolver.HandlerMethod, "Resource resolver handler method");
-			addMethodToBeRemoved(resourceResolver.GetDataMethod, "Resource resolver 'get resource data' method");
+			AddResourceToBeRemoved(rsrc, "Encrypted resources");
+			AddCctorInitCallToBeRemoved(resourceResolver.InitMethod);
+			AddCallToBeRemoved(module.EntryPoint, resourceResolver.InitMethod);
+			AddMethodToBeRemoved(resourceResolver.InitMethod, "Resource resolver init method");
+			AddMethodToBeRemoved(resourceResolver.InitMethod2, "Resource resolver init method #2");
+			AddMethodToBeRemoved(resourceResolver.HandlerMethod, "Resource resolver handler method");
+			AddMethodToBeRemoved(resourceResolver.GetDataMethod, "Resource resolver 'get resource data' method");
 		}
 
-		void dumpEmbeddedAssemblies() {
+		void DumpEmbeddedAssemblies() {
 			if (!options.DumpEmbeddedAssemblies)
 				return;
-			foreach (var info in assemblyResolver.getAssemblyInfos()) {
+			foreach (var info in assemblyResolver.GetAssemblyInfos()) {
 				if (info.resource != null && info.resource == resourceResolver.Resource)
 					continue;
-				DeobfuscatedFile.createAssemblyFile(info.data, info.simpleName, info.extension);
-				addResourceToBeRemoved(info.resource, string.Format("Embedded assembly: {0}", info.fullName));
+				DeobfuscatedFile.CreateAssemblyFile(info.data, info.simpleName, info.extension);
+				AddResourceToBeRemoved(info.resource, string.Format("Embedded assembly: {0}", info.fullName));
 			}
-			addCctorInitCallToBeRemoved(assemblyResolver.InitMethod);
-			addCallToBeRemoved(module.EntryPoint, assemblyResolver.InitMethod);
-			addMethodToBeRemoved(assemblyResolver.InitMethod, "Assembly resolver init method");
-			addMethodToBeRemoved(assemblyResolver.HandlerMethod, "Assembly resolver handler method");
-			addMethodToBeRemoved(assemblyResolver.DecryptMethod, "Assembly resolver decrypt method");
+			AddCctorInitCallToBeRemoved(assemblyResolver.InitMethod);
+			AddCallToBeRemoved(module.EntryPoint, assemblyResolver.InitMethod);
+			AddMethodToBeRemoved(assemblyResolver.InitMethod, "Assembly resolver init method");
+			AddMethodToBeRemoved(assemblyResolver.HandlerMethod, "Assembly resolver handler method");
+			AddMethodToBeRemoved(assemblyResolver.DecryptMethod, "Assembly resolver decrypt method");
 		}
 
-		public override void deobfuscateMethodEnd(Blocks blocks) {
+		public override void DeobfuscateMethodEnd(Blocks blocks) {
 			if (options.RestoreFields)
-				fieldsRestorer.deobfuscate(blocks);
-			base.deobfuscateMethodEnd(blocks);
+				fieldsRestorer.Deobfuscate(blocks);
+			base.DeobfuscateMethodEnd(blocks);
 		}
 
-		public override void deobfuscateEnd() {
+		public override void DeobfuscateEnd() {
 			if (options.RestoreFields && CanRemoveTypes)
-				fieldsRestorer.cleanUp();
-			removeInlinedMethods();
+				fieldsRestorer.CleanUp();
+			RemoveInlinedMethods();
 
 			if (options.RestoreFields)
-				addTypesToBeRemoved(fieldsRestorer.FieldStructs, "Type with moved fields");
+				AddTypesToBeRemoved(fieldsRestorer.FieldStructs, "Type with moved fields");
 
 			if (CanRemoveStringDecrypterType) {
-				addMethodsToBeRemoved(stringDecrypter.DecrypterMethods, "String decrypter method");
-				stringDecrypter.cleanup();
+				AddMethodsToBeRemoved(stringDecrypter.DecrypterMethods, "String decrypter method");
+				stringDecrypter.CleanUp();
 			}
 
-			addFieldsToBeRemoved(arrayBlockState.cleanUp(), "Control flow obfuscation array");
+			AddFieldsToBeRemoved(arrayBlockState.CleanUp(), "Control flow obfuscation array");
 
-			base.deobfuscateEnd();
+			base.DeobfuscateEnd();
 		}
 
-		void removeInlinedMethods() {
+		void RemoveInlinedMethods() {
 			if (!options.InlineMethods || !options.RemoveInlinedMethods)
 				return;
-			removeInlinedMethods(DsInlinedMethodsFinder.find(module, staticStringInliner.Methods));
+			RemoveInlinedMethods(DsInlinedMethodsFinder.Find(module, staticStringInliner.Methods));
 		}
 
-		public override IEnumerable<int> getStringDecrypterMethods() {
+		public override IEnumerable<int> GetStringDecrypterMethods() {
 			var list = new List<int>();
 			foreach (var method in stringDecrypter.DecrypterMethods)
 				list.Add(method.MDToken.ToInt32());
diff --git a/de4dot.code/deobfuscators/DeepSea/DsConstantsReader.cs b/de4dot.code/deobfuscators/DeepSea/DsConstantsReader.cs
index 0a7fec6e..f184ecb3 100644
--- a/de4dot.code/deobfuscators/DeepSea/DsConstantsReader.cs
+++ b/de4dot.code/deobfuscators/DeepSea/DsConstantsReader.cs
@@ -27,12 +27,12 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			: base(instrs) {
 		}
 
-		protected override bool getLocalConstantInt32(Instruction instr, out int value) {
+		protected override bool GetLocalConstantInt32(Instruction instr, out int value) {
 			value = 0;
 			return true;
 		}
 
-		protected override bool getArgConstantInt32(Instruction instr, out int value) {
+		protected override bool GetArgConstantInt32(Instruction instr, out int value) {
 			value = 0;
 			return true;
 		}
diff --git a/de4dot.code/deobfuscators/DeepSea/DsInlinedMethodsFinder.cs b/de4dot.code/deobfuscators/DeepSea/DsInlinedMethodsFinder.cs
index e55d946d..4df877eb 100644
--- a/de4dot.code/deobfuscators/DeepSea/DsInlinedMethodsFinder.cs
+++ b/de4dot.code/deobfuscators/DeepSea/DsInlinedMethodsFinder.cs
@@ -22,7 +22,7 @@ using dnlib.DotNet;
 
 namespace de4dot.code.deobfuscators.DeepSea {
 	static class DsInlinedMethodsFinder {
-		public static List<MethodDef> find(ModuleDefMD module, IEnumerable<MethodDef> notInlinedMethods) {
+		public static List<MethodDef> Find(ModuleDefMD module, IEnumerable<MethodDef> notInlinedMethods) {
 			var notInlinedMethodsDict = new Dictionary<MethodDef, bool>();
 			foreach (var method in notInlinedMethods)
 				notInlinedMethodsDict[method] = true;
@@ -31,7 +31,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 
 			foreach (var type in module.GetTypes()) {
 				foreach (var method in type.Methods) {
-					if (!notInlinedMethodsDict.ContainsKey(method) && DsMethodCallInliner.canInline(method))
+					if (!notInlinedMethodsDict.ContainsKey(method) && DsMethodCallInliner.CanInline(method))
 						inlinedMethods.Add(method);
 				}
 			}
diff --git a/de4dot.code/deobfuscators/DeepSea/DsMethodCallInliner.cs b/de4dot.code/deobfuscators/DeepSea/DsMethodCallInliner.cs
index 26c64d40..aa4cc60c 100644
--- a/de4dot.code/deobfuscators/DeepSea/DsMethodCallInliner.cs
+++ b/de4dot.code/deobfuscators/DeepSea/DsMethodCallInliner.cs
@@ -36,20 +36,20 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			this.cflowDeobfuscator = cflowDeobfuscator;
 		}
 
-		protected override bool deobfuscateInternal() {
+		protected override bool DeobfuscateInternal() {
 			bool changed = false;
 
 			var instructions = block.Instructions;
 			for (int i = 0; i < instructions.Count; i++) {
 				var instr = instructions[i].Instruction;
 				if (instr.OpCode.Code == Code.Call)
-					changed |= inlineMethod(instr, i);
+					changed |= InlineMethod(instr, i);
 			}
 
 			return changed;
 		}
 
-		bool inlineMethod(Instruction callInstr, int instrIndex) {
+		bool InlineMethod(Instruction callInstr, int instrIndex) {
 			var method = callInstr.Operand as MethodDef;
 			if (method == null) {
 				var ms = callInstr.Operand as MethodSpec;
@@ -58,63 +58,63 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				if (method == null)
 					return false;
 			}
-			if (!canInline(method))
+			if (!CanInline(method))
 				return false;
 
 			if (instrIndex < 2)
 				return false;
 			var ldci4_1st = block.Instructions[instrIndex - 2];
 			var ldci4_2nd = block.Instructions[instrIndex - 1];
-			if (!ldci4_1st.isLdcI4() || !ldci4_2nd.isLdcI4())
+			if (!ldci4_1st.IsLdcI4() || !ldci4_2nd.IsLdcI4())
 				return false;
 
-			if (!inlineMethod(method, instrIndex, ldci4_1st.getLdcI4Value(), ldci4_2nd.getLdcI4Value()))
+			if (!InlineMethod(method, instrIndex, ldci4_1st.GetLdcI4Value(), ldci4_2nd.GetLdcI4Value()))
 				return false;
 
 			return true;
 		}
 
-		protected override Instruction onAfterLoadArg(MethodDef methodToInline, Instruction instr, ref int instrIndex) {
+		protected override Instruction OnAfterLoadArg(MethodDef methodToInline, Instruction instr, ref int instrIndex) {
 			if (instr.OpCode.Code != Code.Box)
 				return instr;
 			if (methodToInline.MethodSig.GetGenParamCount() == 0)
 				return instr;
-			return DotNetUtils.getInstruction(methodToInline.Body.Instructions, ref instrIndex);
+			return DotNetUtils.GetInstruction(methodToInline.Body.Instructions, ref instrIndex);
 		}
 
-		bool inlineMethod(MethodDef methodToInline, int instrIndex, int const1, int const2) {
-			this.methodToInline = methodToInline = cflowDeobfuscator.deobfuscate(methodToInline);
+		bool InlineMethod(MethodDef methodToInline, int instrIndex, int const1, int const2) {
+			this.methodToInline = methodToInline = cflowDeobfuscator.Deobfuscate(methodToInline);
 
 			parameters = methodToInline.Parameters;
 			arg1 = parameters[parameters.Count - 2];
 			arg2 = parameters[parameters.Count - 1];
 			returnValue = null;
 
-			instructionEmulator.init(methodToInline);
+			instructionEmulator.Initialize(methodToInline);
 			foreach (var arg in parameters) {
 				if (!arg.IsNormalMethodParameter)
 					continue;
 				if (arg.Type.ElementType >= ElementType.Boolean && arg.Type.ElementType <= ElementType.U4)
-					instructionEmulator.setArg(arg, new Int32Value(0));
+					instructionEmulator.SetArg(arg, new Int32Value(0));
 			}
-			instructionEmulator.setArg(arg1, new Int32Value(const1));
-			instructionEmulator.setArg(arg2, new Int32Value(const2));
+			instructionEmulator.SetArg(arg1, new Int32Value(const1));
+			instructionEmulator.SetArg(arg2, new Int32Value(const2));
 
 			int index = 0;
-			if (!emulateInstructions(ref index, false))
+			if (!EmulateInstructions(ref index, false))
 				return false;
-			var patcher = tryInlineOtherMethod(instrIndex, methodToInline, methodToInline.Body.Instructions[index], index + 1, 2);
+			var patcher = TryInlineOtherMethod(instrIndex, methodToInline, methodToInline.Body.Instructions[index], index + 1, 2);
 			if (patcher == null)
 				return false;
-			if (!emulateToReturn(patcher.afterIndex, patcher.lastInstr))
+			if (!EmulateToReturn(patcher.afterIndex, patcher.lastInstr))
 				return false;
-			patcher.patch(block);
-			block.insert(instrIndex, OpCodes.Pop.ToInstruction());
-			block.insert(instrIndex, OpCodes.Pop.ToInstruction());
+			patcher.Patch(block);
+			block.Insert(instrIndex, OpCodes.Pop.ToInstruction());
+			block.Insert(instrIndex, OpCodes.Pop.ToInstruction());
 			return true;
 		}
 
-		bool emulateInstructions(ref int index, bool allowUnknownArgs) {
+		bool EmulateInstructions(ref int index, bool allowUnknownArgs) {
 			Instruction instr;
 			var instrs = methodToInline.Body.Instructions;
 			int counter = 0;
@@ -161,7 +161,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				case Code.Mul:
 				case Code.Rem:
 				case Code.Div:
-					instructionEmulator.emulate(instr);
+					instructionEmulator.Emulate(instr);
 					index++;
 					break;
 
@@ -177,7 +177,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 							goto done;
 						checkInstrs = true;
 					}
-					instructionEmulator.emulate(instr);
+					instructionEmulator.Emulate(instr);
 					index++;
 					break;
 
@@ -187,8 +187,8 @@ namespace de4dot.code.deobfuscators.DeepSea {
 					goto done;
 
 				case Code.Switch:
-					var value = instructionEmulator.pop() as Int32Value;
-					if (value == null || !value.allBitsValid())
+					var value = instructionEmulator.Pop() as Int32Value;
+					if (value == null || !value.AllBitsValid())
 						return false;
 					var targets = (Instruction[])instr.Operand;
 					if (value.value >= 0 && value.value < targets.Length)
@@ -204,21 +204,21 @@ namespace de4dot.code.deobfuscators.DeepSea {
 
 				case Code.Brtrue:
 				case Code.Brtrue_S:
-					index = emulateBrtrue(index);
+					index = EmulateBrtrue(index);
 					break;
 
 				case Code.Brfalse:
 				case Code.Brfalse_S:
-					index = emulateBrfalse(index);
+					index = EmulateBrfalse(index);
 					break;
 
 				case Code.Isinst:
 				case Code.Castclass:
-					if (returnValue != null && instructionEmulator.peek() == returnValue) {
+					if (returnValue != null && instructionEmulator.Peek() == returnValue) {
 						// Do nothing
 					}
 					else
-						instructionEmulator.emulate(instr);
+						instructionEmulator.Emulate(instr);
 					index++;
 					break;
 
@@ -250,50 +250,50 @@ done:
 			return true;
 		}
 
-		int emulateBranch(int stackArgs, Bool3 cond, Instruction instrTrue, Instruction instrFalse) {
+		int EmulateBranch(int stackArgs, Bool3 cond, Instruction instrTrue, Instruction instrFalse) {
 			if (cond == Bool3.Unknown)
 				return -1;
 			Instruction instr = cond == Bool3.True ? instrTrue : instrFalse;
 			return methodToInline.Body.Instructions.IndexOf(instr);
 		}
 
-		int emulateBrtrue(int instrIndex) {
-			var val1 = instructionEmulator.pop();
+		int EmulateBrtrue(int instrIndex) {
+			var val1 = instructionEmulator.Pop();
 
 			var instr = methodToInline.Body.Instructions[instrIndex];
 			var instrTrue = (Instruction)instr.Operand;
 			var instrFalse = methodToInline.Body.Instructions[instrIndex + 1];
 
-			if (val1.isInt32())
-				return emulateBranch(1, Int32Value.compareTrue((Int32Value)val1), instrTrue, instrFalse);
+			if (val1.IsInt32())
+				return EmulateBranch(1, Int32Value.CompareTrue((Int32Value)val1), instrTrue, instrFalse);
 			return -1;
 		}
 
-		int emulateBrfalse(int instrIndex) {
-			var val1 = instructionEmulator.pop();
+		int EmulateBrfalse(int instrIndex) {
+			var val1 = instructionEmulator.Pop();
 
 			var instr = methodToInline.Body.Instructions[instrIndex];
 			var instrTrue = (Instruction)instr.Operand;
 			var instrFalse = methodToInline.Body.Instructions[instrIndex + 1];
 
-			if (val1.isInt32())
-				return emulateBranch(1, Int32Value.compareFalse((Int32Value)val1), instrTrue, instrFalse);
+			if (val1.IsInt32())
+				return EmulateBranch(1, Int32Value.CompareFalse((Int32Value)val1), instrTrue, instrFalse);
 			return -1;
 		}
 
-		bool emulateToReturn(int index, Instruction lastInstr) {
+		bool EmulateToReturn(int index, Instruction lastInstr) {
 			int pushes, pops;
 			lastInstr.CalculateStackUsage(false, out pushes, out pops);
-			instructionEmulator.pop(pops);
+			instructionEmulator.Pop(pops);
 
 			returnValue = null;
 			if (pushes != 0) {
 				returnValue = new UnknownValue();
-				instructionEmulator.setProtected(returnValue);
-				instructionEmulator.push(returnValue);
+				instructionEmulator.SetProtected(returnValue);
+				instructionEmulator.Push(returnValue);
 			}
 
-			if (!emulateInstructions(ref index, true))
+			if (!EmulateInstructions(ref index, true))
 				return false;
 			if (index >= methodToInline.Body.Instructions.Count)
 				return false;
@@ -301,13 +301,13 @@ done:
 				return false;
 
 			if (returnValue != null) {
-				if (instructionEmulator.pop() != returnValue)
+				if (instructionEmulator.Pop() != returnValue)
 					return false;
 			}
-			return instructionEmulator.stackSize() == 0;
+			return instructionEmulator.StackSize() == 0;
 		}
 
-		public static bool canInline(MethodDef method) {
+		public static bool CanInline(MethodDef method) {
 			if (method == null || method.Body == null)
 				return false;
 			if (method.Attributes != (MethodAttributes.Assembly | MethodAttributes.Static))
@@ -329,21 +329,21 @@ done:
 
 			var param1 = parameters[paramCount - 1];
 			var param2 = parameters[paramCount - 2];
-			if (!isIntType(param1.ElementType))
+			if (!IsIntType(param1.ElementType))
 				return false;
-			if (!isIntType(param2.ElementType))
+			if (!IsIntType(param2.ElementType))
 				return false;
 
 			return true;
 		}
 
-		static bool isIntType(ElementType etype) {
+		static bool IsIntType(ElementType etype) {
 			return etype == ElementType.Char || etype == ElementType.I2 || etype == ElementType.I4;
 		}
 
-		protected override bool isReturn(MethodDef methodToInline, int instrIndex) {
+		protected override bool IsReturn(MethodDef methodToInline, int instrIndex) {
 			int oldIndex = instrIndex;
-			if (base.isReturn(methodToInline, oldIndex))
+			if (base.IsReturn(methodToInline, oldIndex))
 				return true;
 
 			return false;
diff --git a/de4dot.code/deobfuscators/DeepSea/DsUtils.cs b/de4dot.code/deobfuscators/DeepSea/DsUtils.cs
index 0be027d5..0392d8b0 100644
--- a/de4dot.code/deobfuscators/DeepSea/DsUtils.cs
+++ b/de4dot.code/deobfuscators/DeepSea/DsUtils.cs
@@ -24,27 +24,27 @@ using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.DeepSea {
 	static class DsUtils {
-		public static IList<object> getArgValues(IList<Instruction> instrs, int index) {
-			return getArgValues(DotNetUtils.getArgPushes(instrs, index));
+		public static IList<object> GetArgValues(IList<Instruction> instrs, int index) {
+			return GetArgValues(DotNetUtils.GetArgPushes(instrs, index));
 		}
 
-		public static IList<object> getArgValues(IList<Instruction> argInstrs) {
+		public static IList<object> GetArgValues(IList<Instruction> argInstrs) {
 			if (argInstrs == null)
 				return null;
 			var args = new List<object>(argInstrs.Count);
 			foreach (var argInstr in argInstrs) {
 				object arg;
-				getArgValue(argInstr, out arg);
+				GetArgValue(argInstr, out arg);
 				args.Add(arg);
 			}
 			return args;
 		}
 
-		public static bool getArgValue(MethodDef method, int index, out object arg) {
-			return getArgValue(method.Body.Instructions[index], out arg);
+		public static bool GetArgValue(MethodDef method, int index, out object arg) {
+			return GetArgValue(method.Body.Instructions[index], out arg);
 		}
 
-		public static bool getArgValue(Instruction instr, out object arg) {
+		public static bool GetArgValue(Instruction instr, out object arg) {
 			switch (instr.OpCode.Code) {
 			case Code.Ldc_I4_S: arg = (int)(sbyte)instr.Operand; return true;
 			case Code.Ldc_I4_M1: arg = -1; return true;
diff --git a/de4dot.code/deobfuscators/DeepSea/FieldsRestorer.cs b/de4dot.code/deobfuscators/DeepSea/FieldsRestorer.cs
index a501ae3a..603e2a9d 100644
--- a/de4dot.code/deobfuscators/DeepSea/FieldsRestorer.cs
+++ b/de4dot.code/deobfuscators/DeepSea/FieldsRestorer.cs
@@ -34,8 +34,8 @@ namespace de4dot.code.deobfuscators.DeepSea {
 		public List<TypeDef> FieldStructs {
 			get {
 				var list = new List<TypeDef>(structToOwners.Count);
-				foreach (var structType in structToOwners.getKeys()) {
-					if (!hasNoMethods(structType))
+				foreach (var structType in structToOwners.GetKeys()) {
+					if (!HasNoMethods(structType))
 						continue;
 
 					list.Add(structType);
@@ -44,7 +44,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			}
 		}
 
-		static bool hasNoMethods(TypeDef type) {
+		static bool HasNoMethods(TypeDef type) {
 			if (type.Methods.Count == 0)
 				return true;
 			if (type.BaseType == null)
@@ -63,39 +63,39 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			this.module = module;
 		}
 
-		public void initialize() {
-			foreach (var kv in getMovedTypes()) {
+		public void Initialize() {
+			foreach (var kv in GetMovedTypes()) {
 				var structType = kv.Key;
-				structToOwners.add(structType, kv.Value);
+				structToOwners.Add(structType, kv.Value);
 
 				foreach (var ownerType in kv.Value) {
 					foreach (var ownerField in ownerType.Fields) {
-						if (DotNetUtils.getType(module, ownerField.FieldSig.GetFieldType()) != structType)
+						if (DotNetUtils.GetType(module, ownerField.FieldSig.GetFieldType()) != structType)
 							continue;
-						structFieldsToFix.add(ownerField, true);
+						structFieldsToFix.Add(ownerField, true);
 						break;
 					}
 
 					var fieldsDict = new FieldDefAndDeclaringTypeDict<FieldDef>();
-					typeToFieldsDict.add(ownerType, fieldsDict);
+					typeToFieldsDict.Add(ownerType, fieldsDict);
 					foreach (var structField in structType.Fields) {
 						var newField = module.UpdateRowId(new FieldDefUser(structField.Name, structField.FieldSig.Clone(), structField.Attributes));
 						ownerType.Fields.Add(newField);
-						fieldsDict.add(structField, newField);
+						fieldsDict.Add(structField, newField);
 					}
 				}
 			}
 		}
 
-		Dictionary<TypeDef, List<TypeDef>> getMovedTypes() {
+		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.FieldSig.GetFieldType());
+				foreach (var field in GetPossibleFields(type)) {
+					var fieldType = DotNetUtils.GetType(module, field.FieldSig.GetFieldType());
 					if (fieldType == null)
 						continue;
-					if (!checkBaseType(fieldType))
+					if (!CheckBaseType(fieldType))
 						continue;
 					if ((fieldType.Attributes & ~TypeAttributes.Sealed) != TypeAttributes.NestedAssembly)
 						continue;
@@ -107,9 +107,9 @@ namespace de4dot.code.deobfuscators.DeepSea {
 						continue;
 					if (fieldType.HasEvents || fieldType.HasProperties || fieldType.HasInterfaces)
 						continue;
-					if (checkMethods(fieldType))
+					if (CheckMethods(fieldType))
 						continue;
-					if (!checkFields(fieldType))
+					if (!CheckFields(fieldType))
 						continue;
 
 					List<TypeDef> list;
@@ -127,15 +127,15 @@ namespace de4dot.code.deobfuscators.DeepSea {
 
 				foreach (var field in type.Fields) {
 					if (field.IsStatic || field.FieldSig.GetFieldType().TryGetTypeDef() != structType)
-						removeType(candidates, field.FieldSig.GetFieldType());
+						RemoveType(candidates, field.FieldSig.GetFieldType());
 				}
 				foreach (var method in type.Methods) {
-					removeType(candidates, method.MethodSig.GetRetType());
+					RemoveType(candidates, method.MethodSig.GetRetType());
 					foreach (var parameter in method.MethodSig.GetParams())
-						removeType(candidates, parameter);
+						RemoveType(candidates, parameter);
 					if (method.Body != null) {
 						foreach (var local in method.Body.Variables)
-							removeType(candidates, local.Type);
+							RemoveType(candidates, local.Type);
 					}
 				}
 			}
@@ -143,43 +143,43 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return candidates;
 		}
 
-		IEnumerable<FieldDef> getPossibleFields(TypeDef type) {
+		IEnumerable<FieldDef> GetPossibleFields(TypeDef type) {
 			var typeToFields = new TypeDefDict<List<FieldDef>>();
 			foreach (var field in type.Fields) {
 				if (field.Attributes != FieldAttributes.Private)
 					continue;
-				var fieldType = DotNetUtils.getType(module, field.FieldSig.GetFieldType());
+				var fieldType = DotNetUtils.GetType(module, field.FieldSig.GetFieldType());
 				if (fieldType == null)
 					continue;
-				if (!checkBaseType(fieldType))
+				if (!CheckBaseType(fieldType))
 					continue;
-				var list = typeToFields.find(fieldType);
+				var list = typeToFields.Find(fieldType);
 				if (list == null)
-					typeToFields.add(fieldType, list = new List<FieldDef>());
+					typeToFields.Add(fieldType, list = new List<FieldDef>());
 				list.Add(field);
 			}
 
-			foreach (var list in typeToFields.getValues()) {
+			foreach (var list in typeToFields.GetValues()) {
 				if (list.Count == 1)
 					yield return list[0];
 			}
 		}
 
-		static bool checkBaseType(TypeDef type) {
+		static bool CheckBaseType(TypeDef type) {
 			if (type == null || type.BaseType == null)
 				return false;
 			var fn = type.BaseType.FullName;
 			return fn == "System.ValueType" || fn == "System.Object";
 		}
 
-		void removeType(Dictionary<TypeDef, List<TypeDef>> candidates, TypeSig type) {
-			var typeDef = DotNetUtils.getType(module, 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(TypeDef type) {
+		static bool CheckMethods(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (method.Name == ".cctor")
 					continue;
@@ -197,7 +197,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return false;
 		}
 
-		static bool checkFields(TypeDef type) {
+		static bool CheckFields(TypeDef type) {
 			if (type.Fields.Count == 0)
 				return false;
 			foreach (var field in type.Fields) {
@@ -209,14 +209,14 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return true;
 		}
 
-		public void deobfuscate(Blocks blocks) {
-			deobfuscateNormal(blocks);
-			fixFieldCtorCalls(blocks);
+		public void Deobfuscate(Blocks blocks) {
+			DeobfuscateNormal(blocks);
+			FixFieldCtorCalls(blocks);
 		}
 
-		void deobfuscateNormal(Blocks blocks) {
+		void DeobfuscateNormal(Blocks blocks) {
 			var instrsToRemove = new List<int>();
-			foreach (var block in blocks.MethodBlocks.getAllBlocks()) {
+			foreach (var block in blocks.MethodBlocks.GetAllBlocks()) {
 				instrsToRemove.Clear();
 				var instrs = block.Instructions;
 				for (int i = instrs.Count - 1; i >= 0; i--) {
@@ -224,23 +224,23 @@ namespace de4dot.code.deobfuscators.DeepSea {
 					if (instr.OpCode.Code != Code.Ldflda && instr.OpCode.Code != Code.Ldfld)
 						continue;
 					var structField = instr.Operand as IField;
-					if (structField == null || !structFieldsToFix.find(structField))
+					if (structField == null || !structFieldsToFix.Find(structField))
 						continue;
 
-					var ldStFld = instrs[findLdStFieldIndex(instrs, i + 1)];
-					ldStFld.Operand = getNewField(structField, ldStFld.Operand as IField);
+					var ldStFld = instrs[FindLdStFieldIndex(instrs, i + 1)];
+					ldStFld.Operand = GetNewField(structField, ldStFld.Operand as IField);
 					instrsToRemove.Add(i);
 				}
 				if (instrsToRemove.Count > 0)
-					block.remove(instrsToRemove);
+					block.Remove(instrsToRemove);
 			}
 		}
 
-		void fixFieldCtorCalls(Blocks blocks) {
+		void FixFieldCtorCalls(Blocks blocks) {
 			if (blocks.Method.Name != ".ctor")
 				return;
 			var instrsToRemove = new List<int>();
-			foreach (var block in blocks.MethodBlocks.getAllBlocks()) {
+			foreach (var block in blocks.MethodBlocks.GetAllBlocks()) {
 				var instrs = block.Instructions;
 				for (int i = 0; i < instrs.Count; i++) {
 					var stfld = instrs[i];
@@ -249,38 +249,38 @@ namespace de4dot.code.deobfuscators.DeepSea {
 					var field = stfld.Operand as IField;
 					if (field == null)
 						continue;
-					if (!structFieldsToFix.find(field))
+					if (!structFieldsToFix.Find(field))
 						continue;
-					var instrs2 = toInstructionList(instrs);
-					var instrPushes = DotNetUtils.getArgPushes(instrs2, i);
+					var instrs2 = ToInstructionList(instrs);
+					var instrPushes = DotNetUtils.GetArgPushes(instrs2, i);
 					if (instrPushes == null || instrPushes.Count != 2)
 						continue;
-					block.remove(i, 1);
-					block.remove(instrs2.IndexOf(instrPushes[1]), 1);
-					block.remove(instrs2.IndexOf(instrPushes[0]), 1);
+					block.Remove(i, 1);
+					block.Remove(instrs2.IndexOf(instrPushes[1]), 1);
+					block.Remove(instrs2.IndexOf(instrPushes[0]), 1);
 					i -= 3;
 				}
 			}
 		}
 
-		static IList<Instruction> toInstructionList(IEnumerable<Instr> instrs) {
+		static IList<Instruction> ToInstructionList(IEnumerable<Instr> instrs) {
 			var newInstrs = new List<Instruction>();
 			foreach (var instr in instrs)
 				newInstrs.Add(instr.Instruction);
 			return newInstrs;
 		}
 
-		FieldDef getNewField(IField structField, IField oldFieldRef) {
-			var fieldsDict = typeToFieldsDict.find(structField.DeclaringType);
+		FieldDef GetNewField(IField structField, IField oldFieldRef) {
+			var fieldsDict = typeToFieldsDict.Find(structField.DeclaringType);
 			if (fieldsDict == null)
 				throw new ApplicationException("Could not find structField declaringType");
-			var newField = fieldsDict.find(oldFieldRef);
+			var newField = fieldsDict.Find(oldFieldRef);
 			if (newField == null)
 				throw new ApplicationException("Could not find new field");
 			return newField;
 		}
 
-		static int findLdStFieldIndex(IList<Instr> instrs, int index) {
+		static int FindLdStFieldIndex(IList<Instr> instrs, int index) {
 			int stack = 0;
 			for (int i = index; i < instrs.Count; i++) {
 				var instr = instrs[i];
@@ -300,8 +300,8 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			throw new ApplicationException("Could not find ldfld/stfld");
 		}
 
-		public void cleanUp() {
-			foreach (var field in structFieldsToFix.getKeys())
+		public void CleanUp() {
+			foreach (var field in structFieldsToFix.GetKeys())
 				field.DeclaringType.Fields.Remove(field);
 		}
 	}
diff --git a/de4dot.code/deobfuscators/DeepSea/ResolverBase.cs b/de4dot.code/deobfuscators/DeepSea/ResolverBase.cs
index c25d8d5e..a4c291e0 100644
--- a/de4dot.code/deobfuscators/DeepSea/ResolverBase.cs
+++ b/de4dot.code/deobfuscators/DeepSea/ResolverBase.cs
@@ -46,36 +46,36 @@ namespace de4dot.code.deobfuscators.DeepSea {
 
 		public ResolverBase(ModuleDefMD module, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
 			this.module = module;
-			this.frameworkType = DotNetUtils.getFrameworkType(module);
+			this.frameworkType = DotNetUtils.GetFrameworkType(module);
 			this.simpleDeobfuscator = simpleDeobfuscator;
 			this.deob = deob;
 		}
 
-		public void find() {
-			if (checkCalledMethods(DotNetUtils.getModuleTypeCctor(module)))
+		public void Find() {
+			if (CheckCalledMethods(DotNetUtils.GetModuleTypeCctor(module)))
 				return;
-			if (checkCalledMethods(module.EntryPoint))
+			if (CheckCalledMethods(module.EntryPoint))
 				return;
 		}
 
-		bool checkCalledMethods(MethodDef checkMethod) {
+		bool CheckCalledMethods(MethodDef checkMethod) {
 			if (checkMethod == null || checkMethod.Body == null)
 				return false;
 
-			foreach (var method in DotNetUtils.getCalledMethods(module, checkMethod)) {
+			foreach (var method in DotNetUtils.GetCalledMethods(module, checkMethod)) {
 				if (method.Name == ".cctor" || method.Name == ".ctor")
 					continue;
-				if (!method.IsStatic || !DotNetUtils.isMethod(method, "System.Void", "()"))
+				if (!method.IsStatic || !DotNetUtils.IsMethod(method, "System.Void", "()"))
 					continue;
 
-				if (checkResolverInitMethod(method))
+				if (CheckResolverInitMethod(method))
 					return true;
 			}
 
 			return false;
 		}
 
-		bool checkResolverInitMethod(MethodDef resolverInitMethod) {
+		bool CheckResolverInitMethod(MethodDef resolverInitMethod) {
 			if (resolverInitMethod == null || resolverInitMethod.Body == null)
 				return false;
 			if (resolverInitMethod.Body.ExceptionHandlers.Count != 1)
@@ -83,19 +83,19 @@ namespace de4dot.code.deobfuscators.DeepSea {
 
 			switch (frameworkType) {
 			case FrameworkType.Silverlight:
-				return checkResolverInitMethodSilverlight(resolverInitMethod);
+				return CheckResolverInitMethodSilverlight(resolverInitMethod);
 			default:
-				return checkResolverInitMethodDesktop(resolverInitMethod);
+				return CheckResolverInitMethodDesktop(resolverInitMethod);
 			}
 		}
 
-		bool checkResolverInitMethodDesktop(MethodDef resolverInitMethod) {
-			simpleDeobfuscator.deobfuscate(resolverInitMethod);
-			if (!checkResolverInitMethodInternal(resolverInitMethod))
+		bool CheckResolverInitMethodDesktop(MethodDef resolverInitMethod) {
+			simpleDeobfuscator.Deobfuscate(resolverInitMethod);
+			if (!CheckResolverInitMethodInternal(resolverInitMethod))
 				return false;
 
-			foreach (var resolveHandlerMethod in getLdftnMethods(resolverInitMethod)) {
-				if (!checkHandlerMethodDesktop(resolveHandlerMethod))
+			foreach (var resolveHandlerMethod in GetLdftnMethods(resolverInitMethod)) {
+				if (!CheckHandlerMethodDesktop(resolveHandlerMethod))
 					continue;
 
 				initMethod = resolverInitMethod;
@@ -106,13 +106,13 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return false;
 		}
 
-		protected virtual bool checkResolverInitMethodSilverlight(MethodDef resolverInitMethod) {
+		protected virtual bool CheckResolverInitMethodSilverlight(MethodDef resolverInitMethod) {
 			return false;
 		}
 
-		protected abstract bool checkResolverInitMethodInternal(MethodDef resolverInitMethod);
+		protected abstract bool CheckResolverInitMethodInternal(MethodDef resolverInitMethod);
 
-		IEnumerable<MethodDef> getLdftnMethods(MethodDef method) {
+		IEnumerable<MethodDef> GetLdftnMethods(MethodDef method) {
 			var list = new List<MethodDef>();
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Ldftn)
@@ -124,59 +124,59 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return list;
 		}
 
-		bool checkHandlerMethodDesktop(MethodDef 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)"))
+			if (!DotNetUtils.IsMethod(handler, "System.Reflection.Assembly", "(System.Object,System.ResolveEventArgs)"))
 				return false;
-			return checkHandlerMethodDesktopInternal(handler);
+			return CheckHandlerMethodDesktopInternal(handler);
 		}
 
-		protected abstract bool checkHandlerMethodDesktopInternal(MethodDef handler);
+		protected abstract bool CheckHandlerMethodDesktopInternal(MethodDef handler);
 
 		// 3.0.3.41 - 3.0.4.44
-		protected static byte[] decryptResourceV3Old(EmbeddedResource resource) {
-			return decryptResourceV3Old(resource.GetResourceData());
+		protected static byte[] DecryptResourceV3Old(EmbeddedResource resource) {
+			return DecryptResourceV3Old(resource.GetResourceData());
 		}
 
 		// 3.0.3.41 - 3.0.4.44
-		protected static byte[] decryptResourceV3Old(byte[] data) {
-			return decryptResource(data, 0, data.Length, 0);
+		protected static byte[] DecryptResourceV3Old(byte[] data) {
+			return DecryptResource(data, 0, data.Length, 0);
 		}
 
-		protected static byte[] decryptResourceV41SL(EmbeddedResource resource) {
+		protected static byte[] DecryptResourceV41SL(EmbeddedResource resource) {
 			var data = resource.GetResourceData();
 			byte k = data[0];
 			for (int i = 0; i < data.Length - 1; i++)
 				data[i + 1] ^= (byte)((k << (i & 5)) + i);
-			return inflateIfNeeded(data, 1, data.Length - 1);
+			return InflateIfNeeded(data, 1, data.Length - 1);
 		}
 
-		protected static byte[] decryptResourceV3(EmbeddedResource resource) {
-			return decryptResourceV3(resource.GetResourceData());
+		protected static byte[] DecryptResourceV3(EmbeddedResource resource) {
+			return DecryptResourceV3(resource.GetResourceData());
 		}
 
-		protected static byte[] decryptResourceV3(byte[] data) {
-			return decryptResource(data, 1, data.Length - 1, data[0]);
+		protected static byte[] DecryptResourceV3(byte[] data) {
+			return DecryptResource(data, 1, data.Length - 1, data[0]);
 		}
 
-		protected static byte[] decryptResourceV4(byte[] data, int magic) {
-			return decryptResource(data, 0, data.Length, magic);
+		protected static byte[] DecryptResourceV4(byte[] data, int magic) {
+			return DecryptResource(data, 0, data.Length, magic);
 		}
 
-		protected static byte[] decryptResource(byte[] data, int start, int len, int magic) {
+		protected static byte[] DecryptResource(byte[] data, int start, int len, int magic) {
 			for (int i = start; i < start + len; i++)
 				data[i] ^= (byte)(i - start + magic);
-			return inflateIfNeeded(data, start, len);
+			return InflateIfNeeded(data, start, len);
 		}
 
-		protected static byte[] inflateIfNeeded(byte[] data) {
-			return inflateIfNeeded(data, 0, data.Length);
+		protected static byte[] InflateIfNeeded(byte[] data) {
+			return InflateIfNeeded(data, 0, data.Length);
 		}
 
-		protected static byte[] inflateIfNeeded(byte[] data, int start, int len) {
+		protected static byte[] InflateIfNeeded(byte[] data, int start, int len) {
 			if (BitConverter.ToInt16(data, start) != 0x5A4D)
-				return DeobUtils.inflate(data, start, len, true);
+				return DeobUtils.Inflate(data, start, len, true);
 
 			var data2 = new byte[len];
 			Array.Copy(data, start, data2, 0, data2.Length);
diff --git a/de4dot.code/deobfuscators/DeepSea/ResourceResolver.cs b/de4dot.code/deobfuscators/DeepSea/ResourceResolver.cs
index 685c237b..5301f666 100644
--- a/de4dot.code/deobfuscators/DeepSea/ResourceResolver.cs
+++ b/de4dot.code/deobfuscators/DeepSea/ResourceResolver.cs
@@ -87,25 +87,25 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			: base(module, simpleDeobfuscator, deob) {
 		}
 
-		protected override bool checkResolverInitMethodInternal(MethodDef resolverInitMethod) {
-			return DotNetUtils.callsMethod(resolverInitMethod, "System.Void System.AppDomain::add_ResourceResolve(System.ResolveEventHandler)");
+		protected override bool CheckResolverInitMethodInternal(MethodDef resolverInitMethod) {
+			return DotNetUtils.CallsMethod(resolverInitMethod, "System.Void System.AppDomain::add_ResourceResolve(System.ResolveEventHandler)");
 		}
 
-		protected override bool checkHandlerMethodDesktopInternal(MethodDef handler) {
-			if (checkHandlerV3(handler)) {
+		protected override bool CheckHandlerMethodDesktopInternal(MethodDef handler) {
+			if (CheckHandlerV3(handler)) {
 				version = ResourceVersion.V3;
 				return true;
 			}
 
-			simpleDeobfuscator.deobfuscate(handler);
-			if ((data40 = checkHandlerV40(handler)) != null) {
+			simpleDeobfuscator.Deobfuscate(handler);
+			if ((data40 = CheckHandlerV40(handler)) != null) {
 				version = ResourceVersion.V40;
 				return true;
 			}
 
-			var info = getHandlerArgs41(handler);
+			var info = GetHandlerArgs41(handler);
 			Data41 data41Tmp;
-			if (info != null && checkHandlerV41(info, out data41Tmp)) {
+			if (info != null && CheckHandlerV41(info, out data41Tmp)) {
 				version = ResourceVersion.V41;
 				data41 = data41Tmp;
 				return true;
@@ -114,7 +114,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return false;
 		}
 
-		HandlerInfo getHandlerArgs41(MethodDef handler) {
+		HandlerInfo GetHandlerArgs41(MethodDef handler) {
 			var instrs = handler.Body.Instructions;
 			for (int i = 0; i < instrs.Count; i++) {
 				var instr = instrs[i];
@@ -123,9 +123,9 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				var calledMethod = instr.Operand as MethodDef;
 				if (calledMethod == null)
 					continue;
-				if (getLdtokenField(calledMethod) == null)
+				if (GetLdtokenField(calledMethod) == null)
 					continue;
-				var args = DsUtils.getArgValues(instrs, i);
+				var args = DsUtils.GetArgValues(instrs, i);
 				if (args == null)
 					continue;
 
@@ -134,16 +134,16 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return null;
 		}
 
-		bool checkHandlerV41(HandlerInfo info, out Data41 data41) {
+		bool CheckHandlerV41(HandlerInfo info, out Data41 data41) {
 			data41 = new Data41();
 			data41.resolveHandler2 = info.handler;
-			data41.resourceField = getLdtokenField(info.handler);
+			data41.resourceField = GetLdtokenField(info.handler);
 			if (data41.resourceField == null)
 				return false;
 			bool isOtherRetail;
-			int magicArgIndex = getMagicArgIndex41Retail(info.handler, out isOtherRetail);
+			int magicArgIndex = GetMagicArgIndex41Retail(info.handler, out isOtherRetail);
 			if (magicArgIndex < 0) {
-				magicArgIndex = getMagicArgIndex41Trial(info.handler);
+				magicArgIndex = GetMagicArgIndex41Trial(info.handler);
 				data41.isTrial = true;
 			}
 			var asmVer = module.Assembly.Version;
@@ -161,7 +161,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return true;
 		}
 
-		static int getMagicArgIndex41Retail(MethodDef method, out bool isOtherRetail) {
+		static int GetMagicArgIndex41Retail(MethodDef method, out bool isOtherRetail) {
 			isOtherRetail = false;
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 4; i++) {
@@ -191,7 +191,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return -1;
 		}
 
-		static int getMagicArgIndex41Trial(MethodDef method) {
+		static int GetMagicArgIndex41Trial(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 2; i++) {
 				var ldarg = instrs[i];
@@ -207,7 +207,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return -1;
 		}
 
-		static FieldDef getLdtokenField(MethodDef method) {
+		static FieldDef GetLdtokenField(MethodDef method) {
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Ldtoken)
 					continue;
@@ -231,11 +231,11 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			"System.String",
 			"System.String[]",
 		};
-		static bool checkHandlerV3(MethodDef handler) {
-			return new LocalTypes(handler).all(handlerLocalTypes_V3);
+		static bool CheckHandlerV3(MethodDef handler) {
+			return new LocalTypes(handler).All(handlerLocalTypes_V3);
 		}
 
-		static Data40 checkHandlerV40(MethodDef handler) {
+		static Data40 CheckHandlerV40(MethodDef handler) {
 			var data40 = new Data40();
 
 			var instrs = handler.Body.Instructions;
@@ -254,9 +254,9 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				var method = ldtoken.Operand as MethodDef;
 				if (method != null) {
 					// >= 4.0.4
-					if (!DotNetUtils.isMethod(method, "System.Byte[]", "()"))
+					if (!DotNetUtils.IsMethod(method, "System.Byte[]", "()"))
 						continue;
-					field = getResourceField(method);
+					field = GetResourceField(method);
 					methodSig = "(System.ResolveEventArgs,System.RuntimeMethodHandle,System.Int32,System.String,System.Int32)";
 				}
 				else {
@@ -286,7 +286,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				if (call.OpCode.Code != Code.Call)
 					continue;
 				var resolveHandler2 = call.Operand as MethodDef;
-				if (!DotNetUtils.isMethod(resolveHandler2, "System.Reflection.Assembly", methodSig))
+				if (!DotNetUtils.IsMethod(resolveHandler2, "System.Reflection.Assembly", methodSig))
 					continue;
 
 				data40.resourceField = field;
@@ -298,7 +298,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return null;
 		}
 
-		static FieldDef getResourceField(MethodDef method) {
+		static FieldDef GetResourceField(MethodDef method) {
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Ldtoken)
 					continue;
@@ -310,15 +310,15 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return null;
 		}
 
-		public void initialize() {
+		public void Initialize() {
 			if (resolveHandler == null)
 				return;
 
 			if (version == ResourceVersion.V3) {
-				simpleDeobfuscator.deobfuscate(resolveHandler);
-				simpleDeobfuscator.decryptStrings(resolveHandler, deob);
+				simpleDeobfuscator.Deobfuscate(resolveHandler);
+				simpleDeobfuscator.DecryptStrings(resolveHandler, deob);
 				data30 = new Data30();
-				data30.resource = DeobUtils.getEmbeddedResourceFromCodeStrings(module, resolveHandler);
+				data30.resource = DeobUtils.GetEmbeddedResourceFromCodeStrings(module, resolveHandler);
 				if (data30.resource == null) {
 					Logger.w("Could not find resource of encrypted resources");
 					return;
@@ -326,7 +326,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			}
 		}
 
-		public bool mergeResources(out EmbeddedResource rsrc) {
+		public bool MergeResources(out EmbeddedResource rsrc) {
 			rsrc = null;
 
 			switch (version) {
@@ -334,27 +334,27 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				if (data30.resource == null)
 					return false;
 
-				DeobUtils.decryptAndAddResources(module, data30.resource.Name.String, () => decryptResourceV3(data30.resource));
+				DeobUtils.DecryptAndAddResources(module, data30.resource.Name.String, () => DecryptResourceV3(data30.resource));
 				rsrc = data30.resource;
 				return true;
 
 			case ResourceVersion.V40:
-				return decryptResource(data40.resourceField, data40.magic);
+				return DecryptResource(data40.resourceField, data40.magic);
 
 			case ResourceVersion.V41:
-				return decryptResource(data41.resourceField, data41.magic);
+				return DecryptResource(data41.resourceField, data41.magic);
 
 			default:
 				return true;
 			}
 		}
 
-		bool decryptResource(FieldDef 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.MDToken.ToInt32(), (uint)resourceField.RVA);
-			DeobUtils.decryptAndAddResources(module, name, () => decryptResourceV4(resourceField.InitialValue, magic));
+			DeobUtils.DecryptAndAddResources(module, name, () => DecryptResourceV4(resourceField.InitialValue, magic));
 			resourceField.InitialValue = new byte[1];
 			resourceField.FieldSig.Type = module.CorLibTypes.Byte;
 			resourceField.RVA = 0;
diff --git a/de4dot.code/deobfuscators/DeepSea/StringDecrypter.cs b/de4dot.code/deobfuscators/DeepSea/StringDecrypter.cs
index 43a14e77..13c241d4 100644
--- a/de4dot.code/deobfuscators/DeepSea/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/DeepSea/StringDecrypter.cs
@@ -40,17 +40,17 @@ namespace de4dot.code.deobfuscators.DeepSea {
 		interface IDecrypterInfo {
 			DecrypterVersion Version { get; }
 			MethodDef Method { get; }
-			string decrypt(object[] args);
-			void cleanup();
+			string Decrypt(object[] args);
+			void CleanUp();
 		}
 
-		static short[] findKey(MethodDef initMethod, FieldDef keyField) {
+		static short[] FindKey(MethodDef initMethod, FieldDef keyField) {
 			var fields = new FieldDefAndDeclaringTypeDict<bool>();
-			fields.add(keyField, true);
-			return findKey(initMethod, fields);
+			fields.Add(keyField, true);
+			return FindKey(initMethod, fields);
 		}
 
-		static short[] findKey(MethodDef initMethod, FieldDefAndDeclaringTypeDict<bool> fields) {
+		static short[] FindKey(MethodDef initMethod, FieldDefAndDeclaringTypeDict<bool> fields) {
 			var instrs = initMethod.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 2; i++) {
 				var ldci4 = instrs[i];
@@ -69,21 +69,21 @@ namespace de4dot.code.deobfuscators.DeepSea {
 
 				int startInitIndex = i;
 				i++;
-				var array = ArrayFinder.getInitializedInt16Array(ldci4.GetLdcI4Value(), initMethod, ref i);
+				var array = ArrayFinder.GetInitializedInt16Array(ldci4.GetLdcI4Value(), initMethod, ref i);
 				if (array == null)
 					continue;
 
-				var field = getStoreField(initMethod, startInitIndex, local);
+				var field = GetStoreField(initMethod, startInitIndex, local);
 				if (field == null)
 					continue;
-				if (fields.find(field))
+				if (fields.Find(field))
 					return array;
 			}
 
 			return null;
 		}
 
-		static FieldDef getStoreField(MethodDef method, int startIndex, Local 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];
@@ -101,12 +101,12 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return null;
 		}
 
-		static bool findMagic(MethodDef method, out int magic) {
+		static bool FindMagic(MethodDef method, out int magic) {
 			int arg1, arg2;
-			return findMagic(method, out arg1, out arg2, out magic);
+			return FindMagic(method, out arg1, out arg2, out magic);
 		}
 
-		static bool findMagic(MethodDef 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 = instrs[i].GetParameterIndex()) < 0)
@@ -126,7 +126,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return false;
 		}
 
-		static void removeInitializeArrayCall(MethodDef method, FieldDef 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];
@@ -192,17 +192,17 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				Method = method;
 			}
 
-			public static bool isPossibleDecrypterMethod(MethodDef method, ref bool? state) {
-				if (!checkMethodSignature(method))
+			public static bool IsPossibleDecrypterMethod(MethodDef method, ref bool? state) {
+				if (!CheckMethodSignature(method))
 					return false;
-				var fields = getFields(method);
+				var fields = GetFields(method);
 				if (fields == null || fields.Count != 3)
 					return false;
 
 				return true;
 			}
 
-			static bool checkMethodSignature(MethodDef method) {
+			static bool CheckMethodSignature(MethodDef method) {
 				if (method.MethodSig.GetRetType().GetElementType() != ElementType.String)
 					return false;
 				int count = 0;
@@ -213,7 +213,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return count >= 2;
 			}
 
-			static FieldDefAndDeclaringTypeDict<bool> getFields(MethodDef method) {
+			static FieldDefAndDeclaringTypeDict<bool> GetFields(MethodDef method) {
 				var fields = new FieldDefAndDeclaringTypeDict<bool>();
 				foreach (var instr in method.Body.Instructions) {
 					if (instr.OpCode.Code != Code.Ldsfld && instr.OpCode.Code != Code.Stsfld)
@@ -223,20 +223,20 @@ namespace de4dot.code.deobfuscators.DeepSea {
 						continue;
 					if (field.DeclaringType != method.DeclaringType)
 						continue;
-					fields.add(field, true);
+					fields.Add(field, true);
 				}
 				return fields;
 			}
 
-			public bool initialize() {
-				if (!findMagic(Method, out arg1, out arg2, out magic))
+			public bool Initialize() {
+				if (!FindMagic(Method, out arg1, out arg2, out magic))
 					return false;
 
-				fields = getFields(Method);
+				fields = GetFields(Method);
 				if (fields == null)
 					return false;
 
-				arrayInfo = getArrayInfo(cctor);
+				arrayInfo = GetArrayInfo(cctor);
 				if (arrayInfo == null)
 					return false;
 
@@ -245,24 +245,24 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				encryptedData = new ushort[arrayInfo.initField.InitialValue.Length / 2];
 				Buffer.BlockCopy(arrayInfo.initField.InitialValue, 0, encryptedData, 0, arrayInfo.initField.InitialValue.Length);
 
-				decryptType = getDecryptType(Method);
-				keyShift = findKeyShift(cctor);
-				key = findKey();
+				decryptType = GetDecryptType(Method);
+				keyShift = FindKeyShift(cctor);
+				key = FindKey();
 				if (key == null || key.Length == 0)
 					return false;
 
 				return true;
 			}
 
-			static DecryptType getDecryptType(MethodDef method) {
-				if (DeobUtils.hasInteger(method, 0xFFF0))
+			static DecryptType GetDecryptType(MethodDef method) {
+				if (DeobUtils.HasInteger(method, 0xFFF0))
 					return DecryptType.Type2;
-				if (DeobUtils.hasInteger(method, 0xFFC0))
+				if (DeobUtils.HasInteger(method, 0xFFC0))
 					return DecryptType.Type3;
 				return DecryptType.Type1;	// trial
 			}
 
-			int findKeyShift(MethodDef method) {
+			int FindKeyShift(MethodDef method) {
 				var instrs = method.Body.Instructions;
 				for (int i = 0; i < instrs.Count - 3; i++) {
 					int index = i;
@@ -282,7 +282,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 					if (!ldci4_2.IsLdcI4())
 						continue;
 
-					if (findNextFieldUse(method, index) < 0)
+					if (FindNextFieldUse(method, index) < 0)
 						continue;
 
 					return ldci4_2.GetLdcI4Value();
@@ -290,14 +290,14 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return -1;
 			}
 
-			int findNextFieldUse(MethodDef 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 IField;
-					if (!fields.find(field))
+					if (!fields.Find(field))
 						return -1;
 
 					return i;
@@ -305,14 +305,14 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return -1;
 			}
 
-			ArrayInfo getArrayInfo(MethodDef method) {
+			ArrayInfo GetArrayInfo(MethodDef method) {
 				var instructions = method.Body.Instructions;
 				for (int i = 0; i < instructions.Count; i++) {
 					var ldci4_arraySizeInBytes = instructions[i];
 					if (!ldci4_arraySizeInBytes.IsLdcI4())
 						continue;
 					i++;
-					var instrs = DotNetUtils.getInstructions(instructions, i, OpCodes.Newarr, OpCodes.Dup, OpCodes.Ldtoken, OpCodes.Call, OpCodes.Stsfld);
+					var instrs = DotNetUtils.GetInstructions(instructions, i, OpCodes.Newarr, OpCodes.Dup, OpCodes.Ldtoken, OpCodes.Call, OpCodes.Stsfld);
 					if (instrs == null)
 						continue;
 
@@ -324,7 +324,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 						continue;
 					if (initField == null || initField.InitialValue == null || initField.InitialValue.Length == 0)
 						continue;
-					if (!fields.find(field))
+					if (!fields.Find(field))
 						continue;
 
 					return new ArrayInfo(sizeInBytes, elementType, initField, field);
@@ -332,20 +332,20 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return null;
 			}
 
-			short[] findKey() {
+			short[] FindKey() {
 				if (cctor.Module.Assembly == null)
 					return null;
 				var pkt = cctor.Module.Assembly.PublicKeyToken;
 				if (!PublicKeyBase.IsNullOrEmpty2(pkt))
-					return getPublicKeyTokenKey(pkt.Data);
-				return findKey(cctor);
+					return GetPublicKeyTokenKey(pkt.Data);
+				return FindKey(cctor);
 			}
 
-			short[] findKey(MethodDef initMethod) {
-				return StringDecrypter.findKey(initMethod, fields);
+			short[] FindKey(MethodDef initMethod) {
+				return StringDecrypter.FindKey(initMethod, fields);
 			}
 
-			short[] getPublicKeyTokenKey(byte[] publicKeyToken) {
+			short[] GetPublicKeyTokenKey(byte[] publicKeyToken) {
 				if (keyShift < 0)
 					throw new ApplicationException("Could not find shift value");
 				var key = new short[publicKeyToken.Length];
@@ -356,23 +356,23 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return key;
 			}
 
-			public string decrypt(object[] args) {
+			public string Decrypt(object[] args) {
 				switch (decryptType) {
 				case DecryptType.Type1:
-					return decryptTrial((int)args[arg1], (int)args[arg2]);
+					return DecryptTrial((int)args[arg1], (int)args[arg2]);
 
 				case DecryptType.Type2:
-					return decryptRetail2((int)args[arg1], (int)args[arg2]);
+					return DecryptRetail2((int)args[arg1], (int)args[arg2]);
 
 				case DecryptType.Type3:
-					return decryptRetail3((int)args[arg1], (int)args[arg2]);
+					return DecryptRetail3((int)args[arg1], (int)args[arg2]);
 
 				default:
 					throw new ApplicationException("Unknown type");
 				}
 			}
 
-			string decryptTrial(int magic2, int magic3) {
+			string DecryptTrial(int magic2, int magic3) {
 				int offset = magic ^ magic2 ^ magic3;
 				var keyChar = encryptedData[offset + 1];
 				int cachedIndex = encryptedData[offset] ^ keyChar;
@@ -384,15 +384,15 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return sb.ToString();
 			}
 
-			string decryptRetail2(int magic2, int magic3) {
-				return decryptRetail(magic2, magic3, 2, 1, 0, 8, 0);
+			string DecryptRetail2(int magic2, int magic3) {
+				return DecryptRetail(magic2, magic3, 2, 1, 0, 8, 0);
 			}
 
-			string decryptRetail3(int magic2, int magic3) {
-				return decryptRetail(magic2, magic3, 0, 2, 1, 0x20, 17);
+			string DecryptRetail3(int magic2, int magic3) {
+				return DecryptRetail(magic2, magic3, 0, 2, 1, 0x20, 17);
 			}
 
-			string decryptRetail(int magic2, int magic3, int keyCharOffs, int cachedIndexOffs, int flagsOffset, int flag, int keyDispl) {
+			string DecryptRetail(int magic2, int magic3, int keyCharOffs, int cachedIndexOffs, int flagsOffset, int flag, int keyDispl) {
 				int offset = magic ^ magic2 ^ magic3;
 				var keyChar = encryptedData[offset + keyCharOffs];
 				int cachedIndex = encryptedData[offset + cachedIndexOffs] ^ keyChar;
@@ -410,11 +410,11 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return sb.ToString();
 			}
 
-			public void cleanup() {
+			public void CleanUp() {
 				arrayInfo.initField.InitialValue = new byte[1];
 				arrayInfo.initField.FieldSig.Type = arrayInfo.initField.Module.CorLibTypes.Byte;
 				arrayInfo.initField.RVA = 0;
-				removeInitializeArrayCall(cctor, arrayInfo.initField);
+				RemoveInitializeArrayCall(cctor, arrayInfo.initField);
 			}
 		}
 
@@ -439,23 +439,23 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				this.Method = method;
 			}
 
-			public static bool isPossibleDecrypterMethod(MethodDef method, ref bool? state) {
+			public static bool IsPossibleDecrypterMethod(MethodDef method, ref bool? state) {
 				if (state == null)
-					state = checkFields(method.DeclaringType.Fields);
+					state = CheckFields(method.DeclaringType.Fields);
 				if (!state.Value)
 					return false;
-				return DotNetUtils.isMethod(method, "System.String", "(System.Int32,System.Int32)");
+				return DotNetUtils.IsMethod(method, "System.String", "(System.Int32,System.Int32)");
 			}
 
-			public bool initialize() {
-				if (!findMagic(Method, out magic))
+			public bool Initialize() {
+				if (!FindMagic(Method, out magic))
 					return false;
 
-				var charArrayFields = findFields();
+				var charArrayFields = FindFields();
 				if (charArrayFields == null || charArrayFields.Count != 2)
 					return false;
 
-				encryptedStringsField = findEncryptedStrings(cctor, charArrayFields, out encryptedDataField);
+				encryptedStringsField = FindEncryptedStrings(cctor, charArrayFields, out encryptedDataField);
 				if (encryptedStringsField == null)
 					return false;
 				if (encryptedDataField.InitialValue.Length % 2 == 1)
@@ -466,14 +466,14 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				charArrayFields.Remove(encryptedStringsField);
 				keyField = charArrayFields[0];
 
-				key = findKey();
+				key = FindKey();
 				if (key == null || key.Length == 0)
 					return false;
 
 				return true;
 			}
 
-			List<FieldDef> findFields() {
+			List<FieldDef> FindFields() {
 				var charArrayFields = new List<FieldDef>();
 
 				foreach (var instr in Method.Body.Instructions) {
@@ -507,9 +507,9 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return charArrayFields;
 			}
 
-			static FieldDef findEncryptedStrings(MethodDef initMethod, List<FieldDef> ourFields, out FieldDef 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);
+					var instrs = DotNetUtils.GetInstructions(initMethod.Body.Instructions, i, OpCodes.Ldtoken, OpCodes.Call, OpCodes.Stsfld);
 					if (instrs == null)
 						continue;
 
@@ -518,7 +518,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 						continue;
 
 					var savedField = instrs[2].Operand as FieldDef;
-					if (savedField == null || !matches(ourFields, savedField))
+					if (savedField == null || !Matches(ourFields, savedField))
 						continue;
 
 					return savedField;
@@ -528,7 +528,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return null;
 			}
 
-			static bool matches(IEnumerable<FieldDef> ourFields, FieldDef field) {
+			static bool Matches(IEnumerable<FieldDef> ourFields, FieldDef field) {
 				foreach (var ourField in ourFields) {
 					if (FieldEqualityComparer.CompareDeclaringTypes.Equals(ourField, field))
 						return true;
@@ -536,20 +536,20 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return false;
 			}
 
-			short[] findKey() {
+			short[] FindKey() {
 				if (cctor.Module.Assembly == null)
 					return null;
 				var pkt = cctor.Module.Assembly.PublicKeyToken;
 				if (!PublicKeyBase.IsNullOrEmpty2(pkt))
-					return getPublicKeyTokenKey(pkt.Data);
-				return findKey(cctor);
+					return GetPublicKeyTokenKey(pkt.Data);
+				return FindKey(cctor);
 			}
 
-			short[] findKey(MethodDef initMethod) {
-				return StringDecrypter.findKey(initMethod, keyField);
+			short[] FindKey(MethodDef initMethod) {
+				return StringDecrypter.FindKey(initMethod, keyField);
 			}
 
-			static short[] getPublicKeyTokenKey(byte[] publicKeyToken) {
+			static short[] GetPublicKeyTokenKey(byte[] publicKeyToken) {
 				var key = new short[publicKeyToken.Length];
 				for (int i = 0; i < publicKeyToken.Length; i++) {
 					int b = publicKeyToken[i];
@@ -558,11 +558,11 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return key;
 			}
 
-			public string decrypt(object[] args) {
-				return decrypt((int)args[0], (int)args[1]);
+			public string Decrypt(object[] args) {
+				return Decrypt((int)args[0], (int)args[1]);
 			}
 
-			string decrypt(int magic2, int magic3) {
+			string Decrypt(int magic2, int magic3) {
 				int index = magic ^ magic2 ^ magic3;
 				int cachedIndex = encryptedData[index++];
 				int stringLen = encryptedData[index++] + ((int)encryptedData[index++] << 16);
@@ -572,11 +572,11 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return sb.ToString();
 			}
 
-			public void cleanup() {
+			public void CleanUp() {
 				encryptedDataField.InitialValue = new byte[1];
 				encryptedDataField.FieldSig.Type = encryptedDataField.Module.CorLibTypes.Byte;
 				encryptedDataField.RVA = 0;
-				removeInitializeArrayCall(cctor, encryptedDataField);
+				RemoveInitializeArrayCall(cctor, encryptedDataField);
 			}
 		}
 
@@ -594,12 +594,12 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				get { return DecrypterVersion.V1_3; }
 			}
 
-			public static bool isPossibleDecrypterMethod(MethodDef method, ref bool? state) {
+			public static bool IsPossibleDecrypterMethod(MethodDef method, ref bool? state) {
 				if (state == null)
-					state = checkFields(method.DeclaringType.Fields);
+					state = CheckFields(method.DeclaringType.Fields);
 				if (!state.Value)
 					return false;
-				return DotNetUtils.isMethod(method, "System.String", "(System.Int32)");
+				return DotNetUtils.IsMethod(method, "System.String", "(System.Int32)");
 			}
 
 			public DecrypterInfo13(MethodDef cctor, MethodDef method) {
@@ -607,11 +607,11 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				this.Method = method;
 			}
 
-			public string decrypt(object[] args) {
-				return decrypt((int)args[0]);
+			public string Decrypt(object[] args) {
+				return Decrypt((int)args[0]);
 			}
 
-			string decrypt(int magic2) {
+			string Decrypt(int magic2) {
 				var es = encryptedStrings[magic ^ magic2];
 				var sb = new StringBuilder(es.Length);
 				for (int i = 0; i < es.Length; i++)
@@ -619,24 +619,24 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return sb.ToString();
 			}
 
-			public bool initialize() {
-				if (!findMagic(Method, out magic))
+			public bool Initialize() {
+				if (!FindMagic(Method, out magic))
 					return false;
 
-				if (!findFields())
+				if (!FindFields())
 					return false;
 
-				if (!findEncryptedStrings(Method))
+				if (!FindEncryptedStrings(Method))
 					return false;
 
-				key = findKey();
+				key = FindKey();
 				if (key == null || key.Length == 0)
 					return false;
 
 				return true;
 			}
 
-			bool findFields() {
+			bool FindFields() {
 				foreach (var instr in Method.Body.Instructions) {
 					if (instr.OpCode.Code != Code.Stsfld && instr.OpCode.Code != Code.Ldsfld)
 						continue;
@@ -666,20 +666,20 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return keyField != null && cachedStringsField != null;
 			}
 
-			short[] findKey() {
+			short[] FindKey() {
 				if (cctor.Module.Assembly == null)
 					return null;
 				var pkt = cctor.Module.Assembly.PublicKeyToken;
 				if (!PublicKeyBase.IsNullOrEmpty2(pkt))
-					return getPublicKeyTokenKey(pkt.Data);
-				return findKey(cctor);
+					return GetPublicKeyTokenKey(pkt.Data);
+				return FindKey(cctor);
 			}
 
-			short[] findKey(MethodDef initMethod) {
-				return StringDecrypter.findKey(initMethod, keyField);
+			short[] FindKey(MethodDef initMethod) {
+				return StringDecrypter.FindKey(initMethod, keyField);
 			}
 
-			static short[] getPublicKeyTokenKey(byte[] publicKeyToken) {
+			static short[] GetPublicKeyTokenKey(byte[] publicKeyToken) {
 				var key = new short[publicKeyToken.Length];
 				for (int i = 0; i < publicKeyToken.Length; i++) {
 					int b = publicKeyToken[i];
@@ -688,7 +688,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return key;
 			}
 
-			static bool findMagic(MethodDef 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];
@@ -706,8 +706,8 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return false;
 			}
 
-			bool findEncryptedStrings(MethodDef method) {
-				var switchInstr = getOnlySwitchInstruction(method);
+			bool FindEncryptedStrings(MethodDef method) {
+				var switchInstr = GetOnlySwitchInstruction(method);
 				if (switchInstr == null)
 					return false;
 				var targets = (Instruction[])switchInstr.Operand;
@@ -721,7 +721,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return true;
 			}
 
-			static Instruction getOnlySwitchInstruction(MethodDef method) {
+			static Instruction GetOnlySwitchInstruction(MethodDef method) {
 				Instruction switchInstr = null;
 				foreach (var instr in method.Body.Instructions) {
 					if (instr.OpCode.Code != Code.Switch)
@@ -733,7 +733,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 				return switchInstr;
 			}
 
-			public void cleanup() {
+			public void CleanUp() {
 			}
 
 			public override string ToString() {
@@ -752,7 +752,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 		public List<MethodDef> DecrypterMethods {
 			get {
 				var methods = new List<MethodDef>(methodToInfo.Count);
-				foreach (var info in methodToInfo.getValues())
+				foreach (var info in methodToInfo.GetValues())
 					methods.Add(info.Method);
 				return methods;
 			}
@@ -762,7 +762,7 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			this.module = module;
 		}
 
-		public void find(ISimpleDeobfuscator simpleDeobfuscator) {
+		public void Find(ISimpleDeobfuscator simpleDeobfuscator) {
 			if (module.Assembly == null)
 				return;
 
@@ -781,38 +781,38 @@ namespace de4dot.code.deobfuscators.DeepSea {
 
 					IDecrypterInfo info = null;
 
-					if (DecrypterInfo13.isPossibleDecrypterMethod(method, ref v13State)) {
-						deobfuscateCctor(simpleDeobfuscator, cctor, ref deobfuscatedCctor, hasPublicKeyToken);
-						simpleDeobfuscator.deobfuscate(method);
-						info = getInfoV13(cctor, method);
+					if (DecrypterInfo13.IsPossibleDecrypterMethod(method, ref v13State)) {
+						DeobfuscateCctor(simpleDeobfuscator, cctor, ref deobfuscatedCctor, hasPublicKeyToken);
+						simpleDeobfuscator.Deobfuscate(method);
+						info = GetInfoV13(cctor, method);
 					}
-					else if (DecrypterInfo40.isPossibleDecrypterMethod(method, ref v40State)) {
-						deobfuscateCctor(simpleDeobfuscator, cctor, ref deobfuscatedCctor, hasPublicKeyToken);
-						simpleDeobfuscator.deobfuscate(method);
-						info = getInfoV40(cctor, method);
+					else if (DecrypterInfo40.IsPossibleDecrypterMethod(method, ref v40State)) {
+						DeobfuscateCctor(simpleDeobfuscator, cctor, ref deobfuscatedCctor, hasPublicKeyToken);
+						simpleDeobfuscator.Deobfuscate(method);
+						info = GetInfoV40(cctor, method);
 					}
-					else if (DecrypterInfo41.isPossibleDecrypterMethod(method, ref v41State)) {
-						deobfuscateCctor(simpleDeobfuscator, cctor, ref deobfuscatedCctor, hasPublicKeyToken);
-						simpleDeobfuscator.deobfuscate(method);
-						info = getInfoV41(cctor, method);
+					else if (DecrypterInfo41.IsPossibleDecrypterMethod(method, ref v41State)) {
+						DeobfuscateCctor(simpleDeobfuscator, cctor, ref deobfuscatedCctor, hasPublicKeyToken);
+						simpleDeobfuscator.Deobfuscate(method);
+						info = GetInfoV41(cctor, method);
 					}
 
 					if (info == null)
 						continue;
-					methodToInfo.add(method, info);
+					methodToInfo.Add(method, info);
 					version = info.Version;
 				}
 			}
 		}
 
-		static void deobfuscateCctor(ISimpleDeobfuscator simpleDeobfuscator, MethodDef 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);
+			simpleDeobfuscator.Deobfuscate(cctor);
 			deobfuscatedCctor = true;
 		}
 
-		static bool checkFields(IEnumerable<FieldDef> fields) {
+		static bool CheckFields(IEnumerable<FieldDef> fields) {
 			bool foundCharAry = false, foundStringAry = false;
 			foreach (var field in fields) {
 				if (foundCharAry && foundStringAry)
@@ -829,35 +829,35 @@ namespace de4dot.code.deobfuscators.DeepSea {
 			return foundCharAry && foundStringAry;
 		}
 
-		DecrypterInfo13 getInfoV13(MethodDef cctor, MethodDef method) {
+		DecrypterInfo13 GetInfoV13(MethodDef cctor, MethodDef method) {
 			var info = new DecrypterInfo13(cctor, method);
-			if (!info.initialize())
+			if (!info.Initialize())
 				return null;
 			return info;
 		}
 
-		DecrypterInfo40 getInfoV40(MethodDef cctor, MethodDef method) {
+		DecrypterInfo40 GetInfoV40(MethodDef cctor, MethodDef method) {
 			var info = new DecrypterInfo40(cctor, method);
-			if (!info.initialize())
+			if (!info.Initialize())
 				return null;
 			return info;
 		}
 
-		DecrypterInfo41 getInfoV41(MethodDef cctor, MethodDef method) {
+		DecrypterInfo41 GetInfoV41(MethodDef cctor, MethodDef method) {
 			var info = new DecrypterInfo41(cctor, method);
-			if (!info.initialize())
+			if (!info.Initialize())
 				return null;
 			return info;
 		}
 
-		public string decrypt(IMethod method, object[] args) {
-			var info = methodToInfo.find(method);
-			return info.decrypt(args);
+		public string Decrypt(IMethod method, object[] args) {
+			var info = methodToInfo.Find(method);
+			return info.Decrypt(args);
 		}
 
-		public void cleanup() {
-			foreach (var info in methodToInfo.getValues())
-				info.cleanup();
+		public void CleanUp() {
+			foreach (var info in methodToInfo.GetValues())
+				info.CleanUp();
 		}
 	}
 }
diff --git a/de4dot.code/deobfuscators/DeobUtils.cs b/de4dot.code/deobfuscators/DeobUtils.cs
index 783ee98a..fbb999dc 100644
--- a/de4dot.code/deobfuscators/DeobUtils.cs
+++ b/de4dot.code/deobfuscators/DeobUtils.cs
@@ -29,22 +29,22 @@ using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators {
 	static class DeobUtils {
-		public static void decryptAndAddResources(ModuleDef module, string encryptedName, Func<byte[]> decryptResource) {
-			Logger.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 = ModuleDefMD.Load(decryptedResourceData);
 
-			Logger.Instance.indent();
+			Logger.Instance.Indent();
 			foreach (var rsrc in resourceModule.Resources) {
-				Logger.v("Adding decrypted resource {0}", Utils.toCsharpString(rsrc.Name));
+				Logger.v("Adding decrypted resource {0}", Utils.ToCsharpString(rsrc.Name));
 				module.Resources.Add(rsrc);
 			}
-			Logger.Instance.deIndent();
+			Logger.Instance.DeIndent();
 		}
 
-		public static T lookup<T>(ModuleDefMD module, T def, string errorMessage) where T : class, ICodedToken {
+		public static T Lookup<T>(ModuleDefMD module, T def, string errorMessage) where T : class, ICodedToken {
 			if (def == null)
 				return null;
 			var newDef = module.ResolveToken(def.MDToken.Raw) as T;
@@ -53,11 +53,11 @@ namespace de4dot.code.deobfuscators {
 			return newDef;
 		}
 
-		public static byte[] readModule(ModuleDef module) {
-			return Utils.readFile(module.Location);
+		public static byte[] ReadModule(ModuleDef module) {
+			return Utils.ReadFile(module.Location);
 		}
 
-		public static bool isCode(short[] nativeCode, byte[] code) {
+		public static bool IsCode(short[] nativeCode, byte[] code) {
 			if (nativeCode.Length != code.Length)
 				return false;
 			for (int i = 0; i < nativeCode.Length; i++) {
@@ -69,19 +69,19 @@ namespace de4dot.code.deobfuscators {
 			return true;
 		}
 
-		public static byte[] md5Sum(byte[] data) {
+		public static byte[] Md5Sum(byte[] data) {
 			return MD5.Create().ComputeHash(data);
 		}
 
-		public static byte[] sha1Sum(byte[] data) {
+		public static byte[] Sha1Sum(byte[] data) {
 			return SHA1.Create().ComputeHash(data);
 		}
 
-		public static byte[] sha256Sum(byte[] data) {
+		public static byte[] Sha256Sum(byte[] data) {
 			return SHA256.Create().ComputeHash(data);
 		}
 
-		public static byte[] aesDecrypt(byte[] data, byte[] key, byte[] iv) {
+		public static byte[] AesDecrypt(byte[] data, byte[] key, byte[] iv) {
 			using (var aes = new RijndaelManaged { Mode = CipherMode.CBC }) {
 				using (var transform = aes.CreateDecryptor(key, iv)) {
 					return transform.TransformFinalBlock(data, 0, data.Length);
@@ -89,7 +89,7 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		public static byte[] des3Decrypt(byte[] data, byte[] key, byte[] iv) {
+		public static byte[] Des3Decrypt(byte[] data, byte[] key, byte[] iv) {
 			using (var des3 = TripleDES.Create()) {
 				using (var transform = des3.CreateDecryptor(key, iv)) {
 					return transform.TransformFinalBlock(data, 0, data.Length);
@@ -97,7 +97,7 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		public static byte[] desDecrypt(byte[] data, int start, int len, byte[] key, byte[] iv) {
+		public static byte[] DesDecrypt(byte[] data, int start, int len, byte[] key, byte[] iv) {
 			using (var des = new DESCryptoServiceProvider()) {
 				using (var transform = des.CreateDecryptor(key, iv)) {
 					return transform.TransformFinalBlock(data, start, len);
@@ -106,7 +106,7 @@ namespace de4dot.code.deobfuscators {
 		}
 
 		// Code converted from C implementation @ http://en.wikipedia.org/wiki/XXTEA (btea() func)
-		public static void xxteaDecrypt(uint[] v, uint[] key) {
+		public static void XxteaDecrypt(uint[] v, uint[] key) {
 			const uint DELTA = 0x9E3779B9;
 			int n = v.Length;
 			uint rounds = (uint)(6 + 52 / n);
@@ -127,7 +127,7 @@ namespace de4dot.code.deobfuscators {
 		}
 
 		// Code converted from C implementation @ http://en.wikipedia.org/wiki/XTEA (decipher() func)
-		public static void xteaDecrypt(ref uint v0, ref uint v1, uint[] key, int rounds) {
+		public static void XteaDecrypt(ref uint v0, ref uint v1, uint[] key, int rounds) {
 			const uint delta = 0x9E3779B9;
 			uint sum = (uint)(delta * rounds);
 			for (int i = 0; i < rounds; i++) {
@@ -137,7 +137,7 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		public static string getExtension(ModuleKind kind) {
+		public static string GetExtension(ModuleKind kind) {
 			switch (kind) {
 			case ModuleKind.Dll:
 				return ".dll";
@@ -150,19 +150,19 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		public static byte[] inflate(byte[] data, bool noHeader) {
-			return inflate(data, 0, data.Length, noHeader);
+		public static byte[] Inflate(byte[] data, bool noHeader) {
+			return Inflate(data, 0, data.Length, noHeader);
 		}
 
-		public static byte[] inflate(byte[] data, int start, int len, bool noHeader) {
-			return inflate(data, start, len, new Inflater(noHeader));
+		public static byte[] Inflate(byte[] data, int start, int len, bool noHeader) {
+			return Inflate(data, start, len, new Inflater(noHeader));
 		}
 
-		public static byte[] inflate(byte[] data, Inflater inflater) {
-			return inflate(data, 0, data.Length, inflater);
+		public static byte[] Inflate(byte[] data, Inflater inflater) {
+			return Inflate(data, 0, data.Length, inflater);
 		}
 
-		public static byte[] inflate(byte[] data, int start, int len, Inflater inflater) {
+		public static byte[] Inflate(byte[] data, int start, int len, Inflater inflater) {
 			var buffer = new byte[0x1000];
 			var memStream = new MemoryStream();
 			inflater.SetInput(data, start, len);
@@ -175,7 +175,7 @@ namespace de4dot.code.deobfuscators {
 			return memStream.ToArray();
 		}
 
-		public static byte[] gunzip(Stream input, int decompressedSize) {
+		public static byte[] Gunzip(Stream input, int decompressedSize) {
 			using (var gzip = new GZipStream(input, CompressionMode.Decompress)) {
 				var decompressed = new byte[decompressedSize];
 				if (gzip.Read(decompressed, 0, decompressedSize) != decompressedSize)
@@ -184,16 +184,16 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		public static EmbeddedResource getEmbeddedResourceFromCodeStrings(ModuleDef module, MethodDef method) {
-			foreach (var s in DotNetUtils.getCodeStrings(method)) {
-				var resource = DotNetUtils.getResource(module, s) as EmbeddedResource;
+		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)
 					return resource;
 			}
 			return null;
 		}
 
-		public static int readVariableLengthInt32(byte[] data, ref int index) {
+		public static int ReadVariableLengthInt32(byte[] data, ref int index) {
 			byte b = data[index++];
 			if ((b & 0x80) == 0)
 				return b;
@@ -205,15 +205,15 @@ namespace de4dot.code.deobfuscators {
 					data[index++];
 		}
 
-		public static bool hasInteger(MethodDef method, uint value) {
-			return hasInteger(method, (int)value);
+		public static bool HasInteger(MethodDef method, uint value) {
+			return HasInteger(method, (int)value);
 		}
 
-		public static bool hasInteger(MethodDef method, int value) {
-			return indexOfLdci4Instruction(method, value) >= 0;
+		public static bool HasInteger(MethodDef method, int value) {
+			return IndexOfLdci4Instruction(method, value) >= 0;
 		}
 
-		public static int indexOfLdci4Instruction(MethodDef method, int value) {
+		public static int IndexOfLdci4Instruction(MethodDef method, int value) {
 			if (method == null || method.Body == null)
 				return -1;
 			var instrs = method.Body.Instructions;
@@ -227,8 +227,8 @@ namespace de4dot.code.deobfuscators {
 			return -1;
 		}
 
-		public static IEnumerable<MethodDef> getInitCctors(ModuleDef module, int maxCctors) {
-			var cctor = DotNetUtils.getModuleTypeCctor(module);
+		public static IEnumerable<MethodDef> GetInitCctors(ModuleDef module, int maxCctors) {
+			var cctor = DotNetUtils.GetModuleTypeCctor(module);
 			if (cctor != null)
 				yield return cctor;
 
@@ -251,7 +251,7 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		public static List<MethodDef> getAllResolveHandlers(MethodDef method) {
+		public static List<MethodDef> GetAllResolveHandlers(MethodDef method) {
 			var list = new List<MethodDef>();
 			if (method == null || method.Body == null)
 				return list;
@@ -261,15 +261,15 @@ namespace de4dot.code.deobfuscators {
 				var handler = instr.Operand as MethodDef;
 				if (handler == null)
 					continue;
-				if (!DotNetUtils.isMethod(handler, "System.Reflection.Assembly", "(System.Object,System.ResolveEventArgs)"))
+				if (!DotNetUtils.IsMethod(handler, "System.Reflection.Assembly", "(System.Object,System.ResolveEventArgs)"))
 					continue;
 				list.Add(handler);
 			}
 			return list;
 		}
 
-		public static MethodDef getResolveMethod(MethodDef method) {
-			var handlers = DeobUtils.getAllResolveHandlers(method);
+		public static MethodDef GetResolveMethod(MethodDef method) {
+			var handlers = DeobUtils.GetAllResolveHandlers(method);
 			if (handlers.Count == 0)
 				return null;
 			return handlers[0];
diff --git a/de4dot.code/deobfuscators/DeobfuscatorBase.cs b/de4dot.code/deobfuscators/DeobfuscatorBase.cs
index 5acdff26..e8c2b5a7 100644
--- a/de4dot.code/deobfuscators/DeobfuscatorBase.cs
+++ b/de4dot.code/deobfuscators/DeobfuscatorBase.cs
@@ -119,20 +119,20 @@ namespace de4dot.code.deobfuscators {
 			DefaultDecrypterType = DecrypterType.Static;
 		}
 
-		public virtual byte[] unpackNativeFile(IPEImage peImage) {
+		public virtual byte[] UnpackNativeFile(IPEImage peImage) {
 			return null;
 		}
 
-		public virtual void init(ModuleDefMD module) {
-			setModule(module);
+		public virtual void Initialize(ModuleDefMD module) {
+			SetModule(module);
 		}
 
-		protected void setModule(ModuleDefMD module) {
+		protected void SetModule(ModuleDefMD module) {
 			this.module = module;
 			initializedDataCreator = new InitializedDataCreator(module);
 		}
 
-		protected void preserveTokensAndTypes() {
+		protected void PreserveTokensAndTypes() {
 			keepTypes = true;
 			mdFlags = Operations.MetaDataFlags;
 			mdFlags |= MetaDataFlags.PreserveRids |
@@ -141,98 +141,98 @@ namespace de4dot.code.deobfuscators {
 						MetaDataFlags.PreserveExtraSignatureData;
 		}
 
-		protected virtual bool checkValidName(string name) {
-			return optionsBase.ValidNameRegex.isMatch(name);
+		protected virtual bool CheckValidName(string name) {
+			return optionsBase.ValidNameRegex.IsMatch(name);
 		}
 
-		public virtual int detect() {
-			scanForObfuscator();
-			return detectInternal();
+		public virtual int Detect() {
+			ScanForObfuscator();
+			return DetectInternal();
 		}
 
-		protected abstract void scanForObfuscator();
-		protected abstract int detectInternal();
+		protected abstract void ScanForObfuscator();
+		protected abstract int DetectInternal();
 
-		public virtual bool getDecryptedModule(int count, ref byte[] newFileData, ref DumpedMethods dumpedMethods) {
+		public virtual bool GetDecryptedModule(int count, ref byte[] newFileData, ref DumpedMethods dumpedMethods) {
 			return false;
 		}
 
-		public virtual IDeobfuscator moduleReloaded(ModuleDefMD module) {
+		public virtual IDeobfuscator ModuleReloaded(ModuleDefMD module) {
 			throw new ApplicationException("moduleReloaded() must be overridden by the deobfuscator");
 		}
 
-		public virtual void deobfuscateBegin() {
+		public virtual void DeobfuscateBegin() {
 			ModuleBytes = null;
 		}
 
-		public virtual void deobfuscateMethodBegin(Blocks blocks) {
+		public virtual void DeobfuscateMethodBegin(Blocks blocks) {
 		}
 
-		public virtual void deobfuscateMethodEnd(Blocks blocks) {
-			removeMethodCalls(blocks);
+		public virtual void DeobfuscateMethodEnd(Blocks blocks) {
+			RemoveMethodCalls(blocks);
 		}
 
-		public virtual void deobfuscateStrings(Blocks blocks) {
-			staticStringInliner.decrypt(blocks);
+		public virtual void DeobfuscateStrings(Blocks blocks) {
+			staticStringInliner.Decrypt(blocks);
 		}
 
-		public virtual bool deobfuscateOther(Blocks blocks) {
+		public virtual bool DeobfuscateOther(Blocks blocks) {
 			return false;
 		}
 
-		public virtual void deobfuscateEnd() {
+		public virtual void DeobfuscateEnd() {
 			if (CanRemoveTypes) {
-				removeTypesWithInvalidBaseTypes();
+				RemoveTypesWithInvalidBaseTypes();
 
-				deleteEmptyCctors();
-				deleteMethods();
-				deleteFields();
-				deleteCustomAttributes();
-				deleteOtherAttributes();
-				deleteTypes();
-				deleteDllResources();
+				DeleteEmptyCctors();
+				DeleteMethods();
+				DeleteFields();
+				DeleteCustomAttributes();
+				DeleteOtherAttributes();
+				DeleteTypes();
+				DeleteDllResources();
 			}
 
-			restoreBaseType();
-			fixMDHeaderVersion();
+			RestoreBaseType();
+			FixMDHeaderVersion();
 		}
 
-		static bool isTypeWithInvalidBaseType(TypeDef moduleType, TypeDef type) {
+		static bool IsTypeWithInvalidBaseType(TypeDef moduleType, TypeDef type) {
 			return type.BaseType == null && !type.IsInterface && type != moduleType;
 		}
 
-		void restoreBaseType() {
-			var moduleType = DotNetUtils.getModuleType(module);
+		void RestoreBaseType() {
+			var moduleType = DotNetUtils.GetModuleType(module);
 			foreach (var type in module.GetTypes()) {
-				if (!isTypeWithInvalidBaseType(moduleType, type))
+				if (!IsTypeWithInvalidBaseType(moduleType, type))
 					continue;
 				var corSig = module.CorLibTypes.GetCorLibTypeSig(type);
 				if (corSig != null && corSig.ElementType == ElementType.Object)
 					continue;
 				Logger.v("Adding System.Object as base type: {0} ({1:X8})",
-							Utils.removeNewlines(type),
+							Utils.RemoveNewlines(type),
 							type.MDToken.ToInt32());
 				type.BaseType = module.CorLibTypes.Object.TypeDefOrRef;
 			}
 		}
 
-		void fixMDHeaderVersion() {
+		void FixMDHeaderVersion() {
 			// Version 1.1 supports generics but it's a little different. Most tools
 			// will have a problem reading the MD tables, so switch to the standard v2.0.
 			if (module.TablesHeaderVersion == 0x0101)
 				module.TablesHeaderVersion = 0x0200;
 		}
 
-		void removeTypesWithInvalidBaseTypes() {
-			var moduleType = DotNetUtils.getModuleType(module);
+		void RemoveTypesWithInvalidBaseTypes() {
+			var moduleType = DotNetUtils.GetModuleType(module);
 			foreach (var type in module.GetTypes()) {
-				if (!isTypeWithInvalidBaseType(moduleType, type))
+				if (!IsTypeWithInvalidBaseType(moduleType, type))
 					continue;
-				addTypeToBeRemoved(type, "Invalid type with no base type (anti-reflection)");
+				AddTypeToBeRemoved(type, "Invalid type with no base type (anti-reflection)");
 			}
 		}
 
-		protected void fixEnumTypes() {
+		protected void FixEnumTypes() {
 			foreach (var type in module.GetTypes()) {
 				if (!type.IsEnum)
 					continue;
@@ -245,7 +245,7 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		protected void fixInterfaces() {
+		protected void FixInterfaces() {
 			foreach (var type in module.GetTypes()) {
 				if (!type.IsInterface)
 					continue;
@@ -253,13 +253,13 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		public abstract IEnumerable<int> getStringDecrypterMethods();
+		public abstract IEnumerable<int> GetStringDecrypterMethods();
 
 		class MethodCallRemover {
 			Dictionary<string, MethodDefAndDeclaringTypeDict<bool>> methodNameInfos = new Dictionary<string, MethodDefAndDeclaringTypeDict<bool>>();
 			MethodDefAndDeclaringTypeDict<MethodDefAndDeclaringTypeDict<bool>> methodRefInfos = new MethodDefAndDeclaringTypeDict<MethodDefAndDeclaringTypeDict<bool>>();
 
-			void checkMethod(IMethod methodToBeRemoved) {
+			void CheckMethod(IMethod methodToBeRemoved) {
 				var sig = methodToBeRemoved.MethodSig;
 				if (sig.Params.Count != 0)
 					throw new ApplicationException(string.Format("Method takes params: {0}", methodToBeRemoved));
@@ -267,52 +267,52 @@ namespace de4dot.code.deobfuscators {
 					throw new ApplicationException(string.Format("Method has a return value: {0}", methodToBeRemoved));
 			}
 
-			public void add(string method, MethodDef methodToBeRemoved) {
+			public void Add(string method, MethodDef methodToBeRemoved) {
 				if (methodToBeRemoved == null)
 					return;
-				checkMethod(methodToBeRemoved);
+				CheckMethod(methodToBeRemoved);
 
 				MethodDefAndDeclaringTypeDict<bool> dict;
 				if (!methodNameInfos.TryGetValue(method, out dict))
 					methodNameInfos[method] = dict = new MethodDefAndDeclaringTypeDict<bool>();
-				dict.add(methodToBeRemoved, true);
+				dict.Add(methodToBeRemoved, true);
 			}
 
-			public void add(MethodDef method, MethodDef methodToBeRemoved) {
+			public void Add(MethodDef method, MethodDef methodToBeRemoved) {
 				if (method == null || methodToBeRemoved == null)
 					return;
-				checkMethod(methodToBeRemoved);
+				CheckMethod(methodToBeRemoved);
 
-				var dict = methodRefInfos.find(method);
+				var dict = methodRefInfos.Find(method);
 				if (dict == null)
-					methodRefInfos.add(method, dict = new MethodDefAndDeclaringTypeDict<bool>());
-				dict.add(methodToBeRemoved, true);
+					methodRefInfos.Add(method, dict = new MethodDefAndDeclaringTypeDict<bool>());
+				dict.Add(methodToBeRemoved, true);
 			}
 
-			public void removeAll(Blocks blocks) {
-				var allBlocks = blocks.MethodBlocks.getAllBlocks();
+			public void RemoveAll(Blocks blocks) {
+				var allBlocks = blocks.MethodBlocks.GetAllBlocks();
 
-				removeAll(allBlocks, blocks, blocks.Method.Name.String);
-				removeAll(allBlocks, blocks, blocks.Method);
+				RemoveAll(allBlocks, blocks, blocks.Method.Name.String);
+				RemoveAll(allBlocks, blocks, blocks.Method);
 			}
 
-			void removeAll(IList<Block> allBlocks, Blocks blocks, string method) {
+			void RemoveAll(IList<Block> allBlocks, Blocks blocks, string method) {
 				MethodDefAndDeclaringTypeDict<bool> info;
 				if (!methodNameInfos.TryGetValue(method, out info))
 					return;
 
-				removeCalls(allBlocks, blocks, info);
+				RemoveCalls(allBlocks, blocks, info);
 			}
 
-			void removeAll(IList<Block> allBlocks, Blocks blocks, MethodDef method) {
-				var info = methodRefInfos.find(method);
+			void RemoveAll(IList<Block> allBlocks, Blocks blocks, MethodDef method) {
+				var info = methodRefInfos.Find(method);
 				if (info == null)
 					return;
 
-				removeCalls(allBlocks, blocks, info);
+				RemoveCalls(allBlocks, blocks, info);
 			}
 
-			void removeCalls(IList<Block> allBlocks, Blocks blocks, MethodDefAndDeclaringTypeDict<bool> info) {
+			void RemoveCalls(IList<Block> allBlocks, Blocks blocks, MethodDefAndDeclaringTypeDict<bool> info) {
 				var instrsToDelete = new List<int>();
 				foreach (var block in allBlocks) {
 					instrsToDelete.Clear();
@@ -324,88 +324,88 @@ namespace de4dot.code.deobfuscators {
 						if (destMethod == null)
 							continue;
 
-						if (info.find(destMethod)) {
-							Logger.v("Removed call to {0}", Utils.removeNewlines(destMethod));
+						if (info.Find(destMethod)) {
+							Logger.v("Removed call to {0}", Utils.RemoveNewlines(destMethod));
 							instrsToDelete.Add(i);
 						}
 					}
-					block.remove(instrsToDelete);
+					block.Remove(instrsToDelete);
 				}
 			}
 		}
 
-		public void addCctorInitCallToBeRemoved(MethodDef methodToBeRemoved) {
-			methodCallRemover.add(".cctor", methodToBeRemoved);
+		public void AddCctorInitCallToBeRemoved(MethodDef methodToBeRemoved) {
+			methodCallRemover.Add(".cctor", methodToBeRemoved);
 		}
 
-		public void addModuleCctorInitCallToBeRemoved(MethodDef methodToBeRemoved) {
-			methodCallRemover.add(DotNetUtils.getModuleTypeCctor(module), methodToBeRemoved);
+		public void AddModuleCctorInitCallToBeRemoved(MethodDef methodToBeRemoved) {
+			methodCallRemover.Add(DotNetUtils.GetModuleTypeCctor(module), methodToBeRemoved);
 		}
 
-		public void addCtorInitCallToBeRemoved(MethodDef methodToBeRemoved) {
-			methodCallRemover.add(".ctor", methodToBeRemoved);
+		public void AddCtorInitCallToBeRemoved(MethodDef methodToBeRemoved) {
+			methodCallRemover.Add(".ctor", methodToBeRemoved);
 		}
 
-		public void addCallToBeRemoved(MethodDef method, MethodDef methodToBeRemoved) {
-			methodCallRemover.add(method, methodToBeRemoved);
+		public void AddCallToBeRemoved(MethodDef method, MethodDef methodToBeRemoved) {
+			methodCallRemover.Add(method, methodToBeRemoved);
 		}
 
-		void removeMethodCalls(Blocks blocks) {
-			methodCallRemover.removeAll(blocks);
+		void RemoveMethodCalls(Blocks blocks) {
+			methodCallRemover.RemoveAll(blocks);
 		}
 
-		protected void addMethodsToBeRemoved(IEnumerable<MethodDef> methods, string reason) {
+		protected void AddMethodsToBeRemoved(IEnumerable<MethodDef> methods, string reason) {
 			foreach (var method in methods)
-				addMethodToBeRemoved(method, reason);
+				AddMethodToBeRemoved(method, reason);
 		}
 
-		protected void addMethodToBeRemoved(MethodDef method, string reason) {
+		protected void AddMethodToBeRemoved(MethodDef method, string reason) {
 			if (method != null)
 				methodsToRemove.Add(new RemoveInfo<MethodDef>(method, reason));
 		}
 
-		protected void addFieldsToBeRemoved(IEnumerable<FieldDef> fields, string reason) {
+		protected void AddFieldsToBeRemoved(IEnumerable<FieldDef> fields, string reason) {
 			foreach (var field in fields)
-				addFieldToBeRemoved(field, reason);
+				AddFieldToBeRemoved(field, reason);
 		}
 
-		protected void addFieldToBeRemoved(FieldDef field, string reason) {
+		protected void AddFieldToBeRemoved(FieldDef field, string reason) {
 			if (field != null)
 				fieldsToRemove.Add(new RemoveInfo<FieldDef>(field, reason));
 		}
 
-		protected void addAttributesToBeRemoved(IEnumerable<TypeDef> attrs, string reason) {
+		protected void AddAttributesToBeRemoved(IEnumerable<TypeDef> attrs, string reason) {
 			foreach (var attr in attrs)
-				addAttributeToBeRemoved(attr, reason);
+				AddAttributeToBeRemoved(attr, reason);
 		}
 
-		protected void addAttributeToBeRemoved(TypeDef attr, string reason) {
+		protected void AddAttributeToBeRemoved(TypeDef attr, string reason) {
 			if (attr == null)
 				return;
-			addTypeToBeRemoved(attr, reason);
+			AddTypeToBeRemoved(attr, reason);
 			attrsToRemove.Add(new RemoveInfo<TypeDef>(attr, reason));
 		}
 
-		protected void addTypesToBeRemoved(IEnumerable<TypeDef> types, string reason) {
+		protected void AddTypesToBeRemoved(IEnumerable<TypeDef> types, string reason) {
 			foreach (var type in types)
-				addTypeToBeRemoved(type, reason);
+				AddTypeToBeRemoved(type, reason);
 		}
 
-		protected void addTypeToBeRemoved(TypeDef type, string reason) {
+		protected void AddTypeToBeRemoved(TypeDef type, string reason) {
 			if (type != null)
 				typesToRemove.Add(new RemoveInfo<TypeDef>(type, reason));
 		}
 
-		protected void addResourceToBeRemoved(Resource resource, string reason) {
+		protected void AddResourceToBeRemoved(Resource resource, string reason) {
 			if (resource != null)
 				resourcesToRemove.Add(new RemoveInfo<Resource>(resource, reason));
 		}
 
-		void deleteEmptyCctors() {
+		void DeleteEmptyCctors() {
 			var emptyCctorsToRemove = new List<MethodDef>();
 			foreach (var type in module.GetTypes()) {
 				var cctor = type.FindStaticConstructor();
-				if (cctor != null && DotNetUtils.isEmpty(cctor))
+				if (cctor != null && DotNetUtils.IsEmpty(cctor))
 					emptyCctorsToRemove.Add(cctor);
 			}
 
@@ -413,7 +413,7 @@ namespace de4dot.code.deobfuscators {
 				return;
 
 			Logger.v("Removing empty .cctor methods");
-			Logger.Instance.indent();
+			Logger.Instance.Indent();
 			foreach (var cctor in emptyCctorsToRemove) {
 				var type = cctor.DeclaringType;
 				if (type == null)
@@ -421,18 +421,18 @@ namespace de4dot.code.deobfuscators {
 				if (type.Methods.Remove(cctor))
 					Logger.v("{0:X8}, type: {1} ({2:X8})",
 								cctor.MDToken.ToUInt32(),
-								Utils.removeNewlines(type),
+								Utils.RemoveNewlines(type),
 								type.MDToken.ToUInt32());
 			}
-			Logger.Instance.deIndent();
+			Logger.Instance.DeIndent();
 		}
 
-		void deleteMethods() {
+		void DeleteMethods() {
 			if (methodsToRemove.Count == 0)
 				return;
 
 			Logger.v("Removing methods");
-			Logger.Instance.indent();
+			Logger.Instance.Indent();
 			foreach (var info in methodsToRemove) {
 				var method = info.obj;
 				if (method == null)
@@ -442,20 +442,20 @@ namespace de4dot.code.deobfuscators {
 					continue;
 				if (type.Methods.Remove(method))
 					Logger.v("Removed method {0} ({1:X8}) (Type: {2}) (reason: {3})",
-								Utils.removeNewlines(method),
+								Utils.RemoveNewlines(method),
 								method.MDToken.ToUInt32(),
-								Utils.removeNewlines(type),
+								Utils.RemoveNewlines(type),
 								info.reason);
 			}
-			Logger.Instance.deIndent();
+			Logger.Instance.DeIndent();
 		}
 
-		void deleteFields() {
+		void DeleteFields() {
 			if (fieldsToRemove.Count == 0)
 				return;
 
 			Logger.v("Removing fields");
-			Logger.Instance.indent();
+			Logger.Instance.Indent();
 			foreach (var info in fieldsToRemove) {
 				var field = info.obj;
 				if (field == null)
@@ -465,22 +465,22 @@ namespace de4dot.code.deobfuscators {
 					continue;
 				if (type.Fields.Remove(field))
 					Logger.v("Removed field {0} ({1:X8}) (Type: {2}) (reason: {3})",
-								Utils.removeNewlines(field),
+								Utils.RemoveNewlines(field),
 								field.MDToken.ToUInt32(),
-								Utils.removeNewlines(type),
+								Utils.RemoveNewlines(type),
 								info.reason);
 			}
-			Logger.Instance.deIndent();
+			Logger.Instance.DeIndent();
 		}
 
-		void deleteTypes() {
+		void DeleteTypes() {
 			var types = module.Types;
 			if (types == null || typesToRemove.Count == 0)
 				return;
 
 			Logger.v("Removing types");
-			Logger.Instance.indent();
-			var moduleType = DotNetUtils.getModuleType(module);
+			Logger.Instance.Indent();
+			var moduleType = DotNetUtils.GetModuleType(module);
 			foreach (var info in typesToRemove) {
 				var typeDef = info.obj;
 				if (typeDef == null || typeDef == moduleType)
@@ -492,26 +492,26 @@ namespace de4dot.code.deobfuscators {
 					removed = types.Remove(typeDef);
 				if (removed)
 					Logger.v("Removed type {0} ({1:X8}) (reason: {2})",
-								Utils.removeNewlines(typeDef),
+								Utils.RemoveNewlines(typeDef),
 								typeDef.MDToken.ToUInt32(),
 								info.reason);
 			}
-			Logger.Instance.deIndent();
+			Logger.Instance.DeIndent();
 		}
 
-		void deleteCustomAttributes() {
+		void DeleteCustomAttributes() {
 			if (attrsToRemove.Count == 0)
 				return;
 
 			Logger.v("Removing custom attributes");
-			Logger.Instance.indent();
-			deleteCustomAttributes(module.CustomAttributes);
+			Logger.Instance.Indent();
+			DeleteCustomAttributes(module.CustomAttributes);
 			if (module.Assembly != null)
-				deleteCustomAttributes(module.Assembly.CustomAttributes);
-			Logger.Instance.deIndent();
+				DeleteCustomAttributes(module.Assembly.CustomAttributes);
+			Logger.Instance.DeIndent();
 		}
 
-		void deleteCustomAttributes(IList<CustomAttribute> customAttrs) {
+		void DeleteCustomAttributes(IList<CustomAttribute> customAttrs) {
 			if (customAttrs == null)
 				return;
 			foreach (var info in attrsToRemove) {
@@ -523,7 +523,7 @@ namespace de4dot.code.deobfuscators {
 						customAttrs.RemoveAt(i);
 						i--;
 						Logger.v("Removed custom attribute {0} ({1:X8}) (reason: {2})",
-									Utils.removeNewlines(typeDef),
+									Utils.RemoveNewlines(typeDef),
 									typeDef.MDToken.ToUInt32(),
 									info.reason);
 						break;
@@ -532,51 +532,51 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		void deleteOtherAttributes() {
+		void DeleteOtherAttributes() {
 			Logger.v("Removing other attributes");
-			Logger.Instance.indent();
-			deleteOtherAttributes(module.CustomAttributes);
+			Logger.Instance.Indent();
+			DeleteOtherAttributes(module.CustomAttributes);
 			if (module.Assembly != null)
-				deleteOtherAttributes(module.Assembly.CustomAttributes);
-			Logger.Instance.deIndent();
+				DeleteOtherAttributes(module.Assembly.CustomAttributes);
+			Logger.Instance.DeIndent();
 		}
 
-		void deleteOtherAttributes(IList<CustomAttribute> customAttributes) {
+		void DeleteOtherAttributes(IList<CustomAttribute> customAttributes) {
 			for (int i = customAttributes.Count - 1; i >= 0; i--) {
 				var attr = customAttributes[i].TypeFullName;
 				if (attr == "System.Runtime.CompilerServices.SuppressIldasmAttribute") {
-					Logger.v("Removed attribute {0}", Utils.removeNewlines(attr));
+					Logger.v("Removed attribute {0}", Utils.RemoveNewlines(attr));
 					customAttributes.RemoveAt(i);
 				}
 			}
 		}
 
-		void deleteDllResources() {
+		void DeleteDllResources() {
 			if (!module.HasResources || resourcesToRemove.Count == 0)
 				return;
 
 			Logger.v("Removing resources");
-			Logger.Instance.indent();
+			Logger.Instance.Indent();
 			foreach (var info in resourcesToRemove) {
 				var resource = info.obj;
 				if (resource == null)
 					continue;
 				if (module.Resources.Remove(resource))
-					Logger.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);
 			}
-			Logger.Instance.deIndent();
+			Logger.Instance.DeIndent();
 		}
 
-		protected void setInitLocals() {
+		protected void SetInitLocals() {
 			foreach (var type in module.GetTypes()) {
 				foreach (var method in type.Methods) {
-					if (isFatHeader(method))
+					if (IsFatHeader(method))
 						method.Body.InitLocals = true;
 				}
 			}
 		}
 
-		static bool isFatHeader(MethodDef method) {
+		static bool IsFatHeader(MethodDef method) {
 			if (method == null || method.Body == null)
 				return false;
 			var body = method.Body;
@@ -586,13 +586,13 @@ namespace de4dot.code.deobfuscators {
 				return true;
 			if (body.ExceptionHandlers.Count > 0)
 				return true;
-			if (getCodeSize(method) > 63)
+			if (GetCodeSize(method) > 63)
 				return true;
 
 			return false;
 		}
 
-		static int getCodeSize(MethodDef method) {
+		static int GetCodeSize(MethodDef method) {
 			if (method == null || method.Body == null)
 				return 0;
 			int size = 0;
@@ -605,7 +605,7 @@ namespace de4dot.code.deobfuscators {
 			return Name;
 		}
 
-		protected void findPossibleNamesToRemove(MethodDef method) {
+		protected void FindPossibleNamesToRemove(MethodDef method) {
 			if (method == null || !method.HasBody)
 				return;
 
@@ -615,53 +615,53 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		protected void addResources(string reason) {
+		protected void AddResources(string reason) {
 			if (!module.HasResources)
 				return;
 
 			foreach (var name in namesToPossiblyRemove) {
 				foreach (var resource in module.Resources) {
 					if (resource.Name == name) {
-						addResourceToBeRemoved(resource, reason);
+						AddResourceToBeRemoved(resource, reason);
 						break;
 					}
 				}
 			}
 		}
 
-		protected bool removeProxyDelegates(ProxyCallFixerBase proxyCallFixer) {
-			return removeProxyDelegates(proxyCallFixer, true);
+		protected bool RemoveProxyDelegates(ProxyCallFixerBase proxyCallFixer) {
+			return RemoveProxyDelegates(proxyCallFixer, true);
 		}
 
-		protected bool removeProxyDelegates(ProxyCallFixerBase proxyCallFixer, bool removeCreators) {
+		protected bool RemoveProxyDelegates(ProxyCallFixerBase proxyCallFixer, bool removeCreators) {
 			if (proxyCallFixer.Errors != 0) {
 				Logger.v("Not removing proxy delegates and creator type since errors were detected.");
 				return false;
 			}
-			addTypesToBeRemoved(proxyCallFixer.DelegateTypes, "Proxy delegate type");
+			AddTypesToBeRemoved(proxyCallFixer.DelegateTypes, "Proxy delegate type");
 			if (removeCreators && proxyCallFixer.RemovedDelegateCreatorCalls > 0) {
-				addTypesToBeRemoved(proxyCallFixer.DelegateCreatorTypes, "Proxy delegate creator type");
+				AddTypesToBeRemoved(proxyCallFixer.DelegateCreatorTypes, "Proxy delegate creator type");
 				foreach (var tuple in proxyCallFixer.OtherMethods)
-					addMethodToBeRemoved(tuple.Item1, tuple.Item2);
+					AddMethodToBeRemoved(tuple.Item1, tuple.Item2);
 			}
 			return true;
 		}
 
-		protected Resource getResource(IEnumerable<string> strings) {
-			return DotNetUtils.getResource(module, strings);
+		protected Resource GetResource(IEnumerable<string> strings) {
+			return DotNetUtils.GetResource(module, strings);
 		}
 
-		protected CustomAttribute getAssemblyAttribute(IType attr) {
+		protected CustomAttribute GetAssemblyAttribute(IType attr) {
 			if (module.Assembly == null)
 				return null;
 			return module.Assembly.CustomAttributes.Find(attr);
 		}
 
-		protected CustomAttribute getModuleAttribute(IType attr) {
+		protected CustomAttribute GetModuleAttribute(IType attr) {
 			return module.CustomAttributes.Find(attr);
 		}
 
-		protected bool hasMetadataStream(string name) {
+		protected bool HasMetadataStream(string name) {
 			foreach (var stream in module.MetaData.AllStreams) {
 				if (stream.Name == name)
 					return true;
@@ -669,7 +669,7 @@ namespace de4dot.code.deobfuscators {
 			return false;
 		}
 
-		List<T> getObjectsToRemove<T>(IList<RemoveInfo<T>> removeThese) where T : class, ICodedToken {
+		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)
@@ -678,94 +678,94 @@ namespace de4dot.code.deobfuscators {
 			return list;
 		}
 
-		protected List<TypeDef> getTypesToRemove() {
-			return getObjectsToRemove(typesToRemove);
+		protected List<TypeDef> GetTypesToRemove() {
+			return GetObjectsToRemove(typesToRemove);
 		}
 
-		protected List<MethodDef> getMethodsToRemove() {
-			return getObjectsToRemove(methodsToRemove);
+		protected List<MethodDef> GetMethodsToRemove() {
+			return GetObjectsToRemove(methodsToRemove);
 		}
 
-		public virtual bool isValidNamespaceName(string ns) {
+		public virtual bool IsValidNamespaceName(string ns) {
 			if (ns == null)
 				return false;
 			foreach (var part in ns.Split(new char[] { '.' })) {
-				if (!checkValidName(part))
+				if (!CheckValidName(part))
 					return false;
 			}
 			return true;
 		}
 
-		public virtual bool isValidTypeName(string name) {
-			return name != null && checkValidName(name);
+		public virtual bool IsValidTypeName(string name) {
+			return name != null && CheckValidName(name);
 		}
 
-		public virtual bool isValidMethodName(string name) {
-			return name != null && checkValidName(name);
+		public virtual bool IsValidMethodName(string name) {
+			return name != null && CheckValidName(name);
 		}
 
-		public virtual bool isValidPropertyName(string name) {
-			return name != null && checkValidName(name);
+		public virtual bool IsValidPropertyName(string name) {
+			return name != null && CheckValidName(name);
 		}
 
-		public virtual bool isValidEventName(string name) {
-			return name != null && checkValidName(name);
+		public virtual bool IsValidEventName(string name) {
+			return name != null && CheckValidName(name);
 		}
 
-		public virtual bool isValidFieldName(string name) {
-			return name != null && checkValidName(name);
+		public virtual bool IsValidFieldName(string name) {
+			return name != null && CheckValidName(name);
 		}
 
-		public virtual bool isValidGenericParamName(string name) {
-			return name != null && checkValidName(name);
+		public virtual bool IsValidGenericParamName(string name) {
+			return name != null && CheckValidName(name);
 		}
 
-		public virtual bool isValidMethodArgName(string name) {
-			return name != null && checkValidName(name);
+		public virtual bool IsValidMethodArgName(string name) {
+			return name != null && CheckValidName(name);
 		}
 
-		public virtual bool isValidMethodReturnArgName(string name) {
-			return string.IsNullOrEmpty(name) || 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 bool IsValidResourceKeyName(string name) {
+			return name != null && CheckValidName(name);
 		}
 
 		public virtual void OnWriterEvent(ModuleWriterBase writer, ModuleWriterEvent evt) {
 		}
 
-		protected void findAndRemoveInlinedMethods() {
-			removeInlinedMethods(InlinedMethodsFinder.find(module));
+		protected void FindAndRemoveInlinedMethods() {
+			RemoveInlinedMethods(InlinedMethodsFinder.Find(module));
 		}
 
-		protected void removeInlinedMethods(List<MethodDef> inlinedMethods) {
-			addMethodsToBeRemoved(new UnusedMethodsFinder(module, inlinedMethods, getRemovedMethods()).find(), "Inlined method");
+		protected void RemoveInlinedMethods(List<MethodDef> inlinedMethods) {
+			AddMethodsToBeRemoved(new UnusedMethodsFinder(module, inlinedMethods, GetRemovedMethods()).Find(), "Inlined method");
 		}
 
-		protected MethodCollection getRemovedMethods() {
+		protected MethodCollection GetRemovedMethods() {
 			var removedMethods = new MethodCollection();
-			removedMethods.add(getMethodsToRemove());
-			removedMethods.addAndNested(getTypesToRemove());
+			removedMethods.Add(GetMethodsToRemove());
+			removedMethods.AddAndNested(GetTypesToRemove());
 			return removedMethods;
 		}
 
-		protected bool isTypeCalled(TypeDef decrypterType) {
+		protected bool IsTypeCalled(TypeDef decrypterType) {
 			if (decrypterType == null)
 				return false;
 
 			var decrypterMethods = new MethodCollection();
-			decrypterMethods.addAndNested(decrypterType);
+			decrypterMethods.AddAndNested(decrypterType);
 
-			var removedMethods = getRemovedMethods();
+			var removedMethods = GetRemovedMethods();
 
 			foreach (var type in module.GetTypes()) {
 				foreach (var method in type.Methods) {
 					if (method.Body == null)
 						continue;
-					if (decrypterMethods.exists(method))
+					if (decrypterMethods.Exists(method))
 						break;	// decrypter type / nested type method
-					if (removedMethods.exists(method))
+					if (removedMethods.Exists(method))
 						continue;
 
 					foreach (var instr in method.Body.Instructions) {
@@ -776,7 +776,7 @@ namespace de4dot.code.deobfuscators {
 							var calledMethod = instr.Operand as IMethod;
 							if (calledMethod == null)
 								break;
-							if (decrypterMethods.exists(calledMethod))
+							if (decrypterMethods.Exists(calledMethod))
 								return true;
 							break;
 
@@ -790,7 +790,7 @@ namespace de4dot.code.deobfuscators {
 			return false;
 		}
 
-		protected bool hasNativeMethods() {
+		protected bool HasNativeMethods() {
 			if (module.VTableFixups != null)
 				return true;
 			foreach (var type in module.GetTypes()) {
@@ -806,7 +806,7 @@ namespace de4dot.code.deobfuscators {
 			return false;
 		}
 
-		protected static int toInt32(bool b) {
+		protected static int ToInt32(bool b) {
 			return b ? 1 : 0;
 		}
 
diff --git a/de4dot.code/deobfuscators/DeobfuscatorInfoBase.cs b/de4dot.code/deobfuscators/DeobfuscatorInfoBase.cs
index 0e5ba228..e5ca4b90 100644
--- a/de4dot.code/deobfuscators/DeobfuscatorInfoBase.cs
+++ b/de4dot.code/deobfuscators/DeobfuscatorInfoBase.cs
@@ -28,25 +28,25 @@ namespace de4dot.code.deobfuscators {
 		}
 
 		public DeobfuscatorInfoBase(string nameRegex) {
-			validNameRegex = new NameRegexOption(null, makeArgName("name"), "Valid name regex pattern", nameRegex ?? DeobfuscatorBase.DEFAULT_VALID_NAME_REGEX);
+			validNameRegex = new NameRegexOption(null, MakeArgName("name"), "Valid name regex pattern", nameRegex ?? DeobfuscatorBase.DEFAULT_VALID_NAME_REGEX);
 		}
 
-		protected string makeArgName(string name) {
+		protected string MakeArgName(string name) {
 			return string.Format("{0}-{1}", Type, name);
 		}
 
 		public abstract string Type { get; }
 		public abstract string Name { get; }
-		public abstract IDeobfuscator createDeobfuscator();
+		public abstract IDeobfuscator CreateDeobfuscator();
 
-		protected virtual IEnumerable<Option> getOptionsInternal() {
+		protected virtual IEnumerable<Option> GetOptionsInternal() {
 			return new List<Option>();
 		}
 
-		public IEnumerable<Option> getOptions() {
+		public IEnumerable<Option> GetOptions() {
 			var options = new List<Option>();
 			options.Add(validNameRegex);
-			options.AddRange(getOptionsInternal());
+			options.AddRange(GetOptionsInternal());
 			return options;
 		}
 	}
diff --git a/de4dot.code/deobfuscators/Dotfuscator/Deobfuscator.cs b/de4dot.code/deobfuscators/Dotfuscator/Deobfuscator.cs
index 8ac8282b..b6e41355 100644
--- a/de4dot.code/deobfuscators/Dotfuscator/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/Dotfuscator/Deobfuscator.cs
@@ -38,7 +38,7 @@ namespace de4dot.code.deobfuscators.Dotfuscator {
 			get { return THE_TYPE; }
 		}
 
-		public override IDeobfuscator createDeobfuscator() {
+		public override IDeobfuscator CreateDeobfuscator() {
 			return new Deobfuscator(new Deobfuscator.Options {
 				RenameResourcesInCode = false,
 				ValidNameRegex = validNameRegex.get(),
@@ -73,7 +73,7 @@ namespace de4dot.code.deobfuscators.Dotfuscator {
 			this.options = options;
 		}
 
-		protected override int detectInternal() {
+		protected override int DetectInternal() {
 			int val = 0;
 
 			if (stringDecrypter.Detected)
@@ -84,25 +84,25 @@ namespace de4dot.code.deobfuscators.Dotfuscator {
 			return val;
 		}
 
-		protected override void scanForObfuscator() {
+		protected override void ScanForObfuscator() {
 			stringDecrypter = new StringDecrypter(module);
-			stringDecrypter.find(DeobfuscatedFile);
-			findDotfuscatorAttribute();
+			stringDecrypter.Find(DeobfuscatedFile);
+			FindDotfuscatorAttribute();
 		}
 
-		void findDotfuscatorAttribute() {
+		void FindDotfuscatorAttribute() {
 			foreach (var type in module.Types) {
 				if (type.FullName == "DotfuscatorAttribute") {
 					foundDotfuscatorAttribute = true;
-					addAttributeToBeRemoved(type, "Obfuscator attribute");
-					initializeVersion(type);
+					AddAttributeToBeRemoved(type, "Obfuscator attribute");
+					InitializeVersion(type);
 					return;
 				}
 			}
 		}
 
-		void initializeVersion(TypeDef attr) {
-			var s = DotNetUtils.getCustomArgAsString(getAssemblyAttribute(attr), 0);
+		void InitializeVersion(TypeDef attr) {
+			var s = DotNetUtils.GetCustomArgAsString(GetAssemblyAttribute(attr), 0);
 			if (s == null)
 				return;
 
@@ -112,21 +112,21 @@ namespace de4dot.code.deobfuscators.Dotfuscator {
 			obfuscatorName = "Dotfuscator " + val.Groups[1].ToString();
 		}
 
-		public override void deobfuscateBegin() {
-			base.deobfuscateBegin();
+		public override void DeobfuscateBegin() {
+			base.DeobfuscateBegin();
 			foreach (var info in stringDecrypter.StringDecrypterInfos)
-				staticStringInliner.add(info.method, (method, gim, args) => stringDecrypter.decrypt(method, (string)args[0], (int)args[1]));
-			DeobfuscatedFile.stringDecryptersAdded();
+				staticStringInliner.Add(info.method, (method, gim, args) => stringDecrypter.Decrypt(method, (string)args[0], (int)args[1]));
+			DeobfuscatedFile.StringDecryptersAdded();
 		}
 
-		public override void deobfuscateEnd() {
+		public override void DeobfuscateEnd() {
 			if (CanRemoveStringDecrypterType)
-				addMethodsToBeRemoved(stringDecrypter.StringDecrypters, "String decrypter method");
+				AddMethodsToBeRemoved(stringDecrypter.StringDecrypters, "String decrypter method");
 
-			base.deobfuscateEnd();
+			base.DeobfuscateEnd();
 		}
 
-		public override IEnumerable<int> getStringDecrypterMethods() {
+		public override IEnumerable<int> GetStringDecrypterMethods() {
 			var list = new List<int>();
 			foreach (var method in stringDecrypter.StringDecrypters)
 				list.Add(method.MDToken.ToInt32());
diff --git a/de4dot.code/deobfuscators/Dotfuscator/StringDecrypter.cs b/de4dot.code/deobfuscators/Dotfuscator/StringDecrypter.cs
index c9826c1e..71466c7b 100644
--- a/de4dot.code/deobfuscators/Dotfuscator/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/Dotfuscator/StringDecrypter.cs
@@ -43,36 +43,36 @@ namespace de4dot.code.deobfuscators.Dotfuscator {
 		public IEnumerable<MethodDef> StringDecrypters {
 			get {
 				var list = new List<MethodDef>(stringDecrypterMethods.Count);
-				foreach (var info in stringDecrypterMethods.getValues())
+				foreach (var info in stringDecrypterMethods.GetValues())
 					list.Add(info.method);
 				return list;
 			}
 		}
 
 		public IEnumerable<StringDecrypterInfo> StringDecrypterInfos {
-			get { return stringDecrypterMethods.getValues(); }
+			get { return stringDecrypterMethods.GetValues(); }
 		}
 
 		public StringDecrypter(ModuleDefMD module) {
 			this.module = module;
 		}
 
-		public void find(ISimpleDeobfuscator simpleDeobfuscator) {
+		public void Find(ISimpleDeobfuscator simpleDeobfuscator) {
 			foreach (var type in module.GetTypes())
-				findStringDecrypterMethods(type, simpleDeobfuscator);
+				FindStringDecrypterMethods(type, simpleDeobfuscator);
 		}
 
-		void findStringDecrypterMethods(TypeDef type, ISimpleDeobfuscator simpleDeobfuscator) {
-			foreach (var method in DotNetUtils.findMethods(type.Methods, "System.String", new string[] { "System.String", "System.Int32" })) {
+		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;
 
-				if (DotNetUtils.getMethodCalls(method, "System.Char[] System.String::ToCharArray()") != 1)
+				if (DotNetUtils.GetMethodCalls(method, "System.Char[] System.String::ToCharArray()") != 1)
 					continue;
-				if (DotNetUtils.getMethodCalls(method, "System.String System.String::Intern(System.String)") != 1)
+				if (DotNetUtils.GetMethodCalls(method, "System.String System.String::Intern(System.String)") != 1)
 					continue;
 
-				simpleDeobfuscator.deobfuscate(method);
+				simpleDeobfuscator.Deobfuscate(method);
 				var instructions = method.Body.Instructions;
 				for (int i = 0; i <= instructions.Count - 3; i++) {
 					var ldci4 = method.Body.Instructions[i];
@@ -84,15 +84,15 @@ namespace de4dot.code.deobfuscators.Dotfuscator {
 						continue;
 
 					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);
+					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(IMethod method, string encrypted, int value) {
-			var info = stringDecrypterMethods.findAny(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 c223c8eb..023edce0 100644
--- a/de4dot.code/deobfuscators/Eazfuscator_NET/AssemblyResolver.cs
+++ b/de4dot.code/deobfuscators/Eazfuscator_NET/AssemblyResolver.cs
@@ -78,16 +78,16 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 
 		public AssemblyResolver(ModuleDefMD module, DecrypterType decrypterType) {
 			this.module = module;
-			this.frameworkType = DotNetUtils.getFrameworkType(module);
+			this.frameworkType = DotNetUtils.GetFrameworkType(module);
 			this.decrypterType = decrypterType;
 			this.codeCompilerMethodCallRestorer = new CodeCompilerMethodCallRestorer(module);
 		}
 
-		public void find() {
-			checkCalledMethods(DotNetUtils.getModuleTypeCctor(module));
+		public void Find() {
+			CheckCalledMethods(DotNetUtils.GetModuleTypeCctor(module));
 		}
 
-		bool checkCalledMethods(MethodDef method) {
+		bool CheckCalledMethods(MethodDef method) {
 			if (method == null || method.Body == null)
 				return false;
 
@@ -98,33 +98,33 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				var calledMethod = instr.Operand as MethodDef;
 				if (calledMethod == null || !calledMethod.IsStatic || calledMethod.Body == null)
 					continue;
-				if (!DotNetUtils.isMethod(calledMethod, "System.Void", "()"))
+				if (!DotNetUtils.IsMethod(calledMethod, "System.Void", "()"))
 					continue;
 
 				if (frameworkType == FrameworkType.Silverlight) {
-					if (!checkInitMethodSilverlight(calledMethod))
+					if (!CheckInitMethodSilverlight(calledMethod))
 						continue;
 				}
 				else {
-					if (!checkInitMethod(calledMethod))
+					if (!CheckInitMethod(calledMethod))
 						continue;
 				}
 
-				decryptMethod = getDecryptMethod();
-				updateDecrypterType();
-				findCodeDomMethods();
+				decryptMethod = GetDecryptMethod();
+				UpdateDecrypterType();
+				FindCodeDomMethods();
 				return true;
 			}
 
 			return false;
 		}
 
-		bool checkInitMethodSilverlight(MethodDef method) {
+		bool CheckInitMethodSilverlight(MethodDef method) {
 			var type = method.DeclaringType;
 			if (type.NestedTypes.Count != 2)
 				return false;
 
-			var resolveHandler = getResolveMethodSilverlight(method);
+			var resolveHandler = GetResolveMethodSilverlight(method);
 			if (resolveHandler == null)
 				return false;
 
@@ -134,17 +134,17 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return true;
 		}
 
-		static MethodDef getResolveMethodSilverlight(MethodDef 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 MethodDef;
 				if (calledMethod == null)
 					continue;
-				if (!DotNetUtils.isMethod(calledMethod, "System.Void", "()"))
+				if (!DotNetUtils.IsMethod(calledMethod, "System.Void", "()"))
 					continue;
-				if (!DeobUtils.hasInteger(calledMethod, ',') ||
-					!DeobUtils.hasInteger(calledMethod, '|'))
+				if (!DeobUtils.HasInteger(calledMethod, ',') ||
+					!DeobUtils.HasInteger(calledMethod, '|'))
 					continue;
 
 				return calledMethod;
@@ -153,18 +153,18 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return null;
 		}
 
-		bool checkInitMethod(MethodDef method) {
+		bool CheckInitMethod(MethodDef method) {
 			var type = method.DeclaringType;
 			if (type.NestedTypes.Count < 2 || type.NestedTypes.Count > 6)
 				return false;
-			if (DotNetUtils.getPInvokeMethod(type, "kernel32", "MoveFileEx") == null)
+			if (DotNetUtils.GetPInvokeMethod(type, "kernel32", "MoveFileEx") == null)
 				return false;
 
-			var resolveHandler = DeobUtils.getResolveMethod(method);
+			var resolveHandler = DeobUtils.GetResolveMethod(method);
 			if (resolveHandler == null)
 				return false;
-			if (!DeobUtils.hasInteger(resolveHandler, ',') ||
-				!DeobUtils.hasInteger(resolveHandler, '|'))
+			if (!DeobUtils.HasInteger(resolveHandler, ',') ||
+				!DeobUtils.HasInteger(resolveHandler, '|'))
 				return false;
 
 			initMethod = method;
@@ -173,14 +173,14 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return true;
 		}
 
-		MethodDef getDecryptMethod() {
+		MethodDef GetDecryptMethod() {
 			foreach (var method in resolverType.Methods) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
-				if (!DotNetUtils.isMethod(method, "System.Byte[]", "(System.Byte[])"))
+				if (!DotNetUtils.IsMethod(method, "System.Byte[]", "(System.Byte[])"))
 					continue;
-				if (!DeobUtils.hasInteger(method, 32) ||
-					!DeobUtils.hasInteger(method, 121))
+				if (!DeobUtils.HasInteger(method, 32) ||
+					!DeobUtils.HasInteger(method, 121))
 					continue;
 
 				return method;
@@ -189,16 +189,16 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			throw new ApplicationException("Could not find decrypt method");
 		}
 
-		void updateDecrypterType() {
-			var theDecrypterType = getDecrypterType(decryptMethod);
+		void UpdateDecrypterType() {
+			var theDecrypterType = GetDecrypterType(decryptMethod);
 			if (theDecrypterType == null)
 				return;
 			decrypterType.Type = theDecrypterType;
-			if (!decrypterType.initialize())
+			if (!decrypterType.Initialize())
 				throw new ApplicationException("Could not initialize decrypterType");
 		}
 
-		TypeDef getDecrypterType(MethodDef method) {
+		TypeDef GetDecrypterType(MethodDef method) {
 			if (method == null || method.Body == null)
 				return null;
 
@@ -208,7 +208,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				var calledMethod = instr.Operand as MethodDef;
 				if (calledMethod == null || !calledMethod.IsStatic || calledMethod.DeclaringType == resolverType)
 					continue;
-				if (!DotNetUtils.isMethod(calledMethod, "System.Void", "(System.Byte[])"))
+				if (!DotNetUtils.IsMethod(calledMethod, "System.Void", "(System.Byte[])"))
 					continue;
 
 				return calledMethod.DeclaringType;
@@ -217,24 +217,24 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return null;
 		}
 
-		public void initialize(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
+		public void Initialize(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
 			if (handlerMethod == null)
 				return;
 
-			findOtherType();
+			FindOtherType();
 
-			simpleDeobfuscator.deobfuscate(handlerMethod);
-			simpleDeobfuscator.decryptStrings(handlerMethod, deob);
-			if (!createAssemblyInfos())
+			simpleDeobfuscator.Deobfuscate(handlerMethod);
+			simpleDeobfuscator.DecryptStrings(handlerMethod, deob);
+			if (!CreateAssemblyInfos())
 				throw new ApplicationException("Could not initialize assembly infos");
 
-			simpleDeobfuscator.deobfuscate(decryptMethod);
-			simpleDeobfuscator.decryptStrings(decryptMethod, deob);
-			if (!createDecryptKey())
+			simpleDeobfuscator.Deobfuscate(decryptMethod);
+			simpleDeobfuscator.DecryptStrings(decryptMethod, deob);
+			if (!CreateDecryptKey())
 				throw new ApplicationException("Could not initialize decryption key");
 		}
 
-		void findOtherType() {
+		void FindOtherType() {
 			foreach (var type in module.Types) {
 				// This type is added by EF 3.1+. The last number seems to be an int32 hash of
 				// the assembly name, but - replaced with _.
@@ -246,18 +246,18 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			}
 		}
 
-		bool createDecryptKey() {
+		bool CreateDecryptKey() {
 			if (decryptMethod == null)
 				return false;
 
-			foreach (var s in DotNetUtils.getCodeStrings(decryptMethod)) {
-				decryptKey = decodeBase64(s);
+			foreach (var s in DotNetUtils.GetCodeStrings(decryptMethod)) {
+				decryptKey = DecodeBase64(s);
 				if (decryptKey == null || decryptKey.Length == 0)
 					continue;
 
 				if (decrypterType.Detected) {
 					var data = new byte[8];
-					ulong magic = decrypterType.getMagic();
+					ulong magic = decrypterType.GetMagic();
 					data[0] = (byte)magic;
 					data[7] = (byte)(magic >> 8);
 					data[6] = (byte)(magic >> 16);
@@ -277,7 +277,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return false;
 		}
 
-		static byte[] decodeBase64(string s) {
+		static byte[] DecodeBase64(string s) {
 			try {
 				return Convert.FromBase64String(s);
 			}
@@ -286,10 +286,10 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			}
 		}
 
-		bool createAssemblyInfos() {
-			int numElements = DeobUtils.hasInteger(handlerMethod, 3) ? 3 : 2;
-			foreach (var s in DotNetUtils.getCodeStrings(handlerMethod)) {
-				var infos = createAssemblyInfos(s, numElements);
+		bool CreateAssemblyInfos() {
+			int numElements = DeobUtils.HasInteger(handlerMethod, 3) ? 3 : 2;
+			foreach (var s in DotNetUtils.GetCodeStrings(handlerMethod)) {
+				var infos = CreateAssemblyInfos(s, numElements);
 				if (infos == null)
 					continue;
 
@@ -300,16 +300,16 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return false;
 		}
 
-		List<AssemblyInfo> createAssemblyInfos(string s, int numElements) {
+		List<AssemblyInfo> CreateAssemblyInfos(string s, int numElements) {
 			try {
-				return tryCreateAssemblyInfos(s, numElements);
+				return TryCreateAssemblyInfos(s, numElements);
 			}
 			catch (FormatException) {
 				return null;	// Convert.FromBase64String() failed
 			}
 		}
 
-		List<AssemblyInfo> tryCreateAssemblyInfos(string s, int numElements) {
+		List<AssemblyInfo> TryCreateAssemblyInfos(string s, int numElements) {
 			var ary = s.Split(',');
 			if (ary.Length == 0 || ary.Length % numElements != 0)
 				return null;
@@ -323,7 +323,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				if (numElements >= 3)
 					info.Filename = Encoding.UTF8.GetString(Convert.FromBase64String(ary[i + 2]));
 				else
-					info.Filename = Utils.getAssemblySimpleName(info.AssemblyFullName) + ".dll";
+					info.Filename = Utils.GetAssemblySimpleName(info.AssemblyFullName) + ".dll";
 				int index = info.ResourceName.IndexOf('|');
 				if (index >= 0) {
 					var flags = info.ResourceName.Substring(0, index);
@@ -338,33 +338,33 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return infos;
 		}
 
-		public void initializeEmbeddedFiles() {
+		public void InitializeEmbeddedFiles() {
 			foreach (var info in assemblyInfos) {
-				info.Resource = DotNetUtils.getResource(module, info.ResourceName) as EmbeddedResource;
+				info.Resource = DotNetUtils.GetResource(module, info.ResourceName) as EmbeddedResource;
 				if (info.Resource == null)
-					throw new ApplicationException(string.Format("Could not find resource {0}", Utils.toCsharpString(info.ResourceName)));
+					throw new ApplicationException(string.Format("Could not find resource {0}", Utils.ToCsharpString(info.ResourceName)));
 
 				info.Data = info.Resource.GetResourceData();
 				if (info.IsEncrypted)
-					decrypt(info.Data);
+					Decrypt(info.Data);
 				if (info.IsCompressed)
-					info.Data = decompress(info.Data);
+					info.Data = Decompress(info.Data);
 
-				initializeNameAndExtension(info);
+				InitializeNameAndExtension(info);
 			}
 		}
 
-		static void initializeNameAndExtension(AssemblyInfo info) {
+		static void InitializeNameAndExtension(AssemblyInfo info) {
 			try {
 				var mod = ModuleDefMD.Load(info.Data);
 				info.AssemblyFullName = mod.Assembly.FullName;
 				info.SimpleName = mod.Assembly.Name.String;
-				info.Extension = DeobUtils.getExtension(mod.Kind);
+				info.Extension = DeobUtils.GetExtension(mod.Kind);
 				return;
 			}
 			catch {
 			}
-			Logger.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;
@@ -377,41 +377,41 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 		}
 
 		static readonly byte[] key2 = new byte[] { 148, 68, 208, 52 };
-		void decrypt(byte[] encryptedData) {
+		void Decrypt(byte[] encryptedData) {
 			var indexes = new byte[256];
 			for (int i = 0; i < indexes.Length; i++)
 				indexes[i] = (byte)i;
 			byte i1 = 0, i2 = 0;
 			for (int i = 0; i < indexes.Length; i++) {
 				i2 += (byte)(decryptKey[i % decryptKey.Length] + indexes[i]);
-				swap(indexes, i, i2);
+				Swap(indexes, i, i2);
 			}
 
 			byte val = 0;
 			for (int i = 0; i < encryptedData.Length; i++) {
 				if ((i & 0x1F) == 0) {
 					i2 += indexes[++i1];
-					swap(indexes, i1, i2);
+					Swap(indexes, i1, i2);
 					val = indexes[(byte)(indexes[i1] + indexes[i2])];
 				}
 				encryptedData[i] ^= (byte)(val ^ key2[(i >> 2) & 3] ^ key2[(i + 1) & 3]);
 			}
 		}
 
-		static void swap(byte[] data, int i, int j) {
+		static void Swap(byte[] data, int i, int j) {
 			byte tmp = data[i];
 			data[i] = data[j];
 			data[j] = tmp;
 		}
 
-		byte[] decompress(byte[] compressedData) {
+		byte[] Decompress(byte[] compressedData) {
 			// First dword is sig: 0x9B728BC7
 			// Second dword is decompressed length
-			return DeobUtils.inflate(compressedData, 8, compressedData.Length - 8, true);
+			return DeobUtils.Inflate(compressedData, 8, compressedData.Length - 8, true);
 		}
 
-		public AssemblyInfo get(string asmFullName) {
-			var simpleName = Utils.getAssemblySimpleName(asmFullName);
+		public AssemblyInfo Get(string asmFullName) {
+			var simpleName = Utils.GetAssemblySimpleName(asmFullName);
 			for (int i = 0; i < assemblyInfos.Count; i++) {
 				var info = assemblyInfos[i];
 				if (info.SimpleName != simpleName)
@@ -424,11 +424,11 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return null;
 		}
 
-		public void deobfuscate(Blocks blocks) {
-			codeCompilerMethodCallRestorer.deobfuscate(blocks);
+		public void Deobfuscate(Blocks blocks) {
+			codeCompilerMethodCallRestorer.Deobfuscate(blocks);
 		}
 
-		void findCodeDomMethods() {
+		void FindCodeDomMethods() {
 			if (resolverType == null)
 				return;
 
@@ -436,15 +436,15 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				if (nestedType.Fields.Count != 0)
 					continue;
 
-				var CompileAssemblyFromDom1         = getTheOnlyMethod(nestedType, "System.CodeDom.Compiler.CodeDomProvider", "CompileAssemblyFromDom", "System.CodeDom.Compiler.CompilerResults", "System.CodeDom.Compiler.CompilerParameters,System.CodeDom.CodeCompileUnit[]");
-				var CompileAssemblyFromFile1        = getTheOnlyMethod(nestedType, "System.CodeDom.Compiler.CodeDomProvider", "CompileAssemblyFromFile", "System.CodeDom.Compiler.CompilerResults", "System.CodeDom.Compiler.CompilerParameters,System.String[]");
-				var CompileAssemblyFromSource1      = getTheOnlyMethod(nestedType, "System.CodeDom.Compiler.CodeDomProvider", "CompileAssemblyFromSource", "System.CodeDom.Compiler.CompilerResults", "System.CodeDom.Compiler.CompilerParameters,System.String[]");
-				var CompileAssemblyFromDom2         = getTheOnlyMethod(nestedType, "System.CodeDom.Compiler.ICodeCompiler", "CompileAssemblyFromDom", "System.CodeDom.Compiler.CompilerResults", "System.CodeDom.Compiler.CompilerParameters,System.CodeDom.CodeCompileUnit");
-				var CompileAssemblyFromDomBatch2    = getTheOnlyMethod(nestedType, "System.CodeDom.Compiler.ICodeCompiler", "CompileAssemblyFromDomBatch", "System.CodeDom.Compiler.CompilerResults", "System.CodeDom.Compiler.CompilerParameters,System.CodeDom.CodeCompileUnit[]");
-				var CompileAssemblyFromFile2        = getTheOnlyMethod(nestedType, "System.CodeDom.Compiler.ICodeCompiler", "CompileAssemblyFromFile", "System.CodeDom.Compiler.CompilerResults", "System.CodeDom.Compiler.CompilerParameters,System.String");
-				var CompileAssemblyFromFileBatch2   = getTheOnlyMethod(nestedType, "System.CodeDom.Compiler.ICodeCompiler", "CompileAssemblyFromFileBatch", "System.CodeDom.Compiler.CompilerResults", "System.CodeDom.Compiler.CompilerParameters,System.String[]");
-				var CompileAssemblyFromSource2      = getTheOnlyMethod(nestedType, "System.CodeDom.Compiler.ICodeCompiler", "CompileAssemblyFromSource", "System.CodeDom.Compiler.CompilerResults", "System.CodeDom.Compiler.CompilerParameters,System.String");
-				var CompileAssemblyFromSourceBatch2 = getTheOnlyMethod(nestedType, "System.CodeDom.Compiler.ICodeCompiler", "CompileAssemblyFromSourceBatch", "System.CodeDom.Compiler.CompilerResults", "System.CodeDom.Compiler.CompilerParameters,System.String[]");
+				var CompileAssemblyFromDom1         = GetTheOnlyMethod(nestedType, "System.CodeDom.Compiler.CodeDomProvider", "CompileAssemblyFromDom", "System.CodeDom.Compiler.CompilerResults", "System.CodeDom.Compiler.CompilerParameters,System.CodeDom.CodeCompileUnit[]");
+				var CompileAssemblyFromFile1        = GetTheOnlyMethod(nestedType, "System.CodeDom.Compiler.CodeDomProvider", "CompileAssemblyFromFile", "System.CodeDom.Compiler.CompilerResults", "System.CodeDom.Compiler.CompilerParameters,System.String[]");
+				var CompileAssemblyFromSource1      = GetTheOnlyMethod(nestedType, "System.CodeDom.Compiler.CodeDomProvider", "CompileAssemblyFromSource", "System.CodeDom.Compiler.CompilerResults", "System.CodeDom.Compiler.CompilerParameters,System.String[]");
+				var CompileAssemblyFromDom2         = GetTheOnlyMethod(nestedType, "System.CodeDom.Compiler.ICodeCompiler", "CompileAssemblyFromDom", "System.CodeDom.Compiler.CompilerResults", "System.CodeDom.Compiler.CompilerParameters,System.CodeDom.CodeCompileUnit");
+				var CompileAssemblyFromDomBatch2    = GetTheOnlyMethod(nestedType, "System.CodeDom.Compiler.ICodeCompiler", "CompileAssemblyFromDomBatch", "System.CodeDom.Compiler.CompilerResults", "System.CodeDom.Compiler.CompilerParameters,System.CodeDom.CodeCompileUnit[]");
+				var CompileAssemblyFromFile2        = GetTheOnlyMethod(nestedType, "System.CodeDom.Compiler.ICodeCompiler", "CompileAssemblyFromFile", "System.CodeDom.Compiler.CompilerResults", "System.CodeDom.Compiler.CompilerParameters,System.String");
+				var CompileAssemblyFromFileBatch2   = GetTheOnlyMethod(nestedType, "System.CodeDom.Compiler.ICodeCompiler", "CompileAssemblyFromFileBatch", "System.CodeDom.Compiler.CompilerResults", "System.CodeDom.Compiler.CompilerParameters,System.String[]");
+				var CompileAssemblyFromSource2      = GetTheOnlyMethod(nestedType, "System.CodeDom.Compiler.ICodeCompiler", "CompileAssemblyFromSource", "System.CodeDom.Compiler.CompilerResults", "System.CodeDom.Compiler.CompilerParameters,System.String");
+				var CompileAssemblyFromSourceBatch2 = GetTheOnlyMethod(nestedType, "System.CodeDom.Compiler.ICodeCompiler", "CompileAssemblyFromSourceBatch", "System.CodeDom.Compiler.CompilerResults", "System.CodeDom.Compiler.CompilerParameters,System.String[]");
 
 				if (CompileAssemblyFromDom1 == null && CompileAssemblyFromFile1 == null &&
 					CompileAssemblyFromSource1 == null && CompileAssemblyFromDom2 == null &&
@@ -454,20 +454,20 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 					continue;
 				}
 
-				codeCompilerMethodCallRestorer.add_CodeDomProvider_CompileAssemblyFromDom(CompileAssemblyFromDom1);
-				codeCompilerMethodCallRestorer.add_CodeDomProvider_CompileAssemblyFromFile(CompileAssemblyFromFile1);
-				codeCompilerMethodCallRestorer.add_CodeDomProvider_CompileAssemblyFromSource(CompileAssemblyFromSource1);
-				codeCompilerMethodCallRestorer.add_ICodeCompiler_CompileAssemblyFromDom(CompileAssemblyFromDom2);
-				codeCompilerMethodCallRestorer.add_ICodeCompiler_CompileAssemblyFromDomBatch(CompileAssemblyFromDomBatch2);
-				codeCompilerMethodCallRestorer.add_ICodeCompiler_CompileAssemblyFromFile(CompileAssemblyFromFile2);
-				codeCompilerMethodCallRestorer.add_ICodeCompiler_CompileAssemblyFromFileBatch(CompileAssemblyFromFileBatch2);
-				codeCompilerMethodCallRestorer.add_ICodeCompiler_CompileAssemblyFromSource(CompileAssemblyFromSource2);
-				codeCompilerMethodCallRestorer.add_ICodeCompiler_CompileAssemblyFromSourceBatch(CompileAssemblyFromSourceBatch2);
+				codeCompilerMethodCallRestorer.Add_CodeDomProvider_CompileAssemblyFromDom(CompileAssemblyFromDom1);
+				codeCompilerMethodCallRestorer.Add_CodeDomProvider_CompileAssemblyFromFile(CompileAssemblyFromFile1);
+				codeCompilerMethodCallRestorer.Add_CodeDomProvider_CompileAssemblyFromSource(CompileAssemblyFromSource1);
+				codeCompilerMethodCallRestorer.Add_ICodeCompiler_CompileAssemblyFromDom(CompileAssemblyFromDom2);
+				codeCompilerMethodCallRestorer.Add_ICodeCompiler_CompileAssemblyFromDomBatch(CompileAssemblyFromDomBatch2);
+				codeCompilerMethodCallRestorer.Add_ICodeCompiler_CompileAssemblyFromFile(CompileAssemblyFromFile2);
+				codeCompilerMethodCallRestorer.Add_ICodeCompiler_CompileAssemblyFromFileBatch(CompileAssemblyFromFileBatch2);
+				codeCompilerMethodCallRestorer.Add_ICodeCompiler_CompileAssemblyFromSource(CompileAssemblyFromSource2);
+				codeCompilerMethodCallRestorer.Add_ICodeCompiler_CompileAssemblyFromSourceBatch(CompileAssemblyFromSourceBatch2);
 				break;
 			}
 		}
 
-		static MethodDef getTheOnlyMethod(TypeDef type, string typeName, string methodName, string returnType, string parameters) {
+		static MethodDef GetTheOnlyMethod(TypeDef type, string typeName, string methodName, string returnType, string parameters) {
 			MethodDef foundMethod = null;
 
 			foreach (var method in type.Methods) {
@@ -475,9 +475,9 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 					continue;
 				if (method.IsPrivate)
 					continue;
-				if (!DotNetUtils.isMethod(method, returnType, "(" + typeName + "," + parameters + ")"))
+				if (!DotNetUtils.IsMethod(method, returnType, "(" + typeName + "," + parameters + ")"))
 					continue;
-				if (!DotNetUtils.callsMethod(method, returnType + " " + typeName + "::" + methodName + "(" + parameters + ")"))
+				if (!DotNetUtils.CallsMethod(method, returnType + " " + typeName + "::" + methodName + "(" + parameters + ")"))
 					continue;
 
 				if (foundMethod != null)
diff --git a/de4dot.code/deobfuscators/Eazfuscator_NET/CodeCompilerMethodCallRestorer.cs b/de4dot.code/deobfuscators/Eazfuscator_NET/CodeCompilerMethodCallRestorer.cs
index 499b528c..35e5b3eb 100644
--- a/de4dot.code/deobfuscators/Eazfuscator_NET/CodeCompilerMethodCallRestorer.cs
+++ b/de4dot.code/deobfuscators/Eazfuscator_NET/CodeCompilerMethodCallRestorer.cs
@@ -23,98 +23,98 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 	class CodeCompilerMethodCallRestorer : MethodCallRestorerBase {
 		ITypeDefOrRef CodeDomProvider {
 			get {
-				return builder.type("System.CodeDom.Compiler", "CodeDomProvider", "System").ToTypeDefOrRef();
+				return builder.Type("System.CodeDom.Compiler", "CodeDomProvider", "System").ToTypeDefOrRef();
 			}
 		}
 
 		ITypeDefOrRef ICodeCompiler {
 			get {
-				return builder.type("System.CodeDom.Compiler", "ICodeCompiler", "System").ToTypeDefOrRef();
+				return builder.Type("System.CodeDom.Compiler", "ICodeCompiler", "System").ToTypeDefOrRef();
 			}
 		}
 
 		TypeSig CompilerResults {
 			get {
-				return builder.type("System.CodeDom.Compiler", "CompilerResults", "System");
+				return builder.Type("System.CodeDom.Compiler", "CompilerResults", "System");
 			}
 		}
 
 		TypeSig CompilerParameters {
 			get {
-				return builder.type("System.CodeDom.Compiler", "CompilerParameters", "System");
+				return builder.Type("System.CodeDom.Compiler", "CompilerParameters", "System");
 			}
 		}
 
 		TypeSig CodeCompileUnit {
 			get {
-				return builder.type("System.CodeDom", "CodeCompileUnit", "System");
+				return builder.Type("System.CodeDom", "CodeCompileUnit", "System");
 			}
 		}
 
 		TypeSig CodeCompileUnitArray {
-			get { return builder.array(CodeCompileUnit); }
+			get { return builder.Array(CodeCompileUnit); }
 		}
 
 		TypeSig StringArray {
-			get { return builder.array(builder.String); }
+			get { return builder.Array(builder.String); }
 		}
 
 		public CodeCompilerMethodCallRestorer(ModuleDefMD module)
 			: base(module) {
 		}
 
-		public void add_CodeDomProvider_CompileAssemblyFromDom(MethodDef oldMethod) {
+		public void Add_CodeDomProvider_CompileAssemblyFromDom(MethodDef oldMethod) {
 			if (oldMethod == null)
 				return;
-			add(oldMethod, builder.instanceMethod("CompileAssemblyFromDom", CodeDomProvider, CompilerResults, CompilerParameters, CodeCompileUnitArray));
+			Add(oldMethod, builder.InstanceMethod("CompileAssemblyFromDom", CodeDomProvider, CompilerResults, CompilerParameters, CodeCompileUnitArray));
 		}
 
-		public void add_CodeDomProvider_CompileAssemblyFromFile(MethodDef oldMethod) {
+		public void Add_CodeDomProvider_CompileAssemblyFromFile(MethodDef oldMethod) {
 			if (oldMethod == null)
 				return;
-			add(oldMethod, builder.instanceMethod("CompileAssemblyFromFile", CodeDomProvider, CompilerResults, CompilerParameters, StringArray));
+			Add(oldMethod, builder.InstanceMethod("CompileAssemblyFromFile", CodeDomProvider, CompilerResults, CompilerParameters, StringArray));
 		}
 
-		public void add_CodeDomProvider_CompileAssemblyFromSource(MethodDef oldMethod) {
+		public void Add_CodeDomProvider_CompileAssemblyFromSource(MethodDef oldMethod) {
 			if (oldMethod == null)
 				return;
-			add(oldMethod, builder.instanceMethod("CompileAssemblyFromSource", CodeDomProvider, CompilerResults, CompilerParameters, StringArray));
+			Add(oldMethod, builder.InstanceMethod("CompileAssemblyFromSource", CodeDomProvider, CompilerResults, CompilerParameters, StringArray));
 		}
 
-		public void add_ICodeCompiler_CompileAssemblyFromDom(MethodDef oldMethod) {
+		public void Add_ICodeCompiler_CompileAssemblyFromDom(MethodDef oldMethod) {
 			if (oldMethod == null)
 				return;
-			add(oldMethod, builder.instanceMethod("CompileAssemblyFromDom", ICodeCompiler, CompilerResults, CompilerParameters, CodeCompileUnit));
+			Add(oldMethod, builder.InstanceMethod("CompileAssemblyFromDom", ICodeCompiler, CompilerResults, CompilerParameters, CodeCompileUnit));
 		}
 
-		public void add_ICodeCompiler_CompileAssemblyFromDomBatch(MethodDef oldMethod) {
+		public void Add_ICodeCompiler_CompileAssemblyFromDomBatch(MethodDef oldMethod) {
 			if (oldMethod == null)
 				return;
-			add(oldMethod, builder.instanceMethod("CompileAssemblyFromDomBatch", ICodeCompiler, CompilerResults, CompilerParameters, CodeCompileUnitArray));
+			Add(oldMethod, builder.InstanceMethod("CompileAssemblyFromDomBatch", ICodeCompiler, CompilerResults, CompilerParameters, CodeCompileUnitArray));
 		}
 
-		public void add_ICodeCompiler_CompileAssemblyFromFile(MethodDef oldMethod) {
+		public void Add_ICodeCompiler_CompileAssemblyFromFile(MethodDef oldMethod) {
 			if (oldMethod == null)
 				return;
-			add(oldMethod, builder.instanceMethod("CompileAssemblyFromFile", ICodeCompiler, CompilerResults, CompilerParameters, builder.String));
+			Add(oldMethod, builder.InstanceMethod("CompileAssemblyFromFile", ICodeCompiler, CompilerResults, CompilerParameters, builder.String));
 		}
 
-		public void add_ICodeCompiler_CompileAssemblyFromFileBatch(MethodDef oldMethod) {
+		public void Add_ICodeCompiler_CompileAssemblyFromFileBatch(MethodDef oldMethod) {
 			if (oldMethod == null)
 				return;
-			add(oldMethod, builder.instanceMethod("CompileAssemblyFromFileBatch", ICodeCompiler, CompilerResults, CompilerParameters, StringArray));
+			Add(oldMethod, builder.InstanceMethod("CompileAssemblyFromFileBatch", ICodeCompiler, CompilerResults, CompilerParameters, StringArray));
 		}
 
-		public void add_ICodeCompiler_CompileAssemblyFromSource(MethodDef oldMethod) {
+		public void Add_ICodeCompiler_CompileAssemblyFromSource(MethodDef oldMethod) {
 			if (oldMethod == null)
 				return;
-			add(oldMethod, builder.instanceMethod("CompileAssemblyFromSource", ICodeCompiler, CompilerResults, CompilerParameters, builder.String));
+			Add(oldMethod, builder.InstanceMethod("CompileAssemblyFromSource", ICodeCompiler, CompilerResults, CompilerParameters, builder.String));
 		}
 
-		public void add_ICodeCompiler_CompileAssemblyFromSourceBatch(MethodDef oldMethod) {
+		public void Add_ICodeCompiler_CompileAssemblyFromSourceBatch(MethodDef oldMethod) {
 			if (oldMethod == null)
 				return;
-			add(oldMethod, builder.instanceMethod("CompileAssemblyFromSourceBatch", ICodeCompiler, CompilerResults, CompilerParameters, StringArray));
+			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 87c57c46..c9b7f940 100644
--- a/de4dot.code/deobfuscators/Eazfuscator_NET/DecrypterType.cs
+++ b/de4dot.code/deobfuscators/Eazfuscator_NET/DecrypterType.cs
@@ -59,40 +59,40 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			this.simpleDeobfuscator = simpleDeobfuscator;
 		}
 
-		public bool initialize() {
+		public bool Initialize() {
 			if (initialized)
 				return true;
 
-			int64Method = findInt64Method();
+			int64Method = FindInt64Method();
 			if (int64Method == null)
 				return false;
 
-			if (!initializeEfConstMethods())
+			if (!InitializeEfConstMethods())
 				return false;
-			if (!findInt1And2())
+			if (!FindInt1And2())
 				return false;
-			if (!findInt3())
+			if (!FindInt3())
 				return false;
-			if (!findMethodInts())
+			if (!FindMethodInts())
 				return false;
 
 			initialized = true;
 			return true;
 		}
 
-		bool initializeEfConstMethods() {
+		bool InitializeEfConstMethods() {
 			if (type == null)
 				return false;
 
 			efConstMethods = new MethodDef[6];
 
-			efConstMethods[0] = findEfConstMethodCall(int64Method);
-			efConstMethods[5] = findEfConstMethodCall(efConstMethods[0]);
-			efConstMethods[4] = findEfConstMethodCall(efConstMethods[5]);
-			var calls = findEfConstMethodCalls(efConstMethods[4]);
+			efConstMethods[0] = FindEfConstMethodCall(int64Method);
+			efConstMethods[5] = FindEfConstMethodCall(efConstMethods[0]);
+			efConstMethods[4] = FindEfConstMethodCall(efConstMethods[5]);
+			var calls = FindEfConstMethodCalls(efConstMethods[4]);
 			if (calls.Count != 2)
 				return false;
-			if (getNumberOfTypeofs(calls[0]) == 3) {
+			if (GetNumberOfTypeofs(calls[0]) == 3) {
 				efConstMethods[2] = calls[0];
 				efConstMethods[1] = calls[1];
 			}
@@ -100,7 +100,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				efConstMethods[2] = calls[0];
 				efConstMethods[1] = calls[1];
 			}
-			efConstMethods[3] = findEfConstMethodCall(efConstMethods[1]);
+			efConstMethods[3] = FindEfConstMethodCall(efConstMethods[1]);
 
 			foreach (var m in efConstMethods) {
 				if (m == null)
@@ -109,7 +109,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return true;
 		}
 
-		static int getNumberOfTypeofs(MethodDef method) {
+		static int GetNumberOfTypeofs(MethodDef method) {
 			if (method == null)
 				return 0;
 			int count = 0;
@@ -120,14 +120,14 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return count;
 		}
 
-		MethodDef findEfConstMethodCall(MethodDef method) {
-			var list = findEfConstMethodCalls(method);
+		MethodDef FindEfConstMethodCall(MethodDef method) {
+			var list = FindEfConstMethodCalls(method);
 			if (list == null || list.Count != 1)
 				return null;
 			return list[0];
 		}
 
-		List<MethodDef> findEfConstMethodCalls(MethodDef method) {
+		List<MethodDef> FindEfConstMethodCalls(MethodDef method) {
 			if (method == null)
 				return null;
 			var list = new List<MethodDef>();
@@ -137,7 +137,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				var calledMethod = instr.Operand as MethodDef;
 				if (calledMethod == null || !calledMethod.IsStatic || calledMethod.Body == null)
 					continue;
-				if (!DotNetUtils.isMethod(calledMethod, "System.Int32", "()"))
+				if (!DotNetUtils.IsMethod(calledMethod, "System.Int32", "()"))
 					continue;
 				if (type.NestedTypes.IndexOf(calledMethod.DeclaringType) < 0)
 					continue;
@@ -147,15 +147,15 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return list;
 		}
 
-		MethodDef findInt64Method() {
+		MethodDef FindInt64Method() {
 			if (type == null)
 				return null;
 			foreach (var method in type.Methods) {
 				if (!method.IsStatic || method.Body == null || method.HasGenericParameters)
 					continue;
-				if (!DotNetUtils.isMethod(method, "System.Int64", "()"))
+				if (!DotNetUtils.IsMethod(method, "System.Int64", "()"))
 					continue;
-				if (!findInt64(method))
+				if (!FindInt64(method))
 					continue;
 
 				return method;
@@ -164,7 +164,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return null;
 		}
 
-		bool findInt64(MethodDef method) {
+		bool FindInt64(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 1; i++) {
 				var ldci8 = instrs[i];
@@ -180,8 +180,8 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return false;
 		}
 
-		bool findInt1And2() {
-			var consts = getConstants(efConstMethods[2]);
+		bool FindInt1And2() {
+			var consts = GetConstants(efConstMethods[2]);
 			if (consts.Count != 2)
 				return false;
 			i1 = consts[0];
@@ -189,26 +189,26 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return true;
 		}
 
-		bool findInt3() {
-			var consts = getConstants(efConstMethods[5]);
+		bool FindInt3() {
+			var consts = GetConstants(efConstMethods[5]);
 			if (consts.Count != 1)
 				return false;
 			i3 = consts[0];
 			return true;
 		}
 
-		bool findMethodInts() {
+		bool FindMethodInts() {
 			foreach (var nestedType in type.NestedTypes) {
-				var methods = getBinaryIntMethods(nestedType);
+				var methods = GetBinaryIntMethods(nestedType);
 				if (methods.Count < 3)
 					continue;
 				foreach (var m in methods)
-					simpleDeobfuscator.deobfuscate(m);
-				if (!findMethod1Int(methods))
+					simpleDeobfuscator.Deobfuscate(m);
+				if (!FindMethod1Int(methods))
 					continue;
-				if (!findMethod2Int(methods))
+				if (!FindMethod2Int(methods))
 					continue;
-				if (!findMethod3Int(methods))
+				if (!FindMethod3Int(methods))
 					continue;
 
 				return true;
@@ -216,12 +216,12 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return false;
 		}
 
-		static List<MethodDef> getBinaryIntMethods(TypeDef type) {
+		static List<MethodDef> GetBinaryIntMethods(TypeDef type) {
 			var list = new List<MethodDef>();
 			foreach (var method in type.Methods) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
-				if (!DotNetUtils.isMethod(method, "System.Int32", "(System.Int32,System.Int32)"))
+				if (!DotNetUtils.IsMethod(method, "System.Int32", "(System.Int32,System.Int32)"))
 					continue;
 
 				list.Add(method);
@@ -229,11 +229,11 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return list;
 		}
 
-		bool findMethod1Int(IEnumerable<MethodDef> methods) {
+		bool FindMethod1Int(IEnumerable<MethodDef> methods) {
 			foreach (var method in methods) {
-				if (countInstructions(method, Code.Ldarg_0) != 1)
+				if (CountInstructions(method, Code.Ldarg_0) != 1)
 					continue;
-				var constants = getConstants(method);
+				var constants = GetConstants(method);
 				if (constants.Count != 1)
 					continue;
 
@@ -243,9 +243,9 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return false;
 		}
 
-		bool findMethod2Int(IEnumerable<MethodDef> methods) {
+		bool FindMethod2Int(IEnumerable<MethodDef> methods) {
 			foreach (var method in methods) {
-				var constants = getConstants(method);
+				var constants = GetConstants(method);
 				if (constants.Count != 2)
 					continue;
 
@@ -256,11 +256,11 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return false;
 		}
 
-		bool findMethod3Int(IEnumerable<MethodDef> methods) {
+		bool FindMethod3Int(IEnumerable<MethodDef> methods) {
 			foreach (var method in methods) {
-				if (countInstructions(method, Code.Ldarg_0) != 2)
+				if (CountInstructions(method, Code.Ldarg_0) != 2)
 					continue;
-				var constants = getConstants(method);
+				var constants = GetConstants(method);
 				if (constants.Count != 1)
 					continue;
 
@@ -270,7 +270,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return false;
 		}
 
-		static int countInstructions(MethodDef 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)
@@ -279,7 +279,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return count;
 		}
 
-		static List<int> getConstants(MethodDef method) {
+		static List<int> GetConstants(MethodDef method) {
 			var list = new List<int>();
 
 			if (method == null)
@@ -290,7 +290,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			var constantsReader = new EfConstantsReader(method);
 			while (true) {
 				int val;
-				if (!constantsReader.getNextInt32(ref index, out val))
+				if (!constantsReader.GetNextInt32(ref index, out val))
 					break;
 
 				if (index < instrs.Count && instrs[index].OpCode.Code != Code.Ret)
@@ -300,43 +300,43 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return list;
 		}
 
-		int binOp1(int a, int b) {
+		int BinOp1(int a, int b) {
 			return a ^ (b - m1_i1);
 		}
 
-		int binOp2(int a, int b) {
+		int BinOp2(int a, int b) {
 			return (a - m2_i1) ^ (b + m2_i2);
 		}
 
-		int binOp3(int a, int b) {
+		int BinOp3(int a, int b) {
 			return a ^ (b - m3_i1) ^ (a - b);
 		}
 
-		int constMethod1() {
-			return binOp3(binOp2(efConstMethods[1].DeclaringType.MDToken.ToInt32(), binOp3(efConstMethods[0].DeclaringType.MDToken.ToInt32(), efConstMethods[4].DeclaringType.MDToken.ToInt32())), constMethod6());
+		int ConstMethod1() {
+			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.MDToken.ToInt32(), efConstMethods[3].DeclaringType.MDToken.ToInt32() ^ binOp2(efConstMethods[1].DeclaringType.MDToken.ToInt32(), binOp3(efConstMethods[5].DeclaringType.MDToken.ToInt32(), constMethod4())));
+		int ConstMethod2() {
+			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.MDToken.ToInt32()), binOp2(efConstMethods[0].DeclaringType.MDToken.ToInt32() ^ efConstMethods[5].DeclaringType.MDToken.ToInt32(), i2));
+		int ConstMethod3() {
+			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.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 ConstMethod4() {
+			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.MDToken.ToInt32(), constMethod2())), efConstMethods[5].DeclaringType.MDToken.ToInt32());
+		int ConstMethod5() {
+			return BinOp2(BinOp2(ConstMethod3(), BinOp1(efConstMethods[4].DeclaringType.MDToken.ToInt32(), ConstMethod2())), efConstMethods[5].DeclaringType.MDToken.ToInt32());
 		}
 
-		int constMethod6() {
-			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())));
+		int ConstMethod6() {
+			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() {
+		public ulong GetMagic() {
 			if (type == null)
 				throw new ApplicationException("Can't calculate magic since type isn't initialized");
 
@@ -346,7 +346,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 					bytes.AddRange(module.Assembly.PublicKeyToken.Data);
 				bytes.AddRange(Encoding.Unicode.GetBytes(module.Assembly.Name.String));
 			}
-			int cm1 = constMethod1();
+			int cm1 = ConstMethod1();
 			bytes.Add((byte)(type.MDToken.ToInt32() >> 24));
 			bytes.Add((byte)(cm1 >> 16));
 			bytes.Add((byte)(type.MDToken.ToInt32() >> 8));
diff --git a/de4dot.code/deobfuscators/Eazfuscator_NET/Deobfuscator.cs b/de4dot.code/deobfuscators/Eazfuscator_NET/Deobfuscator.cs
index ff0f8aaf..284d2dbe 100644
--- a/de4dot.code/deobfuscators/Eazfuscator_NET/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/Eazfuscator_NET/Deobfuscator.cs
@@ -41,7 +41,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			get { return THE_TYPE; }
 		}
 
-		public override IDeobfuscator createDeobfuscator() {
+		public override IDeobfuscator CreateDeobfuscator() {
 			return new Deobfuscator(new Deobfuscator.Options {
 				ValidNameRegex = validNameRegex.get(),
 			});
@@ -79,12 +79,12 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			this.options = options;
 		}
 
-		protected override int detectInternal() {
+		protected override int DetectInternal() {
 			int val = 0;
 
-			int sum = toInt32(stringDecrypter.Detected) +
-					toInt32(assemblyResolver.Detected) +
-					toInt32(resourceResolver.Detected);
+			int sum = ToInt32(stringDecrypter.Detected) +
+					ToInt32(assemblyResolver.Detected) +
+					ToInt32(resourceResolver.Detected);
 			if (sum > 0)
 				val += 100 + 10 * (sum - 1);
 			if (detectedVersion)
@@ -93,20 +93,20 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return val;
 		}
 
-		protected override void scanForObfuscator() {
+		protected override void ScanForObfuscator() {
 			decrypterType = new DecrypterType(module, DeobfuscatedFile);
 			stringDecrypter = new StringDecrypter(module, decrypterType);
-			stringDecrypter.find();
+			stringDecrypter.Find();
 			assemblyResolver = new AssemblyResolver(module, decrypterType);
-			assemblyResolver.find();
+			assemblyResolver.Find();
 			resourceResolver = new ResourceResolver(module, assemblyResolver);
-			resourceResolver.find();
+			resourceResolver.Find();
 			if (stringDecrypter.Detected)
-				detectVersion();
+				DetectVersion();
 		}
 
-		void detectVersion() {
-			var version = new VersionDetector(module, stringDecrypter).detect();
+		void DetectVersion() {
+			var version = new VersionDetector(module, stringDecrypter).Detect();
 			if (version == null)
 				return;
 
@@ -114,63 +114,63 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			obfuscatorName = DeobfuscatorInfo.THE_NAME + " " +  version;
 		}
 
-		public override void deobfuscateBegin() {
-			base.deobfuscateBegin();
+		public override void DeobfuscateBegin() {
+			base.DeobfuscateBegin();
 
-			stringDecrypter.initialize(DeobfuscatedFile);
-			staticStringInliner.add(stringDecrypter.Method, (method2, gim, args) => {
-				return stringDecrypter.decrypt((int)args[0]);
+			stringDecrypter.Initialize(DeobfuscatedFile);
+			staticStringInliner.Add(stringDecrypter.Method, (method2, gim, args) => {
+				return stringDecrypter.Decrypt((int)args[0]);
 			});
-			DeobfuscatedFile.stringDecryptersAdded();
+			DeobfuscatedFile.StringDecryptersAdded();
 
-			assemblyResolver.initialize(DeobfuscatedFile, this);
-			assemblyResolver.initializeEmbeddedFiles();
-			addModuleCctorInitCallToBeRemoved(assemblyResolver.InitMethod);
+			assemblyResolver.Initialize(DeobfuscatedFile, this);
+			assemblyResolver.InitializeEmbeddedFiles();
+			AddModuleCctorInitCallToBeRemoved(assemblyResolver.InitMethod);
 
-			resourceResolver.initialize(DeobfuscatedFile, this);
-			foreach (var info in resourceResolver.mergeResources())
-				addResourceToBeRemoved(info.Resource, "Encrypted resources");
-			addModuleCctorInitCallToBeRemoved(resourceResolver.InitMethod);
+			resourceResolver.Initialize(DeobfuscatedFile, this);
+			foreach (var info in resourceResolver.MergeResources())
+				AddResourceToBeRemoved(info.Resource, "Encrypted resources");
+			AddModuleCctorInitCallToBeRemoved(resourceResolver.InitMethod);
 
 			resourceMethodsRestorer = new ResourceMethodsRestorer(module);
 			if ((Operations.RenamerFlags & (RenamerFlags.RenameTypes | RenamerFlags.RenameNamespaces)) != 0)
-				resourceMethodsRestorer.find(DeobfuscatedFile, this);
+				resourceMethodsRestorer.Find(DeobfuscatedFile, this);
 
-			dumpEmbeddedAssemblies();
+			DumpEmbeddedAssemblies();
 		}
 
-		void dumpEmbeddedAssemblies() {
+		void DumpEmbeddedAssemblies() {
 			foreach (var info in assemblyResolver.AssemblyInfos) {
-				DeobfuscatedFile.createAssemblyFile(info.Data, info.SimpleName, info.Extension);
-				addResourceToBeRemoved(info.Resource, string.Format("Embedded assembly: {0}", info.AssemblyFullName));
+				DeobfuscatedFile.CreateAssemblyFile(info.Data, info.SimpleName, info.Extension);
+				AddResourceToBeRemoved(info.Resource, string.Format("Embedded assembly: {0}", info.AssemblyFullName));
 			}
 		}
 
-		public override void deobfuscateMethodEnd(Blocks blocks) {
-			resourceMethodsRestorer.deobfuscate(blocks);
-			assemblyResolver.deobfuscate(blocks);
-			base.deobfuscateMethodEnd(blocks);
+		public override void DeobfuscateMethodEnd(Blocks blocks) {
+			resourceMethodsRestorer.Deobfuscate(blocks);
+			assemblyResolver.Deobfuscate(blocks);
+			base.DeobfuscateMethodEnd(blocks);
 		}
 
-		public override void deobfuscateEnd() {
+		public override void DeobfuscateEnd() {
 			if (CanRemoveStringDecrypterType) {
-				addTypesToBeRemoved(stringDecrypter.Types, "String decrypter type");
-				addTypeToBeRemoved(decrypterType.Type, "Decrypter type");
-				addTypesToBeRemoved(stringDecrypter.DynocodeTypes, "Dynocode type");
-				addResourceToBeRemoved(stringDecrypter.Resource, "Encrypted strings");
+				AddTypesToBeRemoved(stringDecrypter.Types, "String decrypter type");
+				AddTypeToBeRemoved(decrypterType.Type, "Decrypter type");
+				AddTypesToBeRemoved(stringDecrypter.DynocodeTypes, "Dynocode type");
+				AddResourceToBeRemoved(stringDecrypter.Resource, "Encrypted strings");
 			}
-			addTypeToBeRemoved(assemblyResolver.Type, "Assembly resolver type");
-			addTypeToBeRemoved(assemblyResolver.OtherType, "Assembly resolver other type");
-			addTypeToBeRemoved(resourceResolver.Type, "Resource resolver type");
-			addTypeToBeRemoved(resourceMethodsRestorer.Type, "GetManifestResourceStream type");
-			addResourceToBeRemoved(resourceMethodsRestorer.Resource, "GetManifestResourceStream type resource");
+			AddTypeToBeRemoved(assemblyResolver.Type, "Assembly resolver type");
+			AddTypeToBeRemoved(assemblyResolver.OtherType, "Assembly resolver other type");
+			AddTypeToBeRemoved(resourceResolver.Type, "Resource resolver type");
+			AddTypeToBeRemoved(resourceMethodsRestorer.Type, "GetManifestResourceStream type");
+			AddResourceToBeRemoved(resourceMethodsRestorer.Resource, "GetManifestResourceStream type resource");
 
-			fixInterfaces();
-			stringDecrypterBugWorkaround();
-			base.deobfuscateEnd();
+			FixInterfaces();
+			StringDecrypterBugWorkaround();
+			base.DeobfuscateEnd();
 		}
 
-		void stringDecrypterBugWorkaround() {
+		void StringDecrypterBugWorkaround() {
 			// There's a bug in Eazfuscator.NET when the VM and string encryption features are
 			// enabled. The string decrypter's initialization code checks to make sure it's not
 			// called by eg. a dynamic method. When it's called from the VM code, it is
@@ -205,16 +205,16 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 
 			var cctor = module.GlobalType.FindOrCreateStaticConstructor();
 			var blocks = new Blocks(cctor);
-			var block = blocks.MethodBlocks.getAllBlocks()[0];
-			block.insert(0, OpCodes.Call.ToInstruction(newMethod));
+			var block = blocks.MethodBlocks.GetAllBlocks()[0];
+			block.Insert(0, OpCodes.Call.ToInstruction(newMethod));
 
 			IList<Instruction> allInstructions;
 			IList<ExceptionHandler> allExceptionHandlers;
-			blocks.getCode(out allInstructions, out allExceptionHandlers);
-			DotNetUtils.restoreBody(cctor, allInstructions, allExceptionHandlers);
+			blocks.GetCode(out allInstructions, out allExceptionHandlers);
+			DotNetUtils.RestoreBody(cctor, allInstructions, allExceptionHandlers);
 		}
 
-		public override IEnumerable<int> getStringDecrypterMethods() {
+		public override IEnumerable<int> GetStringDecrypterMethods() {
 			var list = new List<int>();
 			if (stringDecrypter.Method != null)
 				list.Add(stringDecrypter.Method.MDToken.ToInt32());
diff --git a/de4dot.code/deobfuscators/Eazfuscator_NET/Dynocode.cs b/de4dot.code/deobfuscators/Eazfuscator_NET/Dynocode.cs
index eb30a416..fcd689ba 100644
--- a/de4dot.code/deobfuscators/Eazfuscator_NET/Dynocode.cs
+++ b/de4dot.code/deobfuscators/Eazfuscator_NET/Dynocode.cs
@@ -24,7 +24,7 @@ using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 	interface IDynocodeGenerator {
-		IEnumerable<int> getValues(int input);
+		IEnumerable<int> GetValues(int input);
 	}
 
 	// Something added in EF 3.5 which they call Dynocode. The string decrypter can now
@@ -43,7 +43,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			public int magic6;
 			public int magic7;
 
-			public IEnumerable<int> getValues(int input) {
+			public IEnumerable<int> GetValues(int input) {
 				yield return magic1;
 				yield return magic2;
 				yield return input ^ magic3;
@@ -57,7 +57,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 		class DCGen2 : IDynocodeGenerator {
 			public int magic1;
 
-			public IEnumerable<int> getValues(int input) {
+			public IEnumerable<int> GetValues(int input) {
 				int x = 0;
 				int y = 1;
 				while (true) {
@@ -76,9 +76,9 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			public int magic2;
 			public DCGen2 dc2;
 
-			public IEnumerable<int> getValues(int input) {
+			public IEnumerable<int> GetValues(int input) {
 				int i = 7;
-				foreach (var val in dc2.getValues(input)) {
+				foreach (var val in dc2.GetValues(input)) {
 					int x = val ^ input;
 					if ((x % 4) == 0)
 						x ^= magic1;
@@ -102,7 +102,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			this.simpleDeobfuscator = simpleDeobfuscator;
 		}
 
-		public IDynocodeGenerator getDynocodeGenerator(TypeDef type) {
+		public IDynocodeGenerator GetDynocodeGenerator(TypeDef type) {
 			if (type == null)
 				return null;
 			var dt = type.DeclaringType;
@@ -113,44 +113,44 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				return dcGen;
 
 			if (dt.NestedTypes.Count == 1)
-				dcGen = getDCGen1(type);
+				dcGen = GetDCGen1(type);
 			else if (dt.NestedTypes.Count == 2)
-				dcGen = getDCGen3(type);
+				dcGen = GetDCGen3(type);
 
 			typeToDCGen[type] = dcGen;
 
 			return dcGen;
 		}
 
-		DCGen1 getDCGen1(TypeDef type) {
-			var method = getMoveNext(type);
+		DCGen1 GetDCGen1(TypeDef type) {
+			var method = GetMoveNext(type);
 			if (method == null)
 				return null;
-			simpleDeobfuscator.deobfuscate(method);
-			var swLabels = getSwitchLabels(method);
+			simpleDeobfuscator.Deobfuscate(method);
+			var swLabels = GetSwitchLabels(method);
 			if (swLabels == null || swLabels.Count < 7)
 				return null;
 
 			var dcGen = new DCGen1();
-			if (!getMagicDC1(method, swLabels[0], out dcGen.magic1))
+			if (!GetMagicDC1(method, swLabels[0], out dcGen.magic1))
 				return null;
-			if (!getMagicDC1(method, swLabels[1], out dcGen.magic2))
+			if (!GetMagicDC1(method, swLabels[1], out dcGen.magic2))
 				return null;
-			if (!getMagicXorDC1(method, swLabels[2], out dcGen.magic3))
+			if (!GetMagicXorDC1(method, swLabels[2], out dcGen.magic3))
 				return null;
-			if (!getMagicDC1(method, swLabels[3], out dcGen.magic4))
+			if (!GetMagicDC1(method, swLabels[3], out dcGen.magic4))
 				return null;
-			if (!getMagicDC1(method, swLabels[4], out dcGen.magic5))
+			if (!GetMagicDC1(method, swLabels[4], out dcGen.magic5))
 				return null;
-			if (!getMagicDC1(method, swLabels[5], out dcGen.magic6))
+			if (!GetMagicDC1(method, swLabels[5], out dcGen.magic6))
 				return null;
-			if (!getMagicXorDC1(method, swLabels[6], out dcGen.magic7))
+			if (!GetMagicXorDC1(method, swLabels[6], out dcGen.magic7))
 				return null;
 
 			return dcGen;
 		}
 
-		static IList<Instruction> getSwitchLabels(MethodDef method) {
+		static IList<Instruction> GetSwitchLabels(MethodDef method) {
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Switch)
 					continue;
@@ -159,7 +159,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return null;
 		}
 
-		static bool getMagicDC1(MethodDef method, Instruction target, out int magic) {
+		static bool GetMagicDC1(MethodDef method, Instruction target, out int magic) {
 			magic = 0;
 			var instrs = method.Body.Instructions;
 			int index = instrs.IndexOf(target);
@@ -187,7 +187,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return false;
 		}
 
-		static bool getMagicXorDC1(MethodDef method, Instruction target, out int magic) {
+		static bool GetMagicXorDC1(MethodDef method, Instruction target, out int magic) {
 			magic = 0;
 			var instrs = method.Body.Instructions;
 			int index = instrs.IndexOf(target);
@@ -212,26 +212,26 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return false;
 		}
 
-		DCGen3 getDCGen3(TypeDef type) {
-			var method = getMoveNext(type);
+		DCGen3 GetDCGen3(TypeDef type) {
+			var method = GetMoveNext(type);
 			if (method == null)
 				return null;
-			simpleDeobfuscator.deobfuscate(method);
+			simpleDeobfuscator.Deobfuscate(method);
 
 			var dcGen = new DCGen3();
 			int index = 0;
-			if (!getMagicDC3(method, ref index, out dcGen.magic1))
+			if (!GetMagicDC3(method, ref index, out dcGen.magic1))
 				return null;
-			if (!getMagicDC3(method, ref index, out dcGen.magic2))
+			if (!GetMagicDC3(method, ref index, out dcGen.magic2))
 				return null;
 
 			var dt = type.DeclaringType;
-			dcGen.dc2 = getDCGen2(dt.NestedTypes[0] == type ? dt.NestedTypes[1] : dt.NestedTypes[0]);
+			dcGen.dc2 = GetDCGen2(dt.NestedTypes[0] == type ? dt.NestedTypes[1] : dt.NestedTypes[0]);
 
 			return dcGen;
 		}
 
-		static bool getMagicDC3(MethodDef method, ref int index, out int magic) {
+		static bool GetMagicDC3(MethodDef method, ref int index, out int magic) {
 			var instrs = method.Body.Instructions;
 			for (int i = index; i < instrs.Count - 2; i++) {
 				var ldci4 = instrs[i];
@@ -251,21 +251,21 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return false;
 		}
 
-		DCGen2 getDCGen2(TypeDef type) {
-			var method = getMoveNext(type);
+		DCGen2 GetDCGen2(TypeDef type) {
+			var method = GetMoveNext(type);
 			if (method == null)
 				return null;
-			simpleDeobfuscator.deobfuscate(method);
+			simpleDeobfuscator.Deobfuscate(method);
 
 			var dcGen = new DCGen2();
 			int index = 0;
-			if (!getMagicDC3(method, ref index, out dcGen.magic1))
+			if (!GetMagicDC3(method, ref index, out dcGen.magic1))
 				return null;
 
 			return dcGen;
 		}
 
-		static MethodDef getMoveNext(TypeDef type) {
+		static MethodDef GetMoveNext(TypeDef type) {
 			foreach (var m in type.Methods) {
 				if (!m.IsVirtual)
 					continue;
@@ -279,7 +279,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 					continue;
 				if (m.Name != "MoveNext")
 					continue;
-				if (!DotNetUtils.isMethod(m, "System.Boolean", "()"))
+				if (!DotNetUtils.IsMethod(m, "System.Boolean", "()"))
 					continue;
 				return m;
 			}
diff --git a/de4dot.code/deobfuscators/Eazfuscator_NET/EfConstantsReader.cs b/de4dot.code/deobfuscators/Eazfuscator_NET/EfConstantsReader.cs
index 0b816256..adbc7378 100644
--- a/de4dot.code/deobfuscators/Eazfuscator_NET/EfConstantsReader.cs
+++ b/de4dot.code/deobfuscators/Eazfuscator_NET/EfConstantsReader.cs
@@ -24,17 +24,17 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 	class EfConstantsReader : ConstantsReader {
 		public EfConstantsReader(MethodDef method)
 			: base(method) {
-			initialize();
+			Initialize();
 		}
 
-		void initialize() {
-			findConstants();
+		void Initialize() {
+			FindConstants();
 		}
 
-		void findConstants() {
+		void FindConstants() {
 			for (int index = 0; index < instructions.Count; ) {
 				int value;
-				if (!getInt32(ref index, out value))
+				if (!GetInt32(ref index, out value))
 					break;
 				var stloc = instructions[index];
 				if (!stloc.IsStloc())
diff --git a/de4dot.code/deobfuscators/Eazfuscator_NET/EfUtils.cs b/de4dot.code/deobfuscators/Eazfuscator_NET/EfUtils.cs
index acb18705..201c6e1b 100644
--- a/de4dot.code/deobfuscators/Eazfuscator_NET/EfUtils.cs
+++ b/de4dot.code/deobfuscators/Eazfuscator_NET/EfUtils.cs
@@ -24,7 +24,7 @@ using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 	static class EfUtils {
-		public static int findOpCodeIndex(MethodDef 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,9 +35,9 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return -1;
 		}
 
-		public static int findOpCodeIndex(MethodDef 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);
+				index = FindOpCodeIndex(method, index, code);
 				if (index < 0)
 					break;
 				var instr = method.Body.Instructions[index];
@@ -49,7 +49,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return -1;
 		}
 
-		public static Instruction getNextStore(MethodDef 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];
 
diff --git a/de4dot.code/deobfuscators/Eazfuscator_NET/ResourceMethodsRestorer.cs b/de4dot.code/deobfuscators/Eazfuscator_NET/ResourceMethodsRestorer.cs
index ca0f26e0..ec9a2216 100644
--- a/de4dot.code/deobfuscators/Eazfuscator_NET/ResourceMethodsRestorer.cs
+++ b/de4dot.code/deobfuscators/Eazfuscator_NET/ResourceMethodsRestorer.cs
@@ -37,48 +37,48 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			: base(module) {
 		}
 
-		public void find(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
+		public void Find(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
 			foreach (var type in module.Types) {
 				if (type.Fields.Count != 1)
 					continue;
 				if (type.HasNestedTypes || type.HasGenericParameters || type.IsValueType)
 					continue;
-				if (DotNetUtils.getField(type, "System.Reflection.Assembly") == null)
+				if (DotNetUtils.GetField(type, "System.Reflection.Assembly") == null)
 					continue;
 				if (type.FindStaticConstructor() == null)
 					continue;
 
-				var getStream2 = getTheOnlyMethod(type, "System.IO.Stream", "(System.Reflection.Assembly,System.Type,System.String)");
-				var getNames = getTheOnlyMethod(type, "System.String[]", "(System.Reflection.Assembly)");
-				var bitmapCtor = getTheOnlyMethod(type, "System.Drawing.Bitmap", "(System.Type,System.String)");
-				var iconCtor = getTheOnlyMethod(type, "System.Drawing.Icon", "(System.Type,System.String)");
+				var getStream2 = GetTheOnlyMethod(type, "System.IO.Stream", "(System.Reflection.Assembly,System.Type,System.String)");
+				var getNames = GetTheOnlyMethod(type, "System.String[]", "(System.Reflection.Assembly)");
+				var bitmapCtor = GetTheOnlyMethod(type, "System.Drawing.Bitmap", "(System.Type,System.String)");
+				var iconCtor = GetTheOnlyMethod(type, "System.Drawing.Icon", "(System.Type,System.String)");
 				if (getStream2 == null && getNames == null && bitmapCtor == null && iconCtor == null)
 					continue;
 
-				var resource = findGetManifestResourceStreamTypeResource(type, simpleDeobfuscator, deob);
+				var resource = FindGetManifestResourceStreamTypeResource(type, simpleDeobfuscator, deob);
 				if (resource == null && getStream2 != null)
 					continue;
 
 				getManifestResourceStreamType = type;
-				createGetManifestResourceStream2(getStream2);
-				createGetManifestResourceNames(getNames);
-				createBitmapCtor(bitmapCtor);
-				createIconCtor(iconCtor);
+				CreateGetManifestResourceStream2(getStream2);
+				CreateGetManifestResourceNames(getNames);
+				CreateBitmapCtor(bitmapCtor);
+				CreateIconCtor(iconCtor);
 				getManifestResourceStreamTypeResource = resource;
 				break;
 			}
 		}
 
-		EmbeddedResource findGetManifestResourceStreamTypeResource(TypeDef 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;
-				if (!DotNetUtils.isMethod(method, "System.String", "(System.Reflection.Assembly,System.Type,System.String)"))
+				if (!DotNetUtils.IsMethod(method, "System.String", "(System.Reflection.Assembly,System.Type,System.String)"))
 					continue;
-				simpleDeobfuscator.deobfuscate(method);
-				simpleDeobfuscator.decryptStrings(method, deob);
-				foreach (var s in DotNetUtils.getCodeStrings(method)) {
-					var resource = DotNetUtils.getResource(module, s) as EmbeddedResource;
+				simpleDeobfuscator.Deobfuscate(method);
+				simpleDeobfuscator.DecryptStrings(method, deob);
+				foreach (var s in DotNetUtils.GetCodeStrings(method)) {
+					var resource = DotNetUtils.GetResource(module, s) as EmbeddedResource;
 					if (resource != null)
 						return resource;
 				}
@@ -86,7 +86,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return null;
 		}
 
-		static MethodDef getTheOnlyMethod(TypeDef type, string returnType, string parameters) {
+		static MethodDef GetTheOnlyMethod(TypeDef type, string returnType, string parameters) {
 			MethodDef foundMethod = null;
 
 			foreach (var method in type.Methods) {
@@ -94,7 +94,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 					continue;
 				if (method.IsPrivate)
 					continue;
-				if (!DotNetUtils.isMethod(method, returnType, parameters))
+				if (!DotNetUtils.IsMethod(method, returnType, parameters))
 					continue;
 
 				if (foundMethod != null)
diff --git a/de4dot.code/deobfuscators/Eazfuscator_NET/ResourceResolver.cs b/de4dot.code/deobfuscators/Eazfuscator_NET/ResourceResolver.cs
index 042ee815..d32e25d6 100644
--- a/de4dot.code/deobfuscators/Eazfuscator_NET/ResourceResolver.cs
+++ b/de4dot.code/deobfuscators/Eazfuscator_NET/ResourceResolver.cs
@@ -50,20 +50,20 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			this.assemblyResolver = assemblyResolver;
 		}
 
-		public void find() {
+		public void Find() {
 			if (!assemblyResolver.Detected)
 				return;
-			checkCalledMethods(DotNetUtils.getModuleTypeCctor(module));
+			CheckCalledMethods(DotNetUtils.GetModuleTypeCctor(module));
 		}
 
-		bool checkCalledMethods(MethodDef 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 MethodDef))
+				if (!CheckInitMethod(instr.Operand as MethodDef))
 					continue;
 
 				return true;
@@ -72,18 +72,18 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return false;
 		}
 
-		bool checkInitMethod(MethodDef method) {
+		bool CheckInitMethod(MethodDef method) {
 			if (method == null || !method.IsStatic || method.Body == null)
 				return false;
-			if (!DotNetUtils.isMethod(method, "System.Void", "()"))
+			if (!DotNetUtils.IsMethod(method, "System.Void", "()"))
 				return false;
 			var type = method.DeclaringType;
 			if (type.NestedTypes.Count != 1)
 				return false;
-			if (DotNetUtils.getField(type, "System.Reflection.Assembly") == null)
+			if (DotNetUtils.GetField(type, "System.Reflection.Assembly") == null)
 				return false;
 
-			var resolveHandler = DeobUtils.getResolveMethod(method);
+			var resolveHandler = DeobUtils.GetResolveMethod(method);
 			if (resolveHandler == null)
 				return false;
 
@@ -93,26 +93,26 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return true;
 		}
 
-		public void initialize(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
-			if (!initializeInfos(simpleDeobfuscator, deob))
+		public void Initialize(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
+			if (!InitializeInfos(simpleDeobfuscator, deob))
 				throw new ApplicationException("Could not initialize resource decrypter");
 		}
 
-		bool initializeInfos(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
+		bool InitializeInfos(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
 			if (handlerMethod == null)
 				return true;
 
 			foreach (var method in resolverType.Methods) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
-				if (!DotNetUtils.isMethod(method, "System.Void", "()"))
+				if (!DotNetUtils.IsMethod(method, "System.Void", "()"))
 					continue;
-				if (!DeobUtils.hasInteger(method, ':') || !DeobUtils.hasInteger(method, '|'))
+				if (!DeobUtils.HasInteger(method, ':') || !DeobUtils.HasInteger(method, '|'))
 					continue;
 
-				simpleDeobfuscator.deobfuscate(method);
-				simpleDeobfuscator.decryptStrings(method, deob);
-				if (!initializeInfos(method))
+				simpleDeobfuscator.Deobfuscate(method);
+				simpleDeobfuscator.DecryptStrings(method, deob);
+				if (!InitializeInfos(method))
 					continue;
 
 				return true;
@@ -121,8 +121,8 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return false;
 		}
 
-		bool initializeInfos(MethodDef method) {
-			foreach (var s in DotNetUtils.getCodeStrings(method)) {
+		bool InitializeInfos(MethodDef method) {
+			foreach (var s in DotNetUtils.GetCodeStrings(method)) {
 				if (string.IsNullOrEmpty(s))
 					continue;
 				var ary = s.Split(':');
@@ -136,14 +136,14 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return false;
 		}
 
-		public List<AssemblyResolver.AssemblyInfo> mergeResources() {
+		public List<AssemblyResolver.AssemblyInfo> MergeResources() {
 			var list = new List<AssemblyResolver.AssemblyInfo>();
 			foreach (var asmName in resourceInfos) {
-				var asmInfo = assemblyResolver.get(asmName);
+				var asmInfo = assemblyResolver.Get(asmName);
 				if (asmInfo == null)
-					throw new ApplicationException(string.Format("Could not find resource assembly {0}", Utils.toCsharpString(asmName)));
+					throw new ApplicationException(string.Format("Could not find resource assembly {0}", Utils.ToCsharpString(asmName)));
 
-				DeobUtils.decryptAndAddResources(module, asmInfo.ResourceName, () => asmInfo.Data);
+				DeobUtils.DecryptAndAddResources(module, asmInfo.ResourceName, () => asmInfo.Data);
 				list.Add(asmInfo);
 			}
 			resourceInfos.Clear();
diff --git a/de4dot.code/deobfuscators/Eazfuscator_NET/StringDecrypter.cs b/de4dot.code/deobfuscators/Eazfuscator_NET/StringDecrypter.cs
index c771cfb1..dd40699d 100644
--- a/de4dot.code/deobfuscators/Eazfuscator_NET/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/Eazfuscator_NET/StringDecrypter.cs
@@ -69,11 +69,11 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				foreach (var method in type.Methods) {
 					if (method.IsStatic || method.Body == null || method.IsPrivate || method.GenericParameters.Count > 0)
 						continue;
-					if (DotNetUtils.isMethod(method, "System.Int16", "()"))
+					if (DotNetUtils.IsMethod(method, "System.Int16", "()"))
 						readInt16Method = method;
-					else if (DotNetUtils.isMethod(method, "System.Int32", "()"))
+					else if (DotNetUtils.IsMethod(method, "System.Int32", "()"))
 						readInt32Method = method;
-					else if (DotNetUtils.isMethod(method, "System.Byte[]", "(System.Int32)"))
+					else if (DotNetUtils.IsMethod(method, "System.Byte[]", "(System.Int32)"))
 						readBytesMethod = method;
 				}
 			}
@@ -117,7 +117,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			this.decrypterType = decrypterType;
 		}
 
-		static bool checkIfV32OrLater(TypeDef type) {
+		static bool CheckIfV32OrLater(TypeDef type) {
 			int numInts = 0;
 			foreach (var field in type.Fields) {
 				if (field.FieldSig.GetFieldType().GetElementType() == ElementType.I4)
@@ -126,18 +126,18 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return numInts >= 2;
 		}
 
-		public void find() {
+		public void Find() {
 			foreach (var type in module.Types) {
-				if (!checkType(type))
+				if (!CheckType(type))
 					continue;
 
 				foreach (var method in type.Methods) {
-					if (!checkDecrypterMethod(method))
+					if (!CheckDecrypterMethod(method))
 						continue;
 
 					stringType = type;
 					stringMethod = method;
-					isV32OrLater = checkIfV32OrLater(stringType);
+					isV32OrLater = CheckIfV32OrLater(stringType);
 					return;
 				}
 			}
@@ -147,15 +147,15 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			"System.Byte[]",
 			"System.Int16",
 		};
-		bool checkType(TypeDef type) {
-			if (!new FieldTypes(type).all(requiredFieldTypes))
+		bool CheckType(TypeDef type) {
+			if (!new FieldTypes(type).All(requiredFieldTypes))
 				return false;
 			if (type.NestedTypes.Count == 0) {
-				return DotNetUtils.findFieldType(type, "System.IO.BinaryReader", true) != null &&
-					DotNetUtils.findFieldType(type, "System.Collections.Generic.Dictionary`2<System.Int32,System.String>", true) != null;
+				return DotNetUtils.FindFieldType(type, "System.IO.BinaryReader", true) != null &&
+					DotNetUtils.FindFieldType(type, "System.Collections.Generic.Dictionary`2<System.Int32,System.String>", true) != null;
 			}
 			else if (type.NestedTypes.Count == 3) {
-				streamHelperType = findStreamHelperType(type);
+				streamHelperType = FindStreamHelperType(type);
 				return streamHelperType != null;
 			}
 			else if (type.NestedTypes.Count == 1) {
@@ -169,14 +169,14 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			"System.IO.Stream",
 			"System.Byte[]",
 		};
-		static StreamHelperType findStreamHelperType(TypeDef type) {
+		static StreamHelperType FindStreamHelperType(TypeDef type) {
 			foreach (var field in type.Fields) {
 				var nested = field.FieldSig.GetFieldType().TryGetTypeDef();
 				if (nested == null)
 					continue;
 				if (nested.DeclaringType != type)
 					continue;
-				if (!new FieldTypes(nested).exactly(streamHelperTypeFields))
+				if (!new FieldTypes(nested).Exactly(streamHelperTypeFields))
 					continue;
 				var streamHelperType = new StreamHelperType(nested);
 				if (!streamHelperType.Detected)
@@ -196,12 +196,12 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			"System.Reflection.Assembly",
 			"System.String",
 		};
-		static bool checkDecrypterMethod(MethodDef method) {
+		static bool CheckDecrypterMethod(MethodDef method) {
 			if (method == null || !method.IsStatic || method.Body == null)
 				return false;
-			if (!DotNetUtils.isMethod(method, "System.String", "(System.Int32)"))
+			if (!DotNetUtils.IsMethod(method, "System.String", "(System.Int32)"))
 				return false;
-			if (!new LocalTypes(method).all(requiredLocalTypes))
+			if (!new LocalTypes(method).All(requiredLocalTypes))
 				return false;
 
 			foreach (var instr in method.Body.Instructions) {
@@ -214,11 +214,11 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return false;
 		}
 
-		public void initialize(ISimpleDeobfuscator simpleDeobfuscator) {
+		public void Initialize(ISimpleDeobfuscator simpleDeobfuscator) {
 			if (stringType == null)
 				return;
 
-			if (!findConstants(simpleDeobfuscator)) {
+			if (!FindConstants(simpleDeobfuscator)) {
 				if (encryptedResource == null)
 					Logger.w("Could not find encrypted resource. Strings cannot be decrypted.");
 				else
@@ -227,58 +227,58 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			}
 		}
 
-		bool findConstants(ISimpleDeobfuscator simpleDeobfuscator) {
+		bool FindConstants(ISimpleDeobfuscator simpleDeobfuscator) {
 			dynocode = new Dynocode(simpleDeobfuscator);
-			simpleDeobfuscator.deobfuscate(stringMethod);
+			simpleDeobfuscator.Deobfuscate(stringMethod);
 			stringMethodConsts = new EfConstantsReader(stringMethod);
 
-			if (!findResource(stringMethod))
+			if (!FindResource(stringMethod))
 				return false;
 
-			checkMinus2 = isV32OrLater || DeobUtils.hasInteger(stringMethod, -2);
-			usePublicKeyToken = callsGetPublicKeyToken(stringMethod);
+			checkMinus2 = isV32OrLater || DeobUtils.HasInteger(stringMethod, -2);
+			usePublicKeyToken = CallsGetPublicKeyToken(stringMethod);
 
-			var int64Method = findInt64Method(stringMethod);
+			var int64Method = FindInt64Method(stringMethod);
 			if (int64Method != null)
 				decrypterType.Type = int64Method.DeclaringType;
 
-			if (!findShorts())
+			if (!FindShorts())
 				return false;
-			if (!findInt3())
+			if (!FindInt3())
 				return false;
-			if (!findInt4())
+			if (!FindInt4())
 				return false;
-			if (checkMinus2 && !findInt5())
+			if (checkMinus2 && !FindInt5())
 				return false;
-			dataDecrypterType = findDataDecrypterType(stringMethod);
+			dataDecrypterType = FindDataDecrypterType(stringMethod);
 			if (dataDecrypterType == null)
 				return false;
 
 			if (isV32OrLater) {
 				bool initializedAll;
-				int index = findInitIntsIndex(stringMethod, out initializedAll);
+				int index = FindInitIntsIndex(stringMethod, out initializedAll);
 
 				var cctor = stringType.FindStaticConstructor();
 				if (!initializedAll && cctor != null) {
-					simpleDeobfuscator.deobfuscate(cctor);
-					if (!findIntsCctor(cctor))
+					simpleDeobfuscator.Deobfuscate(cctor);
+					if (!FindIntsCctor(cctor))
 						return false;
 				}
 
-				if (decrypterType.Detected && !decrypterType.initialize())
+				if (decrypterType.Detected && !decrypterType.Initialize())
 					return false;
 
-				if (!findInts(index))
+				if (!FindInts(index))
 					return false;
 			}
 
-			initializeFlags();
-			initialize();
+			InitializeFlags();
+			Initialize();
 
 			return true;
 		}
 
-		void initializeFlags() {
+		void InitializeFlags() {
 			if (!isV32OrLater) {
 				rldFlag = 0x40000000;
 				bytesFlag = 0x80000000;
@@ -288,19 +288,19 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			var instrs = stringMethod.Body.Instructions;
 			for (int i = 0; i < instrs.Count; i++) {
 				var ldci4 = instrs[i];
-				if (!stringMethodConsts.isLoadConstantInt32(ldci4))
+				if (!stringMethodConsts.IsLoadConstantInt32(ldci4))
 					continue;
 				int index = i, tmp;
-				if (!stringMethodConsts.getInt32(ref index, out tmp) || !isFlagsMask(tmp))
+				if (!stringMethodConsts.GetInt32(ref index, out tmp) || !IsFlagsMask(tmp))
 					continue;
-				if (findFlags(i))
+				if (FindFlags(i))
 					return;
 			}
 
 			throw new ApplicationException("Could not find string decrypter flags");
 		}
 
-		static bool isFlagsMask(int value) {
+		static bool IsFlagsMask(int value) {
 			return value == 0x1FFFFFFF || value == 0x0FFFFFFF;
 		}
 
@@ -315,8 +315,8 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			}
 		}
 
-		bool findFlags(int index) {
-			var flags = findFlags2(index);
+		bool FindFlags(int index) {
+			var flags = FindFlags2(index);
 			if (flags == null)
 				return false;
 
@@ -327,23 +327,23 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return true;
 		}
 
-		List<FlagsInfo> findFlags2(int index) {
+		List<FlagsInfo> FindFlags2(int index) {
 			var flags = new List<FlagsInfo>(3);
 			for (int i = index - 1; i >= 0; i--) {
 				var instr = stringMethod.Body.Instructions[i];
 				if (instr.OpCode.FlowControl != FlowControl.Next)
 					break;
-				if (!stringMethodConsts.isLoadConstantInt32(instr))
+				if (!stringMethodConsts.IsLoadConstantInt32(instr))
 					continue;
 				int index2 = i, value;
-				if (!stringMethodConsts.getInt32(ref index2, out value))
+				if (!stringMethodConsts.GetInt32(ref index2, out value))
 					continue;
 				if ((uint)value != 0x80000000 && value != 0x40000000 && value != 0x20000000)
 					continue;
-				var local = getFlagsLocal(stringMethod, index2);
+				var local = GetFlagsLocal(stringMethod, index2);
 				if (local == null)
 					continue;
-				int offset = getFlagsOffset(stringMethod, index2, local);
+				int offset = GetFlagsOffset(stringMethod, index2, local);
 				if (offset < 0)
 					continue;
 
@@ -357,7 +357,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return null;
 		}
 
-		static int getFlagsOffset(MethodDef method, int index, Local local) {
+		static int GetFlagsOffset(MethodDef method, int index, Local local) {
 			var instrs = method.Body.Instructions;
 			for (; index < instrs.Count; index++) {
 				var ldloc = instrs[index];
@@ -371,7 +371,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return -1;
 		}
 
-		static Local getFlagsLocal(MethodDef method, int index) {
+		static Local GetFlagsLocal(MethodDef method, int index) {
 			var instrs = method.Body.Instructions;
 			if (index + 5 >= instrs.Count)
 				return null;
@@ -391,7 +391,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return stloc.GetLocal(method.Body.Variables);
 		}
 
-		void initialize() {
+		void Initialize() {
 			reader = new BinaryReader(encryptedResource.GetResourceStream());
 			short len = (short)(reader.ReadInt16() ^ s1);
 			if (len != 0)
@@ -400,7 +400,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				keyLen = reader.ReadInt16() ^ s2;
 		}
 
-		public string decrypt(int val) {
+		public string Decrypt(int val) {
 			validStringDecrypterValue = val;
 			while (true) {
 				int offset = magic1 ^ i3 ^ val ^ i6;
@@ -424,7 +424,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				}
 
 				var bytes = reader.ReadBytes(flags & 0x1FFFFFFF);
-				decrypt1(bytes, tmpKey);
+				Decrypt1(bytes, tmpKey);
 				var pkt = PublicKeyBase.ToPublicKeyToken(module.Assembly.PublicKey);
 				if (usePublicKeyToken && !PublicKeyBase.IsNullOrEmpty2(pkt)) {
 					for (int i = 0; i < bytes.Length; i++)
@@ -474,14 +474,14 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return dst;
 		}
 
-		static void decrypt1(byte[] dest, byte[] key) {
+		static void Decrypt1(byte[] dest, byte[] key) {
 			byte b = (byte)((key[1] + 7) ^ (dest.Length + 11));
 			uint lcg = (uint)((key[0] | (key[2] << 8)) + (b << 3));
 			b += 3;
 			ushort xn = 0;
 			for (int i = 0; i < dest.Length; i++) {
 				if ((i & 1) == 0) {
-					lcg = lcgNext(lcg);
+					lcg = LcgNext(lcg);
 					xn = (ushort)(lcg >> 16);
 				}
 				byte tmp = dest[i];
@@ -491,25 +491,25 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			}
 		}
 
-		static uint lcgNext(uint lcg) {
+		static uint LcgNext(uint lcg) {
 			return lcg * 214013 + 2531011;
 		}
 
-		bool findResource(MethodDef method) {
-			encryptedResource = findResourceFromCodeString(method) ??
-								findResourceFromStringBuilder(method);
+		bool FindResource(MethodDef method) {
+			encryptedResource = FindResourceFromCodeString(method) ??
+								FindResourceFromStringBuilder(method);
 			return encryptedResource != null;
 		}
 
-		EmbeddedResource findResourceFromCodeString(MethodDef method) {
-			return DotNetUtils.getResource(module, DotNetUtils.getCodeStrings(method)) as EmbeddedResource;
+		EmbeddedResource FindResourceFromCodeString(MethodDef method) {
+			return DotNetUtils.GetResource(module, DotNetUtils.GetCodeStrings(method)) as EmbeddedResource;
 		}
 
-		EmbeddedResource findResourceFromStringBuilder(MethodDef method) {
-			int startIndex = EfUtils.findOpCodeIndex(method, 0, Code.Newobj, "System.Void System.Text.StringBuilder::.ctor()");
+		EmbeddedResource FindResourceFromStringBuilder(MethodDef method) {
+			int startIndex = EfUtils.FindOpCodeIndex(method, 0, Code.Newobj, "System.Void System.Text.StringBuilder::.ctor()");
 			if (startIndex < 0)
 				return null;
-			int endIndex = EfUtils.findOpCodeIndex(method, startIndex, Code.Call, "System.String System.Text.StringBuilder::ToString()");
+			int endIndex = EfUtils.FindOpCodeIndex(method, startIndex, Code.Call, "System.String System.Text.StringBuilder::ToString()");
 			if (endIndex < 0)
 				return null;
 
@@ -522,9 +522,9 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 					sb.Append((char)(val >> shift));
 					shift = 0;
 				}
-				if (stringMethodConsts.isLoadConstantInt32(instr)) {
+				if (stringMethodConsts.IsLoadConstantInt32(instr)) {
 					int tmp;
-					if (!stringMethodConsts.getInt32(ref i, out tmp))
+					if (!stringMethodConsts.GetInt32(ref i, out tmp))
 						break;
 					if (i >= endIndex)
 						break;
@@ -539,17 +539,17 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				}
 			}
 
-			return DotNetUtils.getResource(module, sb.ToString()) as EmbeddedResource;
+			return DotNetUtils.GetResource(module, sb.ToString()) as EmbeddedResource;
 		}
 
-		static MethodDef findInt64Method(MethodDef 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 MethodDef;
 				if (calledMethod == null)
 					continue;
-				if (!DotNetUtils.isMethod(calledMethod, "System.Int64", "()"))
+				if (!DotNetUtils.IsMethod(calledMethod, "System.Int64", "()"))
 					continue;
 
 				return calledMethod;
@@ -557,14 +557,14 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return null;
 		}
 
-		static TypeDef findDataDecrypterType(MethodDef 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 MethodDef;
 				if (calledMethod == null)
 					continue;
-				if (!DotNetUtils.isMethod(calledMethod, "System.Byte[]", "(System.Byte[],System.Byte[])"))
+				if (!DotNetUtils.IsMethod(calledMethod, "System.Byte[]", "(System.Byte[],System.Byte[])"))
 					continue;
 
 				return calledMethod.DeclaringType;
@@ -572,26 +572,26 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return null;
 		}
 
-		bool findShorts() {
+		bool FindShorts() {
 			int index = 0;
-			if (!findShort(ref index, ref s1))
+			if (!FindShort(ref index, ref s1))
 				return false;
-			if (!findShort(ref index, ref s2))
+			if (!FindShort(ref index, ref s2))
 				return false;
-			if (!findShort(ref index, ref s3))
+			if (!FindShort(ref index, ref s3))
 				return false;
 
 			return true;
 		}
 
-		bool findShort(ref int index, ref short s) {
-			if (!findCallReadInt16(ref index))
+		bool FindShort(ref int index, ref short s) {
+			if (!FindCallReadInt16(ref index))
 				return false;
 			index++;
-			return stringMethodConsts.getInt16(ref index, out s);
+			return stringMethodConsts.GetInt16(ref index, out s);
 		}
 
-		bool findInts(int index) {
+		bool FindInts(int index) {
 			if (index < 0)
 				return false;
 
@@ -600,7 +600,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 
 			var emu = new InstructionEmulator(stringMethod);
 			foreach (var kv in stringMethodConsts.Locals32)
-				emu.setLocal(kv.Key, new Int32Value(kv.Value));
+				emu.SetLocal(kv.Key, new Int32Value(kv.Value));
 
 			var fields = new Dictionary<FieldDef, int?>();
 			for (int i = index; i < instrs.Count - 2; i++) {
@@ -613,7 +613,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 					if (field == null || field.DeclaringType != stringMethod.DeclaringType || field.FieldType.GetElementType() != ElementType.I4)
 						goto default;
 					fields[field] = null;
-					emu.push(new Int32Value(i1));
+					emu.Push(new Int32Value(i1));
 					break;
 
 				case Code.Stsfld:
@@ -622,8 +622,8 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 						goto default;
 					if (fields.ContainsKey(field) && fields[field] == null)
 						goto default;
-					var val = emu.pop() as Int32Value;
-					if (val == null || !val.allBitsValid())
+					var val = emu.Pop() as Int32Value;
+					if (val == null || !val.AllBitsValid())
 						fields[field] = null;
 					else
 						fields[field] = val.value;
@@ -633,18 +633,18 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 					var method = instr.Operand as MethodDef;
 					if (!decrypterType.Detected || method != decrypterType.Int64Method)
 						goto done;
-					emu.push(new Int64Value((long)decrypterType.getMagic()));
+					emu.Push(new Int64Value((long)decrypterType.GetMagic()));
 					break;
 
 				case Code.Newobj:
-					if (!emulateDynocode(emu, ref i))
+					if (!EmulateDynocode(emu, ref i))
 						goto default;
 					break;
 
 				default:
 					if (instr.OpCode.FlowControl != FlowControl.Next)
 						goto done;
-					emu.emulate(instr);
+					emu.Emulate(instr);
 					break;
 				}
 			}
@@ -660,7 +660,7 @@ done: ;
 			return false;
 		}
 
-		bool emulateDynocode(InstructionEmulator emu, ref int index) {
+		bool EmulateDynocode(InstructionEmulator emu, ref int index) {
 			var instrs = stringMethod.Body.Instructions;
 			var instr = instrs[index];
 
@@ -674,38 +674,38 @@ done: ;
 			if (!ldloc.IsLdloc() || instrs[index + 4].OpCode.Code != Code.Stfld)
 				return false;
 
-			var initValue = emu.getLocal(ldloc.GetLocal(stringMethod.Body.Variables)) as Int32Value;
-			if (initValue == null || !initValue.allBitsValid())
+			var initValue = emu.GetLocal(ldloc.GetLocal(stringMethod.Body.Variables)) as Int32Value;
+			if (initValue == null || !initValue.AllBitsValid())
 				return false;
 
-			int leaveIndex = findLeave(instrs, index);
+			int leaveIndex = FindLeave(instrs, index);
 			if (leaveIndex < 0)
 				return false;
 			var afterLoop = instrs[leaveIndex].Operand as Instruction;
 			if (afterLoop == null)
 				return false;
 			int newIndex = instrs.IndexOf(afterLoop);
-			var loopLocal = getDCLoopLocal(index, newIndex);
+			var loopLocal = GetDCLoopLocal(index, newIndex);
 			if (loopLocal == null)
 				return false;
-			var initValue2 = emu.getLocal(loopLocal) as Int32Value;
-			if (initValue2 == null || !initValue2.allBitsValid())
+			var initValue2 = emu.GetLocal(loopLocal) as Int32Value;
+			if (initValue2 == null || !initValue2.AllBitsValid())
 				return false;
 
-			var dcGen = dynocode.getDynocodeGenerator(ctor.DeclaringType);
+			var dcGen = dynocode.GetDynocodeGenerator(ctor.DeclaringType);
 			if (dcGen == null)
 				return false;
 			int loopLocalValue = initValue2.value;
-			foreach (var val in dcGen.getValues(initValue.value))
+			foreach (var val in dcGen.GetValues(initValue.value))
 				loopLocalValue ^= val;
 
-			emu.setLocal(loopLocal, new Int32Value(loopLocalValue));
-			emu.emulate(instr);
+			emu.SetLocal(loopLocal, new Int32Value(loopLocalValue));
+			emu.Emulate(instr);
 			index = newIndex - 1;
 			return true;
 		}
 
-		Local getDCLoopLocal(int start, int end) {
+		Local GetDCLoopLocal(int start, int end) {
 			var instrs = stringMethod.Body.Instructions;
 			for (int i = start; i < end - 1; i++) {
 				if (instrs[i].OpCode.Code != Code.Xor)
@@ -718,7 +718,7 @@ done: ;
 			return null;
 		}
 
-		static int findLeave(IList<Instruction> instrs, int index) {
+		static int FindLeave(IList<Instruction> instrs, int index) {
 			for (int i = index; i < instrs.Count; i++) {
 				if (instrs[i].OpCode.Code == Code.Leave_S || instrs[i].OpCode.Code == Code.Leave)
 					return i;
@@ -726,7 +726,7 @@ done: ;
 			return -1;
 		}
 
-		static int findInitIntsIndex(MethodDef method, out bool initializedAll) {
+		static int FindInitIntsIndex(MethodDef method, out bool initializedAll) {
 			initializedAll = false;
 
 			var instrs = method.Body.Instructions;
@@ -761,27 +761,27 @@ done: ;
 			return -1;
 		}
 
-		bool findIntsCctor(MethodDef cctor) {
+		bool FindIntsCctor(MethodDef cctor) {
 			int index = 0;
-			if (!findCallGetFrame(cctor, ref index))
-				return findIntsCctor2(cctor);
+			if (!FindCallGetFrame(cctor, ref index))
+				return FindIntsCctor2(cctor);
 
 			int tmp1, tmp2, tmp3 = 0;
 			var constantsReader = new EfConstantsReader(cctor);
-			if (!constantsReader.getNextInt32(ref index, out tmp1))
+			if (!constantsReader.GetNextInt32(ref index, out tmp1))
 				return false;
-			if (tmp1 == 0 && !constantsReader.getNextInt32(ref index, out tmp1))
+			if (tmp1 == 0 && !constantsReader.GetNextInt32(ref index, out tmp1))
 				return false;
-			if (!constantsReader.getNextInt32(ref index, out tmp2))
+			if (!constantsReader.GetNextInt32(ref index, out tmp2))
 				return false;
-			if (tmp2 == 0 && !constantsReader.getNextInt32(ref index, out tmp2))
+			if (tmp2 == 0 && !constantsReader.GetNextInt32(ref index, out tmp2))
 				return false;
 
 			index = 0;
 			var instrs = cctor.Body.Instructions;
 			while (index < instrs.Count) {
 				int tmp4;
-				if (!constantsReader.getNextInt32(ref index, out tmp4))
+				if (!constantsReader.GetNextInt32(ref index, out tmp4))
 					break;
 				if (index < instrs.Count && instrs[index].IsLdloc())
 					tmp3 = tmp4;
@@ -792,13 +792,13 @@ done: ;
 		}
 
 		// Compact Framework doesn't have StackFrame
-		bool findIntsCctor2(MethodDef cctor) {
+		bool FindIntsCctor2(MethodDef cctor) {
 			int index = 0;
 			var instrs = cctor.Body.Instructions;
 			var constantsReader = new EfConstantsReader(cctor);
 			while (index >= 0) {
 				int val;
-				if (!constantsReader.getNextInt32(ref index, out val))
+				if (!constantsReader.GetNextInt32(ref index, out val))
 					break;
 				if (index < instrs.Count && instrs[index].OpCode.Code == Code.Add) {
 					i1 = val;
@@ -809,14 +809,14 @@ done: ;
 			return false;
 		}
 
-		bool findInt3() {
+		bool FindInt3() {
 			if (!isV32OrLater)
-				return findInt3Old();
-			return findInt3New();
+				return FindInt3Old();
+			return FindInt3New();
 		}
 
 		// <= 3.1
-		bool findInt3Old() {
+		bool FindInt3Old() {
 			var instrs = stringMethod.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 4; i++) {
 				var ldarg0 = instrs[i];
@@ -829,7 +829,7 @@ done: ;
 
 				int index = i + 1;
 				int value;
-				if (!stringMethodConsts.getInt32(ref index, out value))
+				if (!stringMethodConsts.GetInt32(ref index, out value))
 					continue;
 				if (index >= instrs.Count)
 					continue;
@@ -845,7 +845,7 @@ done: ;
 		}
 
 		// 3.2+
-		bool findInt3New() {
+		bool FindInt3New() {
 			var instrs = stringMethod.Body.Instructions;
 			for (int i = 0; i < instrs.Count; i++) {
 				int index = i;
@@ -855,7 +855,7 @@ done: ;
 					continue;
 
 				int value;
-				if (!stringMethodConsts.getInt32(ref index, out value))
+				if (!stringMethodConsts.GetInt32(ref index, out value))
 					continue;
 
 				if (index + 3 >= instrs.Count)
@@ -871,7 +871,7 @@ done: ;
 					continue;
 
 				i3 = value;
-				if (!findInt6(index++))
+				if (!FindInt6(index++))
 					return false;
 				return true;
 			}
@@ -880,42 +880,42 @@ done: ;
 		}
 
 		// v3.3.134+
-		bool findInt6(int index) {
-			index = getNextLdci4InSameBlock(index);
+		bool FindInt6(int index) {
+			index = GetNextLdci4InSameBlock(index);
 			if (index < 0)
 				return true;
 
-			return stringMethodConsts.getNextInt32(ref index, out i6);
+			return stringMethodConsts.GetNextInt32(ref index, out i6);
 		}
 
-		bool findInt4() {
+		bool FindInt4() {
 			int index = 0;
-			if (!findCallReadInt32(ref index))
+			if (!FindCallReadInt32(ref index))
 				return false;
-			if (!stringMethodConsts.getNextInt32(ref index, out i4))
+			if (!stringMethodConsts.GetNextInt32(ref index, out i4))
 				return false;
 
 			return true;
 		}
 
-		int getNextLdci4InSameBlock(int index) {
+		int GetNextLdci4InSameBlock(int index) {
 			var instrs = stringMethod.Body.Instructions;
 			for (int i = index; i < instrs.Count; i++) {
 				var instr = instrs[i];
 				if (instr.OpCode.FlowControl != FlowControl.Next)
 					return -1;
-				if (stringMethodConsts.isLoadConstantInt32(instr))
+				if (stringMethodConsts.IsLoadConstantInt32(instr))
 					return i;
 			}
 
 			return -1;
 		}
 
-		bool findInt5() {
+		bool FindInt5() {
 			int index = -1;
 			while (true) {
 				index++;
-				if (!findCallReadBytes(ref index))
+				if (!FindCallReadBytes(ref index))
 					return false;
 				if (index <= 0)
 					continue;
@@ -924,37 +924,37 @@ done: ;
 					continue;
 				if (ldci4.GetLdcI4Value() != 4)
 					continue;
-				if (!stringMethodConsts.getNextInt32(ref index, out i5))
+				if (!stringMethodConsts.GetNextInt32(ref index, out i5))
 					return false;
 
 				return true;
 			}
 		}
 
-		static bool callsGetPublicKeyToken(MethodDef method) {
+		static bool CallsGetPublicKeyToken(MethodDef method) {
 			int index = 0;
-			return findCall(method, ref index, "System.Byte[] System.Reflection.AssemblyName::GetPublicKeyToken()");
+			return FindCall(method, ref index, "System.Byte[] System.Reflection.AssemblyName::GetPublicKeyToken()");
 		}
 
-		bool findCallReadInt16(ref int index) {
-			return findCall(stringMethod, ref index, streamHelperType == null ? "System.Int16 System.IO.BinaryReader::ReadInt16()" : streamHelperType.readInt16Method.FullName);
+		bool FindCallReadInt16(ref int index) {
+			return FindCall(stringMethod, ref index, streamHelperType == null ? "System.Int16 System.IO.BinaryReader::ReadInt16()" : streamHelperType.readInt16Method.FullName);
 		}
 
-		bool findCallReadInt32(ref int index) {
-			return findCall(stringMethod, ref index, streamHelperType == null ? "System.Int32 System.IO.BinaryReader::ReadInt32()" : streamHelperType.readInt32Method.FullName);
+		bool FindCallReadInt32(ref int index) {
+			return FindCall(stringMethod, ref index, streamHelperType == null ? "System.Int32 System.IO.BinaryReader::ReadInt32()" : streamHelperType.readInt32Method.FullName);
 		}
 
-		bool findCallReadBytes(ref int index) {
-			return findCall(stringMethod, ref index, streamHelperType == null ? "System.Byte[] System.IO.BinaryReader::ReadBytes(System.Int32)" : streamHelperType.readBytesMethod.FullName);
+		bool FindCallReadBytes(ref int index) {
+			return FindCall(stringMethod, ref index, streamHelperType == null ? "System.Byte[] System.IO.BinaryReader::ReadBytes(System.Int32)" : streamHelperType.readBytesMethod.FullName);
 		}
 
-		static bool findCallGetFrame(MethodDef method, ref int index) {
-			return findCall(method, ref index, "System.Diagnostics.StackFrame System.Diagnostics.StackTrace::GetFrame(System.Int32)");
+		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(MethodDef 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))
+				if (!FindCallvirt(method, ref index))
 					return false;
 
 				var calledMethod = method.Body.Instructions[index].Operand as IMethod;
@@ -968,7 +968,7 @@ done: ;
 			return false;
 		}
 
-		static bool findCallvirt(MethodDef 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 bdf9962b..f88d7f10 100644
--- a/de4dot.code/deobfuscators/Eazfuscator_NET/VersionDetector.cs
+++ b/de4dot.code/deobfuscators/Eazfuscator_NET/VersionDetector.cs
@@ -29,10 +29,10 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 
 		public VersionDetector(ModuleDefMD module, StringDecrypter stringDecrypter) {
 			this.stringDecrypter = stringDecrypter;
-			this.frameworkType = DotNetUtils.getFrameworkType(module);
+			this.frameworkType = DotNetUtils.GetFrameworkType(module);
 		}
 
-		public string detect() {
+		public string Detect() {
 			var decryptStringType = stringDecrypter.Type;
 			var decryptStringMethod = stringDecrypter.Method;
 			if (decryptStringType == null || decryptStringMethod == null)
@@ -51,7 +51,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			if (cctor == null)
 				return null;
 
-			bool hasConstantM2 = DeobUtils.hasInteger(decryptStringMethod, -2);
+			bool hasConstantM2 = DeobUtils.HasInteger(decryptStringMethod, -2);
 
 			/////////////////////////////////////////////////////////////////
 			/////////////////////////////////////////////////////////////////
@@ -64,7 +64,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				"System.Int16",
 				"System.Boolean",
 			};
-			var locals11 = createLocalsArray(
+			var locals11 = CreateLocalsArray(
 				"System.Boolean",
 				"System.Byte[]",
 				"System.Char[]",
@@ -82,8 +82,8 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				decryptStringMethod.Body.MaxStack >= 35 &&
 				decryptStringMethod.Body.MaxStack <= 50 &&
 				decryptStringMethod.Body.ExceptionHandlers.Count == 0 &&
-				new LocalTypes(decryptStringMethod).exactly(locals11) &&
-				checkTypeFields(fields11)) {
+				new LocalTypes(decryptStringMethod).Exactly(locals11) &&
+				CheckTypeFields(fields11)) {
 				return "1.1 - 1.2";
 			}
 
@@ -99,7 +99,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				"System.Boolean",
 				"System.Byte[]",
 			};
-			var locals13 = createLocalsArray(
+			var locals13 = CreateLocalsArray(
 				"System.Boolean",
 				"System.Byte",
 				"System.Byte[]",
@@ -118,8 +118,8 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				decryptStringMethod.Body.MaxStack >= 35 &&
 				decryptStringMethod.Body.MaxStack <= 50 &&
 				decryptStringMethod.Body.ExceptionHandlers.Count == 0 &&
-				new LocalTypes(decryptStringMethod).exactly(locals13) &&
-				checkTypeFields(fields13)) {
+				new LocalTypes(decryptStringMethod).Exactly(locals13) &&
+				CheckTypeFields(fields13)) {
 				return "1.3";
 			}
 
@@ -135,7 +135,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				"System.Boolean",
 				"System.Byte[]",
 			};
-			var locals14 = createLocalsArray(
+			var locals14 = CreateLocalsArray(
 				"System.Boolean",
 				"System.Byte",
 				"System.Byte[]",
@@ -154,8 +154,8 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				decryptStringMethod.Body.MaxStack >= 150 &&
 				decryptStringMethod.Body.MaxStack <= 200 &&
 				decryptStringMethod.Body.ExceptionHandlers.Count == 0 &&
-				new LocalTypes(decryptStringMethod).exactly(locals14) &&
-				checkTypeFields(fields14)) {
+				new LocalTypes(decryptStringMethod).Exactly(locals14) &&
+				CheckTypeFields(fields14)) {
 				return "1.4 - 2.3";
 			}
 
@@ -171,7 +171,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				"System.Boolean",
 				"System.Byte[]",
 			};
-			var locals24 = createLocalsArray(
+			var locals24 = CreateLocalsArray(
 				"System.Boolean",
 				"System.Byte",
 				"System.Byte[]",
@@ -191,8 +191,8 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				decryptStringMethod.Body.MaxStack >= 1 &&
 				decryptStringMethod.Body.MaxStack <= 8 &&
 				decryptStringMethod.Body.ExceptionHandlers.Count == 0 &&
-				new LocalTypes(decryptStringMethod).exactly(locals24) &&
-				checkTypeFields(fields24)) {
+				new LocalTypes(decryptStringMethod).Exactly(locals24) &&
+				CheckTypeFields(fields24)) {
 				return "2.4 - 2.5";
 			}
 
@@ -208,7 +208,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				"System.Boolean",
 				"System.Byte[]",
 			};
-			var locals26 = createLocalsArray(
+			var locals26 = CreateLocalsArray(
 				"System.Boolean",
 				"System.Byte",
 				"System.Byte[]",
@@ -229,8 +229,8 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				decryptStringMethod.Body.MaxStack >= 1 &&
 				decryptStringMethod.Body.MaxStack <= 8 &&
 				decryptStringMethod.Body.ExceptionHandlers.Count == 1 &&
-				new LocalTypes(decryptStringMethod).exactly(locals26) &&
-				checkTypeFields(fields26)) {
+				new LocalTypes(decryptStringMethod).Exactly(locals26) &&
+				CheckTypeFields(fields26)) {
 				return "2.6";
 			}
 
@@ -246,7 +246,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				"System.Boolean",
 				"System.Byte[]",
 			};
-			var locals27 = createLocalsArray(
+			var locals27 = CreateLocalsArray(
 				"System.Boolean",
 				"System.Byte",
 				"System.Byte[]",
@@ -267,8 +267,8 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				decryptStringMethod.Body.MaxStack >= 1 &&
 				decryptStringMethod.Body.MaxStack <= 8 &&
 				decryptStringMethod.Body.ExceptionHandlers.Count == 1 &&
-				new LocalTypes(decryptStringMethod).exactly(locals27) &&
-				checkTypeFields(fields27)) {
+				new LocalTypes(decryptStringMethod).Exactly(locals27) &&
+				CheckTypeFields(fields27)) {
 				return "2.7";
 			}
 
@@ -285,7 +285,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				"System.Byte[]",
 				"System.Boolean",
 			};
-			var locals28 = createLocalsArray(
+			var locals28 = CreateLocalsArray(
 				"System.Boolean",
 				"System.Byte",
 				"System.Byte[]",
@@ -306,8 +306,8 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				decryptStringMethod.Body.MaxStack >= 1 &&
 				decryptStringMethod.Body.MaxStack <= 8 &&
 				decryptStringMethod.Body.ExceptionHandlers.Count == 1 &&
-				new LocalTypes(decryptStringMethod).exactly(locals28) &&
-				checkTypeFields(fields28)) {
+				new LocalTypes(decryptStringMethod).Exactly(locals28) &&
+				CheckTypeFields(fields28)) {
 				return "2.8";
 			}
 
@@ -323,7 +323,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				"System.Int32",
 				"System.Byte[]",
 			};
-			var locals29 = createLocalsArray(
+			var locals29 = CreateLocalsArray(
 				"System.Boolean",
 				"System.Byte",
 				"System.Byte[]",
@@ -349,8 +349,8 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				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)) {
+				new LocalTypes(decryptStringMethod).Exactly(locals29) &&
+				CheckTypeFields(fields29)) {
 				return "2.9";
 			}
 
@@ -366,7 +366,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				"System.Int32",
 				"System.Byte[]",
 			};
-			var locals30 = createLocalsArray(
+			var locals30 = CreateLocalsArray(
 				"System.Boolean",
 				"System.Byte",
 				"System.Byte[]",
@@ -383,15 +383,15 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				"System.String",
 				"System.Type"
 			);
-			var olocals30 = createLocalsArray(
+			var olocals30 = CreateLocalsArray(
 				"System.Int32"
 			);
 			if (otherMethods.Count == 1 &&
 				decryptStringType.NestedTypes.Count == 0 &&
-				DotNetUtils.isMethod(otherMethods[0], "System.Int32", "(System.Byte[],System.Int32,System.Byte[])") &&
+				DotNetUtils.IsMethod(otherMethods[0], "System.Int32", "(System.Byte[],System.Int32,System.Byte[])") &&
 				otherMethods[0].IsPrivate &&
 				otherMethods[0].IsStatic &&
-				new LocalTypes(otherMethods[0]).exactly(olocals30) &&
+				new LocalTypes(otherMethods[0]).Exactly(olocals30) &&
 				!hasConstantM2 &&
 				decryptStringMethod.IsNoInlining &&
 				decryptStringMethod.IsAssembly &&
@@ -399,8 +399,8 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				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)) {
+				new LocalTypes(decryptStringMethod).Exactly(locals30) &&
+				CheckTypeFields(fields30)) {
 				return "3.0";
 			}
 
@@ -416,7 +416,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				"System.Int32",
 				"System.Byte[]",
 			};
-			var locals31 = createLocalsArray(
+			var locals31 = CreateLocalsArray(
 				"System.Boolean",
 				"System.Byte",
 				"System.Byte[]",
@@ -433,15 +433,15 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				"System.String",
 				"System.Type"
 			);
-			var olocals31 = createLocalsArray(
+			var olocals31 = CreateLocalsArray(
 				"System.Int32"
 			);
 			if (otherMethods.Count == 1 &&
 				decryptStringType.NestedTypes.Count == 0 &&
-				DotNetUtils.isMethod(otherMethods[0], "System.Int32", "(System.Byte[],System.Int32,System.Byte[])") &&
+				DotNetUtils.IsMethod(otherMethods[0], "System.Int32", "(System.Byte[],System.Int32,System.Byte[])") &&
 				otherMethods[0].IsPrivate &&
 				otherMethods[0].IsStatic &&
-				new LocalTypes(otherMethods[0]).exactly(olocals31) &&
+				new LocalTypes(otherMethods[0]).Exactly(olocals31) &&
 				hasConstantM2 &&
 				decryptStringMethod.IsNoInlining &&
 				decryptStringMethod.IsAssembly &&
@@ -449,8 +449,8 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				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)) {
+				new LocalTypes(decryptStringMethod).Exactly(locals31) &&
+				CheckTypeFields(fields31)) {
 				return "3.1";
 			}
 
@@ -467,7 +467,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				"System.Byte[]",
 				"System.Int32",
 			};
-			var locals32 = createLocalsArray(
+			var locals32 = CreateLocalsArray(
 				"System.Boolean",
 				"System.Byte",
 				"System.Byte[]",
@@ -485,15 +485,15 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				"System.String",
 				"System.Type"
 			);
-			var olocals32 = createLocalsArray(
+			var olocals32 = CreateLocalsArray(
 				"System.Int32"
 			);
 			if (otherMethods.Count == 1 &&
 				decryptStringType.NestedTypes.Count == 0 &&
-				DotNetUtils.isMethod(otherMethods[0], "System.Void", "(System.Byte[],System.Int32,System.Byte[])") &&
+				DotNetUtils.IsMethod(otherMethods[0], "System.Void", "(System.Byte[],System.Int32,System.Byte[])") &&
 				otherMethods[0].IsPrivate &&
 				otherMethods[0].IsStatic &&
-				new LocalTypes(otherMethods[0]).exactly(olocals32) &&
+				new LocalTypes(otherMethods[0]).Exactly(olocals32) &&
 				hasConstantM2 &&
 				decryptStringMethod.IsNoInlining &&
 				decryptStringMethod.IsAssembly &&
@@ -501,8 +501,8 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				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)) {
+				new LocalTypes(decryptStringMethod).Exactly(locals32) &&
+				CheckTypeFields(fields32)) {
 				return "3.2";
 			}
 
@@ -522,7 +522,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 					"System.Int32",
 					decryptStringType.NestedTypes[0].FullName,
 				};
-				var locals33 = createLocalsArray(
+				var locals33 = CreateLocalsArray(
 					"System.Boolean",
 					"System.Byte",
 					"System.Byte[]",
@@ -540,15 +540,15 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 					"System.String",
 					"System.Type"
 				);
-				var olocals33 = createLocalsArray(
+				var olocals33 = CreateLocalsArray(
 					"System.Int32"
 				);
 				if (otherMethods.Count == 1 &&
 					decryptStringType.NestedTypes.Count == 1 &&
-					DotNetUtils.isMethod(otherMethods[0], "System.Void", "(System.Byte[],System.Int32,System.Byte[])") &&
+					DotNetUtils.IsMethod(otherMethods[0], "System.Void", "(System.Byte[],System.Int32,System.Byte[])") &&
 					otherMethods[0].IsPrivate &&
 					otherMethods[0].IsStatic &&
-					new LocalTypes(otherMethods[0]).exactly(olocals33) &&
+					new LocalTypes(otherMethods[0]).Exactly(olocals33) &&
 					hasConstantM2 &&
 					decryptStringMethod.IsNoInlining &&
 					decryptStringMethod.IsAssembly &&
@@ -556,8 +556,8 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 					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)) {
+					new LocalTypes(decryptStringMethod).Exactly(locals33) &&
+					CheckTypeFields(fields33)) {
 					return "3.3.29 - 3.3.57 (BETA)";
 				}
 			}
@@ -568,22 +568,22 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 
 			if (decryptStringType.NestedTypes.Count == 3) {
 				var fields33 = new string[] {
-					getNestedTypeName(0),
-					getNestedTypeName(1),
+					GetNestedTypeName(0),
+					GetNestedTypeName(1),
 					"System.Byte[]",
 					"System.Int16",
 					"System.Int32",
 					"System.Byte[]",
 					"System.Int32",
 					"System.Int32",
-					getNestedTypeName(2),
+					GetNestedTypeName(2),
 				};
-				var locals33 = createLocalsArray(
+				var locals33 = CreateLocalsArray(
 					"System.Boolean",
 					"System.Byte",
 					"System.Byte[]",
 					"System.Char[]",
-					getNestedTypeName(0),
+					GetNestedTypeName(0),
 					"System.Diagnostics.StackFrame",
 					"System.Diagnostics.StackTrace",
 					"System.Int16",
@@ -596,23 +596,23 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 					"System.String",
 					"System.Type"
 				);
-				var olocals33 = createLocalsArray(
+				var olocals33 = CreateLocalsArray(
 					"System.Int32"
 				);
 				if (otherMethods.Count == 1 &&
 					decryptStringType.NestedTypes.Count == 3 &&
-					DotNetUtils.isMethod(otherMethods[0], "System.Void", "(System.Byte[],System.Int32,System.Byte[])") &&
+					DotNetUtils.IsMethod(otherMethods[0], "System.Void", "(System.Byte[],System.Int32,System.Byte[])") &&
 					otherMethods[0].IsPrivate &&
 					otherMethods[0].IsStatic &&
-					new LocalTypes(otherMethods[0]).exactly(olocals33) &&
+					new LocalTypes(otherMethods[0]).Exactly(olocals33) &&
 					decryptStringMethod.IsNoInlining &&
 					decryptStringMethod.IsAssembly &&
 					!decryptStringMethod.IsSynchronized &&
 					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)) {
+					new LocalTypes(decryptStringMethod).Exactly(locals33) &&
+					CheckTypeFields(fields33)) {
 					return "3.3";
 				}
 
@@ -621,22 +621,22 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				/////////////////////////////////////////////////////////////////
 
 				var fields33_149 = new string[] {
-					getNestedTypeName(0),
-					getNestedTypeName(1),
+					GetNestedTypeName(0),
+					GetNestedTypeName(1),
 					"System.Byte[]",
 					"System.Int16",
 					"System.Int32",
 					"System.Byte[]",
 					"System.Int32",
 					"System.Int32",
-					getNestedTypeName(2),
+					GetNestedTypeName(2),
 				};
-				var locals33_149 = createLocalsArray(
+				var locals33_149 = CreateLocalsArray(
 					"System.Boolean",
 					"System.Byte",
 					"System.Byte[]",
 					"System.Char[]",
-					getNestedTypeName(0),
+					GetNestedTypeName(0),
 					"System.Diagnostics.StackFrame",
 					"System.Diagnostics.StackTrace",
 					"System.Int16",
@@ -650,23 +650,23 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 					"System.Text.StringBuilder",
 					"System.Type"
 				);
-				var olocals33_149 = createLocalsArray(
+				var olocals33_149 = CreateLocalsArray(
 					"System.Int32"
 				);
 				if (otherMethods.Count == 1 &&
 					decryptStringType.NestedTypes.Count == 3 &&
-					DotNetUtils.isMethod(otherMethods[0], "System.Void", "(System.Byte[],System.Int32,System.Byte[])") &&
+					DotNetUtils.IsMethod(otherMethods[0], "System.Void", "(System.Byte[],System.Int32,System.Byte[])") &&
 					otherMethods[0].IsPrivate &&
 					otherMethods[0].IsStatic &&
-					new LocalTypes(otherMethods[0]).exactly(olocals33_149) &&
+					new LocalTypes(otherMethods[0]).Exactly(olocals33_149) &&
 					decryptStringMethod.IsNoInlining &&
 					decryptStringMethod.IsAssembly &&
 					!decryptStringMethod.IsSynchronized &&
 					decryptStringMethod.Body.MaxStack >= 1 &&
 					decryptStringMethod.Body.MaxStack <= 8 &&
 					(decryptStringMethod.Body.ExceptionHandlers.Count == 1 || decryptStringMethod.Body.ExceptionHandlers.Count == 2) &&
-					new LocalTypes(decryptStringMethod).exactly(locals33_149) &&
-					checkTypeFields2(fields33_149)) {
+					new LocalTypes(decryptStringMethod).Exactly(locals33_149) &&
+					CheckTypeFields2(fields33_149)) {
 					return "3.3.149 - 3.4";	// 3.3.149+ (but not SL or CF)
 				}
 
@@ -675,23 +675,23 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 				/////////////////////////////////////////////////////////////////
 
 				var fields35 = new string[] {
-					getNestedTypeName(0),
-					getNestedTypeName(1),
+					GetNestedTypeName(0),
+					GetNestedTypeName(1),
 					"System.Byte[]",
 					"System.Int16",
 					"System.Int32",
 					"System.Byte[]",
 					"System.Int32",
 					"System.Int32",
-					getNestedTypeName(2),
+					GetNestedTypeName(2),
 				};
-				var locals35 = createLocalsArray(
+				var locals35 = CreateLocalsArray(
 					"System.Boolean",
 					"System.Byte",
 					"System.Byte[]",
 					"System.Char[]",
 					"System.Collections.Generic.IEnumerator`1<System.Int32>",
-					getNestedTypeName(0),
+					GetNestedTypeName(0),
 					"System.Diagnostics.StackFrame",
 					"System.Diagnostics.StackTrace",
 					"System.Int16",
@@ -705,23 +705,23 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 					"System.Text.StringBuilder",
 					"System.Type"
 				);
-				var olocals35 = createLocalsArray(
+				var olocals35 = CreateLocalsArray(
 					"System.Int32"
 				);
 				if (otherMethods.Count == 1 &&
 					decryptStringType.NestedTypes.Count == 3 &&
-					DotNetUtils.isMethod(otherMethods[0], "System.Void", "(System.Byte[],System.Int32,System.Byte[])") &&
+					DotNetUtils.IsMethod(otherMethods[0], "System.Void", "(System.Byte[],System.Int32,System.Byte[])") &&
 					otherMethods[0].IsPrivate &&
 					otherMethods[0].IsStatic &&
-					new LocalTypes(otherMethods[0]).exactly(olocals35) &&
+					new LocalTypes(otherMethods[0]).Exactly(olocals35) &&
 					decryptStringMethod.IsNoInlining &&
 					decryptStringMethod.IsAssembly &&
 					!decryptStringMethod.IsSynchronized &&
 					decryptStringMethod.Body.MaxStack >= 1 &&
 					decryptStringMethod.Body.MaxStack <= 8 &&
 					decryptStringMethod.Body.ExceptionHandlers.Count >= 2 &&
-					new LocalTypes(decryptStringMethod).all(locals35) &&
-					checkTypeFields2(fields35)) {
+					new LocalTypes(decryptStringMethod).All(locals35) &&
+					CheckTypeFields2(fields35)) {
 					return "3.5 - 3.6";
 				}
 			}
@@ -729,7 +729,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return null;
 		}
 
-		TypeDef getNestedType(int n) {
+		TypeDef GetNestedType(int n) {
 			var type = stringDecrypter.Type;
 
 			if (n == 0) {
@@ -756,12 +756,12 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return null;
 		}
 
-		string getNestedTypeName(int n) {
-			var nestedType = getNestedType(n);
+		string GetNestedTypeName(int n) {
+			var nestedType = GetNestedType(n);
 			return nestedType == null ? null : nestedType.FullName;
 		}
 
-		bool checkTypeFields(string[] fieldTypes) {
+		bool CheckTypeFields(string[] fieldTypes) {
 			if (fieldTypes.Length != stringDecrypter.Type.Fields.Count)
 				return false;
 			for (int i = 0; i < fieldTypes.Length; i++) {
@@ -771,7 +771,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			return true;
 		}
 
-		bool checkTypeFields2(string[] fieldTypes) {
+		bool CheckTypeFields2(string[] fieldTypes) {
 			if (fieldTypes.Length != stringDecrypter.Type.Fields.Count)
 				return false;
 
@@ -794,7 +794,7 @@ namespace de4dot.code.deobfuscators.Eazfuscator_NET {
 			{ "System.Diagnostics.StackFrame", true },
 			{ "System.Diagnostics.StackTrace", true },
 		};
-		string[] createLocalsArray(params string[] locals) {
+		string[] CreateLocalsArray(params string[] locals) {
 			Dictionary<string, bool> removeLocals = null;
 			switch (frameworkType) {
 			case FrameworkType.CompactFramework:
diff --git a/de4dot.code/deobfuscators/ExceptionLoggerRemover.cs b/de4dot.code/deobfuscators/ExceptionLoggerRemover.cs
index 587e9cf7..692d8b4e 100644
--- a/de4dot.code/deobfuscators/ExceptionLoggerRemover.cs
+++ b/de4dot.code/deobfuscators/ExceptionLoggerRemover.cs
@@ -28,11 +28,11 @@ namespace de4dot.code.deobfuscators {
 
 		public int NumRemovedExceptionLoggers { get; set; }
 
-		public void add(MethodDef exceptionLogger) {
-			exceptionLoggerMethods.add(exceptionLogger, true);
+		public void Add(MethodDef exceptionLogger) {
+			exceptionLoggerMethods.Add(exceptionLogger, true);
 		}
 
-		bool find(Blocks blocks, out TryBlock tryBlock) {
+		bool Find(Blocks blocks, out TryBlock tryBlock) {
 			tryBlock = null;
 
 			foreach (var bb in blocks.MethodBlocks.BaseBlocks) {
@@ -77,7 +77,7 @@ namespace de4dot.code.deobfuscators {
 				var calledMethod = callInstr.Operand as IMethod;
 				if (calledMethod == null)
 					continue;
-				if (!isExceptionLogger(calledMethod))
+				if (!IsExceptionLogger(calledMethod))
 					continue;
 
 				return true;
@@ -86,23 +86,23 @@ namespace de4dot.code.deobfuscators {
 			return false;
 		}
 
-		protected virtual bool isExceptionLogger(IMethod method) {
-			return exceptionLoggerMethods.find(method);
+		protected virtual bool IsExceptionLogger(IMethod method) {
+			return exceptionLoggerMethods.Find(method);
 		}
 
 		protected virtual bool HasExceptionLoggers {
 			get { return exceptionLoggerMethods.Count != 0; }
 		}
 
-		public bool remove(Blocks blocks) {
+		public bool Remove(Blocks blocks) {
 			if (!HasExceptionLoggers)
 				return false;
 
 			TryBlock tryBlock;
-			if (!find(blocks, out tryBlock))
+			if (!Find(blocks, out tryBlock))
 				return false;
 
-			blocks.MethodBlocks.removeTryBlock(tryBlock);
+			blocks.MethodBlocks.RemoveTryBlock(tryBlock);
 			NumRemovedExceptionLoggers++;
 			return true;
 		}
diff --git a/de4dot.code/deobfuscators/Goliath_NET/ArrayDecrypter.cs b/de4dot.code/deobfuscators/Goliath_NET/ArrayDecrypter.cs
index 00c6a8f9..e61e6e41 100644
--- a/de4dot.code/deobfuscators/Goliath_NET/ArrayDecrypter.cs
+++ b/de4dot.code/deobfuscators/Goliath_NET/ArrayDecrypter.cs
@@ -31,16 +31,16 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			"System.Byte[]",
 			"System.Collections.Generic.Dictionary`2<System.Int32,System.Byte[]>",
 		};
-		protected override bool checkDecrypterType(TypeDef type) {
-			return new FieldTypes(type).exactly(requiredFields);
+		protected override bool CheckDecrypterType(TypeDef type) {
+			return new FieldTypes(type).Exactly(requiredFields);
 		}
 
-		protected override bool checkDelegateInvokeMethod(MethodDef invokeMethod) {
-			return DotNetUtils.isMethod(invokeMethod, "System.Byte[]", "(System.Int32)");
+		protected override bool CheckDelegateInvokeMethod(MethodDef invokeMethod) {
+			return DotNetUtils.IsMethod(invokeMethod, "System.Byte[]", "(System.Int32)");
 		}
 
-		public byte[] decrypt(MethodDef method) {
-			var info = getInfo(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 4d3cacca..456c29e6 100644
--- a/de4dot.code/deobfuscators/Goliath_NET/ArrayValueInliner.cs
+++ b/de4dot.code/deobfuscators/Goliath_NET/ArrayValueInliner.cs
@@ -33,13 +33,13 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			this.initializedDataCreator = initializedDataCreator;
 		}
 
-		protected override void inlineReturnValues(IList<CallResult> callResults) {
+		protected override void InlineReturnValues(IList<CallResult> callResults) {
 			foreach (var callResult in callResults) {
 				var block = callResult.block;
 				int num = callResult.callEndIndex - callResult.callStartIndex + 1;
 
 				var arrayData = (byte[])callResult.returnValue;
-				initializedDataCreator.addInitializeArrayCode(block, callResult.callStartIndex, num, module.CorLibTypes.Byte.TypeDefOrRef, arrayData);
+				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 517096d6..70d3983a 100644
--- a/de4dot.code/deobfuscators/Goliath_NET/DecrypterBase.cs
+++ b/de4dot.code/deobfuscators/Goliath_NET/DecrypterBase.cs
@@ -57,7 +57,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 		}
 
 		public TypeDef DelegateInitType {
-			get { return delegateInitType ?? findDelegateInitType();}
+			get { return delegateInitType ?? FindDelegateInitType();}
 		}
 
 		public TypeDef DelegateType {
@@ -67,11 +67,11 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 		public IEnumerable<TypeDef> DecrypterTypes {
 			get {
 				var types = new TypeDefDict<TypeDef>();
-				foreach (var info in decrypterMethods.getValues()) {
+				foreach (var info in decrypterMethods.GetValues()) {
 					if (info.referenced)
-						types.add(info.method.DeclaringType, info.method.DeclaringType);
+						types.Add(info.method.DeclaringType, info.method.DeclaringType);
 				}
-				return types.getValues();
+				return types.GetValues();
 			}
 		}
 
@@ -79,8 +79,8 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			this.module = module;
 		}
 
-		protected Info getInfo(MethodDef method) {
-			var info = decrypterMethods.find(method);
+		protected Info GetInfo(MethodDef method) {
+			var info = decrypterMethods.Find(method);
 			if (info == null)
 				return null;
 
@@ -88,7 +88,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			return info;
 		}
 
-		public void find() {
+		public void Find() {
 			foreach (var tmp in module.Resources) {
 				var resource = tmp as EmbeddedResource;
 				if (resource == null)
@@ -96,11 +96,11 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 				if (!resource.Name.String.EndsWith(".resources", StringComparison.Ordinal))
 					continue;
 				string ns, name;
-				splitTypeName(resource.Name.String.Substring(0, resource.Name.String.Length - 10), out ns, out name);
+				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))
+				if (!CheckDecrypterType(type))
 					continue;
 
 				encryptedResource = resource;
@@ -109,9 +109,9 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			}
 		}
 
-		protected abstract bool checkDecrypterType(TypeDef type);
+		protected abstract bool CheckDecrypterType(TypeDef type);
 
-		void splitTypeName(string fullName, out string ns, out string name) {
+		void SplitTypeName(string fullName, out string ns, out string name) {
 			int index = fullName.LastIndexOf('.');
 			if (index < 0) {
 				ns = "";
@@ -123,11 +123,11 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			}
 		}
 
-		public void initialize() {
+		public void Initialize() {
 			if (encryptedResource == null)
 				return;
 
-			decryptedReader = new BinaryReader(new MemoryStream(decrypt(encryptedResource.GetResourceData())));
+			decryptedReader = new BinaryReader(new MemoryStream(Decrypt(encryptedResource.GetResourceData())));
 
 			delegateType = null;
 			foreach (var type in module.GetTypes()) {
@@ -138,16 +138,16 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 				if (type.Fields.Count != 1)
 					continue;
 				var field = type.Fields[0];
-				var tmpDelegateType = DotNetUtils.getType(module, field.FieldType);
+				var tmpDelegateType = DotNetUtils.GetType(module, field.FieldType);
 				if (tmpDelegateType == null)
 					continue;
 
-				if (!checkDelegateType(tmpDelegateType))
+				if (!CheckDelegateType(tmpDelegateType))
 					continue;
 				if (delegateType != null && delegateType != tmpDelegateType)
 					continue;
 
-				if (!checkCctor(cctor))
+				if (!CheckCctor(cctor))
 					continue;
 
 				delegateType = tmpDelegateType;
@@ -162,16 +162,16 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 						continue;
 					if (sig.RetType.GetElementType() == ElementType.Void)
 						continue;
-					var info = getDecrypterInfo(method, field);
+					var info = GetDecrypterInfo(method, field);
 					if (info == null)
 						continue;
 
-					decrypterMethods.add(info.method, info);
+					decrypterMethods.Add(info.method, info);
 				}
 			}
 		}
 
-		Info getDecrypterInfo(MethodDef method, FieldDef delegateField) {
+		Info GetDecrypterInfo(MethodDef method, FieldDef delegateField) {
 			try {
 				int index = 0;
 				var instrs = method.Body.Instructions;
@@ -204,14 +204,14 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			}
 		}
 
-		bool checkCctor(MethodDef cctor) {
-			var ldtokenType = getLdtokenType(cctor);
+		bool CheckCctor(MethodDef cctor) {
+			var ldtokenType = GetLdtokenType(cctor);
 			if (!new SigComparer().Equals(ldtokenType, cctor.DeclaringType))
 				return false;
 
 			MethodDef initMethod = null;
-			foreach (var method in DotNetUtils.getCalledMethods(module, cctor)) {
-				if (DotNetUtils.isMethod(method, "System.Void", "(System.Type)")) {
+			foreach (var method in DotNetUtils.GetCalledMethods(module, cctor)) {
+				if (DotNetUtils.IsMethod(method, "System.Void", "(System.Type)")) {
 					initMethod = method;
 					break;
 				}
@@ -222,7 +222,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			return true;
 		}
 
-		static ITypeDefOrRef getLdtokenType(MethodDef method) {
+		static ITypeDefOrRef GetLdtokenType(MethodDef method) {
 			if (method == null || method.Body == null)
 				return null;
 			foreach (var instr in method.Body.Instructions) {
@@ -233,18 +233,18 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			return null;
 		}
 
-		bool checkDelegateType(TypeDef type) {
-			if (!DotNetUtils.derivesFromDelegate(type))
+		bool CheckDelegateType(TypeDef type) {
+			if (!DotNetUtils.DerivesFromDelegate(type))
 				return false;
 			var invoke = type.FindMethod("Invoke");
 			if (invoke == null)
 				return false;
-			return checkDelegateInvokeMethod(invoke);
+			return CheckDelegateInvokeMethod(invoke);
 		}
 
-		protected abstract bool checkDelegateInvokeMethod(MethodDef invokeMethod);
+		protected abstract bool CheckDelegateInvokeMethod(MethodDef invokeMethod);
 
-		byte[] decrypt(byte[] encryptedData) {
+		byte[] Decrypt(byte[] encryptedData) {
 			const int KEY_LEN = 0x100;
 			if (encryptedData.Length < KEY_LEN)
 				throw new ApplicationException("Invalid encrypted data length");
@@ -265,7 +265,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			return decryptedData;
 		}
 
-		TypeDef findDelegateInitType() {
+		TypeDef FindDelegateInitType() {
 			if (delegateType == null)
 				return null;
 
@@ -276,7 +276,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 				foreach (var method in type.Methods) {
 					if (!method.IsStatic || method.IsPrivate || method.Body == null)
 						continue;
-					var ldtokenType = getLdtokenType(method);
+					var ldtokenType = GetLdtokenType(method);
 					if (ldtokenType == null)
 						continue;
 					if (!new SigComparer().Equals(ldtokenType, delegateType))
@@ -290,9 +290,9 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			return null;
 		}
 
-		public IEnumerable<MethodDef> getMethods() {
+		public IEnumerable<MethodDef> GetMethods() {
 			var list = new List<MethodDef>(decrypterMethods.Count);
-			foreach (var info in decrypterMethods.getValues())
+			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 4350db8c..d914d05d 100644
--- a/de4dot.code/deobfuscators/Goliath_NET/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/Goliath_NET/Deobfuscator.cs
@@ -35,12 +35,12 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 
 		public DeobfuscatorInfo()
 			: base(DEFAULT_REGEX) {
-			inlineMethods = new BoolOption(null, makeArgName("inline"), "Inline short methods", true);
-			removeInlinedMethods = new BoolOption(null, makeArgName("remove-inlined"), "Remove inlined methods", true);
-			restoreLocals = new BoolOption(null, makeArgName("locals"), "Restore locals", true);
-			decryptIntegers = new BoolOption(null, makeArgName("ints"), "Decrypt integers", true);
-			decryptArrays = new BoolOption(null, makeArgName("arrays"), "Decrypt arrays", true);
-			removeAntiStrongName = new BoolOption(null, makeArgName("sn"), "Remove anti strong name code", true);
+			inlineMethods = new BoolOption(null, MakeArgName("inline"), "Inline short methods", true);
+			removeInlinedMethods = new BoolOption(null, MakeArgName("remove-inlined"), "Remove inlined methods", true);
+			restoreLocals = new BoolOption(null, MakeArgName("locals"), "Restore locals", true);
+			decryptIntegers = new BoolOption(null, MakeArgName("ints"), "Decrypt integers", true);
+			decryptArrays = new BoolOption(null, MakeArgName("arrays"), "Decrypt arrays", true);
+			removeAntiStrongName = new BoolOption(null, MakeArgName("sn"), "Remove anti strong name code", true);
 		}
 
 		public override string Name {
@@ -51,7 +51,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			get { return THE_TYPE; }
 		}
 
-		public override IDeobfuscator createDeobfuscator() {
+		public override IDeobfuscator CreateDeobfuscator() {
 			return new Deobfuscator(new Deobfuscator.Options {
 				RenameResourcesInCode = false,
 				ValidNameRegex = validNameRegex.get(),
@@ -64,7 +64,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			});
 		}
 
-		protected override IEnumerable<Option> getOptionsInternal() {
+		protected override IEnumerable<Option> GetOptionsInternal() {
 			return new List<Option>() {
 				inlineMethods,
 				removeInlinedMethods,
@@ -123,14 +123,14 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			this.options = options;
 		}
 
-		protected override int detectInternal() {
+		protected override int DetectInternal() {
 			int val = 0;
 
-			int sum = toInt32(stringDecrypter.Detected) +
-					toInt32(integerDecrypter.Detected) +
-					toInt32(arrayDecrypter.Detected) +
-					toInt32(strongNameChecker.Detected) +
-					toInt32(hasMetadataStream("#GOLIATH"));
+			int sum = ToInt32(stringDecrypter.Detected) +
+					ToInt32(integerDecrypter.Detected) +
+					ToInt32(arrayDecrypter.Detected) +
+					ToInt32(strongNameChecker.Detected) +
+					ToInt32(HasMetadataStream("#GOLIATH"));
 			if (sum > 0)
 				val += 100 + 10 * (sum - 1);
 			if (foundGoliathAttribute)
@@ -139,31 +139,31 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			return val;
 		}
 
-		protected override void scanForObfuscator() {
-			findGoliathAttribute();
+		protected override void ScanForObfuscator() {
+			FindGoliathAttribute();
 			stringDecrypter = new StringDecrypter(module);
-			stringDecrypter.find();
+			stringDecrypter.Find();
 			integerDecrypter = new IntegerDecrypter(module);
-			integerDecrypter.find();
+			integerDecrypter.Find();
 			arrayDecrypter = new ArrayDecrypter(module);
-			arrayDecrypter.find();
+			arrayDecrypter.Find();
 			strongNameChecker = new StrongNameChecker(module);
-			strongNameChecker.find();
+			strongNameChecker.Find();
 		}
 
-		void findGoliathAttribute() {
+		void FindGoliathAttribute() {
 			foreach (var type in module.Types) {
 				if (type.FullName.Contains("ObfuscatedByGoliath")) {
 					foundGoliathAttribute = true;
-					addAttributeToBeRemoved(type, "Obfuscator attribute");
-					initializeVersion(type);
+					AddAttributeToBeRemoved(type, "Obfuscator attribute");
+					InitializeVersion(type);
 					break;
 				}
 			}
 		}
 
-		void initializeVersion(TypeDef attr) {
-			var s = DotNetUtils.getCustomArgAsString(getAssemblyAttribute(attr), 0);
+		void InitializeVersion(TypeDef attr) {
+			var s = DotNetUtils.GetCustomArgAsString(GetAssemblyAttribute(attr), 0);
 			if (s == null)
 				return;
 
@@ -174,106 +174,106 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			return;
 		}
 
-		public override void deobfuscateBegin() {
-			base.deobfuscateBegin();
+		public override void DeobfuscateBegin() {
+			base.DeobfuscateBegin();
 
 			proxyCallFixer = new ProxyCallFixer(module);
-			proxyCallFixer.find();
+			proxyCallFixer.Find();
 			localsRestorer = new LocalsRestorer(module);
 			if (options.RestoreLocals)
-				localsRestorer.find();
+				localsRestorer.Find();
 
 			logicalExpressionFixer = new LogicalExpressionFixer();
-			stringDecrypter.initialize();
-			integerDecrypter.initialize();
-			arrayDecrypter.initialize();
+			stringDecrypter.Initialize();
+			integerDecrypter.Initialize();
+			arrayDecrypter.Initialize();
 
 			if (options.DecryptIntegers) {
 				int32ValueInliner = new Int32ValueInliner();
-				foreach (var method in integerDecrypter.getMethods()) {
-					int32ValueInliner.add(method, (method2, gim, args) => {
-						return integerDecrypter.decrypt(method2);
+				foreach (var method in integerDecrypter.GetMethods()) {
+					int32ValueInliner.Add(method, (method2, gim, args) => {
+						return integerDecrypter.Decrypt(method2);
 					});
 				}
 			}
 
 			if (options.DecryptArrays) {
 				arrayValueInliner = new ArrayValueInliner(module, initializedDataCreator);
-				foreach (var method in arrayDecrypter.getMethods()) {
-					arrayValueInliner.add(method, (method2, gim, args) => {
-						return arrayDecrypter.decrypt(method2);
+				foreach (var method in arrayDecrypter.GetMethods()) {
+					arrayValueInliner.Add(method, (method2, gim, args) => {
+						return arrayDecrypter.Decrypt(method2);
 					});
 				}
 			}
 
-			foreach (var method in stringDecrypter.getMethods()) {
-				staticStringInliner.add(method, (method2, gim, args) => {
-					return stringDecrypter.decrypt(method2);
+			foreach (var method in stringDecrypter.GetMethods()) {
+				staticStringInliner.Add(method, (method2, gim, args) => {
+					return stringDecrypter.Decrypt(method2);
 				});
-				DeobfuscatedFile.stringDecryptersAdded();
+				DeobfuscatedFile.StringDecryptersAdded();
 			}
 
 			if (options.RemoveAntiStrongName)
-				addTypeToBeRemoved(strongNameChecker.Type, "Strong name checker type");
+				AddTypeToBeRemoved(strongNameChecker.Type, "Strong name checker type");
 
 			startedDeobfuscating = true;
 		}
 
-		public override void deobfuscateMethodBegin(Blocks blocks) {
-			proxyCallFixer.deobfuscate(blocks);
-			base.deobfuscateMethodBegin(blocks);
+		public override void DeobfuscateMethodBegin(Blocks blocks) {
+			proxyCallFixer.Deobfuscate(blocks);
+			base.DeobfuscateMethodBegin(blocks);
 		}
 
-		public override void deobfuscateMethodEnd(Blocks blocks) {
-			stringDecrypter.deobfuscate(blocks);
-			int32ValueInliner.decrypt(blocks);
-			arrayValueInliner.decrypt(blocks);
+		public override void DeobfuscateMethodEnd(Blocks blocks) {
+			stringDecrypter.Deobfuscate(blocks);
+			int32ValueInliner.Decrypt(blocks);
+			arrayValueInliner.Decrypt(blocks);
 			if (options.RestoreLocals)
-				localsRestorer.deobfuscate(blocks);
+				localsRestorer.Deobfuscate(blocks);
 			if (options.RemoveAntiStrongName) {
-				if (strongNameChecker.deobfuscate(blocks))
+				if (strongNameChecker.Deobfuscate(blocks))
 					Logger.v("Removed strong name checker code");
 			}
-			logicalExpressionFixer.deobfuscate(blocks);
-			base.deobfuscateMethodEnd(blocks);
+			logicalExpressionFixer.Deobfuscate(blocks);
+			base.DeobfuscateMethodEnd(blocks);
 		}
 
-		public override void deobfuscateEnd() {
-			removeProxyDelegates(proxyCallFixer);
-			removeInlinedMethods();
-			addTypesToBeRemoved(localsRestorer.Types, "Method locals obfuscation type");
+		public override void DeobfuscateEnd() {
+			RemoveProxyDelegates(proxyCallFixer);
+			RemoveInlinedMethods();
+			AddTypesToBeRemoved(localsRestorer.Types, "Method locals obfuscation type");
 
 			if (CanRemoveStringDecrypterType) {
-				removeDecrypterStuff(stringDecrypter, "String", "strings");
-				addTypeToBeRemoved(stringDecrypter.StringStruct, "String struct");
+				RemoveDecrypterStuff(stringDecrypter, "String", "strings");
+				AddTypeToBeRemoved(stringDecrypter.StringStruct, "String struct");
 			}
 			if (options.DecryptIntegers)
-				removeDecrypterStuff(integerDecrypter, "Integer", "integers");
+				RemoveDecrypterStuff(integerDecrypter, "Integer", "integers");
 			if (options.DecryptArrays)
-				removeDecrypterStuff(arrayDecrypter, "Array", "arrays");
+				RemoveDecrypterStuff(arrayDecrypter, "Array", "arrays");
 
-			base.deobfuscateEnd();
+			base.DeobfuscateEnd();
 		}
 
-		void removeDecrypterStuff(DecrypterBase decrypter, string name1, string name2) {
-			addResourceToBeRemoved(decrypter.EncryptedResource, "Encrypted " + name2);
-			addTypesToBeRemoved(decrypter.DecrypterTypes, name1 + " decrypter type");
-			addTypeToBeRemoved(decrypter.Type, name1 + " resource decrypter type");
+		void RemoveDecrypterStuff(DecrypterBase decrypter, string name1, string name2) {
+			AddResourceToBeRemoved(decrypter.EncryptedResource, "Encrypted " + name2);
+			AddTypesToBeRemoved(decrypter.DecrypterTypes, name1 + " decrypter type");
+			AddTypeToBeRemoved(decrypter.Type, name1 + " resource decrypter type");
 			if (decrypter.DelegateInitType != null) {
-				addTypeToBeRemoved(decrypter.DelegateType, name1 + " resource decrypter delegate type");
-				addTypeToBeRemoved(decrypter.DelegateInitType, name1 + " delegate initializer type");
+				AddTypeToBeRemoved(decrypter.DelegateType, name1 + " resource decrypter delegate type");
+				AddTypeToBeRemoved(decrypter.DelegateInitType, name1 + " delegate initializer type");
 			}
 		}
 
-		void removeInlinedMethods() {
+		void RemoveInlinedMethods() {
 			if (!options.InlineMethods || !options.RemoveInlinedMethods)
 				return;
-			findAndRemoveInlinedMethods();
+			FindAndRemoveInlinedMethods();
 		}
 
-		public override IEnumerable<int> getStringDecrypterMethods() {
+		public override IEnumerable<int> GetStringDecrypterMethods() {
 			var list = new List<int>();
-			foreach (var method in stringDecrypter.getMethods())
+			foreach (var method in stringDecrypter.GetMethods())
 				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 c7b54c28..f41c3d75 100644
--- a/de4dot.code/deobfuscators/Goliath_NET/IntegerDecrypter.cs
+++ b/de4dot.code/deobfuscators/Goliath_NET/IntegerDecrypter.cs
@@ -31,16 +31,16 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			"System.Byte[]",
 			"System.Collections.Generic.Dictionary`2<System.Int32,System.Object>",
 		};
-		protected override bool checkDecrypterType(TypeDef type) {
-			return new FieldTypes(type).exactly(requiredFields);
+		protected override bool CheckDecrypterType(TypeDef type) {
+			return new FieldTypes(type).Exactly(requiredFields);
 		}
 
-		protected override bool checkDelegateInvokeMethod(MethodDef invokeMethod) {
-			return DotNetUtils.isMethod(invokeMethod, "System.Object", "(System.Int32)");
+		protected override bool CheckDelegateInvokeMethod(MethodDef invokeMethod) {
+			return DotNetUtils.IsMethod(invokeMethod, "System.Object", "(System.Int32)");
 		}
 
-		public int decrypt(MethodDef method) {
-			var info = getInfo(method);
+		public int Decrypt(MethodDef method) {
+			var info = GetInfo(method);
 			decryptedReader.BaseStream.Position = info.offset;
 			int len = decryptedReader.ReadInt32();
 			return BitConverter.ToInt32(decryptedReader.ReadBytes(len), 0);
diff --git a/de4dot.code/deobfuscators/Goliath_NET/LocalsRestorer.cs b/de4dot.code/deobfuscators/Goliath_NET/LocalsRestorer.cs
index 134fe565..26593045 100644
--- a/de4dot.code/deobfuscators/Goliath_NET/LocalsRestorer.cs
+++ b/de4dot.code/deobfuscators/Goliath_NET/LocalsRestorer.cs
@@ -40,7 +40,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 		public List<TypeDef> Types {
 			get {
 				var list = new List<TypeDef>(typeToInfo.Count);
-				foreach (var info in typeToInfo.getValues()) {
+				foreach (var info in typeToInfo.GetValues()) {
 					if (info.referenced)
 						list.Add(info.type);
 				}
@@ -52,12 +52,12 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			this.module = module;
 		}
 
-		public void find() {
+		public void Find() {
 			foreach (var type in module.GetTypes())
-				initialize(type);
+				Initialize(type);
 		}
 
-		void initialize(TypeDef type) {
+		void Initialize(TypeDef type) {
 			if (type.HasEvents || type.HasProperties)
 				return;
 
@@ -81,12 +81,12 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			if (!new SigComparer().Equals(ctorParam, typeField.FieldType))
 				return;
 
-			typeToInfo.add(ctor.DeclaringType, new Info(ctor.DeclaringType, typeField.FieldType));
+			typeToInfo.Add(ctor.DeclaringType, new Info(ctor.DeclaringType, typeField.FieldType));
 		}
 
-		public void deobfuscate(Blocks blocks) {
+		public void Deobfuscate(Blocks blocks) {
 			var instrsToRemove = new List<int>();
-			foreach (var block in blocks.MethodBlocks.getAllBlocks()) {
+			foreach (var block in blocks.MethodBlocks.GetAllBlocks()) {
 				instrsToRemove.Clear();
 				var instrs = block.Instructions;
 				for (int i = 0; i < instrs.Count; i++) {
@@ -105,19 +105,19 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 							continue;
 
 						var next = instrs[i + 1];
-						if (!next.isStloc() && !next.isLeave() && next.OpCode.Code != Code.Pop)
+						if (!next.IsStloc() && !next.IsLeave() && next.OpCode.Code != Code.Pop)
 							continue;
 
 						indexToRemove = i;
 						type = ctor.DeclaringType;
-						if (next.isStloc())
-							local = Instr.getLocalVar(blocks.Locals, next);
+						if (next.IsStloc())
+							local = Instr.GetLocalVar(blocks.Locals, next);
 					}
 					else if (instr.OpCode.Code == Code.Ldfld) {
 						if (i == 0)
 							continue;
 						var ldloc = instrs[i - 1];
-						if (!ldloc.isLdloc())
+						if (!ldloc.IsLdloc())
 							continue;
 
 						var field = instr.Operand as IField;
@@ -126,14 +126,14 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 
 						indexToRemove = i;
 						type = field.DeclaringType;
-						local = Instr.getLocalVar(blocks.Locals, ldloc);
+						local = Instr.GetLocalVar(blocks.Locals, ldloc);
 					}
 					else
 						continue;
 
 					if (type == null)
 						continue;
-					var info = typeToInfo.find(type);
+					var info = typeToInfo.Find(type);
 					if (info == null)
 						continue;
 
@@ -143,7 +143,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 						local.Type = info.localType;
 				}
 				if (instrsToRemove.Count > 0)
-					block.remove(instrsToRemove);
+					block.Remove(instrsToRemove);
 			}
 		}
 	}
diff --git a/de4dot.code/deobfuscators/Goliath_NET/LogicalExpressionFixer.cs b/de4dot.code/deobfuscators/Goliath_NET/LogicalExpressionFixer.cs
index 52b9d8b4..fb894547 100644
--- a/de4dot.code/deobfuscators/Goliath_NET/LogicalExpressionFixer.cs
+++ b/de4dot.code/deobfuscators/Goliath_NET/LogicalExpressionFixer.cs
@@ -22,8 +22,8 @@ using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.Goliath_NET {
 	class LogicalExpressionFixer {
-		public void deobfuscate(Blocks blocks) {
-			foreach (var block in blocks.MethodBlocks.getAllBlocks()) {
+		public void Deobfuscate(Blocks blocks) {
+			foreach (var block in blocks.MethodBlocks.GetAllBlocks()) {
 				var instrs = block.Instructions;
 				for (int i = 0; i < instrs.Count - 1; i++) {
 					var first = instrs[i];
diff --git a/de4dot.code/deobfuscators/Goliath_NET/ProxyCallFixer.cs b/de4dot.code/deobfuscators/Goliath_NET/ProxyCallFixer.cs
index 00f00c48..6308582d 100644
--- a/de4dot.code/deobfuscators/Goliath_NET/ProxyCallFixer.cs
+++ b/de4dot.code/deobfuscators/Goliath_NET/ProxyCallFixer.cs
@@ -38,7 +38,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			}
 		}
 
-		public new void find() {
+		public new void Find() {
 			Logger.v("Finding all proxy delegates");
 			var infos = new List<MyInfo>();
 			foreach (var type in module.GetTypes()) {
@@ -48,7 +48,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 				infos.Clear();
 				foreach (var method in type.Methods) {
 					DelegateInfo info;
-					if (!checkProxyMethod(method, out info))
+					if (!CheckProxyMethod(method, out info))
 						continue;
 					infos.Add(new MyInfo(method, info));
 				}
@@ -56,24 +56,24 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 				if (infos.Count == 0)
 					continue;
 
-				Logger.v("Found proxy delegate: {0} ({1:X8})", Utils.removeNewlines(type), type.MDToken.ToUInt32());
+				Logger.v("Found proxy delegate: {0} ({1:X8})", Utils.RemoveNewlines(type), type.MDToken.ToUInt32());
 				RemovedDelegateCreatorCalls++;
-				Logger.Instance.indent();
+				Logger.Instance.Indent();
 				foreach (var info in infos) {
 					var di = info.delegateInfo;
-					add(info.method, di);
+					Add(info.method, di);
 					Logger.v("Field: {0}, Opcode: {1}, Method: {2} ({3:X8})",
-								Utils.removeNewlines(di.field.Name),
+								Utils.RemoveNewlines(di.field.Name),
 								di.callOpcode,
-								Utils.removeNewlines(di.methodRef),
+								Utils.RemoveNewlines(di.methodRef),
 								di.methodRef.MDToken.ToUInt32());
 				}
-				Logger.Instance.deIndent();
+				Logger.Instance.DeIndent();
 				delegateTypesDict[type] = true;
 			}
 		}
 
-		bool checkProxyMethod(MethodDef method, out DelegateInfo info) {
+		bool CheckProxyMethod(MethodDef method, out DelegateInfo info) {
 			info = null;
 			if (!method.IsStatic || method.Body == null)
 				return false;
@@ -135,11 +135,11 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			return true;
 		}
 
-		protected override object checkCctor(TypeDef type, MethodDef cctor) {
+		protected override object CheckCctor(TypeDef type, MethodDef cctor) {
 			throw new System.NotImplementedException();
 		}
 
-		protected override void getCallInfo(object context, FieldDef field, out IMethod 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 c6cbe4f0..e797a89f 100644
--- a/de4dot.code/deobfuscators/Goliath_NET/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/Goliath_NET/StringDecrypter.cs
@@ -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(TypeDef type) {
+		protected override bool CheckDecrypterType(TypeDef type) {
 			var fields = type.Fields;
 			if (fields.Count != 2)
 				return false;
@@ -61,7 +61,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			if (garg.FullName != "System.String") {
 				if (!garg.IsValueType)
 					return false;
-				var gargType = DotNetUtils.getType(module, garg);
+				var gargType = DotNetUtils.GetType(module, garg);
 				if (gargType == null || !gargType.IsClass)
 					return false;
 				if (gargType.Fields.Count != 1)
@@ -80,24 +80,24 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			return true;
 		}
 
-		protected override bool checkDelegateInvokeMethod(MethodDef invokeMethod) {
-			return DotNetUtils.isMethod(invokeMethod, delegateReturnType.FullName, "(System.Int32)");
+		protected override bool CheckDelegateInvokeMethod(MethodDef invokeMethod) {
+			return DotNetUtils.IsMethod(invokeMethod, delegateReturnType.FullName, "(System.Int32)");
 		}
 
-		public string decrypt(MethodDef method) {
-			var info = getInfo(method);
+		public string Decrypt(MethodDef method) {
+			var info = GetInfo(method);
 			decryptedReader.BaseStream.Position = info.offset;
 			int len = decryptedReader.ReadInt32();
 			return Encoding.UTF8.GetString(decryptedReader.ReadBytes(len));
 		}
 
-		public void deobfuscate(Blocks blocks) {
+		public void Deobfuscate(Blocks blocks) {
 			if (!Detected)
 				return;
 			if (stringStructField == null)
 				return;
 
-			foreach (var block in blocks.MethodBlocks.getAllBlocks()) {
+			foreach (var block in blocks.MethodBlocks.GetAllBlocks()) {
 				var instrs = block.Instructions;
 				for (int i = 0; i < instrs.Count - 1; i++) {
 					var ldstr = instrs[i];
@@ -108,7 +108,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 						continue;
 					if (!FieldEqualityComparer.CompareDeclaringTypes.Equals(stringStructField, ldfld.Operand as IField))
 						continue;
-					block.remove(i + 1, 1);
+					block.Remove(i + 1, 1);
 				}
 			}
 		}
diff --git a/de4dot.code/deobfuscators/Goliath_NET/StrongNameChecker.cs b/de4dot.code/deobfuscators/Goliath_NET/StrongNameChecker.cs
index 05257171..b9034cfc 100644
--- a/de4dot.code/deobfuscators/Goliath_NET/StrongNameChecker.cs
+++ b/de4dot.code/deobfuscators/Goliath_NET/StrongNameChecker.cs
@@ -43,20 +43,20 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			this.module = module;
 		}
 
-		public void find() {
+		public void Find() {
 			foreach (var type in module.Types) {
 				if (type.HasFields || type.HasEvents || type.HasProperties)
 					continue;
 
-				var checkMethod = getAntiTamperingDetectionMethod(type);
+				var checkMethod = GetAntiTamperingDetectionMethod(type);
 				if (checkMethod == null)
 					continue;
 
-				if (DotNetUtils.getMethod(type, "System.Byte[]", "(System.Reflection.Assembly)") == null)
+				if (DotNetUtils.GetMethod(type, "System.Byte[]", "(System.Reflection.Assembly)") == null)
 					continue;
-				if (DotNetUtils.getMethod(type, "System.String", "(System.Collections.Generic.Stack`1<System.Int32>)") == null)
+				if (DotNetUtils.GetMethod(type, "System.String", "(System.Collections.Generic.Stack`1<System.Int32>)") == null)
 					continue;
-				if (DotNetUtils.getMethod(type, "System.Int32", "(System.Int32,System.Byte[])") == null)
+				if (DotNetUtils.GetMethod(type, "System.Int32", "(System.Int32,System.Byte[])") == null)
 					continue;
 
 				strongNameType = type;
@@ -65,7 +65,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			}
 		}
 
-		MethodDef getAntiTamperingDetectionMethod(TypeDef type) {
+		MethodDef GetAntiTamperingDetectionMethod(TypeDef type) {
 			var requiredLocals = new string[] {
 				"System.Reflection.Assembly",
 				"System.Collections.Generic.Stack`1<System.Int32>",
@@ -73,11 +73,11 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			foreach (var method in type.Methods) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
-				if (!DotNetUtils.isMethod(method, "System.Void", "(System.Type)"))
+				if (!DotNetUtils.IsMethod(method, "System.Void", "(System.Type)"))
 					continue;
-				if (!new LocalTypes(method).all(requiredLocals))
+				if (!new LocalTypes(method).All(requiredLocals))
 					continue;
-				if (!hasThrow(method))
+				if (!HasThrow(method))
 					continue;
 
 				return method;
@@ -85,7 +85,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			return null;
 		}
 
-		static bool hasThrow(MethodDef method) {
+		static bool HasThrow(MethodDef method) {
 			if (method == null || method.Body == null)
 				return false;
 			foreach (var instr in method.Body.Instructions) {
@@ -95,10 +95,10 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 			return false;
 		}
 
-		public bool deobfuscate(Blocks blocks) {
+		public bool Deobfuscate(Blocks blocks) {
 			if (blocks.Method.Name != ".cctor" && blocks.Method.Name != ".ctor")
 				return false;
-			foreach (var block in blocks.MethodBlocks.getAllBlocks()) {
+			foreach (var block in blocks.MethodBlocks.GetAllBlocks()) {
 				var instrs = block.Instructions;
 				for (int i = 0; i < instrs.Count - 2; i++) {
 					var ldtoken = instrs[i];
@@ -108,7 +108,7 @@ 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 IMethod, "System.Type", "(System.RuntimeTypeHandle)"))
+					if (!DotNetUtils.IsMethod(call1.Operand as IMethod, "System.Type", "(System.RuntimeTypeHandle)"))
 						continue;
 
 					var call2 = instrs[i + 2];
@@ -117,7 +117,7 @@ namespace de4dot.code.deobfuscators.Goliath_NET {
 					if (!MethodEqualityComparer.CompareDeclaringTypes.Equals(call2.Operand as IMethod, strongNameCheckMethod))
 						continue;
 
-					block.remove(i, 3);
+					block.Remove(i, 3);
 					return true;
 				}
 			}
diff --git a/de4dot.code/deobfuscators/IDeobfuscatedFile.cs b/de4dot.code/deobfuscators/IDeobfuscatedFile.cs
index 360ae531..4381742b 100644
--- a/de4dot.code/deobfuscators/IDeobfuscatedFile.cs
+++ b/de4dot.code/deobfuscators/IDeobfuscatedFile.cs
@@ -20,8 +20,8 @@
 namespace de4dot.code.deobfuscators {
 	public interface IDeobfuscatedFile : ISimpleDeobfuscator {
 		IDeobfuscatorContext DeobfuscatorContext { get; }
-		void createAssemblyFile(byte[] data, string assemblyName, string extension);
-		void stringDecryptersAdded();
-		void setDeobfuscator(IDeobfuscator deob);
+		void CreateAssemblyFile(byte[] data, string assemblyName, string extension);
+		void StringDecryptersAdded();
+		void SetDeobfuscator(IDeobfuscator deob);
 	}
 }
diff --git a/de4dot.code/deobfuscators/IDeobfuscator.cs b/de4dot.code/deobfuscators/IDeobfuscator.cs
index 49d4d181..b98ff819 100644
--- a/de4dot.code/deobfuscators/IDeobfuscator.cs
+++ b/de4dot.code/deobfuscators/IDeobfuscator.cs
@@ -69,41 +69,41 @@ namespace de4dot.code.deobfuscators {
 		IDeobfuscatedFile DeobfuscatedFile { get; set; }
 
 		// Returns null or the unpacked .NET PE file
-		byte[] unpackNativeFile(IPEImage peImage);
+		byte[] UnpackNativeFile(IPEImage peImage);
 
-		void init(ModuleDefMD module);
+		void Initialize(ModuleDefMD module);
 
 		// Returns 0 if it's not detected, or > 0 if detected (higher value => more likely true).
 		// This method is always called.
-		int detect();
+		int Detect();
 
 		// If the obfuscator has encrypted parts of the file, then this method should return the
 		// decrypted file. true is returned if args have been initialized, false otherwise.
-		bool getDecryptedModule(int count, ref byte[] newFileData, ref DumpedMethods dumpedMethods);
+		bool GetDecryptedModule(int count, ref byte[] newFileData, ref DumpedMethods dumpedMethods);
 
 		// 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(ModuleDefMD module);
+		IDeobfuscator ModuleReloaded(ModuleDefMD module);
 
 		// Called before all other deobfuscation methods
-		void deobfuscateBegin();
+		void DeobfuscateBegin();
 
 		// Called before the code is deobfuscated
-		void deobfuscateMethodBegin(Blocks blocks);
+		void DeobfuscateMethodBegin(Blocks blocks);
 
 		// Return true if we should deobfuscate control flow again
-		bool deobfuscateOther(Blocks blocks);
+		bool DeobfuscateOther(Blocks blocks);
 
 		// Called after deobfuscateMethodBegin() but before deobfuscateMethodEnd()
-		void deobfuscateStrings(Blocks blocks);
+		void DeobfuscateStrings(Blocks blocks);
 
 		// Called after the code has been deobfuscated
-		void deobfuscateMethodEnd(Blocks blocks);
+		void DeobfuscateMethodEnd(Blocks blocks);
 
 		// Called after all deobfuscation methods
-		void deobfuscateEnd();
+		void DeobfuscateEnd();
 
 		// Returns all string decrypter method tokens
-		IEnumerable<int> getStringDecrypterMethods();
+		IEnumerable<int> GetStringDecrypterMethods();
 	}
 }
diff --git a/de4dot.code/deobfuscators/IDeobfuscatorInfo.cs b/de4dot.code/deobfuscators/IDeobfuscatorInfo.cs
index bc8dec47..8edec9df 100644
--- a/de4dot.code/deobfuscators/IDeobfuscatorInfo.cs
+++ b/de4dot.code/deobfuscators/IDeobfuscatorInfo.cs
@@ -23,7 +23,7 @@ namespace de4dot.code.deobfuscators {
 	public interface IDeobfuscatorInfo {
 		string Type { get; }
 		string Name { get; }
-		IDeobfuscator createDeobfuscator();
-		IEnumerable<Option> getOptions();
+		IDeobfuscator CreateDeobfuscator();
+		IEnumerable<Option> GetOptions();
 	}
 }
diff --git a/de4dot.code/deobfuscators/ILProtector/Deobfuscator.cs b/de4dot.code/deobfuscators/ILProtector/Deobfuscator.cs
index ec930697..a0c4fea2 100644
--- a/de4dot.code/deobfuscators/ILProtector/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/ILProtector/Deobfuscator.cs
@@ -39,13 +39,13 @@ namespace de4dot.code.deobfuscators.ILProtector {
 			get { return THE_TYPE; }
 		}
 
-		public override IDeobfuscator createDeobfuscator() {
+		public override IDeobfuscator CreateDeobfuscator() {
 			return new Deobfuscator(new Deobfuscator.Options {
 				ValidNameRegex = validNameRegex.get(),
 			});
 		}
 
-		protected override IEnumerable<Option> getOptionsInternal() {
+		protected override IEnumerable<Option> GetOptionsInternal() {
 			return new List<Option>() {
 			};
 		}
@@ -78,41 +78,41 @@ namespace de4dot.code.deobfuscators.ILProtector {
 			this.options = options;
 		}
 
-		protected override int detectInternal() {
+		protected override int DetectInternal() {
 			return mainType.Detected ? 150 : 0;
 		}
 
-		protected override void scanForObfuscator() {
+		protected override void ScanForObfuscator() {
 			mainType = new MainType(module);
-			mainType.find();
+			mainType.Find();
 			methodsDecrypter = new MethodsDecrypter(module, mainType);
 			if (mainType.Detected)
-				methodsDecrypter.find();
+				methodsDecrypter.Find();
 
 			if (mainType.Detected && methodsDecrypter.Detected && methodsDecrypter.Version != null)
 				obfuscatorName += " " + methodsDecrypter.Version;
 		}
 
-		public override void deobfuscateBegin() {
-			base.deobfuscateBegin();
+		public override void DeobfuscateBegin() {
+			base.DeobfuscateBegin();
 
 			if (mainType.Detected) {
 				if (methodsDecrypter.Detected) {
-					methodsDecrypter.decrypt();
-					addTypesToBeRemoved(methodsDecrypter.DelegateTypes, "Obfuscator method delegate type");
-					addResourceToBeRemoved(methodsDecrypter.Resource, "Encrypted methods resource");
-					addTypeToBeRemoved(mainType.InvokerDelegate, "Invoker delegate type");
-					addFieldToBeRemoved(mainType.InvokerInstanceField, "Invoker delegate instance field");
+					methodsDecrypter.Decrypt();
+					AddTypesToBeRemoved(methodsDecrypter.DelegateTypes, "Obfuscator method delegate type");
+					AddResourceToBeRemoved(methodsDecrypter.Resource, "Encrypted methods resource");
+					AddTypeToBeRemoved(mainType.InvokerDelegate, "Invoker delegate type");
+					AddFieldToBeRemoved(mainType.InvokerInstanceField, "Invoker delegate instance field");
 					foreach (var pm in mainType.ProtectMethods)
-						addMethodToBeRemoved(pm, "Obfuscator 'Protect' init method");
-					mainType.cleanUp();
+						AddMethodToBeRemoved(pm, "Obfuscator 'Protect' init method");
+					mainType.CleanUp();
 				}
 				else
 					Logger.w("New ILProtector version. Can't decrypt methods (yet)");
 			}
 		}
 
-		public override IEnumerable<int> getStringDecrypterMethods() {
+		public override IEnumerable<int> GetStringDecrypterMethods() {
 			return new List<int>();
 		}
 	}
diff --git a/de4dot.code/deobfuscators/ILProtector/MainType.cs b/de4dot.code/deobfuscators/ILProtector/MainType.cs
index ead60b6b..f853b289 100644
--- a/de4dot.code/deobfuscators/ILProtector/MainType.cs
+++ b/de4dot.code/deobfuscators/ILProtector/MainType.cs
@@ -49,8 +49,8 @@ namespace de4dot.code.deobfuscators.ILProtector {
 			this.module = module;
 		}
 
-		public void find() {
-			checkMethod(DotNetUtils.getModuleTypeCctor(module));
+		public void Find() {
+			CheckMethod(DotNetUtils.GetModuleTypeCctor(module));
 		}
 
 		static string[] ilpLocals = new string[] {
@@ -58,16 +58,16 @@ namespace de4dot.code.deobfuscators.ILProtector {
 			"System.IntPtr",
 			"System.Object[]",
 		};
-		bool checkMethod(MethodDef cctor) {
+		bool CheckMethod(MethodDef cctor) {
 			if (cctor == null || cctor.Body == null)
 				return false;
-			if (!new LocalTypes(cctor).exactly(ilpLocals))
+			if (!new LocalTypes(cctor).Exactly(ilpLocals))
 				return false;
 
 			var type = cctor.DeclaringType;
-			var methods = getPinvokeMethods(type, "Protect");
+			var methods = GetPinvokeMethods(type, "Protect");
 			if (methods.Count == 0)
-				methods = getPinvokeMethods(type, "P0");
+				methods = GetPinvokeMethods(type, "P0");
 			if (methods.Count != 2)
 				return false;
 			if (type.Fields.Count != 1)
@@ -75,7 +75,7 @@ namespace de4dot.code.deobfuscators.ILProtector {
 
 			var theField = type.Fields[0];
 			var theDelegate = theField.FieldType.TryGetTypeDef();
-			if (theDelegate == null || !DotNetUtils.derivesFromDelegate(theDelegate))
+			if (theDelegate == null || !DotNetUtils.DerivesFromDelegate(theDelegate))
 				return false;
 
 			protectMethods = methods;
@@ -84,7 +84,7 @@ namespace de4dot.code.deobfuscators.ILProtector {
 			return true;
 		}
 
-		static List<MethodDef> getPinvokeMethods(TypeDef type, string name) {
+		static List<MethodDef> GetPinvokeMethods(TypeDef type, string name) {
 			var list = new List<MethodDef>();
 			foreach (var method in type.Methods) {
 				if (method.ImplMap != null && method.ImplMap.Name == name)
@@ -93,8 +93,8 @@ namespace de4dot.code.deobfuscators.ILProtector {
 			return list;
 		}
 
-		public void cleanUp() {
-			var cctor = DotNetUtils.getModuleTypeCctor(module);
+		public void CleanUp() {
+			var cctor = DotNetUtils.GetModuleTypeCctor(module);
 			if (cctor != null) {
 				cctor.Body.InitLocals = false;
 				cctor.Body.Variables.Clear();
diff --git a/de4dot.code/deobfuscators/ILProtector/MethodReader.cs b/de4dot.code/deobfuscators/ILProtector/MethodReader.cs
index cf68c2cb..ab81e9d8 100644
--- a/de4dot.code/deobfuscators/ILProtector/MethodReader.cs
+++ b/de4dot.code/deobfuscators/ILProtector/MethodReader.cs
@@ -65,20 +65,20 @@ namespace de4dot.code.deobfuscators.ILProtector {
 			this.module = module;
 		}
 
-		public void read() {
+		public void Read() {
 			flags = (MethodFlags)reader.ReadByte();
-			delegateType = resolve<TypeDef>(readTypeToken());
-			if (!DotNetUtils.derivesFromDelegate(delegateType))
+			delegateType = Resolve<TypeDef>(ReadTypeToken());
+			if (!DotNetUtils.DerivesFromDelegate(delegateType))
 				throw new ApplicationException("Invalid delegate type");
 			if (HasLocals)
-				readLocals((int)reader.Read7BitEncodedUInt32());
+				ReadLocals((int)reader.Read7BitEncodedUInt32());
 			if (HasInstructions)
 				ReadInstructions((int)reader.Read7BitEncodedUInt32());
 			if (HasExceptionHandlers)
-				readExceptionHandlers((int)reader.Read7BitEncodedUInt32());
+				ReadExceptionHandlers((int)reader.Read7BitEncodedUInt32());
 		}
 
-		int getTypeDefOrRefToken(uint token) {
+		int GetTypeDefOrRefToken(uint token) {
 			switch (token & 3) {
 			case 0: return 0x02000000 + (int)(token >> 2);
 			case 1: return 0x01000000 + (int)(token >> 2);
@@ -87,22 +87,22 @@ namespace de4dot.code.deobfuscators.ILProtector {
 			}
 		}
 
-		void readLocals(int numLocals) {
+		void ReadLocals(int numLocals) {
 			var localsTypes = new List<TypeSig>();
 			for (int i = 0; i < numLocals; i++)
-				localsTypes.Add(readType());
+				localsTypes.Add(ReadType());
 			SetLocals(localsTypes);
 		}
 
-		T resolve<T>(int token) {
+		T Resolve<T>(int token) {
 			return (T)module.ResolveToken(token);
 		}
 
-		int readTypeToken() {
-			return getTypeDefOrRefToken(reader.Read7BitEncodedUInt32());
+		int ReadTypeToken() {
+			return GetTypeDefOrRefToken(reader.Read7BitEncodedUInt32());
 		}
 
-		TypeSig readType() {
+		TypeSig ReadType() {
 			switch ((ElementType)reader.ReadByte()) {
 			case ElementType.Void: return module.CorLibTypes.Void;
 			case ElementType.Boolean: return module.CorLibTypes.Boolean;
@@ -118,32 +118,32 @@ namespace de4dot.code.deobfuscators.ILProtector {
 			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.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.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<ITypeDefOrRef>(readTypeToken()).ToTypeSig();
+				return Resolve<ITypeDefOrRef>(ReadTypeToken()).ToTypeSig();
 
 			case ElementType.Array:
-				var arrayType = readType();
+				var arrayType = ReadType();
 				uint rank = reader.Read7BitEncodedUInt32();
 				return new ArraySig(arrayType, rank);
 
 			case ElementType.GenericInst:
 				reader.ReadByte();
-				var genericType = resolve<ITypeDefOrRef>(readTypeToken());
+				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());
+					git.GenericArguments.Add(ReadType());
 				return git;
 
 			case ElementType.Var:
@@ -158,11 +158,11 @@ namespace de4dot.code.deobfuscators.ILProtector {
 		}
 
 		protected override IField ReadInlineField(Instruction instr) {
-			return resolve<IField>(reader.ReadInt32());
+			return Resolve<IField>(reader.ReadInt32());
 		}
 
 		protected override IMethod ReadInlineMethod(Instruction instr) {
-			return resolve<IMethod>(reader.ReadInt32());
+			return Resolve<IMethod>(reader.ReadInt32());
 		}
 
 		protected override MethodSig ReadInlineSig(Instruction instr) {
@@ -178,20 +178,20 @@ namespace de4dot.code.deobfuscators.ILProtector {
 		}
 
 		protected override ITokenOperand ReadInlineTok(Instruction instr) {
-			return resolve<ITokenOperand>(reader.ReadInt32());
+			return Resolve<ITokenOperand>(reader.ReadInt32());
 		}
 
 		protected override ITypeDefOrRef ReadInlineType(Instruction instr) {
-			return resolve<ITypeDefOrRef>(reader.ReadInt32());
+			return Resolve<ITypeDefOrRef>(reader.ReadInt32());
 		}
 
-		void readExceptionHandlers(int numExceptionHandlers) {
+		void ReadExceptionHandlers(int numExceptionHandlers) {
 			exceptionHandlers = new List<ExceptionHandler>(numExceptionHandlers);
 			for (int i = 0; i < numExceptionHandlers; i++)
-				Add(readExceptionHandler());
+				Add(ReadExceptionHandler());
 		}
 
-		ExceptionHandler readExceptionHandler() {
+		ExceptionHandler ReadExceptionHandler() {
 			var eh = new ExceptionHandler((ExceptionHandlerType)(reader.Read7BitEncodedUInt32() & 7));
 
 			uint tryOffset = reader.Read7BitEncodedUInt32();
@@ -204,7 +204,7 @@ namespace de4dot.code.deobfuscators.ILProtector {
 
 			switch (eh.HandlerType) {
 			case ExceptionHandlerType.Catch:
-				eh.CatchType = resolve<ITypeDefOrRef>(reader.ReadInt32());
+				eh.CatchType = Resolve<ITypeDefOrRef>(reader.ReadInt32());
 				break;
 
 			case ExceptionHandlerType.Filter:
diff --git a/de4dot.code/deobfuscators/ILProtector/MethodsDecrypter.cs b/de4dot.code/deobfuscators/ILProtector/MethodsDecrypter.cs
index 1f02470c..47be38aa 100644
--- a/de4dot.code/deobfuscators/ILProtector/MethodsDecrypter.cs
+++ b/de4dot.code/deobfuscators/ILProtector/MethodsDecrypter.cs
@@ -36,7 +36,7 @@ namespace de4dot.code.deobfuscators.ILProtector {
 
 		interface IDecrypter {
 			string Version { get; }
-			byte[] getMethodsData(EmbeddedResource resource);
+			byte[] GetMethodsData(EmbeddedResource resource);
 		}
 
 		class DecrypterBase : IDecrypter {
@@ -51,36 +51,36 @@ namespace de4dot.code.deobfuscators.ILProtector {
 				get { return ilpVersion; }
 			}
 
-			protected void setVersion(Version version) {
+			protected void SetVersion(Version version) {
 				if (version.Revision == 0)
 					ilpVersion = string.Format("{0}.{1}.{2}", version.Major, version.Minor, version.Build);
 				else
 					ilpVersion = version.ToString();
 			}
 
-			public virtual byte[] getMethodsData(EmbeddedResource resource) {
+			public virtual byte[] GetMethodsData(EmbeddedResource resource) {
 				var reader = resource.Data;
 				reader.Position = startOffset;
 				if ((reader.ReadInt32() & 1) != 0)
-					return decompress(reader);
+					return Decompress(reader);
 				else
 					return reader.ReadRemainingBytes();
 			}
 
-			byte[] decompress(IBinaryReader reader) {
-				return decompress(reader, decryptionKey, decryptionKeyMod);
+			byte[] Decompress(IBinaryReader reader) {
+				return Decompress(reader, decryptionKey, decryptionKeyMod);
 			}
 
-			static void copy(byte[] src, int srcIndex, byte[] dst, int dstIndex, int size) {
+			static void Copy(byte[] src, int srcIndex, byte[] dst, int dstIndex, int size) {
 				for (int i = 0; i < size; i++)
 					dst[dstIndex++] = src[srcIndex++];
 			}
 
-			static byte[] decompress(IBinaryReader reader, byte[] key, int keyMod) {
-				return decompress(new byte[reader.Read7BitEncodedUInt32()], reader, key, keyMod);
+			static byte[] Decompress(IBinaryReader reader, byte[] key, int keyMod) {
+				return Decompress(new byte[reader.Read7BitEncodedUInt32()], reader, key, keyMod);
 			}
 
-			protected static byte[] decompress(byte[] decrypted, IBinaryReader reader, byte[] key, int keyMod) {
+			protected static byte[] Decompress(byte[] decrypted, IBinaryReader reader, byte[] key, int keyMod) {
 				int destIndex = 0;
 				while (reader.Position < reader.Length) {
 					if (destIndex >= decrypted.Length)
@@ -94,7 +94,7 @@ namespace de4dot.code.deobfuscators.ILProtector {
 						if ((flags & mask) != 0) {
 							int displ = (int)reader.Read7BitEncodedUInt32();
 							int size = (int)reader.Read7BitEncodedUInt32();
-							copy(decrypted, destIndex - displ, decrypted, destIndex, size);
+							Copy(decrypted, destIndex - displ, decrypted, destIndex, size);
 							destIndex += size;
 						}
 						else {
@@ -116,13 +116,13 @@ namespace de4dot.code.deobfuscators.ILProtector {
 			const uint RESOURCE_MAGIC = 0xC0D31220;
 
 			DecrypterV100(Version ilpVersion) {
-				setVersion(ilpVersion);
+				SetVersion(ilpVersion);
 				this.startOffset = 8;
 				this.decryptionKey = ilpPublicKeyToken;
 				this.decryptionKeyMod = 8;
 			}
 
-			public static DecrypterV100 create(IBinaryReader reader) {
+			public static DecrypterV100 Create(IBinaryReader reader) {
 				reader.Position = 0;
 				if (reader.Length < 12)
 					return null;
@@ -136,18 +136,18 @@ namespace de4dot.code.deobfuscators.ILProtector {
 		// 1.0.5
 		class DecrypterV105 : DecrypterBase {
 			DecrypterV105(Version ilpVersion, byte[] key) {
-				setVersion(ilpVersion);
+				SetVersion(ilpVersion);
 				this.startOffset = 0xA0;
 				this.decryptionKey = key;
 				this.decryptionKeyMod = key.Length - 1;
 			}
 
-			public static DecrypterV105 create(IBinaryReader reader) {
+			public static DecrypterV105 Create(IBinaryReader reader) {
 				reader.Position = 0;
 				if (reader.Length < 0xA4)
 					return null;
 				var key = reader.ReadBytes(0x94);
-				if (!Utils.compare(reader.ReadBytes(8), ilpPublicKeyToken))
+				if (!Utils.Compare(reader.ReadBytes(8), ilpPublicKeyToken))
 					return null;
 				return new DecrypterV105(new Version(reader.ReadByte(), reader.ReadByte(), reader.ReadByte(), reader.ReadByte()), key);
 			}
@@ -167,7 +167,7 @@ namespace de4dot.code.deobfuscators.ILProtector {
 				this.decryptionKeyMod = key0.Length - 1;
 			}
 
-			public static DecrypterV106 create(IBinaryReader reader) {
+			public static DecrypterV106 Create(IBinaryReader reader) {
 				try {
 					int keyXorOffs7 = (ReadByteAt(reader, 0) ^ ReadByteAt(reader, 2)) + 2;
 					reader.Position = keyXorOffs7 + (ReadByteAt(reader, 1) ^ ReadByteAt(reader, keyXorOffs7));
@@ -176,16 +176,16 @@ namespace de4dot.code.deobfuscators.ILProtector {
 					int keyXorOffs6 = (int)reader.Position;
 					int encryptedOffs = (int)reader.Position + sha1DataLen;
 					var sha1Data = reader.ReadBytes(sha1DataLen);
-					uint crc32 = CRC32.checksum(sha1Data);
+					uint crc32 = CRC32.CheckSum(sha1Data);
 
 					reader.Position = reader.Length - 0x18;
 					uint origCrc32 = reader.ReadUInt32();
 					if (crc32 != origCrc32)
 						return null;
 
-					var key0 = DeobUtils.sha1Sum(sha1Data);			// 1.0.6.0
-					var key6 = getKey(reader, key0, keyXorOffs6);	// 1.0.6.6
-					var key7 = getKey(reader, key0, keyXorOffs7);	// 1.0.6.7
+					var key0 = DeobUtils.Sha1Sum(sha1Data);			// 1.0.6.0
+					var key6 = GetKey(reader, key0, keyXorOffs6);	// 1.0.6.6
+					var key7 = GetKey(reader, key0, keyXorOffs7);	// 1.0.6.7
 					return new DecrypterV106(key0, key6, key7, encryptedOffs);
 				}
 				catch (IOException) {
@@ -193,7 +193,7 @@ namespace de4dot.code.deobfuscators.ILProtector {
 				}
 			}
 
-			static byte[] getKey(IBinaryReader reader, byte[] sha1Sum, int offs) {
+			static byte[] GetKey(IBinaryReader reader, byte[] sha1Sum, int offs) {
 				var key = (byte[])sha1Sum.Clone();
 				reader.Position = offs;
 				for (int i = 0; i < key.Length; i++)
@@ -206,7 +206,7 @@ namespace de4dot.code.deobfuscators.ILProtector {
 				return reader.ReadByte();
 			}
 
-			public override byte[] getMethodsData(EmbeddedResource resource) {
+			public override byte[] GetMethodsData(EmbeddedResource resource) {
 				var reader = resource.Data;
 				reader.Position = startOffset;
 				var decrypted = new byte[reader.Read7BitEncodedUInt32()];
@@ -217,8 +217,8 @@ namespace de4dot.code.deobfuscators.ILProtector {
 				foreach (var key in keys) {
 					try {
 						reader.Position = pos;
-						decompress(decrypted, reader, key, decryptionKeyMod);
-						uint crc32 = CRC32.checksum(decrypted);
+						Decompress(decrypted, reader, key, decryptionKeyMod);
+						uint crc32 = CRC32.CheckSum(decrypted);
 						if (crc32 == origCrc32)
 							return decrypted;
 					}
@@ -268,16 +268,16 @@ namespace de4dot.code.deobfuscators.ILProtector {
 			this.mainType = mainType;
 		}
 
-		public void find() {
+		public void Find() {
 			foreach (var tmp in module.Resources) {
 				var resource = tmp as EmbeddedResource;
 				if (resource == null)
 					continue;
 				var reader = resource.Data;
 				reader.Position = 0;
-				if (!checkResourceV100(reader) &&
-					!checkResourceV105(reader) &&
-					!checkResourceV106(reader))
+				if (!CheckResourceV100(reader) &&
+					!CheckResourceV105(reader) &&
+					!CheckResourceV106(reader))
 					continue;
 
 				methodsResource = resource;
@@ -285,32 +285,32 @@ namespace de4dot.code.deobfuscators.ILProtector {
 			}
 		}
 
-		bool checkResourceV100(IBinaryReader reader) {
-			decrypter = DecrypterV100.create(reader);
+		bool CheckResourceV100(IBinaryReader reader) {
+			decrypter = DecrypterV100.Create(reader);
 			return decrypter != null;
 		}
 
-		bool checkResourceV105(IBinaryReader reader) {
-			decrypter = DecrypterV105.create(reader);
+		bool CheckResourceV105(IBinaryReader reader) {
+			decrypter = DecrypterV105.Create(reader);
 			return decrypter != null;
 		}
 
-		bool checkResourceV106(IBinaryReader reader) {
-			decrypter = DecrypterV106.create(reader);
+		bool CheckResourceV106(IBinaryReader reader) {
+			decrypter = DecrypterV106.Create(reader);
 			return decrypter != null;
 		}
 
-		public void decrypt() {
+		public void Decrypt() {
 			if (methodsResource == null || decrypter == null)
 				return;
 
-			foreach (var info in readMethodInfos(decrypter.getMethodsData(methodsResource)))
+			foreach (var info in ReadMethodInfos(decrypter.GetMethodsData(methodsResource)))
 				methodInfos[info.id] = info;
 
-			restoreMethods();
+			RestoreMethods();
 		}
 
-		static MethodInfo2[] readMethodInfos(byte[] data) {
+		static MethodInfo2[] ReadMethodInfos(byte[] data) {
 			var reader = MemoryImageStream.Create(data);
 			int numMethods = (int)reader.Read7BitEncodedUInt32();
 			int totalCodeSize = (int)reader.Read7BitEncodedUInt32();
@@ -330,20 +330,20 @@ namespace de4dot.code.deobfuscators.ILProtector {
 			return methodInfos;
 		}
 
-		void restoreMethods() {
+		void RestoreMethods() {
 			if (methodInfos.Count == 0)
 				return;
 
 			Logger.v("Restoring {0} methods", methodInfos.Count);
-			Logger.Instance.indent();
+			Logger.Instance.Indent();
 			foreach (var type in module.GetTypes()) {
 				foreach (var method in type.Methods) {
 					if (method.Body == null)
 						continue;
 
-					if (restoreMethod(method)) {
+					if (RestoreMethod(method)) {
 						Logger.v("Restored method {0} ({1:X8}). Instrs:{2}, Locals:{3}, Exceptions:{4}",
-							Utils.removeNewlines(method.FullName),
+							Utils.RemoveNewlines(method.FullName),
 							method.MDToken.ToInt32(),
 							method.Body.Instructions.Count,
 							method.Body.Variables.Count,
@@ -351,14 +351,14 @@ namespace de4dot.code.deobfuscators.ILProtector {
 					}
 				}
 			}
-			Logger.Instance.deIndent();
+			Logger.Instance.DeIndent();
 			if (methodInfos.Count != 0)
 				Logger.w("{0} methods weren't restored", methodInfos.Count);
 		}
 
 		const int INVALID_METHOD_ID = -1;
-		bool restoreMethod(MethodDef method) {
-			int methodId = getMethodId(method);
+		bool RestoreMethod(MethodDef method) {
+			int methodId = GetMethodId(method);
 			if (methodId == INVALID_METHOD_ID)
 				return false;
 
@@ -366,21 +366,21 @@ namespace de4dot.code.deobfuscators.ILProtector {
 			var methodInfo = methodInfos[methodId];
 			methodInfos.Remove(methodId);
 			var methodReader = new MethodReader(module, methodInfo.data, parameters);
-			methodReader.read();
+			methodReader.Read();
 
-			restoreMethod(method, methodReader);
+			RestoreMethod(method, methodReader);
 			delegateTypes.Add(methodReader.DelegateType);
 
 			return true;
 		}
 
-		static void restoreMethod(MethodDef method, MethodReader methodReader) {
+		static void RestoreMethod(MethodDef method, MethodReader methodReader) {
 			// body.MaxStackSize = <let dnlib calculate this>
 			method.Body.InitLocals = methodReader.InitLocals;
 			methodReader.RestoreMethod(method);
 		}
 
-		int getMethodId(MethodDef method) {
+		int GetMethodId(MethodDef method) {
 			if (method == null || method.Body == null)
 				return INVALID_METHOD_ID;
 
diff --git a/de4dot.code/deobfuscators/ISimpleDeobfuscator.cs b/de4dot.code/deobfuscators/ISimpleDeobfuscator.cs
index e80ae273..3ec0f4f5 100644
--- a/de4dot.code/deobfuscators/ISimpleDeobfuscator.cs
+++ b/de4dot.code/deobfuscators/ISimpleDeobfuscator.cs
@@ -21,8 +21,8 @@ using dnlib.DotNet;
 
 namespace de4dot.code.deobfuscators {
 	public interface ISimpleDeobfuscator {
-		void deobfuscate(MethodDef method);
-		void deobfuscate(MethodDef method, bool force);
-		void decryptStrings(MethodDef 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 fd303ba4..ba0c0ebe 100644
--- a/de4dot.code/deobfuscators/InitializedDataCreator.cs
+++ b/de4dot.code/deobfuscators/InitializedDataCreator.cs
@@ -35,45 +35,45 @@ namespace de4dot.code.deobfuscators {
 		MemberRef initializeArrayMethod;
 
 		public MemberRef InitializeArrayMethod {
-			get { return createInitializeArrayMethod(); }
+			get { return CreateInitializeArrayMethod(); }
 		}
 
 		public InitializedDataCreator(ModuleDef module) {
 			this.module = module;
 		}
 
-		MemberRef createInitializeArrayMethod() {
+		MemberRef CreateInitializeArrayMethod() {
 			if (initializeArrayMethod == null) {
-				var runtimeHelpersType = DotNetUtils.findOrCreateTypeRef(module, module.CorLibTypes.AssemblyRef, "System.Runtime.CompilerServices", "RuntimeHelpers", false);
-				var systemArrayType = DotNetUtils.findOrCreateTypeRef(module, module.CorLibTypes.AssemblyRef, "System", "Array", false);
-				var runtimeFieldHandleType = DotNetUtils.findOrCreateTypeRef(module, module.CorLibTypes.AssemblyRef, "System", "RuntimeFieldHandle", true);
+				var runtimeHelpersType = DotNetUtils.FindOrCreateTypeRef(module, module.CorLibTypes.AssemblyRef, "System.Runtime.CompilerServices", "RuntimeHelpers", false);
+				var systemArrayType = DotNetUtils.FindOrCreateTypeRef(module, module.CorLibTypes.AssemblyRef, "System", "Array", false);
+				var runtimeFieldHandleType = DotNetUtils.FindOrCreateTypeRef(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, ITypeDefOrRef elementType, byte[] data) {
+		public void AddInitializeArrayCode(Block block, int start, int numToRemove, ITypeDefOrRef elementType, byte[] data) {
 			int index = start;
-			block.replace(index++, numToRemove, Instruction.CreateLdcI4(data.Length / elementType.ToTypeSig().ElementType.GetPrimitiveSize()));
-			block.insert(index++, OpCodes.Newarr.ToInstruction(elementType));
-			block.insert(index++, OpCodes.Dup.ToInstruction());
-			block.insert(index++, OpCodes.Ldtoken.ToInstruction((IField)create(data)));
-			block.insert(index++, OpCodes.Call.ToInstruction((IMethod)InitializeArrayMethod));
+			block.Replace(index++, numToRemove, Instruction.CreateLdcI4(data.Length / elementType.ToTypeSig().ElementType.GetPrimitiveSize()));
+			block.Insert(index++, OpCodes.Newarr.ToInstruction(elementType));
+			block.Insert(index++, OpCodes.Dup.ToInstruction());
+			block.Insert(index++, OpCodes.Ldtoken.ToInstruction((IField)Create(data)));
+			block.Insert(index++, OpCodes.Call.ToInstruction((IMethod)InitializeArrayMethod));
 		}
 
-		void createOurType() {
+		void CreateOurType() {
 			if (ourType != null)
 				return;
 
-			ourType = new TypeDefUser("", string.Format("<PrivateImplementationDetails>{0}", getModuleId()), module.CorLibTypes.Object.TypeDefOrRef);
+			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);
 		}
 
-		object getModuleId() {
+		object GetModuleId() {
 			var memoryStream = new MemoryStream();
 			var writer = new BinaryWriter(memoryStream);
 			if (module.Assembly != null)
@@ -88,15 +88,15 @@ namespace de4dot.code.deobfuscators {
 			return guid.ToString("B");
 		}
 
-		TypeDef getArrayType(long size) {
-			createOurType();
+		TypeDef GetArrayType(long size) {
+			CreateOurType();
 
 			TypeDef arrayType;
 			if (sizeToArrayType.TryGetValue(size, out arrayType))
 				return arrayType;
 
 			if (valueType == null)
-				valueType = DotNetUtils.findOrCreateTypeRef(module, module.CorLibTypes.AssemblyRef, "System", "ValueType", false);
+				valueType = DotNetUtils.FindOrCreateTypeRef(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 |
@@ -107,8 +107,8 @@ namespace de4dot.code.deobfuscators {
 			return arrayType;
 		}
 
-		public FieldDef create(byte[] data) {
-			var arrayType = getArrayType(data.LongLength);
+		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 FieldDefUser(string.Format("field_{0}", unique++), fieldSig, attrs);
diff --git a/de4dot.code/deobfuscators/InlinedMethodsFinder.cs b/de4dot.code/deobfuscators/InlinedMethodsFinder.cs
index 8047ca50..8daa6761 100644
--- a/de4dot.code/deobfuscators/InlinedMethodsFinder.cs
+++ b/de4dot.code/deobfuscators/InlinedMethodsFinder.cs
@@ -24,7 +24,7 @@ using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators {
 	static class InlinedMethodsFinder {
-		public static List<MethodDef> find(ModuleDef 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.
@@ -82,7 +82,7 @@ namespace de4dot.code.deobfuscators {
 					case Code.Ldarga_S:
 					case Code.Call:
 					case Code.Newobj:
-						if (!isCallMethod(method))
+						if (!IsCallMethod(method))
 							continue;
 						break;
 
@@ -97,9 +97,9 @@ namespace de4dot.code.deobfuscators {
 			return inlinedMethods;
 		}
 
-		static bool isCallMethod(MethodDef method) {
+		static bool IsCallMethod(MethodDef method) {
 			int loadIndex = 0;
-			int methodArgsCount = DotNetUtils.getArgsCount(method);
+			int methodArgsCount = DotNetUtils.GetArgsCount(method);
 			var instrs = method.Body.Instructions;
 			int i = 0;
 			for (; i < instrs.Count && i < methodArgsCount; i++) {
diff --git a/de4dot.code/deobfuscators/MPRESS/Deobfuscator.cs b/de4dot.code/deobfuscators/MPRESS/Deobfuscator.cs
index 42e90710..84d4ce7f 100644
--- a/de4dot.code/deobfuscators/MPRESS/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/MPRESS/Deobfuscator.cs
@@ -41,13 +41,13 @@ namespace de4dot.code.deobfuscators.MPRESS {
 			get { return THE_TYPE; }
 		}
 
-		public override IDeobfuscator createDeobfuscator() {
+		public override IDeobfuscator CreateDeobfuscator() {
 			return new Deobfuscator(new Deobfuscator.Options {
 				ValidNameRegex = validNameRegex.get(),
 			});
 		}
 
-		protected override IEnumerable<Option> getOptionsInternal() {
+		protected override IEnumerable<Option> GetOptionsInternal() {
 			return new List<Option>() {
 			};
 		}
@@ -85,7 +85,7 @@ namespace de4dot.code.deobfuscators.MPRESS {
 			this.options = options;
 		}
 
-		protected override int detectInternal() {
+		protected override int DetectInternal() {
 			int val = 0;
 
 			if (version != Version.Unknown)
@@ -94,8 +94,8 @@ namespace de4dot.code.deobfuscators.MPRESS {
 			return val;
 		}
 
-		protected override void scanForObfuscator() {
-			version = detectVersion();
+		protected override void ScanForObfuscator() {
+			version = DetectVersion();
 			switch (version) {
 			case Version.V0x: obfuscatorName += " v0.71 - v0.99"; break;
 			case Version.V1x_217: obfuscatorName += " v1.x - v2.17"; break;
@@ -138,14 +138,14 @@ namespace de4dot.code.deobfuscators.MPRESS {
 			new MethodInfo("System.Int32", "(System.Byte[],System.Byte[],System.Int32)"),
 			new MethodInfo("System.Int32", "(System.String[])"),
 		};
-		Version detectVersion() {
+		Version DetectVersion() {
 			var ep = module.EntryPoint;
 			if (ep == null || ep.Body == null)
 				return Version.Unknown;
 			var type = ep.DeclaringType;
 			if (type == null)
 				return Version.Unknown;
-			if (!new FieldTypes(type).exactly(requiredFields))
+			if (!new FieldTypes(type).Exactly(requiredFields))
 				return Version.Unknown;
 			if (module.Types.Count != 2)
 				return Version.Unknown;
@@ -154,12 +154,12 @@ namespace de4dot.code.deobfuscators.MPRESS {
 			if (module.Types[0].Methods.Count != 0)
 				return Version.Unknown;
 
-			if (checkMethods(type, methods_v0x))
+			if (CheckMethods(type, methods_v0x))
 				return Version.V0x;
-			if (checkMethods(type, methods_v1x)) {
-				var lfMethod = DotNetUtils.getMethod(type, "System.Boolean", "(System.String,System.Byte[]&)");
+			if (CheckMethods(type, methods_v1x)) {
+				var lfMethod = DotNetUtils.GetMethod(type, "System.Boolean", "(System.String,System.Byte[]&)");
 				if (lfMethod != null) {
-					if (DeobUtils.hasInteger(lfMethod, (int)Machine.AMD64))
+					if (DeobUtils.HasInteger(lfMethod, (int)Machine.AMD64))
 						return Version.V218;
 					return Version.V1x_217;
 				}
@@ -167,20 +167,20 @@ namespace de4dot.code.deobfuscators.MPRESS {
 			return Version.Unknown;
 		}
 
-		static bool checkMethods(TypeDef type, MethodInfo[] requiredMethods) {
+		static bool CheckMethods(TypeDef type, MethodInfo[] requiredMethods) {
 			var methods = new List<MethodDef>(type.Methods);
 			foreach (var info in requiredMethods) {
-				if (!checkMethod(methods, info))
+				if (!CheckMethod(methods, info))
 					return false;
 			}
 			return methods.Count == 0;
 		}
 
-		static bool checkMethod(List<MethodDef> 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;
-				if (!DotNetUtils.isMethod(method, info.returnType, info.parameters))
+				if (!DotNetUtils.IsMethod(method, info.returnType, info.parameters))
 					continue;
 
 				methods.Remove(method);
@@ -189,11 +189,11 @@ namespace de4dot.code.deobfuscators.MPRESS {
 			return false;
 		}
 
-		public override bool getDecryptedModule(int count, ref byte[] newFileData, ref DumpedMethods dumpedMethods) {
+		public override bool GetDecryptedModule(int count, ref byte[] newFileData, ref DumpedMethods dumpedMethods) {
 			if (count != 0 || version == Version.Unknown)
 				return false;
 
-			byte[] fileData = ModuleBytes ?? DeobUtils.readModule(module);
+			byte[] fileData = ModuleBytes ?? DeobUtils.ReadModule(module);
 			byte[] decompressed;
 			using (var peImage = new MyPEImage(fileData)) {
 				var section = peImage.Sections[peImage.Sections.Count - 1];
@@ -205,8 +205,8 @@ namespace de4dot.code.deobfuscators.MPRESS {
 				switch (version) {
 				case Version.V0x:
 					compressedLen = fileData.Length - (int)offset;
-					compressed = peImage.offsetReadBytes(offset, compressedLen);
-					decompressed = Lzmat.decompress_old(compressed);
+					compressed = peImage.OffsetReadBytes(offset, compressedLen);
+					decompressed = Lzmat.DecompressOld(compressed);
 					if (decompressed == null)
 						throw new ApplicationException("LZMAT decompression failed");
 					break;
@@ -215,12 +215,12 @@ namespace de4dot.code.deobfuscators.MPRESS {
 				case Version.V218:
 					if (peImage.PEImage.ImageNTHeaders.FileHeader.Machine == Machine.AMD64 && version == Version.V218)
 						offset = section.PointerToRawData + section.VirtualSize;
-					int decompressedLen = (int)peImage.offsetReadUInt32(offset);
+					int decompressedLen = (int)peImage.OffsetReadUInt32(offset);
 					compressedLen = fileData.Length - (int)offset - 4;
-					compressed = peImage.offsetReadBytes(offset + 4, compressedLen);
+					compressed = peImage.OffsetReadBytes(offset + 4, compressedLen);
 					decompressed = new byte[decompressedLen];
 					uint decompressedLen2;
-					if (Lzmat.decompress(decompressed, out decompressedLen2, compressed) != LzmatStatus.OK)
+					if (Lzmat.Decompress(decompressed, out decompressedLen2, compressed) != LzmatStatus.OK)
 						throw new ApplicationException("LZMAT decompression failed");
 					break;
 
@@ -233,19 +233,19 @@ namespace de4dot.code.deobfuscators.MPRESS {
 			return true;
 		}
 
-		public override IDeobfuscator moduleReloaded(ModuleDefMD module) {
+		public override IDeobfuscator ModuleReloaded(ModuleDefMD module) {
 			var newOne = new Deobfuscator(options);
-			newOne.setModule(module);
+			newOne.SetModule(module);
 			return newOne;
 		}
 
-		public override void deobfuscateBegin() {
-			base.deobfuscateBegin();
+		public override void DeobfuscateBegin() {
+			base.DeobfuscateBegin();
 
-			fixInvalidMvid();
+			FixInvalidMvid();
 		}
 
-		void fixInvalidMvid() {
+		void FixInvalidMvid() {
 			if (module.Mvid == Guid.Empty) {
 				var hash = new SHA1Managed().ComputeHash(Encoding.UTF8.GetBytes(module.ToString()));
 				var guid = new Guid(BitConverter.ToInt32(hash, 0),
@@ -258,7 +258,7 @@ namespace de4dot.code.deobfuscators.MPRESS {
 			}
 		}
 
-		public override IEnumerable<int> getStringDecrypterMethods() {
+		public override IEnumerable<int> GetStringDecrypterMethods() {
 			return new List<int>();
 		}
 	}
diff --git a/de4dot.code/deobfuscators/MPRESS/Lzmat.cs b/de4dot.code/deobfuscators/MPRESS/Lzmat.cs
index e0f9dedd..9e4428e5 100644
--- a/de4dot.code/deobfuscators/MPRESS/Lzmat.cs
+++ b/de4dot.code/deobfuscators/MPRESS/Lzmat.cs
@@ -70,7 +70,7 @@ namespace de4dot.code.deobfuscators.MPRESS {
 			return BitConverter.ToUInt16(_p_, (int)_i_);
 		}
 
-		public static LzmatStatus decompress(byte[] pbOut, out uint pcbOut, byte[] pbIn) {
+		public static LzmatStatus Decompress(byte[] pbOut, out uint pcbOut, byte[] pbIn) {
 			pcbOut = 0;
 			uint cbIn = (uint)pbIn.Length;
 
@@ -202,7 +202,7 @@ namespace de4dot.code.deobfuscators.MPRESS {
 	return LzmatStatus.OK;
 		}
 
-		public static byte[] decompress_old(byte[] compressed) {
+		public static byte[] DecompressOld(byte[] compressed) {
 			int srcIndex = 3;
 			int dstIndex = 0;
 			int decompressedLen = compressed[0] + (compressed[1] << 8) + (compressed[2] << 16);
diff --git a/de4dot.code/deobfuscators/MaxtoCode/CryptDecrypter.cs b/de4dot.code/deobfuscators/MaxtoCode/CryptDecrypter.cs
index e8cfe15f..dcfb7fe2 100644
--- a/de4dot.code/deobfuscators/MaxtoCode/CryptDecrypter.cs
+++ b/de4dot.code/deobfuscators/MaxtoCode/CryptDecrypter.cs
@@ -147,23 +147,23 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 		struct Bits {
 			readonly byte[] byteBits;
 
-			public static Bits fromBytes(byte[] bytes) {
-				return fromBytes(bytes, 0, bytes.Length * 8);
+			public static Bits FromBytes(byte[] bytes) {
+				return FromBytes(bytes, 0, bytes.Length * 8);
 			}
 
-			public static Bits fromBytes(byte[] bytes, int index, int numBits) {
+			public static Bits FromBytes(byte[] bytes, int index, int numBits) {
 				return new Bits(bytes, index, numBits);
 			}
 
-			public static Bits fromByteBits(byte[] byteBits1, byte[] byteBits2) {
+			public static Bits FromByteBits(byte[] byteBits1, byte[] byteBits2) {
 				return new Bits(byteBits1, byteBits2);
 			}
 
-			public static Bits fromByteBits(byte[] byteBits) {
-				return fromByteBits(byteBits, 0, byteBits.Length);
+			public static Bits FromByteBits(byte[] byteBits) {
+				return FromByteBits(byteBits, 0, byteBits.Length);
 			}
 
-			public static Bits fromByteBits(byte[] byteBits, int index, int numBits) {
+			public static Bits FromByteBits(byte[] byteBits, int index, int numBits) {
 				var bits = new Bits(numBits);
 				for (int i = 0; i < numBits; i++)
 					bits.byteBits[i] = byteBits[index + i];
@@ -183,14 +183,14 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			}
 
 			Bits(byte[] bytes1, byte[] bytes2) {
-				this.byteBits = concat(bytes1, bytes2);
+				this.byteBits = Concat(bytes1, bytes2);
 			}
 
 			Bits(byte[] bytes, int index, int numBits) {
-				this.byteBits = toByteBits(bytes, index, numBits);
+				this.byteBits = ToByteBits(bytes, index, numBits);
 			}
 
-			static byte[] toByteBits(byte[] bytes, int index, int numBits) {
+			static byte[] ToByteBits(byte[] bytes, int index, int numBits) {
 				var byteBits = new byte[numBits];
 				for (int i = 0; i < numBits; i++) {
 					int j = i / 8;
@@ -200,21 +200,21 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 				return byteBits;
 			}
 
-			static byte[] concat(byte[] bytes1, byte[] bytes2) {
+			static byte[] Concat(byte[] bytes1, byte[] bytes2) {
 				var bytes = new byte[bytes1.Length + bytes2.Length];
 				Array.Copy(bytes1, 0, bytes, 0, bytes1.Length);
 				Array.Copy(bytes2, 0, bytes, bytes1.Length, bytes2.Length);
 				return bytes;
 			}
 
-			public Bits transpose(byte[] bits) {
+			public Bits Transpose(byte[] bits) {
 				var result = new Bits(bits.Length);
 				for (int i = 0; i < bits.Length; i++)
 					result.byteBits[i] = byteBits[bits[i] - 1];
 				return result;
 			}
 
-			public void rol() {
+			public void Rol() {
 				if (byteBits.Length == 0)
 					return;
 				var first = byteBits[0];
@@ -223,21 +223,21 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 				byteBits[byteBits.Length - 1] = first;
 			}
 
-			public void rol(int num) {
+			public void Rol(int num) {
 				for (int i = 0; i < num; i++)
-					rol();
+					Rol();
 			}
 
-			public Bits extract(int index, int numBits) {
-				return fromByteBits(byteBits, index, numBits);
+			public Bits Extract(int index, int numBits) {
+				return FromByteBits(byteBits, index, numBits);
 			}
 
-			public void toBits(byte[] dest, int index) {
-				var bits = toBits();
+			public void ToBits(byte[] dest, int index) {
+				var bits = ToBits();
 				Array.Copy(bits, 0, dest, index, bits.Length);
 			}
 
-			public byte[] toBits() {
+			public byte[] ToBits() {
 				var bits = new byte[(byteBits.Length + 7) / 8];
 				for (int i = 0; i < bits.Length; i++) {
 					byte val = 0;
@@ -250,23 +250,23 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 				return bits;
 			}
 
-			public Bits clone() {
-				return fromByteBits(byteBits, 0, byteBits.Length);
+			public Bits Clone() {
+				return FromByteBits(byteBits, 0, byteBits.Length);
 			}
 
-			public void set(int destIndex, Bits other) {
+			public void Set(int destIndex, Bits other) {
 				for (int i = 0; i < other.byteBits.Length; i++)
 					byteBits[destIndex + i] = other.byteBits[i];
 			}
 
-			public void xor(Bits other) {
+			public void Xor(Bits other) {
 				if (byteBits.Length != other.byteBits.Length)
 					throw new ArgumentException("other");
 				for (int i = 0; i < byteBits.Length; i++)
 					byteBits[i] ^= other.byteBits[i];
 			}
 
-			public void copyTo(byte[] dest, int index) {
+			public void CopyTo(byte[] dest, int index) {
 				for (int i = 0; i < byteBits.Length; i++)
 					dest[index + i] = byteBits[i];
 			}
@@ -278,98 +278,98 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			this.key = key;
 		}
 
-		public static byte[] decrypt(byte[] key, byte[] encrypted) {
-			return new CryptDecrypter(key).decrypt(encrypted);
+		public static byte[] Decrypt(byte[] key, byte[] encrypted) {
+			return new CryptDecrypter(key).Decrypt(encrypted);
 		}
 
-		byte[] decrypt(byte[] encrypted) {
+		byte[] Decrypt(byte[] encrypted) {
 			if (encrypted.Length % 8 != 0)
 				throw new ArgumentException("encrypted");
-			var key1 = createKey(key, 0);
-			var key2 = createKey(key, 8);
+			var key1 = CreateKey(key, 0);
+			var key2 = CreateKey(key, 8);
 
 			var decrypted = new byte[encrypted.Length];
 			int count = encrypted.Length / 8;
 			for (int i = 0; i < count; i++) {
 				var buf = new byte[8];
 				Array.Copy(encrypted, i * 8, buf, 0, buf.Length);
-				buf = decrypt(buf, key1, true);
-				buf = decrypt(buf, key2, false);
-				buf = decrypt(buf, key1, true);
+				buf = Decrypt(buf, key1, true);
+				buf = Decrypt(buf, key2, false);
+				buf = Decrypt(buf, key1, true);
 				Array.Copy(buf, 0, decrypted, i * 8, buf.Length);
 			}
 
 			return decrypted;
 		}
 
-		byte[] decrypt(byte[] data, Bits key, bool flag) {
-			var bits = Bits.fromBytes(data).transpose(ip);
+		byte[] Decrypt(byte[] data, Bits key, bool flag) {
+			var bits = Bits.FromBytes(data).Transpose(ip);
 
 			if (flag) {
 				for (int i = 0, ki = key.ByteBits.Length - 48; i < 16; i++, ki -= 48) {
-					var oldBits = bits.extract(0, 32);
-					var tmp = decrypt(oldBits.clone(), key.extract(ki, 48));
-					tmp.xor(bits.extract(32, 32));
-					bits.set(32, oldBits);
-					bits.set(0, tmp);
+					var oldBits = bits.Extract(0, 32);
+					var tmp = Decrypt(oldBits.Clone(), key.Extract(ki, 48));
+					tmp.Xor(bits.Extract(32, 32));
+					bits.Set(32, oldBits);
+					bits.Set(0, tmp);
 				}
 			}
 			else {
 				for (int i = 0, ki = 0; i < 16; i++, ki += 48) {
-					var oldBits = bits.extract(32, 32);
-					var tmp = decrypt(oldBits.clone(), key.extract(ki, 48));
-					tmp.xor(bits.extract(0, 32));
-					bits.set(0, oldBits);
-					bits.set(32, tmp);
+					var oldBits = bits.Extract(32, 32);
+					var tmp = Decrypt(oldBits.Clone(), key.Extract(ki, 48));
+					tmp.Xor(bits.Extract(0, 32));
+					bits.Set(0, oldBits);
+					bits.Set(32, tmp);
 				}
 			}
 
-			bits = bits.transpose(final);
-			return bits.toBits();
+			bits = bits.Transpose(final);
+			return bits.ToBits();
 		}
 
-		Bits decrypt(Bits data, Bits key) {
-			var newData = data.clone().transpose(esel);
-			newData.xor(key);
-			return Bits.fromByteBits(getSbox(newData)).transpose(perm);
+		Bits Decrypt(Bits data, Bits key) {
+			var newData = data.Clone().Transpose(esel);
+			newData.Xor(key);
+			return Bits.FromByteBits(GetSbox(newData)).Transpose(perm);
 		}
 
-		byte[] getSbox(Bits data) {
+		byte[] GetSbox(Bits data) {
 			var sboxByteBits = new byte[32];
 
 			for (int i = 0; i < 8; i++) {
 				int di = i * 6;
 				int index = (data[di + 0] << 5) + (data[di + 5] << 4) + (data[di + 1] << 3) +
 							(data[di + 2] << 2) + (data[di + 3] << 1) + data[di + 4] + i * 64;
-				Bits.fromBytes(sbox, index, 4).copyTo(sboxByteBits, i * 4);
+				Bits.FromBytes(sbox, index, 4).CopyTo(sboxByteBits, i * 4);
 			}
 
 			return sboxByteBits;
 		}
 
-		static Bits createKey(byte[] data, int index) {
+		static Bits CreateKey(byte[] data, int index) {
 			Bits key1, key2;
-			createKeys(data, index, out key1, out key2);
+			CreateKeys(data, index, out key1, out key2);
 			byte[] newKey = new byte[16 * 6];
 			byte[] tmpData = new byte[28 * 2];
 			for (int i = 0; i < 16; i++) {
 				int rolCount = rots[i];
-				key1.rol(rolCount);
-				key2.rol(rolCount);
-				Bits.fromByteBits(key1.ByteBits, key2.ByteBits).transpose(pc2).toBits(newKey, i * 6);
+				key1.Rol(rolCount);
+				key2.Rol(rolCount);
+				Bits.FromByteBits(key1.ByteBits, key2.ByteBits).Transpose(pc2).ToBits(newKey, i * 6);
 			}
-			return Bits.fromBytes(newKey);
+			return Bits.FromBytes(newKey);
 		}
 
-		static void createKeys(byte[] data, int index, out Bits key1, out Bits key2) {
+		static void CreateKeys(byte[] data, int index, out Bits key1, out Bits key2) {
 			var tmpKey = new byte[8];
 			int len = Math.Min(tmpKey.Length, data.Length - index);
 			if (len == 0)
 				throw new ArgumentException("data");
 			Array.Copy(data, index, tmpKey, 0, len);
-			var bits = Bits.fromBytes(tmpKey).transpose(pc1);
-			key1 = Bits.fromByteBits(bits.ByteBits, 0, 28);
-			key2 = Bits.fromByteBits(bits.ByteBits, 28, 28);
+			var bits = Bits.FromBytes(tmpKey).Transpose(pc1);
+			key1 = Bits.FromByteBits(bits.ByteBits, 0, 28);
+			key2 = Bits.FromByteBits(bits.ByteBits, 28, 28);
 		}
 	}
 }
diff --git a/de4dot.code/deobfuscators/MaxtoCode/Decrypter6.cs b/de4dot.code/deobfuscators/MaxtoCode/Decrypter6.cs
index 8413ee0d..64286ae1 100644
--- a/de4dot.code/deobfuscators/MaxtoCode/Decrypter6.cs
+++ b/de4dot.code/deobfuscators/MaxtoCode/Decrypter6.cs
@@ -35,8 +35,8 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 		static readonly byte[] d4h = new byte[16] { 4, 11, 12, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1 };
 		static readonly byte[] d4l = new byte[16] { 13, 2, 8, 14, 6, 7, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7 };
 
-		public static byte[] decrypt(byte[] key, byte[] encrypted) {
-			return new Decrypter6(key).decrypt(encrypted);
+		public static byte[] Decrypt(byte[] key, byte[] encrypted) {
+			return new Decrypter6(key).Decrypt(encrypted);
 		}
 
 		Decrypter6(byte[] key) {
@@ -44,10 +44,10 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 				throw new ArgumentException("Invalid key size", "key");
 			this.key = new uint[8];
 			Buffer.BlockCopy(key, 0, this.key, 0, key.Length);
-			initialize();
+			Initialize();
 		}
 
-		byte[] decrypt(byte[] encrypted) {
+		byte[] Decrypt(byte[] encrypted) {
 			if ((encrypted.Length & 7) != 0)
 				throw new ArgumentException("Invalid data length", "encrypted");
 			var decrypted = new byte[encrypted.Length];
@@ -55,24 +55,24 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			int count = decrypted.Length / 8;
 			for (int i = 0; i < count; i++) {
 				uint x, y;
-				decrypt(BitConverter.ToUInt32(encrypted, i * 8), BitConverter.ToUInt32(encrypted, i * 8 + 4), out x, out y);
+				Decrypt(BitConverter.ToUInt32(encrypted, i * 8), BitConverter.ToUInt32(encrypted, i * 8 + 4), out x, out y);
 				for (int j = 1; j < 100; j++)
-					decrypt(x, y, out x, out y);
-				writeUInt32(decrypted, i * 8, x);
-				writeUInt32(decrypted, i * 8 + 4, y);
+					Decrypt(x, y, out x, out y);
+				WriteUInt32(decrypted, i * 8, x);
+				WriteUInt32(decrypted, i * 8 + 4, y);
 			}
 
 			return decrypted;
 		}
 
-		static void writeUInt32(byte[] data, int index, uint value) {
+		static void WriteUInt32(byte[] data, int index, uint value) {
 			data[index] = (byte)value;
 			data[index + 1] = (byte)(value >> 8);
 			data[index + 2] = (byte)(value >> 16);
 			data[index + 3] = (byte)(value >> 24);
 		}
 
-		void initialize() {
+		void Initialize() {
 			for (int i = 0; i < 0x100; i++) {
 				gen1[i] = (byte)((d1h[i / 16] << 4) | d1l[i & 0x0F]);
 				gen2[i] = (byte)((d2h[i / 16] << 4) | d2l[i & 0x0F]);
@@ -81,42 +81,42 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			}
 		}
 
-		void decrypt(uint i0, uint i1, out uint o0, out uint o1) {
+		void Decrypt(uint i0, uint i1, out uint o0, out uint o1) {
 			uint x = i0;
-			uint y = decrypt(x + key[0]);
+			uint y = Decrypt(x + key[0]);
 			y ^= i1;
-			x ^= decrypt(y + key[1]);
-			y ^= decrypt(x + key[2]);
-			x ^= decrypt(y + key[3]);
-			y ^= decrypt(x + key[4]);
-			x ^= decrypt(y + key[5]);
-			y ^= decrypt(x + key[6]);
-			x ^= decrypt(y + key[7]);
+			x ^= Decrypt(y + key[1]);
+			y ^= Decrypt(x + key[2]);
+			x ^= Decrypt(y + key[3]);
+			y ^= Decrypt(x + key[4]);
+			x ^= Decrypt(y + key[5]);
+			y ^= Decrypt(x + key[6]);
+			x ^= Decrypt(y + key[7]);
 
 			for (int i = 0; i < 3; i++) {
-				y ^= decrypt(x + key[7]);
-				x ^= decrypt(y + key[6]);
-				y ^= decrypt(x + key[5]);
-				x ^= decrypt(y + key[4]);
-				y ^= decrypt(x + key[3]);
-				x ^= decrypt(y + key[2]);
-				y ^= decrypt(x + key[1]);
-				x ^= decrypt(y + key[0]);
+				y ^= Decrypt(x + key[7]);
+				x ^= Decrypt(y + key[6]);
+				y ^= Decrypt(x + key[5]);
+				x ^= Decrypt(y + key[4]);
+				y ^= Decrypt(x + key[3]);
+				x ^= Decrypt(y + key[2]);
+				y ^= Decrypt(x + key[1]);
+				x ^= Decrypt(y + key[0]);
 			}
 
 			o0 = y;
 			o1 = x;
 		}
 
-		uint decrypt(uint val) {
+		uint Decrypt(uint val) {
 			uint x = (uint)((gen1[(byte)(val >> 24)] << 24) |
 				(gen2[(byte)(val >> 16)] << 16) |
 				(gen3[(byte)(val >> 8)] << 8) |
 				gen4[(byte)val]);
-			return ror(x, 21);
+			return Ror(x, 21);
 		}
 
-		static uint ror(uint val, int n) {
+		static uint Ror(uint val, int n) {
 			return (val << (32 - n)) + (val >> n);
 		}
 	}
diff --git a/de4dot.code/deobfuscators/MaxtoCode/Deobfuscator.cs b/de4dot.code/deobfuscators/MaxtoCode/Deobfuscator.cs
index c75722d5..47bff0f6 100644
--- a/de4dot.code/deobfuscators/MaxtoCode/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/MaxtoCode/Deobfuscator.cs
@@ -32,7 +32,7 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 
 		public DeobfuscatorInfo()
 			: base(DEFAULT_REGEX) {
-			stringCodePage = new IntOption(null, makeArgName("cp"), "String code page", 936);
+			stringCodePage = new IntOption(null, MakeArgName("cp"), "String code page", 936);
 		}
 
 		public override string Name {
@@ -43,7 +43,7 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			get { return THE_TYPE; }
 		}
 
-		public override IDeobfuscator createDeobfuscator() {
+		public override IDeobfuscator CreateDeobfuscator() {
 			return new Deobfuscator(new Deobfuscator.Options {
 				RenameResourcesInCode = false,
 				ValidNameRegex = validNameRegex.get(),
@@ -51,7 +51,7 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			});
 		}
 
-		protected override IEnumerable<Option> getOptionsInternal() {
+		protected override IEnumerable<Option> GetOptionsInternal() {
 			return new List<Option>() {
 				stringCodePage,
 			};
@@ -86,7 +86,7 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			StringFeatures = StringFeatures.AllowStaticDecryption | StringFeatures.AllowDynamicDecryption;
 		}
 
-		protected override int detectInternal() {
+		protected override int DetectInternal() {
 			int val = 0;
 
 			if (mainType.Detected)
@@ -95,29 +95,29 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			return val;
 		}
 
-		protected override void scanForObfuscator() {
+		protected override void ScanForObfuscator() {
 			mainType = new MainType(module);
-			mainType.find();
+			mainType.Find();
 		}
 
-		public override bool getDecryptedModule(int count, ref byte[] newFileData, ref DumpedMethods dumpedMethods) {
+		public override bool GetDecryptedModule(int count, ref byte[] newFileData, ref DumpedMethods dumpedMethods) {
 			if (count != 0 || !mainType.Detected)
 				return false;
 
-			var fileData = DeobUtils.readModule(module);
+			var fileData = DeobUtils.ReadModule(module);
 			decrypterInfo = new DecrypterInfo(mainType, fileData);
 			var methodsDecrypter = new MethodsDecrypter(decrypterInfo);
 
-			if (!methodsDecrypter.decrypt(ref dumpedMethods))
+			if (!methodsDecrypter.Decrypt(ref dumpedMethods))
 				return false;
 
 			newFileData = fileData;
 			return true;
 		}
 
-		public override IDeobfuscator moduleReloaded(ModuleDefMD module) {
+		public override IDeobfuscator ModuleReloaded(ModuleDefMD module) {
 			var newOne = new Deobfuscator(options);
-			newOne.setModule(module);
+			newOne.SetModule(module);
 			newOne.mainType = new MainType(module, mainType);
 			newOne.decrypterInfo = decrypterInfo;
 			decrypterInfo = null;
@@ -126,38 +126,38 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			return newOne;
 		}
 
-		void freePEImage() {
+		void FreePEImage() {
 			if (decrypterInfo != null)
 				decrypterInfo.Dispose();
 			decrypterInfo = null;
 		}
 
-		public override void deobfuscateBegin() {
-			base.deobfuscateBegin();
+		public override void DeobfuscateBegin() {
+			base.DeobfuscateBegin();
 
 			stringDecrypter = new StringDecrypter(decrypterInfo);
-			stringDecrypter.find();
+			stringDecrypter.Find();
 			if (stringDecrypter.Detected) {
-				stringDecrypter.initialize(getEncoding(options.StringCodePage));
-				staticStringInliner.add(stringDecrypter.Method, (method, gim, args) => stringDecrypter.decrypt((uint)args[0]));
-				DeobfuscatedFile.stringDecryptersAdded();
+				stringDecrypter.Initialize(GetEncoding(options.StringCodePage));
+				staticStringInliner.Add(stringDecrypter.Method, (method, gim, args) => stringDecrypter.Decrypt((uint)args[0]));
+				DeobfuscatedFile.StringDecryptersAdded();
 			}
 			else
-				freePEImage();
+				FreePEImage();
 
 			foreach (var method in mainType.InitMethods)
-				addCctorInitCallToBeRemoved(method);
-			addTypeToBeRemoved(mainType.Type, "Obfuscator type");
-			removeDuplicateEmbeddedResources();
-			removeInvalidResources();
+				AddCctorInitCallToBeRemoved(method);
+			AddTypeToBeRemoved(mainType.Type, "Obfuscator type");
+			RemoveDuplicateEmbeddedResources();
+			RemoveInvalidResources();
 		}
 
-		public override void deobfuscateEnd() {
-			freePEImage();
-			base.deobfuscateEnd();
+		public override void DeobfuscateEnd() {
+			FreePEImage();
+			base.DeobfuscateEnd();
 		}
 
-		static Encoding getEncoding(int cp) {
+		static Encoding GetEncoding(int cp) {
 			try {
 				return Encoding.GetEncoding(cp);
 			}
@@ -196,7 +196,7 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			}
 		}
 
-		void removeDuplicateEmbeddedResources() {
+		void RemoveDuplicateEmbeddedResources() {
 			var resources = new Dictionary<ResourceKey, List<EmbeddedResource>>();
 			foreach (var tmp in module.Resources) {
 				var rsrc = tmp as EmbeddedResource;
@@ -229,22 +229,22 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 				foreach (var rsrc in list) {
 					if (rsrc == resourceToKeep)
 						continue;
-					addResourceToBeRemoved(rsrc, string.Format("Duplicate of resource {0}", Utils.toCsharpString(resourceToKeep.Name)));
+					AddResourceToBeRemoved(rsrc, string.Format("Duplicate of resource {0}", Utils.ToCsharpString(resourceToKeep.Name)));
 				}
 			}
 		}
 
-		void removeInvalidResources() {
+		void RemoveInvalidResources() {
 			foreach (var tmp in module.Resources) {
 				var resource = tmp as EmbeddedResource;
 				if (resource == null)
 					continue;
 				if (resource.Offset == null || (resource.Data.FileOffset == 0 && resource.Data.Length == 0))
-					addResourceToBeRemoved(resource, "Invalid resource");
+					AddResourceToBeRemoved(resource, "Invalid resource");
 			}
 		}
 
-		public override IEnumerable<int> getStringDecrypterMethods() {
+		public override IEnumerable<int> GetStringDecrypterMethods() {
 			var list = new List<int>();
 			if (stringDecrypter != null && stringDecrypter.Detected)
 				list.Add(stringDecrypter.Method.MDToken.ToInt32());
@@ -253,7 +253,7 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 
 		protected override void Dispose(bool disposing) {
 			if (disposing)
-				freePEImage();
+				FreePEImage();
 			base.Dispose(disposing);
 		}
 	}
diff --git a/de4dot.code/deobfuscators/MaxtoCode/MainType.cs b/de4dot.code/deobfuscators/MaxtoCode/MainType.cs
index 86b9863a..76d0913c 100644
--- a/de4dot.code/deobfuscators/MaxtoCode/MainType.cs
+++ b/de4dot.code/deobfuscators/MaxtoCode/MainType.cs
@@ -42,7 +42,7 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 				if (mcType == null)
 					return list;
 				foreach (var method in mcType.Methods) {
-					if (method.IsStatic && DotNetUtils.isMethod(method, "System.Void", "()"))
+					if (method.IsStatic && DotNetUtils.IsMethod(method, "System.Void", "()"))
 						list.Add(method);
 				}
 				return list;
@@ -59,30 +59,30 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 
 		public MainType(ModuleDefMD module, MainType oldOne) {
 			this.module = module;
-			this.mcType = lookup(oldOne.mcType, "Could not find main type");
+			this.mcType = Lookup(oldOne.mcType, "Could not find main type");
 		}
 
-		T lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
-			return DeobUtils.lookup(module, def, errorMessage);
+		T Lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
+			return DeobUtils.Lookup(module, def, errorMessage);
 		}
 
-		public void find() {
-			foreach (var cctor in DeobUtils.getInitCctors(module, 3)) {
-				if (checkCctor(cctor))
+		public void Find() {
+			foreach (var cctor in DeobUtils.GetInitCctors(module, 3)) {
+				if (CheckCctor(cctor))
 					break;
 			}
 		}
 
-		bool checkCctor(MethodDef cctor) {
-			foreach (var method in DotNetUtils.getCalledMethods(module, cctor)) {
+		bool CheckCctor(MethodDef cctor) {
+			foreach (var method in DotNetUtils.GetCalledMethods(module, cctor)) {
 				if (method.Name != "Startup")
 					continue;
-				if (!DotNetUtils.isMethod(method, "System.Void", "()"))
+				if (!DotNetUtils.IsMethod(method, "System.Void", "()"))
 					continue;
 
 				ModuleRef module1, module2;
 				bool isOldTmp;
-				if (!checkType(method.DeclaringType, out module1, out module2, out isOldTmp))
+				if (!CheckType(method.DeclaringType, out module1, out module2, out isOldTmp))
 					continue;
 
 				mcType = method.DeclaringType;
@@ -93,29 +93,29 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			return false;
 		}
 
-		static bool checkType(TypeDef type, out ModuleRef module1, out ModuleRef module2, out bool isOld) {
+		static bool CheckType(TypeDef type, out ModuleRef module1, out ModuleRef module2, out bool isOld) {
 			module1 = module2 = null;
 			isOld = false;
 
 			if (type.FindMethod("Startup") == null)
 				return false;
 
-			var pinvokes = getPinvokes(type);
-			var pinvokeList = getPinvokeList(pinvokes, "CheckRuntime");
+			var pinvokes = GetPinvokes(type);
+			var pinvokeList = GetPinvokeList(pinvokes, "CheckRuntime");
 			if (pinvokeList == null)
 				return false;
-			if (getPinvokeList(pinvokes, "MainDLL") == null)
+			if (GetPinvokeList(pinvokes, "MainDLL") == null)
 				return false;
 
 			// Newer versions (3.4+ ???) also have GetModuleBase()
-			isOld = getPinvokeList(pinvokes, "GetModuleBase") == null;
+			isOld = GetPinvokeList(pinvokes, "GetModuleBase") == null;
 
 			module1 = pinvokeList[0].ImplMap.Module;
 			module2 = pinvokeList[1].ImplMap.Module;
 			return true;
 		}
 
-		static Dictionary<string, List<MethodDef>> getPinvokes(TypeDef type) {
+		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.ImplMap;
@@ -129,7 +129,7 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			return pinvokes;
 		}
 
-		static List<MethodDef> getPinvokeList(Dictionary<string, List<MethodDef>> pinvokes, string methodName) {
+		static List<MethodDef> GetPinvokeList(Dictionary<string, List<MethodDef>> pinvokes, string methodName) {
 			List<MethodDef> list;
 			if (!pinvokes.TryGetValue(methodName, out list))
 				return null;
diff --git a/de4dot.code/deobfuscators/MaxtoCode/McKey.cs b/de4dot.code/deobfuscators/MaxtoCode/McKey.cs
index 7e61e9a6..37b77e56 100644
--- a/de4dot.code/deobfuscators/MaxtoCode/McKey.cs
+++ b/de4dot.code/deobfuscators/MaxtoCode/McKey.cs
@@ -32,24 +32,24 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 		public McKey(MyPEImage peImage, PeHeader peHeader) {
 			this.peHeader = peHeader;
 			try {
-				this.data = peImage.readBytes(peHeader.getMcKeyRva(), 0x2000);
+				this.data = peImage.ReadBytes(peHeader.GetMcKeyRva(), 0x2000);
 			}
 			catch (IOException) {
-				this.data = peImage.readBytes(peHeader.getMcKeyRva(), 0x1000);
+				this.data = peImage.ReadBytes(peHeader.GetMcKeyRva(), 0x1000);
 			}
 		}
 
-		public byte[] readBytes(int offset, int len) {
+		public byte[] ReadBytes(int offset, int len) {
 			byte[] bytes = new byte[len];
 			Array.Copy(data, offset, bytes, 0, len);
 			return bytes;
 		}
 
-		public byte readByte(int offset) {
+		public byte ReadByte(int offset) {
 			return data[offset];
 		}
 
-		public uint readUInt32(int offset) {
+		public uint ReadUInt32(int offset) {
 			return BitConverter.ToUInt32(data, offset);
 		}
 	}
diff --git a/de4dot.code/deobfuscators/MaxtoCode/MethodsDecrypter.cs b/de4dot.code/deobfuscators/MaxtoCode/MethodsDecrypter.cs
index cf8be5d5..e97f7245 100644
--- a/de4dot.code/deobfuscators/MaxtoCode/MethodsDecrypter.cs
+++ b/de4dot.code/deobfuscators/MaxtoCode/MethodsDecrypter.cs
@@ -42,15 +42,15 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			List<IDecrypter> decrypters = new List<IDecrypter>();
 			const int ENCRYPTED_DATA_INFO_SIZE = 0x13;
 
-			delegate byte[] Decrypt(byte[] encrypted);
-			readonly Decrypt[] decryptHandlersV1;
-			readonly Decrypt[] decryptHandlersV2;
-			readonly Decrypt[] decryptHandlersV3;
-			readonly Decrypt[] decryptHandlersV4;
-			readonly Decrypt[] decryptHandlersV5a;
-			readonly Decrypt[] decryptHandlersV5b;
-			readonly Decrypt[] decryptHandlersV5c;
-			readonly Decrypt[] decryptHandlersV6a;
+			delegate byte[] DecryptFunc(byte[] encrypted);
+			readonly DecryptFunc[] decryptHandlersV1;
+			readonly DecryptFunc[] decryptHandlersV2;
+			readonly DecryptFunc[] decryptHandlersV3;
+			readonly DecryptFunc[] decryptHandlersV4;
+			readonly DecryptFunc[] decryptHandlersV5a;
+			readonly DecryptFunc[] decryptHandlersV5b;
+			readonly DecryptFunc[] decryptHandlersV5c;
+			readonly DecryptFunc[] decryptHandlersV6a;
 
 			public class DecryptedMethodInfo {
 				public uint bodyRva;
@@ -68,27 +68,27 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 				this.peHeader = peHeader;
 				this.mcKey = mcKey;
 
-				decryptHandlersV1 = new Decrypt[] { decrypt1a, decrypt4a, decrypt2a, decrypt3a, decrypt5, decrypt6, decrypt7 };
-				decryptHandlersV2 = new Decrypt[] { decrypt3a, decrypt2a, decrypt1a, decrypt4a, decrypt5, decrypt6, decrypt7 };
-				decryptHandlersV3 = new Decrypt[] { decrypt1a, decrypt2a, decrypt3a, decrypt4a, decrypt5, decrypt6, decrypt7 };
-				decryptHandlersV4 = new Decrypt[] { decrypt2a, decrypt1a, decrypt3a, decrypt4a, decrypt5, decrypt6, decrypt7 };
-				decryptHandlersV5a = new Decrypt[] { decrypt4a, decrypt2a, decrypt3a, decrypt1a, decrypt5, decrypt6, decrypt7 };
-				decryptHandlersV5b = new Decrypt[] { decrypt4b, decrypt2b, decrypt3b, decrypt1b, decrypt6, decrypt7, decrypt5 };
-				decryptHandlersV5c = new Decrypt[] { decrypt4c, decrypt2c, decrypt3c, decrypt1c, decrypt6, decrypt7, decrypt5 };
-				decryptHandlersV6a = new Decrypt[] { decrypt4d, decrypt2d, decrypt3d, decrypt1d, decrypt6, decrypt7, decrypt5 };
+				decryptHandlersV1 = new DecryptFunc[] { Decrypt1a, Decrypt4a, Decrypt2a, Decrypt3a, Decrypt5, Decrypt6, Decrypt7 };
+				decryptHandlersV2 = new DecryptFunc[] { Decrypt3a, Decrypt2a, Decrypt1a, Decrypt4a, Decrypt5, Decrypt6, Decrypt7 };
+				decryptHandlersV3 = new DecryptFunc[] { Decrypt1a, Decrypt2a, Decrypt3a, Decrypt4a, Decrypt5, Decrypt6, Decrypt7 };
+				decryptHandlersV4 = new DecryptFunc[] { Decrypt2a, Decrypt1a, Decrypt3a, Decrypt4a, Decrypt5, Decrypt6, Decrypt7 };
+				decryptHandlersV5a = new DecryptFunc[] { Decrypt4a, Decrypt2a, Decrypt3a, Decrypt1a, Decrypt5, Decrypt6, Decrypt7 };
+				decryptHandlersV5b = new DecryptFunc[] { Decrypt4b, Decrypt2b, Decrypt3b, Decrypt1b, Decrypt6, Decrypt7, Decrypt5 };
+				decryptHandlersV5c = new DecryptFunc[] { Decrypt4c, Decrypt2c, Decrypt3c, Decrypt1c, Decrypt6, Decrypt7, Decrypt5 };
+				decryptHandlersV6a = new DecryptFunc[] { Decrypt4d, Decrypt2d, Decrypt3d, Decrypt1d, Decrypt6, Decrypt7, Decrypt5 };
 
-				structSize = getStructSize(mcKey);
+				structSize = GetStructSize(mcKey);
 
-				uint methodInfosRva = peHeader.getRva(0x0FF8, mcKey.readUInt32(0x005A));
-				uint encryptedDataRva = peHeader.getRva(0x0FF0, mcKey.readUInt32(0x0046));
+				uint methodInfosRva = peHeader.GetRva(0x0FF8, mcKey.ReadUInt32(0x005A));
+				uint encryptedDataRva = peHeader.GetRva(0x0FF0, mcKey.ReadUInt32(0x0046));
 
-				methodInfosOffset = peImage.rvaToOffset(methodInfosRva);
-				encryptedDataOffset = peImage.rvaToOffset(encryptedDataRva);
+				methodInfosOffset = peImage.RvaToOffset(methodInfosRva);
+				encryptedDataOffset = peImage.RvaToOffset(encryptedDataRva);
 			}
 
-			static uint getStructSize(McKey mcKey) {
-				uint magicLo = mcKey.readUInt32(0x8C0);
-				uint magicHi = mcKey.readUInt32(0x8C4);
+			static uint GetStructSize(McKey mcKey) {
+				uint magicLo = mcKey.ReadUInt32(0x8C0);
+				uint magicHi = mcKey.ReadUInt32(0x8C4);
 				foreach (var info in EncryptionInfos.McKey8C0h) {
 					if (magicLo == info.MagicLo && magicHi == info.MagicHi)
 						return 0xC + 6 * ENCRYPTED_DATA_INFO_SIZE;
@@ -96,12 +96,12 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 				return 0xC + 3 * ENCRYPTED_DATA_INFO_SIZE;
 			}
 
-			EncryptionVersion getVersion() {
+			EncryptionVersion GetVersion() {
 				if (peHeader.EncryptionVersion != EncryptionVersion.Unknown)
 					return peHeader.EncryptionVersion;
 
-				uint m2lo = mcKey.readUInt32(0x8C0);
-				uint m2hi = mcKey.readUInt32(0x8C4);
+				uint m2lo = mcKey.ReadUInt32(0x8C0);
+				uint m2hi = mcKey.ReadUInt32(0x8C4);
 
 				foreach (var info in EncryptionInfos.McKey8C0h) {
 					if (info.MagicLo == m2lo && info.MagicHi == m2hi)
@@ -112,60 +112,60 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 				return EncryptionVersion.Unknown;
 			}
 
-			public DecryptedMethodInfo lookup(uint bodyRva) {
+			public DecryptedMethodInfo Lookup(uint bodyRva) {
 				DecryptedMethodInfo info;
 				infos.TryGetValue(bodyRva, out info);
 				return info;
 			}
 
-			byte readByte(uint offset) {
-				return peImage.offsetReadByte(methodInfosOffset + offset);
+			byte ReadByte(uint offset) {
+				return peImage.OffsetReadByte(methodInfosOffset + offset);
 			}
 
-			short readInt16(uint offset) {
-				return (short)peImage.offsetReadUInt16(methodInfosOffset + offset);
+			short ReadInt16(uint offset) {
+				return (short)peImage.OffsetReadUInt16(methodInfosOffset + offset);
 			}
 
-			uint readUInt32(uint offset) {
-				return peImage.offsetReadUInt32(methodInfosOffset + offset);
+			uint ReadUInt32(uint offset) {
+				return peImage.OffsetReadUInt32(methodInfosOffset + offset);
 			}
 
-			int readInt32(uint offset) {
-				return (int)readUInt32(offset);
+			int ReadInt32(uint offset) {
+				return (int)ReadUInt32(offset);
 			}
 
-			short readEncryptedInt16(uint offset) {
-				return (short)(readInt16(offset) ^ xorKey);
+			short ReadEncryptedInt16(uint offset) {
+				return (short)(ReadInt16(offset) ^ xorKey);
 			}
 
-			int readEncryptedInt32(uint offset) {
-				return (int)readEncryptedUInt32(offset);
+			int ReadEncryptedInt32(uint offset) {
+				return (int)ReadEncryptedUInt32(offset);
 			}
 
-			uint readEncryptedUInt32(uint offset) {
-				return readUInt32(offset) ^ xorKey;
+			uint ReadEncryptedUInt32(uint offset) {
+				return ReadUInt32(offset) ^ xorKey;
 			}
 
 			interface IDecrypter {
-				byte[] decrypt(int type, byte[] encrypted);
+				byte[] Decrypt(int type, byte[] encrypted);
 			}
 
 			class Decrypter : IDecrypter {
-				Decrypt[] decrypterHandlers;
+				DecryptFunc[] decrypterHandlers;
 
-				public Decrypter(Decrypt[] decrypterHandlers) {
+				public Decrypter(DecryptFunc[] decrypterHandlers) {
 					this.decrypterHandlers = decrypterHandlers;
 				}
 
-				public byte[] decrypt(int type, byte[] encrypted) {
+				public byte[] Decrypt(int type, byte[] encrypted) {
 					if (1 <= type && type <= decrypterHandlers.Length)
 						return decrypterHandlers[type - 1](encrypted);
 					throw new ApplicationException(string.Format("Invalid encryption type: {0:X2}", type));
 				}
 			}
 
-			void initializeDecrypter() {
-				switch (getVersion()) {
+			void InitializeDecrypter() {
+				switch (GetVersion()) {
 				case EncryptionVersion.V1: decrypters.Add(new Decrypter(decryptHandlersV1)); break;
 				case EncryptionVersion.V2: decrypters.Add(new Decrypter(decryptHandlersV2)); break;
 				case EncryptionVersion.V3: decrypters.Add(new Decrypter(decryptHandlersV3)); break;
@@ -185,16 +185,16 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 				}
 			}
 
-			public void initializeInfos() {
-				initializeDecrypter();
-				if (!initializeInfos2())
+			public void InitializeInfos() {
+				InitializeDecrypter();
+				if (!InitializeInfos2())
 					throw new ApplicationException("Could not decrypt methods");
 			}
 
-			bool initializeInfos2() {
+			bool InitializeInfos2() {
 				foreach (var decrypter in decrypters) {
 					try {
-						if (initializeInfos2(decrypter))
+						if (InitializeInfos2(decrypter))
 							return true;
 					}
 					catch {
@@ -203,8 +203,8 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 				return false;
 			}
 
-			bool initializeInfos2(IDecrypter decrypter) {
-				int numMethods = readInt32(0) ^ readInt32(4);
+			bool InitializeInfos2(IDecrypter decrypter) {
+				int numMethods = ReadInt32(0) ^ ReadInt32(4);
 				if (numMethods < 0)
 					throw new ApplicationException("Invalid number of encrypted methods");
 
@@ -214,9 +214,9 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 
 				uint offset = 8;
 				for (int i = 0; i < numMethods; i++, offset += structSize) {
-					uint methodBodyRva = readEncryptedUInt32(offset);
-					uint totalSize = readEncryptedUInt32(offset + 4);
-					uint methodInstructionRva = readEncryptedUInt32(offset + 8);
+					uint methodBodyRva = ReadEncryptedUInt32(offset);
+					uint totalSize = ReadEncryptedUInt32(offset + 4);
+					uint methodInstructionRva = ReadEncryptedUInt32(offset + 8);
 
 					// Read the method body header and method body (instrs + exception handlers).
 					// The method body header is always in the first one. The instrs + ex handlers
@@ -226,26 +226,26 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 					int exOffset = 0;
 					for (int j = 0; j < encryptedDataInfos.Length; j++, offset2 += ENCRYPTED_DATA_INFO_SIZE) {
 						// readByte(offset2); <-- index
-						int encryptionType = readEncryptedInt16(offset2 + 1);
-						uint dataOffset = readEncryptedUInt32(offset2 + 3);
-						uint encryptedSize = readEncryptedUInt32(offset2 + 7);
-						uint realSize = readEncryptedUInt32(offset2 + 11);
+						int encryptionType = ReadEncryptedInt16(offset2 + 1);
+						uint dataOffset = ReadEncryptedUInt32(offset2 + 3);
+						uint encryptedSize = ReadEncryptedUInt32(offset2 + 7);
+						uint realSize = ReadEncryptedUInt32(offset2 + 11);
 						if (j == 1)
-							exOffset = readEncryptedInt32(offset2 + 15);
+							exOffset = ReadEncryptedInt32(offset2 + 15);
 						if (j == 1 && exOffset == 0)
 							encryptedDataInfos[j] = null;
 						else
-							encryptedDataInfos[j] = decrypt(decrypter, encryptionType, dataOffset, encryptedSize, realSize);
+							encryptedDataInfos[j] = Decrypt(decrypter, encryptionType, dataOffset, encryptedSize, realSize);
 					}
 
 					var decryptedData = new byte[totalSize];
 					int copyOffset = 0;
-					copyOffset = copyData(decryptedData, encryptedDataInfos[0], copyOffset);
+					copyOffset = CopyData(decryptedData, encryptedDataInfos[0], copyOffset);
 					for (int j = 2; j < encryptedDataInfos.Length; j++)
-						copyOffset = copyData(decryptedData, encryptedDataInfos[j], copyOffset);
-					copyData(decryptedData, encryptedDataInfos[1], exOffset); // Exceptions or padding
+						copyOffset = CopyData(decryptedData, encryptedDataInfos[j], copyOffset);
+					CopyData(decryptedData, encryptedDataInfos[1], exOffset); // Exceptions or padding
 
-					if (!MethodBodyParser.verify(decryptedData))
+					if (!MethodBodyParser.Verify(decryptedData))
 						throw new InvalidMethodBody();
 
 					var info = new DecryptedMethodInfo(methodBodyRva, decryptedData);
@@ -255,78 +255,78 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 				return true;
 			}
 
-			static int copyData(byte[] dest, byte[] source, int offset) {
+			static int CopyData(byte[] dest, byte[] source, int offset) {
 				if (source == null)
 					return offset;
 				Array.Copy(source, 0, dest, offset, source.Length);
 				return offset + source.Length;
 			}
 
-			byte[] readData(uint offset, int size) {
-				return peImage.offsetReadBytes(encryptedDataOffset + offset, size);
+			byte[] ReadData(uint offset, int size) {
+				return peImage.OffsetReadBytes(encryptedDataOffset + offset, size);
 			}
 
-			byte[] decrypt(IDecrypter decrypter, int type, uint dataOffset, uint encryptedSize, uint realSize) {
+			byte[] Decrypt(IDecrypter decrypter, int type, uint dataOffset, uint encryptedSize, uint realSize) {
 				if (realSize == 0)
 					return null;
 				if (realSize > encryptedSize)
 					throw new ApplicationException("Invalid realSize");
 
-				var encrypted = readData(dataOffset, (int)encryptedSize);
-				var decrypted = decrypter.decrypt(type, encrypted);
+				var encrypted = ReadData(dataOffset, (int)encryptedSize);
+				var decrypted = decrypter.Decrypt(type, encrypted);
 				if (realSize > decrypted.Length)
 					throw new ApplicationException("Invalid decrypted length");
 				Array.Resize(ref decrypted, (int)realSize);
 				return decrypted;
 			}
 
-			byte[] decrypt1a(byte[] encrypted) {
-				return decrypt1(encrypted, 0, 0, 0x2000);
+			byte[] Decrypt1a(byte[] encrypted) {
+				return Decrypt1(encrypted, 0, 0, 0x2000);
 			}
 
-			byte[] decrypt1b(byte[] encrypted) {
-				return decrypt1(encrypted, 6, 6, 0x500);
+			byte[] Decrypt1b(byte[] encrypted) {
+				return Decrypt1(encrypted, 6, 6, 0x500);
 			}
 
-			byte[] decrypt1c(byte[] encrypted) {
-				return decrypt1(encrypted, 6, 0, 0x1000);
+			byte[] Decrypt1c(byte[] encrypted) {
+				return Decrypt1(encrypted, 6, 0, 0x1000);
 			}
 
-			byte[] decrypt1d(byte[] encrypted) {
-				return decrypt1(encrypted, 5, 5, 0x500);
+			byte[] Decrypt1d(byte[] encrypted) {
+				return Decrypt1(encrypted, 5, 5, 0x500);
 			}
 
-			byte[] decrypt1(byte[] encrypted, int keyStart, int keyReset, int keyEnd) {
+			byte[] Decrypt1(byte[] encrypted, int keyStart, int keyReset, int keyEnd) {
 				var decrypted = new byte[encrypted.Length];
 				for (int i = 0, ki = keyStart; i < decrypted.Length; i++) {
-					decrypted[i] = (byte)(encrypted[i] ^ mcKey.readByte(ki));
+					decrypted[i] = (byte)(encrypted[i] ^ mcKey.ReadByte(ki));
 					if (++ki == keyEnd)
 						ki = keyReset;
 				}
 				return decrypted;
 			}
 
-			byte[] decrypt2a(byte[] encrypted) {
-				return decrypt2(encrypted, 0x00FA);
+			byte[] Decrypt2a(byte[] encrypted) {
+				return Decrypt2(encrypted, 0x00FA);
 			}
 
-			byte[] decrypt2b(byte[] encrypted) {
-				return decrypt2(encrypted, 0x00FA + 9);
+			byte[] Decrypt2b(byte[] encrypted) {
+				return Decrypt2(encrypted, 0x00FA + 9);
 			}
 
-			byte[] decrypt2c(byte[] encrypted) {
-				return decrypt2(encrypted, 0x00FA + 0x24);
+			byte[] Decrypt2c(byte[] encrypted) {
+				return Decrypt2(encrypted, 0x00FA + 0x24);
 			}
 
-			byte[] decrypt2d(byte[] encrypted) {
-				return decrypt2(encrypted, 0x00FA + 7);
+			byte[] Decrypt2d(byte[] encrypted) {
+				return Decrypt2(encrypted, 0x00FA + 7);
 			}
 
-			byte[] decrypt2(byte[] encrypted, int offset) {
+			byte[] Decrypt2(byte[] encrypted, int offset) {
 				if ((encrypted.Length & 7) != 0)
 					throw new ApplicationException("Invalid encryption #2 length");
-				uint key4 = mcKey.readUInt32(offset + 4 * 4);
-				uint key5 = mcKey.readUInt32(offset + 5 * 4);
+				uint key4 = mcKey.ReadUInt32(offset + 4 * 4);
+				uint key5 = mcKey.ReadUInt32(offset + 5 * 4);
 
 				byte[] decrypted = new byte[encrypted.Length & ~7];
 				var writer = new BinaryWriter(new MemoryStream(decrypted));
@@ -345,28 +345,28 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 				return decrypted;
 			}
 
-			byte[] decrypt3a(byte[] encrypted) {
-				return decrypt3(encrypted, 0x015E);
+			byte[] Decrypt3a(byte[] encrypted) {
+				return Decrypt3(encrypted, 0x015E);
 			}
 
-			byte[] decrypt3b(byte[] encrypted) {
-				return decrypt3(encrypted, 0x015E + 0xE5);
+			byte[] Decrypt3b(byte[] encrypted) {
+				return Decrypt3(encrypted, 0x015E + 0xE5);
 			}
 
-			byte[] decrypt3c(byte[] encrypted) {
-				return decrypt3(encrypted, 0x015E + 0x28);
+			byte[] Decrypt3c(byte[] encrypted) {
+				return Decrypt3(encrypted, 0x015E + 0x28);
 			}
 
-			byte[] decrypt3d(byte[] encrypted) {
-				return decrypt3(encrypted, 0x015E + 8);
+			byte[] Decrypt3d(byte[] encrypted) {
+				return Decrypt3(encrypted, 0x015E + 8);
 			}
 
 			static readonly byte[] decrypt3Shifts = new byte[16] { 5, 11, 14, 21, 6, 20, 17, 29, 4, 10, 3, 2, 7, 1, 26, 18 };
-			byte[] decrypt3(byte[] encrypted, int offset) {
+			byte[] Decrypt3(byte[] encrypted, int offset) {
 				if ((encrypted.Length & 7) != 0)
 					throw new ApplicationException("Invalid encryption #3 length");
-				uint key0 = mcKey.readUInt32(offset + 0 * 4);
-				uint key3 = mcKey.readUInt32(offset + 3 * 4);
+				uint key0 = mcKey.ReadUInt32(offset + 0 * 4);
+				uint key3 = mcKey.ReadUInt32(offset + 3 * 4);
 
 				byte[] decrypted = new byte[encrypted.Length & ~7];
 				var writer = new BinaryWriter(new MemoryStream(decrypted));
@@ -390,31 +390,31 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 				return decrypted;
 			}
 
-			byte[] decrypt4a(byte[] encrypted) {
-				return decrypt4(encrypted, 0, 0, 0x2000);
+			byte[] Decrypt4a(byte[] encrypted) {
+				return Decrypt4(encrypted, 0, 0, 0x2000);
 			}
 
-			byte[] decrypt4b(byte[] encrypted) {
-				return decrypt4(encrypted, 0x14, 0x14, 0x1000);
+			byte[] Decrypt4b(byte[] encrypted) {
+				return Decrypt4(encrypted, 0x14, 0x14, 0x1000);
 			}
 
-			byte[] decrypt4c(byte[] encrypted) {
-				return decrypt4(encrypted, 5, 0, 0x2000);
+			byte[] Decrypt4c(byte[] encrypted) {
+				return Decrypt4(encrypted, 5, 0, 0x2000);
 			}
 
-			byte[] decrypt4d(byte[] encrypted) {
-				return decrypt4(encrypted, 0x0B, 0x0B, 0x1000);
+			byte[] Decrypt4d(byte[] encrypted) {
+				return Decrypt4(encrypted, 0x0B, 0x0B, 0x1000);
 			}
 
-			byte[] decrypt4(byte[] encrypted, int keyStart, int keyReset, int keyEnd) {
+			byte[] Decrypt4(byte[] encrypted, int keyStart, int keyReset, int keyEnd) {
 				var decrypted = new byte[encrypted.Length / 3 * 2 + 1];
 
 				int count = encrypted.Length / 3;
 				int i = 0, ki = keyStart, j = 0;
 				while (count-- > 0) {
-					byte k1 = mcKey.readByte(ki + 1);
-					byte k2 = mcKey.readByte(ki + 2);
-					byte k3 = mcKey.readByte(ki + 3);
+					byte k1 = mcKey.ReadByte(ki + 1);
+					byte k2 = mcKey.ReadByte(ki + 2);
+					byte k3 = mcKey.ReadByte(ki + 3);
 					decrypted[j++] = (byte)(((encrypted[i + 1] ^ k2) >> 4) | ((encrypted[i] ^ k1) & 0xF0));
 					decrypted[j++] = (byte)(((encrypted[i + 1] ^ k2) << 4) + ((encrypted[i + 2] ^ k3) & 0x0F));
 					i += 3;
@@ -424,33 +424,33 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 				}
 
 				if ((encrypted.Length % 3) != 0)
-					decrypted[j] = (byte)(encrypted[i] ^ mcKey.readByte(ki));
+					decrypted[j] = (byte)(encrypted[i] ^ mcKey.ReadByte(ki));
 
 				return decrypted;
 			}
 
-			byte[] decrypt5(byte[] encrypted) {
-				return CryptDecrypter.decrypt(mcKey.readBytes(0x0032, 15), encrypted);
+			byte[] Decrypt5(byte[] encrypted) {
+				return CryptDecrypter.Decrypt(mcKey.ReadBytes(0x0032, 15), encrypted);
 			}
 
-			byte[] decrypt6(byte[] encrypted) {
-				return Decrypter6.decrypt(mcKey.readBytes(0x0096, 32), encrypted);
+			byte[] Decrypt6(byte[] encrypted) {
+				return Decrypter6.Decrypt(mcKey.ReadBytes(0x0096, 32), encrypted);
 			}
 
-			byte[] decrypt7(byte[] encrypted) {
+			byte[] Decrypt7(byte[] encrypted) {
 				var decrypted = (byte[])encrypted.Clone();
-				new Blowfish(getBlowfishKey()).decrypt_LE(decrypted);
+				new Blowfish(GetBlowfishKey()).Decrypt_LE(decrypted);
 				return decrypted;
 			}
 
 			byte[] blowfishKey;
-			byte[] getBlowfishKey() {
+			byte[] GetBlowfishKey() {
 				if (blowfishKey != null)
 					return blowfishKey;
 				var key = new byte[100];
 				int i;
 				for (i = 0; i < key.Length; i++) {
-					byte b = mcKey.readByte(i);
+					byte b = mcKey.ReadByte(i);
 					if (b == 0)
 						break;
 					key[i] = b;
@@ -466,54 +466,54 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			this.decrypterInfo = decrypterInfo;
 		}
 
-		public bool decrypt(ref DumpedMethods dumpedMethods) {
-			dumpedMethods = decryptMethods();
+		public bool Decrypt(ref DumpedMethods dumpedMethods) {
+			dumpedMethods = DecryptMethods();
 			if (dumpedMethods == null)
 				return false;
 
-			decryptResources();
-			decryptStrings();
+			DecryptResources();
+			DecryptStrings();
 
 			return true;
 		}
 
-		DumpedMethods decryptMethods() {
+		DumpedMethods DecryptMethods() {
 			var dumpedMethods = new DumpedMethods();
 
 			var peImage = decrypterInfo.peImage;
 			var methodInfos = new MethodInfos(decrypterInfo.mainType, peImage, decrypterInfo.peHeader, decrypterInfo.mcKey);
-			methodInfos.initializeInfos();
+			methodInfos.InitializeInfos();
 
 			var methodDef = peImage.DotNetFile.MetaData.TablesStream.MethodTable;
 			for (uint rid = 1; rid <= methodDef.Rows; rid++) {
 				var dm = new DumpedMethod();
-				peImage.readMethodTableRowTo(dm, rid);
+				peImage.ReadMethodTableRowTo(dm, rid);
 
-				var info = methodInfos.lookup(dm.mdRVA);
+				var info = methodInfos.Lookup(dm.mdRVA);
 				if (info == null)
 					continue;
 
-				ushort magic = peImage.readUInt16(dm.mdRVA);
+				ushort magic = peImage.ReadUInt16(dm.mdRVA);
 				if (magic != 0xFFF3)
 					continue;
 
-				var mbHeader = MethodBodyParser.parseMethodBody(MemoryImageStream.Create(info.body), out dm.code, out dm.extraSections);
-				peImage.updateMethodHeaderInfo(dm, mbHeader);
+				var mbHeader = MethodBodyParser.ParseMethodBody(MemoryImageStream.Create(info.body), out dm.code, out dm.extraSections);
+				peImage.UpdateMethodHeaderInfo(dm, mbHeader);
 
-				dumpedMethods.add(dm);
+				dumpedMethods.Add(dm);
 			}
 
 			return dumpedMethods;
 		}
 
-		void decryptResources() {
+		void DecryptResources() {
 			var peHeader = decrypterInfo.peHeader;
 			var mcKey = decrypterInfo.mcKey;
 			var peImage = decrypterInfo.peImage;
 			var fileData = decrypterInfo.fileData;
 
-			uint resourceRva = peHeader.getRva(0x0E10, mcKey.readUInt32(0x00A0));
-			uint resourceSize = peHeader.readUInt32(0x0E14) ^ mcKey.readUInt32(0x00AA);
+			uint resourceRva = peHeader.GetRva(0x0E10, mcKey.ReadUInt32(0x00A0));
+			uint resourceSize = peHeader.ReadUInt32(0x0E14) ^ mcKey.ReadUInt32(0x00AA);
 			if (resourceRva == 0 || resourceSize == 0)
 				return;
 			if (resourceRva != (uint)peImage.Cor20Header.Resources.VirtualAddress ||
@@ -523,33 +523,33 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 
 			Logger.v("Decrypting resources @ RVA {0:X8}, {1} bytes", resourceRva, resourceSize);
 
-			int resourceOffset = (int)peImage.rvaToOffset(resourceRva);
+			int resourceOffset = (int)peImage.RvaToOffset(resourceRva);
 			for (int i = 0; i < resourceSize; i++)
 				fileData[resourceOffset + i] ^= mcKey[i % 0x2000];
 		}
 
-		void decryptStrings() {
+		void DecryptStrings() {
 			var peHeader = decrypterInfo.peHeader;
 			var mcKey = decrypterInfo.mcKey;
 			var peImage = decrypterInfo.peImage;
 			var fileData = decrypterInfo.fileData;
 
-			uint usHeapRva = peHeader.getRva(0x0E00, mcKey.readUInt32(0x0078));
-			uint usHeapSize = peHeader.readUInt32(0x0E04) ^ mcKey.readUInt32(0x0082);
+			uint usHeapRva = peHeader.GetRva(0x0E00, mcKey.ReadUInt32(0x0078));
+			uint usHeapSize = peHeader.ReadUInt32(0x0E04) ^ mcKey.ReadUInt32(0x0082);
 			if (usHeapRva == 0 || usHeapSize == 0)
 				return;
 			var usHeap = peImage.DotNetFile.MetaData.USStream;
 			if (usHeap.StartOffset == 0 ||	// Start offset is 0 if it's not present in the file
-				peImage.rvaToOffset(usHeapRva) != (uint)usHeap.StartOffset ||
+				peImage.RvaToOffset(usHeapRva) != (uint)usHeap.StartOffset ||
 				usHeapSize != (uint)(usHeap.EndOffset - usHeap.StartOffset)) {
 				Logger.w("Invalid #US heap RVA and size found");
 			}
 
 			Logger.v("Decrypting strings @ RVA {0:X8}, {1} bytes", usHeapRva, usHeapSize);
-			Logger.Instance.indent();
+			Logger.Instance.Indent();
 
 			int mcKeyOffset = 0;
-			int usHeapOffset = (int)peImage.rvaToOffset(usHeapRva);
+			int usHeapOffset = (int)peImage.RvaToOffset(usHeapRva);
 			int usHeapEnd = usHeapOffset + (int)usHeapSize;
 			usHeapOffset++;
 			while (usHeapOffset < usHeapEnd) {
@@ -559,17 +559,17 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 				}
 
 				int usHeapOffsetOrig = usHeapOffset;
-				int stringDataLength = DeobUtils.readVariableLengthInt32(fileData, ref usHeapOffset);
+				int stringDataLength = DeobUtils.ReadVariableLengthInt32(fileData, ref usHeapOffset);
 				int usHeapOffsetString = usHeapOffset;
 				int encryptedLength = stringDataLength - (usHeapOffset - usHeapOffsetOrig == 1 ? 1 : 2);
 				for (int i = 0; i < encryptedLength; i++) {
-					byte k = mcKey.readByte(mcKeyOffset++ % 0x2000);
-					fileData[usHeapOffset] = rolb((byte)(fileData[usHeapOffset] ^ k), 3);
+					byte k = mcKey.ReadByte(mcKeyOffset++ % 0x2000);
+					fileData[usHeapOffset] = Rolb((byte)(fileData[usHeapOffset] ^ k), 3);
 					usHeapOffset++;
 				}
 
 				try {
-					Logger.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 {
 					Logger.v("Could not decrypt string at offset {0:X8}", usHeapOffsetOrig);
@@ -578,10 +578,10 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 				usHeapOffset++;
 			}
 
-			Logger.Instance.deIndent();
+			Logger.Instance.DeIndent();
 		}
 
-		byte rolb(byte b, int n) {
+		byte Rolb(byte b, int n) {
 			return (byte)((b << n) | (b >> (8 - n)));
 		}
 	}
diff --git a/de4dot.code/deobfuscators/MaxtoCode/PeHeader.cs b/de4dot.code/deobfuscators/MaxtoCode/PeHeader.cs
index 7fd567b3..e8d8d1c8 100644
--- a/de4dot.code/deobfuscators/MaxtoCode/PeHeader.cs
+++ b/de4dot.code/deobfuscators/MaxtoCode/PeHeader.cs
@@ -41,7 +41,7 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 
 		public PeHeader(MainType mainType, MyPEImage peImage) {
 			uint headerOffset;
-			version = getHeaderOffsetAndVersion(peImage, out headerOffset);
+			version = GetHeaderOffsetAndVersion(peImage, out headerOffset);
 
 			switch (version) {
 			case EncryptionVersion.V1:
@@ -58,36 +58,36 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 				break;
 			}
 
-			headerData = peImage.offsetReadBytes(headerOffset, 0x1000);
+			headerData = peImage.OffsetReadBytes(headerOffset, 0x1000);
 		}
 
-		public uint getMcKeyRva() {
-			return getRva(0x0FFC, xorKey);
+		public uint GetMcKeyRva() {
+			return GetRva(0x0FFC, xorKey);
 		}
 
-		public uint getRva(int offset, uint xorKey) {
-			return readUInt32(offset) ^ xorKey;
+		public uint GetRva(int offset, uint xorKey) {
+			return ReadUInt32(offset) ^ xorKey;
 		}
 
-		public uint readUInt32(int offset) {
+		public uint ReadUInt32(int offset) {
 			return BitConverter.ToUInt32(headerData, offset);
 		}
 
-		static EncryptionVersion getHeaderOffsetAndVersion(MyPEImage peImage, out uint headerOffset) {
+		static EncryptionVersion GetHeaderOffsetAndVersion(MyPEImage peImage, out uint headerOffset) {
 			headerOffset = 0;
 
-			var version = getVersion(peImage, headerOffset);
+			var version = GetVersion(peImage, headerOffset);
 			if (version != EncryptionVersion.Unknown)
 				return version;
 
-			var section = peImage.findSection(".rsrc");
+			var section = peImage.FindSection(".rsrc");
 			if (section == null)
 				return EncryptionVersion.Unknown;
 
 			headerOffset = section.PointerToRawData;
 			uint end = section.PointerToRawData + section.SizeOfRawData - 0x1000 + 1;
 			while (headerOffset < end) {
-				version = getVersion(peImage, headerOffset);
+				version = GetVersion(peImage, headerOffset);
 				if (version != EncryptionVersion.Unknown)
 					return version;
 				headerOffset++;
@@ -96,9 +96,9 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			return EncryptionVersion.Unknown;
 		}
 
-		static EncryptionVersion getVersion(MyPEImage peImage, uint headerOffset) {
-			uint m1lo = peImage.offsetReadUInt32(headerOffset + 0x900);
-			uint m1hi = peImage.offsetReadUInt32(headerOffset + 0x904);
+		static EncryptionVersion GetVersion(MyPEImage peImage, uint headerOffset) {
+			uint m1lo = peImage.OffsetReadUInt32(headerOffset + 0x900);
+			uint m1hi = peImage.OffsetReadUInt32(headerOffset + 0x904);
 
 			foreach (var info in EncryptionInfos.Rva900h) {
 				if (info.MagicLo == m1lo && info.MagicHi == m1hi)
diff --git a/de4dot.code/deobfuscators/MaxtoCode/StringDecrypter.cs b/de4dot.code/deobfuscators/MaxtoCode/StringDecrypter.cs
index 7ed30ef5..7ad0f443 100644
--- a/de4dot.code/deobfuscators/MaxtoCode/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/MaxtoCode/StringDecrypter.cs
@@ -42,23 +42,23 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			this.decrypterInfo = decrypterInfo;
 		}
 
-		public void find() {
+		public void Find() {
 			if (decrypterInfo == null)
 				return;
-			decryptMethod = findDecryptMethod(decrypterInfo.mainType.Type);
+			decryptMethod = FindDecryptMethod(decrypterInfo.mainType.Type);
 			if (decryptMethod == null)
 				return;
 		}
 
-		static MethodDef findDecryptMethod(TypeDef type) {
+		static MethodDef FindDecryptMethod(TypeDef type) {
 			if (type == null)
 				return null;
 			foreach (var method in type.Methods) {
 				if (method.Body == null || !method.IsStatic || method.IsPrivate)
 					continue;
-				if (!DotNetUtils.isMethod(method, "System.String", "(System.UInt32)"))
+				if (!DotNetUtils.IsMethod(method, "System.String", "(System.UInt32)"))
 					continue;
-				if (!DotNetUtils.callsMethod(method, "System.String System.Runtime.InteropServices.Marshal::PtrToStringAnsi(System.IntPtr)"))
+				if (!DotNetUtils.CallsMethod(method, "System.String System.Runtime.InteropServices.Marshal::PtrToStringAnsi(System.IntPtr)"))
 					continue;
 
 				return method;
@@ -66,11 +66,11 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			return null;
 		}
 
-		public void initialize(Encoding encoding) {
+		public void Initialize(Encoding encoding) {
 			this.encoding = encoding;
 		}
 
-		void initializeStrings() {
+		void InitializeStrings() {
 			if (decryptedStrings != null)
 				return;
 			var peImage = decrypterInfo.peImage;
@@ -78,31 +78,31 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			var mcKey = decrypterInfo.mcKey;
 			var fileData = decrypterInfo.fileData;
 
-			var stringsRva = peHeader.getRva(0x0AF0, mcKey.readUInt32(0x46));
+			var stringsRva = peHeader.GetRva(0x0AF0, mcKey.ReadUInt32(0x46));
 			if (stringsRva == 0)
 				return;
-			int stringsOffset = (int)peImage.rvaToOffset(stringsRva);
+			int stringsOffset = (int)peImage.RvaToOffset(stringsRva);
 
-			int numStrings = peImage.readInt32(stringsRva) ^ (int)mcKey.readUInt32(0);
+			int numStrings = peImage.ReadInt32(stringsRva) ^ (int)mcKey.ReadUInt32(0);
 			decryptedStrings = new string[numStrings];
 			for (int i = 0, ki = 2, soffs = stringsOffset + 4; i < numStrings; i++) {
-				int stringLen = BitConverter.ToInt32(fileData, soffs) ^ (int)mcKey.readUInt32(ki);
+				int stringLen = BitConverter.ToInt32(fileData, soffs) ^ (int)mcKey.ReadUInt32(ki);
 				ki += 2;
 				if (ki >= 0x1FF0)
 					ki = 0;
 				soffs += 4;
 				var bytes = new byte[stringLen];
 				for (int j = 0; j < stringLen; j++, soffs++) {
-					byte b = (byte)(fileData[soffs] ^ mcKey.readByte(ki));
-					ki = add(ki, 1);
+					byte b = (byte)(fileData[soffs] ^ mcKey.ReadByte(ki));
+					ki = Add(ki, 1);
 					bytes[j] = b;
 				}
 
-				decryptedStrings[i] = decode(bytes);
+				decryptedStrings[i] = Decode(bytes);
 			}
 		}
 
-		string decode(byte[] bytes) {
+		string Decode(byte[] bytes) {
 			string s = encoding.GetString(bytes);
 			int len = s.Length;
 			if (len == 0 || s[len - 1] != 0)
@@ -116,12 +116,12 @@ namespace de4dot.code.deobfuscators.MaxtoCode {
 			return s.Substring(0, len);
 		}
 
-		static int add(int ki, int size) {
+		static int Add(int ki, int size) {
 			return (ki + size) % 0x1FF0;
 		}
 
-		public string decrypt(uint id) {
-			initializeStrings();
+		public string Decrypt(uint id) {
+			InitializeStrings();
 			return decryptedStrings[(int)id - 1];
 		}
 	}
diff --git a/de4dot.code/deobfuscators/MemberReferenceBuilder.cs b/de4dot.code/deobfuscators/MemberReferenceBuilder.cs
index 4348652a..58bbb7eb 100644
--- a/de4dot.code/deobfuscators/MemberReferenceBuilder.cs
+++ b/de4dot.code/deobfuscators/MemberReferenceBuilder.cs
@@ -107,45 +107,45 @@ namespace de4dot.code.deobfuscators {
 			get { return module.CorLibTypes.TypedReference; }
 		}
 
-		public ClassSig type(string ns, string name, string asmSimpleName) {
-			return type(ns, name, findAssemblyRef(asmSimpleName));
+		public ClassSig Type(string ns, string name, string asmSimpleName) {
+			return Type(ns, name, FindAssemblyRef(asmSimpleName));
 		}
 
-		public ClassSig type(string ns, string name) {
-			return type(ns, name, CorLib);
+		public ClassSig Type(string ns, string name) {
+			return Type(ns, name, CorLib);
 		}
 
-		public ClassSig type(string ns, string name, AssemblyRef asmRef) {
-			return (ClassSig)type(false, ns, name, asmRef);
+		public ClassSig Type(string ns, string name, AssemblyRef asmRef) {
+			return (ClassSig)Type(false, ns, name, asmRef);
 		}
 
-		public ValueTypeSig valueType(string ns, string name, string asmSimpleName) {
-			return valueType(ns, name, findAssemblyRef(asmSimpleName));
+		public ValueTypeSig ValueType(string ns, string name, string asmSimpleName) {
+			return ValueType(ns, name, FindAssemblyRef(asmSimpleName));
 		}
 
-		public ValueTypeSig valueType(string ns, string name) {
-			return valueType(ns, name, CorLib);
+		public ValueTypeSig ValueType(string ns, string name) {
+			return ValueType(ns, name, CorLib);
 		}
 
-		public ValueTypeSig valueType(string ns, string name, AssemblyRef asmRef) {
-			return (ValueTypeSig)type(true, ns, name, asmRef);
+		public ValueTypeSig ValueType(string ns, string name, AssemblyRef asmRef) {
+			return (ValueTypeSig)Type(true, ns, name, asmRef);
 		}
 
-		public ClassOrValueTypeSig type(bool isValueType, string ns, string name, IResolutionScope resolutionScope) {
+		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);
+			return (ClassOrValueTypeSig)Add(type);
 		}
 
-		public SZArraySig array(TypeSig typeRef) {
-			return (SZArraySig)add(new SZArraySig(typeRef));
+		public SZArraySig Array(TypeSig typeRef) {
+			return (SZArraySig)Add(new SZArraySig(typeRef));
 		}
 
-		TypeSig add(TypeSig typeRef) {
+		TypeSig Add(TypeSig typeRef) {
 			TypeSig createdTypeRef;
 			if (createdTypes.TryGetValue(typeRef, out createdTypeRef)) {
 				if (createdTypeRef.ElementType != typeRef.ElementType)
@@ -156,15 +156,15 @@ namespace de4dot.code.deobfuscators {
 			return typeRef;
 		}
 
-		public MemberRef instanceMethod(string name, IMemberRefParent declaringType, TypeSig returnType, params TypeSig[] args) {
-			return method(true, name, declaringType, returnType, args);
+		public MemberRef InstanceMethod(string name, IMemberRefParent declaringType, TypeSig returnType, params TypeSig[] args) {
+			return Method(true, name, declaringType, returnType, args);
 		}
 
-		public MemberRef staticMethod(string name, IMemberRefParent declaringType, TypeSig returnType, params TypeSig[] args) {
-			return method(false, name, declaringType, returnType, args);
+		public MemberRef StaticMethod(string name, IMemberRefParent declaringType, TypeSig returnType, params TypeSig[] args) {
+			return Method(false, name, declaringType, returnType, args);
 		}
 
-		public MemberRef method(bool isInstance, string name, IMemberRefParent declaringType, TypeSig returnType, params TypeSig[] args) {
+		public MemberRef Method(bool isInstance, string name, IMemberRefParent declaringType, TypeSig returnType, params TypeSig[] args) {
 			MethodSig sig;
 			if (isInstance)
 				sig = MethodSig.CreateInstance(returnType, args);
@@ -173,7 +173,7 @@ namespace de4dot.code.deobfuscators {
 			return module.UpdateRowId(new MemberRefUser(module, name, sig, declaringType));
 		}
 
-		AssemblyRef findAssemblyRef(string asmSimpleName) {
+		AssemblyRef FindAssemblyRef(string asmSimpleName) {
 			var asmRef = module.GetAssemblyRef(asmSimpleName);
 			if (asmRef == null)
 				throw new ApplicationException(string.Format("Could not find assembly {0} in assembly references", asmSimpleName));
diff --git a/de4dot.code/deobfuscators/MethodBodyParser.cs b/de4dot.code/deobfuscators/MethodBodyParser.cs
index 5c42f0ab..dad9b07c 100644
--- a/de4dot.code/deobfuscators/MethodBodyParser.cs
+++ b/de4dot.code/deobfuscators/MethodBodyParser.cs
@@ -40,23 +40,23 @@ namespace de4dot.code.deobfuscators {
 	}
 
 	static class MethodBodyParser {
-		public static MethodBodyHeader parseMethodBody(IBinaryReader reader, out byte[] code, out byte[] extraSections) {
+		public static MethodBodyHeader ParseMethodBody(IBinaryReader reader, out byte[] code, out byte[] extraSections) {
 			try {
-				return parseMethodBody2(reader, out code, out extraSections);
+				return ParseMethodBody2(reader, out code, out extraSections);
 			}
 			catch (IOException) {
 				throw new InvalidMethodBody();
 			}
 		}
 
-		public static bool verify(byte[] data) {
-			return verify(MemoryImageStream.Create(data));
+		public static bool Verify(byte[] data) {
+			return Verify(MemoryImageStream.Create(data));
 		}
 
-		public static bool verify(IBinaryReader reader) {
+		public static bool Verify(IBinaryReader reader) {
 			try {
 				byte[] code, extraSections;
-				parseMethodBody(reader, out code, out extraSections);
+				ParseMethodBody(reader, out code, out extraSections);
 				return true;
 			}
 			catch (InvalidMethodBody) {
@@ -64,11 +64,11 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		static MethodBodyHeader parseMethodBody2(IBinaryReader reader, out byte[] code, out byte[] extraSections) {
+		static MethodBodyHeader ParseMethodBody2(IBinaryReader reader, out byte[] code, out byte[] extraSections) {
 			var mbHeader = new MethodBodyHeader();
 
 			uint codeOffset;
-			byte b = peek(reader);
+			byte b = Peek(reader);
 			if ((b & 3) == 2) {
 				mbHeader.flags = 2;
 				mbHeader.maxStack = 8;
@@ -97,39 +97,39 @@ namespace de4dot.code.deobfuscators {
 			code = reader.ReadBytes((int)mbHeader.codeSize);
 
 			if ((mbHeader.flags & 8) != 0)
-				extraSections = readExtraSections2(reader);
+				extraSections = ReadExtraSections2(reader);
 			else
 				extraSections = null;
 
 			return mbHeader;
 		}
 
-		static void align(IBinaryReader reader, int alignment) {
+		static void Align(IBinaryReader reader, int alignment) {
 			reader.Position = (reader.Position + alignment - 1) & ~(alignment - 1);
 		}
 
-		public static byte[] readExtraSections(IBinaryReader reader) {
+		public static byte[] ReadExtraSections(IBinaryReader reader) {
 			try {
-				return readExtraSections2(reader);
+				return ReadExtraSections2(reader);
 			}
 			catch (IOException) {
 				throw new InvalidMethodBody();
 			}
 		}
 
-		static byte[] readExtraSections2(IBinaryReader reader) {
-			align(reader, 4);
+		static byte[] ReadExtraSections2(IBinaryReader reader) {
+			Align(reader, 4);
 			int startPos = (int)reader.Position;
-			parseSection(reader);
+			ParseSection(reader);
 			int size = (int)reader.Position - startPos;
 			reader.Position = startPos;
 			return reader.ReadBytes(size);
 		}
 
-		static void parseSection(IBinaryReader reader) {
+		static void ParseSection(IBinaryReader reader) {
 			byte flags;
 			do {
-				align(reader, 4);
+				Align(reader, 4);
 
 				flags = reader.ReadByte();
 				if ((flags & 1) == 0)
@@ -149,7 +149,7 @@ namespace de4dot.code.deobfuscators {
 			} while ((flags & 0x80) != 0);
 		}
 
-		static byte peek(IBinaryReader reader) {
+		static byte Peek(IBinaryReader reader) {
 			byte b = reader.ReadByte();
 			reader.Position--;
 			return b;
diff --git a/de4dot.code/deobfuscators/MethodCallRestorerBase.cs b/de4dot.code/deobfuscators/MethodCallRestorerBase.cs
index a9af1c13..220067af 100644
--- a/de4dot.code/deobfuscators/MethodCallRestorerBase.cs
+++ b/de4dot.code/deobfuscators/MethodCallRestorerBase.cs
@@ -43,66 +43,66 @@ namespace de4dot.code.deobfuscators {
 			this.builder = new MemberRefBuilder(module);
 		}
 
-		public void createGetManifestResourceStream1(MethodDef 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.TypeDefOrRef, streamType, builder.String);
-			add(oldMethod, newMethod, OpCodes.Callvirt);
+			var assemblyType = builder.Type("System.Reflection", "Assembly", builder.CorLib);
+			var streamType = builder.Type("System.IO", "Stream", builder.CorLib);
+			var newMethod = builder.InstanceMethod("GetManifestResourceStream", assemblyType.TypeDefOrRef, streamType, builder.String);
+			Add(oldMethod, newMethod, OpCodes.Callvirt);
 		}
 
-		public void createGetManifestResourceStream2(MethodDef 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.TypeDefOrRef, streamType, typeType, builder.String);
-			add(oldMethod, newMethod, OpCodes.Callvirt);
+			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.TypeDefOrRef, streamType, typeType, builder.String);
+			Add(oldMethod, newMethod, OpCodes.Callvirt);
 		}
 
-		public void createGetManifestResourceNames(MethodDef 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.TypeDefOrRef, stringArrayType);
-			add(oldMethod, newMethod, OpCodes.Callvirt);
+			var assemblyType = builder.Type("System.Reflection", "Assembly", builder.CorLib);
+			var stringArrayType = builder.Array(builder.String);
+			var newMethod = builder.InstanceMethod("GetManifestResourceNames", assemblyType.TypeDefOrRef, stringArrayType);
+			Add(oldMethod, newMethod, OpCodes.Callvirt);
 		}
 
-		public void createBitmapCtor(MethodDef 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.TypeDefOrRef, builder.Void, typeType, builder.String);
-			add(oldMethod, newMethod, OpCodes.Newobj);
+			var bitmapType = builder.Type("System.Drawing", "Bitmap", "System.Drawing");
+			var typeType = builder.Type("System", "Type", builder.CorLib);
+			var newMethod = builder.InstanceMethod(".ctor", bitmapType.TypeDefOrRef, builder.Void, typeType, builder.String);
+			Add(oldMethod, newMethod, OpCodes.Newobj);
 		}
 
-		public void createIconCtor(MethodDef 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.TypeDefOrRef, builder.Void, typeType, builder.String);
-			add(oldMethod, newMethod, OpCodes.Newobj);
+			var iconType = builder.Type("System.Drawing", "Icon", "System.Drawing");
+			var typeType = builder.Type("System", "Type", builder.CorLib);
+			var newMethod = builder.InstanceMethod(".ctor", iconType.TypeDefOrRef, builder.Void, typeType, builder.String);
+			Add(oldMethod, newMethod, OpCodes.Newobj);
 		}
 
-		protected void add(MethodDef oldMethod, IMethod newMethod) {
-			add(oldMethod, newMethod, OpCodes.Callvirt);
+		protected void Add(MethodDef oldMethod, IMethod newMethod) {
+			Add(oldMethod, newMethod, OpCodes.Callvirt);
 		}
 
-		protected void add(MethodDef oldMethod, IMethod newMethod, OpCode opCode) {
+		protected void Add(MethodDef oldMethod, IMethod newMethod, OpCode opCode) {
 			if (oldMethod == null)
 				return;
-			oldToNewMethod.add(oldMethod, new NewMethodInfo(opCode, newMethod));
+			oldToNewMethod.Add(oldMethod, new NewMethodInfo(opCode, newMethod));
 		}
 
-		public void deobfuscate(Blocks blocks) {
+		public void Deobfuscate(Blocks blocks) {
 			if (oldToNewMethod.Count == 0)
 				return;
-			foreach (var block in blocks.MethodBlocks.getAllBlocks()) {
+			foreach (var block in blocks.MethodBlocks.GetAllBlocks()) {
 				var instrs = block.Instructions;
 				for (int i = 0; i < instrs.Count; i++) {
 					var call = instrs[i];
@@ -112,7 +112,7 @@ namespace de4dot.code.deobfuscators {
 					if (calledMethod == null)
 						continue;
 
-					var newMethodInfo = oldToNewMethod.find(calledMethod);
+					var newMethodInfo = oldToNewMethod.Find(calledMethod);
 					if (newMethodInfo == null)
 						continue;
 
diff --git a/de4dot.code/deobfuscators/MethodCollection.cs b/de4dot.code/deobfuscators/MethodCollection.cs
index 975fd8b4..5f63b4ea 100644
--- a/de4dot.code/deobfuscators/MethodCollection.cs
+++ b/de4dot.code/deobfuscators/MethodCollection.cs
@@ -26,36 +26,36 @@ namespace de4dot.code.deobfuscators {
 		TypeDefDict<bool> types = new TypeDefDict<bool>();
 		MethodDefAndDeclaringTypeDict<bool> methods = new MethodDefAndDeclaringTypeDict<bool>();
 
-		public bool exists(IMethod method) {
+		public bool Exists(IMethod method) {
 			if (method == null)
 				return false;
-			if (method.DeclaringType != null && types.find(method.DeclaringType))
+			if (method.DeclaringType != null && types.Find(method.DeclaringType))
 				return true;
-			return methods.find(method);
+			return methods.Find(method);
 		}
 
-		public void add(MethodDef method) {
-			methods.add(method, true);
+		public void Add(MethodDef method) {
+			methods.Add(method, true);
 		}
 
-		public void add(IEnumerable<MethodDef> methods) {
+		public void Add(IEnumerable<MethodDef> methods) {
 			foreach (var method in methods)
-				add(method);
+				Add(method);
 		}
 
-		public void add(TypeDef type) {
-			types.add(type, true);
+		public void Add(TypeDef type) {
+			types.Add(type, true);
 		}
 
-		public void addAndNested(TypeDef type) {
-			add(type);
+		public void AddAndNested(TypeDef type) {
+			Add(type);
 			foreach (var t in type.GetTypes())
-				add(t);
+				Add(t);
 		}
 
-		public void addAndNested(IList<TypeDef> types) {
+		public void AddAndNested(IList<TypeDef> types) {
 			foreach (var type in AllTypesHelper.Types(types))
-				add(type);
+				Add(type);
 		}
 	}
 }
diff --git a/de4dot.code/deobfuscators/MethodStack.cs b/de4dot.code/deobfuscators/MethodStack.cs
index 1c214839..717bf510 100644
--- a/de4dot.code/deobfuscators/MethodStack.cs
+++ b/de4dot.code/deobfuscators/MethodStack.cs
@@ -42,25 +42,25 @@ namespace de4dot.code.deobfuscators {
 				args.Add(null);
 		}
 
-		public void add(Instruction instr) {
+		public void Add(Instruction instr) {
 			args[nextIndex--] = instr;
 		}
 
-		public void set(int i, Instruction instr) {
+		public void Set(int i, Instruction instr) {
 			args[i] = instr;
 		}
 
-		public Instruction get(int i) {
+		public Instruction Get(int i) {
 			if (0 <= i && i < args.Count)
 				return args[i];
 			return null;
 		}
 
-		public Instruction getEnd(int i) {
-			return get(args.Count - 1 - i);
+		public Instruction GetEnd(int i) {
+			return Get(args.Count - 1 - i);
 		}
 
-		public void fixDups() {
+		public void FixDups() {
 			Instruction prev = null, instr;
 			for (int i = 0; i < NumValidArgs; i++, prev = instr) {
 				instr = args[i];
@@ -76,12 +76,12 @@ namespace de4dot.code.deobfuscators {
 
 	static class MethodStack {
 		// May not return all args. The args are returned in reverse order.
-		public static PushedArgs getPushedArgInstructions(IList<Instruction> instructions, int index) {
+		public static PushedArgs GetPushedArgInstructions(IList<Instruction> instructions, int index) {
 			try {
 				int pushes, pops;
 				instructions[index].CalculateStackUsage(false, out pushes, out pops);
 				if (pops != -1)
-					return getPushedArgInstructions(instructions, index, pops);
+					return GetPushedArgInstructions(instructions, index, pops);
 			}
 			catch (System.NullReferenceException) {
 				// Here if eg. invalid metadata token in a call instruction (operand is null)
@@ -90,13 +90,13 @@ namespace de4dot.code.deobfuscators {
 		}
 
 		// May not return all args. The args are returned in reverse order.
-		static PushedArgs getPushedArgInstructions(IList<Instruction> instructions, int index, int numArgs) {
+		static PushedArgs GetPushedArgInstructions(IList<Instruction> instructions, int index, int numArgs) {
 			var pushedArgs = new PushedArgs(numArgs);
 
 			Instruction instr;
 			int skipPushes = 0;
 			while (index >= 0 && pushedArgs.CanAddMore) {
-				instr = getPreviousInstruction(instructions, ref index);
+				instr = GetPreviousInstruction(instructions, ref index);
 				if (instr == null)
 					break;
 
@@ -119,43 +119,43 @@ namespace de4dot.code.deobfuscators {
 				}
 				else {
 					if (pushes == 1)
-						pushedArgs.add(instr);
+						pushedArgs.Add(instr);
 					skipPushes += pops;
 				}
 			}
-			instr = pushedArgs.get(0);
+			instr = pushedArgs.Get(0);
 			if (instr != null && instr.OpCode.Code == Code.Dup) {
-				instr = getPreviousInstruction(instructions, ref index);
+				instr = GetPreviousInstruction(instructions, ref index);
 				if (instr != null) {
 					int pushes, pops;
 					instr.CalculateStackUsage(false, out pushes, out pops);
 					if (pushes == 1 && pops == 0)
-						pushedArgs.set(0, instr);
+						pushedArgs.Set(0, instr);
 				}
 			}
-			pushedArgs.fixDups();
+			pushedArgs.FixDups();
 
 			return pushedArgs;
 		}
 
-		public static TypeSig getLoadedType(MethodDef 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);
+			return GetLoadedType(method, instructions, instrIndex, 0, out wasNewobj);
 		}
 
-		public static TypeSig getLoadedType(MethodDef 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);
+			return GetLoadedType(method, instructions, instrIndex, argIndexFromEnd, out 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 TypeSig GetLoadedType(MethodDef method, IList<Instruction> instructions, int instrIndex, out bool wasNewobj) {
+			return GetLoadedType(method, instructions, instrIndex, 0, out wasNewobj);
 		}
 
-		public static TypeSig getLoadedType(MethodDef 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);
+			var pushedArgs = MethodStack.GetPushedArgInstructions(instructions, instrIndex);
+			var pushInstr = pushedArgs.GetEnd(argIndexFromEnd);
 			if (pushInstr == null)
 				return null;
 
@@ -257,12 +257,12 @@ namespace de4dot.code.deobfuscators {
 				local = pushInstr.Operand as Local;
 				if (local == null)
 					return null;
-				type = createByRefType(local.Type.RemovePinned());
+				type = CreateByRefType(local.Type.RemovePinned());
 				break;
 
 			case Code.Ldarga:
 			case Code.Ldarga_S:
-				type = createByRefType(pushInstr.GetArgumentType(method.MethodSig, method.DeclaringType));
+				type = CreateByRefType(pushInstr.GetArgumentType(method.MethodSig, method.DeclaringType));
 				break;
 
 			case Code.Ldfld:
@@ -278,12 +278,12 @@ namespace de4dot.code.deobfuscators {
 				var field2 = pushInstr.Operand as IField;
 				if (field2 == null || field2.FieldSig == null)
 					return null;
-				type = createByRefType(field2.FieldSig.GetFieldType());
+				type = CreateByRefType(field2.FieldSig.GetFieldType());
 				break;
 
 			case Code.Ldelema:
 			case Code.Unbox:
-				type = createByRefType(pushInstr.Operand as ITypeDefOrRef);
+				type = CreateByRefType(pushInstr.Operand as ITypeDefOrRef);
 				break;
 
 			default:
@@ -293,19 +293,19 @@ namespace de4dot.code.deobfuscators {
 			return type;
 		}
 
-		static ByRefSig createByRefType(ITypeDefOrRef elementType) {
+		static ByRefSig CreateByRefType(ITypeDefOrRef elementType) {
 			if (elementType == null)
 				return null;
 			return new ByRefSig(elementType.ToTypeSig());
 		}
 
-		static ByRefSig createByRefType(TypeSig elementType) {
+		static ByRefSig CreateByRefType(TypeSig elementType) {
 			if (elementType == null)
 				return null;
 			return new ByRefSig(elementType);
 		}
 
-		static Instruction getPreviousInstruction(IList<Instruction> instructions, ref int instrIndex) {
+		static Instruction GetPreviousInstruction(IList<Instruction> instructions, ref int instrIndex) {
 			while (true) {
 				instrIndex--;
 				if (instrIndex < 0)
diff --git a/de4dot.code/deobfuscators/MethodsDecrypter.cs b/de4dot.code/deobfuscators/MethodsDecrypter.cs
index 344638bc..81779260 100644
--- a/de4dot.code/deobfuscators/MethodsDecrypter.cs
+++ b/de4dot.code/deobfuscators/MethodsDecrypter.cs
@@ -24,19 +24,19 @@ using de4dot.mdecrypt;
 
 namespace de4dot.code.deobfuscators {
 	static class MethodsDecrypter {
-		public static DumpedMethods decrypt(ModuleDef module, byte[] moduleCctorBytes) {
-			return decrypt(NewProcessAssemblyClientFactory.getServerClrVersion(module), module.Location, moduleCctorBytes);
+		public static DumpedMethods Decrypt(ModuleDef module, byte[] moduleCctorBytes) {
+			return Decrypt(NewProcessAssemblyClientFactory.GetServerClrVersion(module), module.Location, moduleCctorBytes);
 		}
 
-		public static DumpedMethods decrypt(ServerClrVersion serverVersion, string filename, byte[] moduleCctorBytes) {
-			using (var client = new NewProcessAssemblyClientFactory(serverVersion).create()) {
-				client.connect();
-				client.waitConnected();
+		public static DumpedMethods Decrypt(ServerClrVersion serverVersion, string filename, byte[] moduleCctorBytes) {
+			using (var client = new NewProcessAssemblyClientFactory(serverVersion).Create()) {
+				client.Connect();
+				client.WaitConnected();
 				var info = new DecryptMethodsInfo();
 				info.moduleCctorBytes = moduleCctorBytes;
-				client.Service.installCompileMethod(info);
-				client.Service.loadObfuscator(filename);
-				return client.Service.decryptMethods();
+				client.Service.InstallCompileMethod(info);
+				client.Service.LoadObfuscator(filename);
+				return client.Service.DecryptMethods();
 			}
 		}
 	}
diff --git a/de4dot.code/deobfuscators/MyPEImage.cs b/de4dot.code/deobfuscators/MyPEImage.cs
index 4e25bc45..f933887e 100644
--- a/de4dot.code/deobfuscators/MyPEImage.cs
+++ b/de4dot.code/deobfuscators/MyPEImage.cs
@@ -24,7 +24,7 @@ namespace de4dot.code.deobfuscators {
 				var dotNetDir = peImage.ImageNTHeaders.OptionalHeader.DataDirectories[14];
 				if (dotNetDir.VirtualAddress != 0 && dotNetDir.Size >= 0x48) {
 					dnFile = DotNetFile.Load(peImage, false);
-					dotNetSection = findSection(dotNetDir.VirtualAddress);
+					dotNetSection = FindSection(dotNetDir.VirtualAddress);
 				}
 				return dnFile;
 			}
@@ -59,21 +59,21 @@ namespace de4dot.code.deobfuscators {
 		}
 
 		public MyPEImage(IPEImage peImage) {
-			initialize(peImage);
+			Initialize(peImage);
 		}
 
 		public MyPEImage(byte[] peImageData) {
 			this.ownPeImage = true;
 			this.peImageData = peImageData;
-			initialize(new PEImage(peImageData));
+			Initialize(new PEImage(peImageData));
 		}
 
-		void initialize(IPEImage peImage) {
+		void Initialize(IPEImage peImage) {
 			this.peImage = peImage;
 			this.peStream = peImage.CreateFullStream();
 		}
 
-		ImageSectionHeader findSection(RVA rva) {
+		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;
@@ -81,7 +81,7 @@ namespace de4dot.code.deobfuscators {
 			return null;
 		}
 
-		public ImageSectionHeader findSection(string name) {
+		public ImageSectionHeader FindSection(string name) {
 			foreach (var section in peImage.ImageSectionHeaders) {
 				if (section.DisplayName == name)
 					return section;
@@ -89,7 +89,7 @@ namespace de4dot.code.deobfuscators {
 			return null;
 		}
 
-		public void readMethodTableRowTo(DumpedMethod dm, uint rid) {
+		public void ReadMethodTableRowTo(DumpedMethod dm, uint rid) {
 			dm.token = 0x06000000 + rid;
 			var row = DotNetFile.MetaData.TablesStream.ReadMethodRow(rid);
 			if (row == null)
@@ -102,107 +102,107 @@ namespace de4dot.code.deobfuscators {
 			dm.mdParamList = row.ParamList;
 		}
 
-		public void updateMethodHeaderInfo(DumpedMethod dm, MethodBodyHeader mbHeader) {
+		public void UpdateMethodHeaderInfo(DumpedMethod dm, MethodBodyHeader mbHeader) {
 			dm.mhFlags = mbHeader.flags;
 			dm.mhMaxStack = mbHeader.maxStack;
 			dm.mhCodeSize = dm.code == null ? 0 : (uint)dm.code.Length;
 			dm.mhLocalVarSigTok = mbHeader.localVarSigTok;
 		}
 
-		public uint rvaToOffset(uint rva) {
+		public uint RvaToOffset(uint rva) {
 			return (uint)peImage.ToFileOffset((RVA)rva);
 		}
 
-		static bool isInside(ImageSectionHeader section, uint offset, uint length) {
+		static bool IsInside(ImageSectionHeader section, uint offset, uint length) {
 			return offset >= section.PointerToRawData && offset + length <= section.PointerToRawData + section.SizeOfRawData;
 		}
 
-		public void writeUInt32(uint rva, uint data) {
-			offsetWriteUInt32(rvaToOffset(rva), data);
+		public void WriteUInt32(uint rva, uint data) {
+			OffsetWriteUInt32(RvaToOffset(rva), data);
 		}
 
-		public void writeUInt16(uint rva, ushort data) {
-			offsetWriteUInt16(rvaToOffset(rva), data);
+		public void WriteUInt16(uint rva, ushort data) {
+			OffsetWriteUInt16(RvaToOffset(rva), data);
 		}
 
-		public byte readByte(uint rva) {
-			return offsetReadByte(rvaToOffset(rva));
+		public byte ReadByte(uint rva) {
+			return OffsetReadByte(RvaToOffset(rva));
 		}
 
-		public int readInt32(uint rva) {
-			return (int)offsetReadUInt32(rvaToOffset(rva));
+		public int ReadInt32(uint rva) {
+			return (int)OffsetReadUInt32(RvaToOffset(rva));
 		}
 
-		public ushort readUInt16(uint rva) {
-			return offsetReadUInt16(rvaToOffset(rva));
+		public ushort ReadUInt16(uint rva) {
+			return OffsetReadUInt16(RvaToOffset(rva));
 		}
 
-		public byte[] readBytes(uint rva, int size) {
-			return offsetReadBytes(rvaToOffset(rva), size);
+		public byte[] ReadBytes(uint rva, int size) {
+			return OffsetReadBytes(RvaToOffset(rva), size);
 		}
 
-		public void offsetWriteUInt32(uint offset, uint val) {
+		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) {
+		public void OffsetWriteUInt16(uint offset, ushort val) {
 			peImageData[offset + 0] = (byte)val;
 			peImageData[offset + 1] = (byte)(val >> 8);
 		}
 
-		public uint offsetReadUInt32(uint offset) {
+		public uint OffsetReadUInt32(uint offset) {
 			peStream.Position = offset;
 			return peStream.ReadUInt32();
 		}
 
-		public ushort offsetReadUInt16(uint offset) {
+		public ushort OffsetReadUInt16(uint offset) {
 			peStream.Position = offset;
 			return peStream.ReadUInt16();
 		}
 
-		public byte offsetReadByte(uint offset) {
+		public byte OffsetReadByte(uint offset) {
 			peStream.Position = offset;
 			return peStream.ReadByte();
 		}
 
-		public byte[] offsetReadBytes(uint offset, int size) {
+		public byte[] OffsetReadBytes(uint offset, int size) {
 			peStream.Position = offset;
 			return peStream.ReadBytes(size);
 		}
 
-		public void offsetWrite(uint offset, byte[] data) {
+		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) {
+		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));
+		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) {
+		public bool DotNetSafeWriteOffset(uint offset, byte[] data) {
 			if (DotNetFile != null) {
 				uint length = (uint)data.Length;
 
-				if (!isInside(dotNetSection, offset, length))
+				if (!IsInside(dotNetSection, offset, length))
 					return false;
-				if (intersect(offset, length, DotNetFile.MetaData.ImageCor20Header))
+				if (Intersect(offset, length, DotNetFile.MetaData.ImageCor20Header))
 					return false;
-				if (intersect(offset, length, DotNetFile.MetaData.MetaDataHeader))
+				if (Intersect(offset, length, DotNetFile.MetaData.MetaDataHeader))
 					return false;
 			}
 
-			offsetWrite(offset, data);
+			OffsetWrite(offset, data);
 			return true;
 		}
 
-		public bool dotNetSafeWrite(uint rva, byte[] data) {
-			return dotNetSafeWriteOffset((uint)peImage.ToFileOffset((RVA)rva), data);
+		public bool DotNetSafeWrite(uint rva, byte[] data) {
+			return DotNetSafeWriteOffset((uint)peImage.ToFileOffset((RVA)rva), data);
 		}
 
 		public void Dispose() {
diff --git a/de4dot.code/deobfuscators/ProxyCallFixerBase.cs b/de4dot.code/deobfuscators/ProxyCallFixerBase.cs
index a065d5cc..02be8fda 100644
--- a/de4dot.code/deobfuscators/ProxyCallFixerBase.cs
+++ b/de4dot.code/deobfuscators/ProxyCallFixerBase.cs
@@ -73,28 +73,28 @@ namespace de4dot.code.deobfuscators {
 		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"));
+				delegateCreatorMethods.Add(Lookup(method, "Could not find delegate creator method"));
 			foreach (var kv in oldOne.delegateTypesDict)
-				delegateTypesDict[lookup(kv.Key, "Could not find delegate type")] = kv.Value;
+				delegateTypesDict[Lookup(kv.Key, "Could not find delegate type")] = kv.Value;
 		}
 
-		protected DelegateInfo copy(DelegateInfo di) {
-			var method = lookup(di.methodRef, "Could not find method ref");
-			var field = lookup(di.field, "Could not find delegate field");
+		protected DelegateInfo Copy(DelegateInfo di) {
+			var method = Lookup(di.methodRef, "Could not find method ref");
+			var field = Lookup(di.field, "Could not find delegate field");
 			return new DelegateInfo(field, method, di.callOpcode);
 		}
 
-		protected T lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
-			return DeobUtils.lookup(module, def, errorMessage);
+		protected T Lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
+			return DeobUtils.Lookup(module, def, errorMessage);
 		}
 
-		protected void setDelegateCreatorMethod(MethodDef delegateCreatorMethod) {
+		protected void SetDelegateCreatorMethod(MethodDef delegateCreatorMethod) {
 			if (delegateCreatorMethod == null)
 				return;
 			delegateCreatorMethods.Add(delegateCreatorMethod);
 		}
 
-		protected bool isDelegateCreatorMethod(MethodDef 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<TypeDef> getDelegateTypes() {
+		protected virtual IEnumerable<TypeDef> GetDelegateTypes() {
 			foreach (var type in module.Types) {
 				if (type.BaseType == null || type.BaseType.FullName != "System.MulticastDelegate")
 					continue;
@@ -128,24 +128,24 @@ namespace de4dot.code.deobfuscators {
 			get { return false; }
 		}
 
-		public void deobfuscate(Blocks blocks) {
+		public void Deobfuscate(Blocks blocks) {
 			if (blocks.Method.DeclaringType != null && delegateTypesDict.ContainsKey(blocks.Method.DeclaringType))
 				return;
-			var allBlocks = blocks.MethodBlocks.getAllBlocks();
+			var allBlocks = blocks.MethodBlocks.GetAllBlocks();
 			int loops = ProxyCallIsObfuscated ? 50 : 1;
 			for (int i = 0; i < loops; i++) {
-				if (!deobfuscate(blocks, allBlocks))
+				if (!Deobfuscate(blocks, allBlocks))
 					break;
 			}
-			deobfuscateEnd(blocks, allBlocks);
+			DeobfuscateEnd(blocks, allBlocks);
 		}
 
-		protected abstract bool deobfuscate(Blocks blocks, IList<Block> allBlocks);
+		protected abstract bool Deobfuscate(Blocks blocks, IList<Block> allBlocks);
 
-		protected virtual void deobfuscateEnd(Blocks blocks, IList<Block> allBlocks) {
+		protected virtual void DeobfuscateEnd(Blocks blocks, IList<Block> allBlocks) {
 		}
 
-		protected static void add(Dictionary<Block, List<RemoveInfo>> removeInfos, Block block, int index, DelegateInfo di) {
+		protected static void Add(Dictionary<Block, List<RemoveInfo>> removeInfos, Block block, int index, DelegateInfo di) {
 			List<RemoveInfo> list;
 			if (!removeInfos.TryGetValue(block, out list))
 				removeInfos[block] = list = new List<RemoveInfo>();
@@ -155,7 +155,7 @@ namespace de4dot.code.deobfuscators {
 			});
 		}
 
-		protected static bool fixProxyCalls(Dictionary<Block, List<RemoveInfo>> removeInfos) {
+		protected static bool FixProxyCalls(Dictionary<Block, List<RemoveInfo>> removeInfos) {
 			foreach (var block in removeInfos.Keys) {
 				var list = removeInfos[block];
 				var removeIndexes = new List<int>(list.Count);
@@ -163,13 +163,13 @@ namespace de4dot.code.deobfuscators {
 					if (info.IsCall) {
 						var opcode = info.DelegateInfo.callOpcode;
 						var newInstr = Instruction.Create(opcode, info.DelegateInfo.methodRef);
-						block.replace(info.Index, 1, newInstr);
+						block.Replace(info.Index, 1, newInstr);
 					}
 					else
 						removeIndexes.Add(info.Index);
 				}
 				if (removeIndexes.Count > 0)
-					block.remove(removeIndexes);
+					block.Remove(removeIndexes);
 			}
 
 			return removeInfos.Count > 0;
@@ -189,26 +189,26 @@ namespace de4dot.code.deobfuscators {
 
 		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)));
+			foreach (var key in oldOne.fieldToDelegateInfo.GetKeys())
+				fieldToDelegateInfo.Add(Lookup(key, "Could not find field"), Copy(oldOne.fieldToDelegateInfo.Find(key)));
 		}
 
-		protected void addDelegateInfo(DelegateInfo di) {
-			fieldToDelegateInfo.add(di.field, di);
+		protected void AddDelegateInfo(DelegateInfo di) {
+			fieldToDelegateInfo.Add(di.field, di);
 		}
 
-		protected DelegateInfo getDelegateInfo(IField field) {
+		protected DelegateInfo GetDelegateInfo(IField field) {
 			if (field == null)
 				return null;
-			return fieldToDelegateInfo.find(field);
+			return fieldToDelegateInfo.Find(field);
 		}
 
-		public void find() {
+		public void Find() {
 			if (delegateCreatorMethods.Count == 0)
 				return;
 
 			Logger.v("Finding all proxy delegates");
-			foreach (var tmp in getDelegateTypes()) {
+			foreach (var tmp in GetDelegateTypes()) {
 				var type = tmp;
 				var cctor = type.FindStaticConstructor();
 				if (cctor == null || !cctor.HasBody)
@@ -216,40 +216,40 @@ namespace de4dot.code.deobfuscators {
 				if (!type.HasFields)
 					continue;
 
-				object context = checkCctor(ref type, cctor);
+				object context = CheckCctor(ref type, cctor);
 				if (context == null)
 					continue;
 
-				Logger.v("Found proxy delegate: {0} ({1:X8})", Utils.removeNewlines(type), type.MDToken.ToUInt32());
+				Logger.v("Found proxy delegate: {0} ({1:X8})", Utils.RemoveNewlines(type), type.MDToken.ToUInt32());
 				RemovedDelegateCreatorCalls++;
 
-				Logger.Instance.indent();
+				Logger.Instance.Indent();
 				foreach (var field in type.Fields) {
 					if (!field.IsStatic)
 						continue;
 
 					IMethod calledMethod;
 					OpCode callOpcode;
-					getCallInfo(context, field, out calledMethod, out callOpcode);
+					GetCallInfo(context, field, out calledMethod, out callOpcode);
 
 					if (calledMethod == null)
 						continue;
-					addDelegateInfo(new DelegateInfo(field, calledMethod, callOpcode));
+					AddDelegateInfo(new DelegateInfo(field, calledMethod, callOpcode));
 					Logger.v("Field: {0}, Opcode: {1}, Method: {2} ({3:X8})",
-								Utils.removeNewlines(field.Name),
+								Utils.RemoveNewlines(field.Name),
 								callOpcode,
-								Utils.removeNewlines(calledMethod),
+								Utils.RemoveNewlines(calledMethod),
 								calledMethod.MDToken.Raw);
 				}
-				Logger.Instance.deIndent();
+				Logger.Instance.DeIndent();
 				delegateTypesDict[type] = true;
 			}
 		}
 
-		protected abstract object checkCctor(ref TypeDef type, MethodDef cctor);
-		protected abstract void getCallInfo(object context, FieldDef field, out IMethod 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) {
+		protected override bool Deobfuscate(Blocks blocks, IList<Block> allBlocks) {
 			var removeInfos = new Dictionary<Block, List<RemoveInfo>>();
 
 			foreach (var block in allBlocks) {
@@ -259,34 +259,34 @@ namespace de4dot.code.deobfuscators {
 					if (instr.OpCode != OpCodes.Ldsfld)
 						continue;
 
-					var di = getDelegateInfo(instr.Operand as IField);
+					var di = GetDelegateInfo(instr.Operand as IField);
 					if (di == null)
 						continue;
 
-					var callInfo = findProxyCall(di, block, i);
+					var callInfo = FindProxyCall(di, block, i);
 					if (callInfo != null) {
-						add(removeInfos, block, i, null);
-						add(removeInfos, callInfo.Block, callInfo.Index, di);
+						Add(removeInfos, block, i, null);
+						Add(removeInfos, callInfo.Block, callInfo.Index, di);
 					}
 					else {
 						errors++;
 						Logger.w("Could not fix proxy call. Method: {0} ({1:X8}), Proxy type: {2} ({3:X8})",
-							Utils.removeNewlines(blocks.Method),
+							Utils.RemoveNewlines(blocks.Method),
 							blocks.Method.MDToken.ToInt32(),
-							Utils.removeNewlines(di.field.DeclaringType),
+							Utils.RemoveNewlines(di.field.DeclaringType),
 							di.field.DeclaringType.MDToken.ToInt32());
 					}
 				}
 			}
 
-			return fixProxyCalls(removeInfos);
+			return FixProxyCalls(removeInfos);
 		}
 
-		protected virtual BlockInstr findProxyCall(DelegateInfo di, Block block, int index) {
-			return findProxyCall(di, block, index, new Dictionary<Block, bool>(), 1);
+		protected virtual BlockInstr FindProxyCall(DelegateInfo di, Block block, int index) {
+			return FindProxyCall(di, block, index, new Dictionary<Block, bool>(), 1);
 		}
 
-		BlockInstr findProxyCall(DelegateInfo di, Block block, int index, Dictionary<Block, bool> visited, int stack) {
+		BlockInstr FindProxyCall(DelegateInfo di, Block block, int index, Dictionary<Block, bool> visited, int stack) {
 			if (visited.ContainsKey(block))
 				return null;
 			if (index <= 0)
@@ -309,7 +309,7 @@ namespace de4dot.code.deobfuscators {
 				var calledMethod = instr.Operand as IMethod;
 				if (calledMethod == null)
 					return null;
-				if (stack != (DotNetUtils.hasReturnValue(calledMethod) ? 1 : 0))
+				if (stack != (DotNetUtils.HasReturnValue(calledMethod) ? 1 : 0))
 					continue;
 				if (calledMethod.Name != "Invoke")
 					return null;
@@ -322,8 +322,8 @@ namespace de4dot.code.deobfuscators {
 			if (stack <= 0)
 				return null;
 
-			foreach (var target in block.getTargets()) {
-				var info = findProxyCall(di, target, -1, visited, stack);
+			foreach (var target in block.GetTargets()) {
+				var info = FindProxyCall(di, target, -1, visited, stack);
 				if (info != null)
 					return info;
 			}
@@ -331,13 +331,13 @@ namespace de4dot.code.deobfuscators {
 			return null;
 		}
 
-		protected override void deobfuscateEnd(Blocks blocks, IList<Block> allBlocks) {
-			fixBrokenCalls(blocks.Method, allBlocks);
+		protected override void DeobfuscateEnd(Blocks blocks, IList<Block> allBlocks) {
+			FixBrokenCalls(blocks.Method, allBlocks);
 		}
 
 		// 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(MethodDef 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++) {
@@ -347,7 +347,7 @@ namespace de4dot.code.deobfuscators {
 					var methodRef = call.Operand as IMethod;
 					if (methodRef == null || methodRef.Name != "Invoke")
 						continue;
-					MethodDef method = DotNetUtils.getMethod2(module, methodRef);
+					MethodDef method = DotNetUtils.GetMethod2(module, methodRef);
 					if (method == null || method.DeclaringType == null)
 						continue;
 					if (!delegateTypesDict.ContainsKey(method.DeclaringType))
@@ -356,8 +356,8 @@ namespace de4dot.code.deobfuscators {
 					// Oooops!!! The obfuscator is buggy. Well, let's hope it is, or it's my code. ;)
 
 					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, OpCodes.Ldnull.ToInstruction());
-					block.replace(i + 1, 1, OpCodes.Throw.ToInstruction());
+					block.Insert(i, OpCodes.Ldnull.ToInstruction());
+					block.Replace(i + 1, 1, OpCodes.Throw.ToInstruction());
 					i++;
 				}
 			}
@@ -377,38 +377,38 @@ namespace de4dot.code.deobfuscators {
 
 		protected ProxyCallFixer2(ModuleDefMD module, ProxyCallFixer2 oldOne)
 			: base(module, oldOne) {
-			foreach (var oldMethod in oldOne.proxyMethodToDelegateInfo.getKeys()) {
-				var oldDi = oldOne.proxyMethodToDelegateInfo.find(oldMethod);
-				var method = lookup(oldMethod, "Could not find proxy method");
-				proxyMethodToDelegateInfo.add(method, copy(oldDi));
+			foreach (var oldMethod in oldOne.proxyMethodToDelegateInfo.GetKeys()) {
+				var oldDi = oldOne.proxyMethodToDelegateInfo.Find(oldMethod);
+				var method = Lookup(oldMethod, "Could not find proxy method");
+				proxyMethodToDelegateInfo.Add(method, Copy(oldDi));
 			}
 		}
 
-		public void find() {
+		public void Find() {
 			if (delegateCreatorMethods.Count == 0)
 				return;
 
 			Logger.v("Finding all proxy delegates");
-			find2();
+			Find2();
 		}
 
-		protected void find2() {
-			foreach (var type in getDelegateTypes()) {
+		protected void Find2() {
+			foreach (var type in GetDelegateTypes()) {
 				var cctor = type.FindStaticConstructor();
 				if (cctor == null || !cctor.HasBody)
 					continue;
 				if (!type.HasFields)
 					continue;
 
-				object context = checkCctor(type, cctor);
+				object context = CheckCctor(type, cctor);
 				if (context == null)
 					continue;
 
-				Logger.v("Found proxy delegate: {0} ({1:X8})", Utils.removeNewlines(type), type.MDToken.ToUInt32());
+				Logger.v("Found proxy delegate: {0} ({1:X8})", Utils.RemoveNewlines(type), type.MDToken.ToUInt32());
 				RemovedDelegateCreatorCalls++;
-				var fieldToMethod = getFieldToMethodDictionary(type);
+				var fieldToMethod = GetFieldToMethodDictionary(type);
 
-				Logger.Instance.indent();
+				Logger.Instance.Indent();
 				foreach (var field in type.Fields) {
 					MethodDef proxyMethod;
 					if (!fieldToMethod.TryGetValue(field, out proxyMethod))
@@ -416,30 +416,30 @@ namespace de4dot.code.deobfuscators {
 
 					IMethod calledMethod;
 					OpCode callOpcode;
-					getCallInfo(context, field, out calledMethod, out callOpcode);
+					GetCallInfo(context, field, out calledMethod, out callOpcode);
 
 					if (calledMethod == null)
 						continue;
-					add(proxyMethod, new DelegateInfo(field, calledMethod, callOpcode));
+					Add(proxyMethod, new DelegateInfo(field, calledMethod, callOpcode));
 					Logger.v("Field: {0}, Opcode: {1}, Method: {2} ({3:X8})",
-								Utils.removeNewlines(field.Name),
+								Utils.RemoveNewlines(field.Name),
 								callOpcode,
-								Utils.removeNewlines(calledMethod),
+								Utils.RemoveNewlines(calledMethod),
 								calledMethod.MDToken.ToUInt32());
 				}
-				Logger.Instance.deIndent();
+				Logger.Instance.DeIndent();
 				delegateTypesDict[type] = true;
 			}
 		}
 
-		protected void add(MethodDef method, DelegateInfo di) {
-			proxyMethodToDelegateInfo.add(method, di);
+		protected void Add(MethodDef method, DelegateInfo di) {
+			proxyMethodToDelegateInfo.Add(method, di);
 		}
 
-		protected abstract object checkCctor(TypeDef type, MethodDef cctor);
-		protected abstract void getCallInfo(object context, FieldDef field, out IMethod 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<FieldDef, MethodDef> getFieldToMethodDictionary(TypeDef type) {
+		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")
@@ -461,7 +461,7 @@ namespace de4dot.code.deobfuscators {
 			return dict;
 		}
 
-		protected override bool deobfuscate(Blocks blocks, IList<Block> allBlocks) {
+		protected override bool Deobfuscate(Blocks blocks, IList<Block> allBlocks) {
 			var removeInfos = new Dictionary<Block, List<RemoveInfo>>();
 
 			foreach (var block in allBlocks) {
@@ -474,14 +474,14 @@ namespace de4dot.code.deobfuscators {
 					var method = instr.Operand as IMethod;
 					if (method == null)
 						continue;
-					var di = proxyMethodToDelegateInfo.find(method);
+					var di = proxyMethodToDelegateInfo.Find(method);
 					if (di == null)
 						continue;
-					add(removeInfos, block, i, di);
+					Add(removeInfos, block, i, di);
 				}
 			}
 
-			return fixProxyCalls(removeInfos);
+			return FixProxyCalls(removeInfos);
 		}
 	}
 
@@ -499,11 +499,11 @@ namespace de4dot.code.deobfuscators {
 			: base(module, oldOne) {
 		}
 
-		protected override BlockInstr findProxyCall(DelegateInfo di, Block block, int index) {
+		protected override BlockInstr FindProxyCall(DelegateInfo di, Block block, int index) {
 			index++;
 			if (index >= block.Instructions.Count)
 				return null;
-			var calledMethod = getCalledMethod(block.Instructions[index]);
+			var calledMethod = GetCalledMethod(block.Instructions[index]);
 			if (calledMethod == null)
 				return null;
 			return new BlockInstr {
@@ -512,7 +512,7 @@ namespace de4dot.code.deobfuscators {
 			};
 		}
 
-		static IMethod getCalledMethod(Instr instr) {
+		static IMethod GetCalledMethod(Instr instr) {
 			if (instr.OpCode.Code != Code.Call)
 				return null;
 			return instr.Operand as IMethod;
diff --git a/de4dot.code/deobfuscators/QuickLZ.cs b/de4dot.code/deobfuscators/QuickLZ.cs
index 4a594ad3..d370b789 100644
--- a/de4dot.code/deobfuscators/QuickLZ.cs
+++ b/de4dot.code/deobfuscators/QuickLZ.cs
@@ -13,18 +13,18 @@ using System;
 
 namespace de4dot.code.deobfuscators {
 	class QuickLZBase {
-		protected static uint read32(byte[] data, int index) {
+		protected static uint Read32(byte[] data, int index) {
 			return BitConverter.ToUInt32(data, index);
 		}
 
 		// Can't use Array.Copy() when data overlaps so here's one that works
-		protected static void copy(byte[] src, int srcIndex, byte[] dst, int dstIndex, int size) {
+		protected static void Copy(byte[] src, int srcIndex, byte[] dst, int dstIndex, int size) {
 			for (int i = 0; i < size; i++)
 				dst[dstIndex++] = src[srcIndex++];
 		}
 
 		static int[] indexInc = new int[] { 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0 };
-		public static void decompress(byte[] inData, int inIndex, byte[] outData) {
+		public static void Decompress(byte[] inData, int inIndex, byte[] outData) {
 			int decompressedLength = outData.Length;
 			int outIndex = 0;
 			uint val1 = 1;
@@ -33,35 +33,35 @@ namespace de4dot.code.deobfuscators {
 
 			while (true) {
 				if (val1 == 1) {
-					val1 = read32(inData, inIndex);
+					val1 = Read32(inData, inIndex);
 					inIndex += 4;
 				}
-				uint val2 = read32(inData, inIndex);
+				uint val2 = Read32(inData, inIndex);
 				if ((val1 & 1) == 1) {
 					val1 >>= 1;
 					if ((val2 & 3) == 0) {
 						count = (val2 & 0xFF) >> 2;
-						copy(outData, (int)(outIndex - count), outData, outIndex, 3);
+						Copy(outData, (int)(outIndex - count), outData, outIndex, 3);
 						outIndex += 3;
 						inIndex++;
 					}
 					else if ((val2 & 2) == 0) {
 						count = (val2 & 0xFFFF) >> 2;
-						copy(outData, (int)(outIndex - count), outData, outIndex, 3);
+						Copy(outData, (int)(outIndex - count), outData, outIndex, 3);
 						outIndex += 3;
 						inIndex += 2;
 					}
 					else if ((val2 & 1) == 0) {
 						size = (int)((val2 >> 2) & 0x0F) + 3;
 						count = (val2 & 0xFFFF) >> 6;
-						copy(outData, (int)(outIndex - count), outData, outIndex, size);
+						Copy(outData, (int)(outIndex - count), outData, outIndex, size);
 						outIndex += size;
 						inIndex += 2;
 					}
 					else if ((val2 & 4) == 0) {
 						size = (int)((val2 >> 3) & 0x1F) + 3;
 						count = (val2 & 0xFFFFFF) >> 8;
-						copy(outData, (int)(outIndex - count), outData, outIndex, size);
+						Copy(outData, (int)(outIndex - count), outData, outIndex, size);
 						outIndex += size;
 						inIndex += 3;
 					}
@@ -72,18 +72,18 @@ namespace de4dot.code.deobfuscators {
 							inIndex += 4;
 						}
 						else {
-							size = (int)read32(inData, inIndex + 4);
-							count = read32(inData, inIndex + 8);
+							size = (int)Read32(inData, inIndex + 4);
+							count = Read32(inData, inIndex + 8);
 							inIndex += 12;
 						}
-						copy(outData, (int)(outIndex - count), outData, outIndex, size);
+						Copy(outData, (int)(outIndex - count), outData, outIndex, size);
 						outIndex += size;
 					}
 					else {
 						byte b = (byte)(val2 >> 16);
 						size = (int)(val2 >> 4) & 0x0FFF;
 						if (size == 0) {
-							size = (int)read32(inData, inIndex + 3);
+							size = (int)Read32(inData, inIndex + 3);
 							inIndex += 7;
 						}
 						else
@@ -93,7 +93,7 @@ namespace de4dot.code.deobfuscators {
 					}
 				}
 				else {
-					copy(inData, inIndex, outData, outIndex, 4);
+					Copy(inData, inIndex, outData, outIndex, 4);
 					int index = (int)(val1 & 0x0F);
 					outIndex += indexInc[index];
 					inIndex += indexInc[index];
@@ -116,17 +116,17 @@ namespace de4dot.code.deobfuscators {
 	class QuickLZ : QuickLZBase {
 		static int DEFAULT_QCLZ_SIG = 0x5A4C4351;	// "QCLZ"
 
-		public static bool isCompressed(byte[] data) {
+		public static bool IsCompressed(byte[] data) {
 			if (data.Length < 4)
 				return false;
 			return BitConverter.ToInt32(data, 0) == DEFAULT_QCLZ_SIG;
 		}
 
-		public static byte[] decompress(byte[] inData) {
-			return decompress(inData, DEFAULT_QCLZ_SIG);
+		public static byte[] Decompress(byte[] inData) {
+			return Decompress(inData, DEFAULT_QCLZ_SIG);
 		}
 
-		public static byte[] decompress(byte[] inData, int sig) {
+		public static byte[] Decompress(byte[] inData, int sig) {
 			int mode = BitConverter.ToInt32(inData, 4);
 			int compressedLength = BitConverter.ToInt32(inData, 8);
 			int decompressedLength = BitConverter.ToInt32(inData, 12);
@@ -138,11 +138,11 @@ namespace de4dot.code.deobfuscators {
 			byte[] outData = new byte[decompressedLength];
 
 			if (!isDataCompressed) {
-				copy(inData, headerLength, outData, 0, decompressedLength);
+				Copy(inData, headerLength, outData, 0, decompressedLength);
 				return outData;
 			}
 
-			decompress(inData, headerLength, outData);
+			Decompress(inData, headerLength, outData);
 			return outData;
 		}
 	}
diff --git a/de4dot.code/deobfuscators/RandomNameChecker.cs b/de4dot.code/deobfuscators/RandomNameChecker.cs
index 51323424..a5b7e6a9 100644
--- a/de4dot.code/deobfuscators/RandomNameChecker.cs
+++ b/de4dot.code/deobfuscators/RandomNameChecker.cs
@@ -26,7 +26,7 @@ namespace de4dot.code.deobfuscators {
 		static Regex noUpper = new Regex(@"^[^A-Z]+$");
 		static Regex allUpper = new Regex(@"^[A-Z]+$");
 
-		public static bool isNonRandom(string name) {
+		public static bool IsNonRandom(string name) {
 			if (name.Length < 5)
 				return true;
 			if (noUpper.IsMatch(name))
@@ -35,16 +35,16 @@ namespace de4dot.code.deobfuscators {
 				return true;
 
 			for (int i = 0; i < name.Length - 1; i++) {
-				if (isDigit(name[i]))
+				if (IsDigit(name[i]))
 					return false;
-				if (i > 0 && isUpper(name[i]) && isUpper(name[i - 1]))
+				if (i > 0 && IsUpper(name[i]) && IsUpper(name[i - 1]))
 					return false;
 			}
 
-			var words = getCamelWords(name);
+			var words = GetCamelWords(name);
 			int vowels = 0;
 			foreach (var word in words) {
-				if (word.Length > 1 && hasVowel(word))
+				if (word.Length > 1 && HasVowel(word))
 					vowels++;
 			}
 			switch (words.Count) {
@@ -65,7 +65,7 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		static bool hasVowel(string s) {
+		static bool HasVowel(string s) {
 			foreach (var c in s) {
 				switch (c) {
 				case 'A':
@@ -86,13 +86,13 @@ namespace de4dot.code.deobfuscators {
 			return false;
 		}
 
-		static List<string> getCamelWords(string name) {
+		static List<string> GetCamelWords(string name) {
 			var words = new List<string>();
 			var sb = new StringBuilder();
 
 			for (int i = 0; i < name.Length; i++) {
 				char c = name[i];
-				if (isUpper(c)) {
+				if (IsUpper(c)) {
 					if (sb.Length > 0)
 						words.Add(sb.ToString());
 					sb.Length = 0;
@@ -106,78 +106,78 @@ namespace de4dot.code.deobfuscators {
 		}
 
 		// Returns true if random, false if unknown
-		public static bool isRandom(string name) {
+		public static bool IsRandom(string name) {
 			int len = name.Length;
 			if (len < 5)
 				return false;
 
-			var typeWords = getTypeWords(name);
+			var typeWords = GetTypeWords(name);
 
-			if (countNumbers(typeWords, 2))
+			if (CountNumbers(typeWords, 2))
 				return true;
 
 			int lower, upper, digits;
-			countTypeWords(typeWords, out lower, out upper, out digits);
+			CountTypeWords(typeWords, out lower, out upper, out digits);
 			if (upper >= 3)
 				return true;
 			bool hasTwoUpperWords = upper == 2;
 
 			foreach (var word in typeWords) {
-				if (word.Length > 1 && isDigit(word[0]))
+				if (word.Length > 1 && IsDigit(word[0]))
 					return true;
 			}
 
 			// Check for: lower, digit, lower
 			for (int i = 2; i < typeWords.Count; i++) {
-				if (isDigit(typeWords[i - 1][0]) && isLower(typeWords[i - 2][0]) && isLower(typeWords[i][0]))
+				if (IsDigit(typeWords[i - 1][0]) && IsLower(typeWords[i - 2][0]) && IsLower(typeWords[i][0]))
 					return true;
 			}
 
-			if (hasTwoUpperWords && hasDigit(name))
+			if (hasTwoUpperWords && HasDigit(name))
 				return true;
 
 			// Check if it ends in lower, upper, digit
-			if (isLower(name[len - 3]) && isUpper(name[len - 2]) && isDigit(name[len - 1]))
+			if (IsLower(name[len - 3]) && IsUpper(name[len - 2]) && IsDigit(name[len - 1]))
 				return true;
 
 			return false;
 		}
 
-		static bool hasDigit(string s) {
+		static bool HasDigit(string s) {
 			foreach (var c in s) {
-				if (isDigit(c))
+				if (IsDigit(c))
 					return true;
 			}
 			return false;
 		}
 
-		static List<string> getTypeWords(string s) {
+		static List<string> GetTypeWords(string s) {
 			var words = new List<string>();
 			var sb = new StringBuilder();
 
 			for (int i = 0; i < s.Length; ) {
-				if (isDigit(s[i])) {
+				if (IsDigit(s[i])) {
 					sb.Length = 0;
-					while (i < s.Length && isDigit(s[i]))
+					while (i < s.Length && IsDigit(s[i]))
 						sb.Append(s[i++]);
 					words.Add(sb.ToString());
 				}
-				else if (isUpper(s[i])) {
+				else if (IsUpper(s[i])) {
 					sb.Length = 0;
-					while (i < s.Length && isUpper(s[i]))
+					while (i < s.Length && IsUpper(s[i]))
 						sb.Append(s[i++]);
 					words.Add(sb.ToString());
 				}
-				else if (isLower(s[i])) {
+				else if (IsLower(s[i])) {
 					sb.Length = 0;
-					while (i < s.Length && isLower(s[i]))
+					while (i < s.Length && IsLower(s[i]))
 						sb.Append(s[i++]);
 					words.Add(sb.ToString());
 				}
 				else {
 					sb.Length = 0;
 					while (i < s.Length) {
-						if (isDigit(s[i]) || isUpper(s[i]) || isLower(s[i]))
+						if (IsDigit(s[i]) || IsUpper(s[i]) || IsLower(s[i]))
 							break;
 						sb.Append(s[i++]);
 					}
@@ -188,19 +188,19 @@ namespace de4dot.code.deobfuscators {
 			return words;
 		}
 
-		static bool countNumbers(List<string> words, int numbers) {
+		static bool CountNumbers(List<string> words, int numbers) {
 			int num = 0;
 			foreach (var word in words) {
 				if (string.IsNullOrEmpty(word))
 					continue;
-				if (isDigit(word[0]) && ++num >= numbers)
+				if (IsDigit(word[0]) && ++num >= numbers)
 					return true;
 			}
 			return false;
 		}
 
 		// 2+ chars only
-		static void countTypeWords(List<string> words, out int lower, out int upper, out int digits) {
+		static void CountTypeWords(List<string> words, out int lower, out int upper, out int digits) {
 			lower = 0;
 			upper = 0;
 			digits = 0;
@@ -209,24 +209,24 @@ namespace de4dot.code.deobfuscators {
 				if (word.Length <= 1)
 					continue;
 				char c = word[0];
-				if (isDigit(c))
+				if (IsDigit(c))
 					digits++;
-				else if (isLower(c))
+				else if (IsLower(c))
 					lower++;
-				else if (isUpper(c))
+				else if (IsUpper(c))
 					upper++;
 			}
 		}
 
-		static bool isLower(char c) {
+		static bool IsLower(char c) {
 			return 'a' <= c && c <= 'z';
 		}
 
-		static bool isUpper(char c) {
+		static bool IsUpper(char c) {
 			return 'A' <= c && c <= 'Z';
 		}
 
-		static bool isDigit(char c) {
+		static bool IsDigit(char c) {
 			return '0' <= c && c <= '9';
 		}
 	}
diff --git a/de4dot.code/deobfuscators/Rummage/Deobfuscator.cs b/de4dot.code/deobfuscators/Rummage/Deobfuscator.cs
index 1561977a..5b517de5 100644
--- a/de4dot.code/deobfuscators/Rummage/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/Rummage/Deobfuscator.cs
@@ -38,7 +38,7 @@ namespace de4dot.code.deobfuscators.Rummage {
 			get { return THE_TYPE; }
 		}
 
-		public override IDeobfuscator createDeobfuscator() {
+		public override IDeobfuscator CreateDeobfuscator() {
 			return new Deobfuscator(new Deobfuscator.Options {
 				ValidNameRegex = validNameRegex.get(),
 			});
@@ -68,23 +68,23 @@ namespace de4dot.code.deobfuscators.Rummage {
 			: base(options) {
 		}
 
-		protected override int detectInternal() {
+		protected override int DetectInternal() {
 			int val = 0;
 
-			int sum = toInt32(stringDecrypter.Detected);
+			int sum = ToInt32(stringDecrypter.Detected);
 			if (sum > 0)
 				val += 100 + 10 * (sum - 1);
 
 			return val;
 		}
 
-		protected override void scanForObfuscator() {
+		protected override void ScanForObfuscator() {
 			stringDecrypter = new StringDecrypter(module);
-			stringDecrypter.find();
-			detectVersion();
+			stringDecrypter.Find();
+			DetectVersion();
 		}
 
-		void detectVersion() {
+		void DetectVersion() {
 			string version;
 			switch (stringDecrypter.Version) {
 			case RummageVersion.V1_1_445: version = "v1.1 - v2.0"; break;
@@ -95,28 +95,28 @@ namespace de4dot.code.deobfuscators.Rummage {
 				obfuscatorName += " " + version;
 		}
 
-		public override void deobfuscateBegin() {
-			base.deobfuscateBegin();
+		public override void DeobfuscateBegin() {
+			base.DeobfuscateBegin();
 
-			stringDecrypter.initialize();
+			stringDecrypter.Initialize();
 		}
 
 
-		public override void deobfuscateMethodEnd(Blocks blocks) {
+		public override void DeobfuscateMethodEnd(Blocks blocks) {
 			if (CanRemoveStringDecrypterType)
-				stringDecrypter.deobfuscate(blocks);
-			base.deobfuscateMethodEnd(blocks);
+				stringDecrypter.Deobfuscate(blocks);
+			base.DeobfuscateMethodEnd(blocks);
 		}
 
-		public override void deobfuscateEnd() {
+		public override void DeobfuscateEnd() {
 			if (CanRemoveStringDecrypterType) {
-				addTypeToBeRemoved(stringDecrypter.Type, "String decrypter type");
-				addTypesToBeRemoved(stringDecrypter.OtherTypes, "Decrypted string type");
+				AddTypeToBeRemoved(stringDecrypter.Type, "String decrypter type");
+				AddTypesToBeRemoved(stringDecrypter.OtherTypes, "Decrypted string type");
 			}
-			base.deobfuscateEnd();
+			base.DeobfuscateEnd();
 		}
 
-		public override IEnumerable<int> getStringDecrypterMethods() {
+		public override IEnumerable<int> GetStringDecrypterMethods() {
 			return new List<int>();
 		}
 	}
diff --git a/de4dot.code/deobfuscators/Rummage/StringDecrypter.cs b/de4dot.code/deobfuscators/Rummage/StringDecrypter.cs
index c42bb08a..cddd02c5 100644
--- a/de4dot.code/deobfuscators/Rummage/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/Rummage/StringDecrypter.cs
@@ -34,8 +34,8 @@ namespace de4dot.code.deobfuscators.Rummage {
 		interface IDecrypter {
 			RummageVersion Version { get; }
 			MethodDef Method { get; }
-			void initialize();
-			string decrypt(int stringId);
+			void Initialize();
+			string Decrypt(int stringId);
 		}
 
 		abstract class DecrypterBaseV11 : IDecrypter {
@@ -59,21 +59,21 @@ namespace de4dot.code.deobfuscators.Rummage {
 				this.fileDispl = fileDispl;
 			}
 
-			public void initialize() {
+			public void Initialize() {
 				reader = new BinaryReader(new FileStream(decrypterMethod.DeclaringType.Module.Location, FileMode.Open, FileAccess.Read, FileShare.Read));
-				initializeImpl();
+				InitializeImpl();
 			}
 
-			protected abstract void initializeImpl();
+			protected abstract void InitializeImpl();
 
-			protected static MethodDef findDecrypterMethod(TypeDef type) {
+			protected static MethodDef FindDecrypterMethod(TypeDef type) {
 				MethodDef cctor = null, decrypterMethod = null;
 				foreach (var method in type.Methods) {
 					if (!method.IsStatic || method.Body == null)
 						return null;
 					if (method.Name == ".cctor")
 						cctor = method;
-					else if (DotNetUtils.isMethod(method, "System.String", "(System.Int32)"))
+					else if (DotNetUtils.IsMethod(method, "System.String", "(System.Int32)"))
 						decrypterMethod = method;
 					else
 						return null;
@@ -84,19 +84,19 @@ namespace de4dot.code.deobfuscators.Rummage {
 				return decrypterMethod;
 			}
 
-			public abstract string decrypt(int stringId);
+			public abstract string Decrypt(int stringId);
 
-			protected string decryptInternal(int stringId) {
+			protected string DecryptInternal(int stringId) {
 				uint v0 = reader.ReadUInt32();
 				uint v1 = reader.ReadUInt32();
-				DeobUtils.xteaDecrypt(ref v0, ref v1, key, 32);
+				DeobUtils.XteaDecrypt(ref v0, ref v1, key, 32);
 				int utf8Length = (int)v0;
 				var decrypted = new uint[(utf8Length + 11) / 8 * 2 - 1];
 				decrypted[0] = v1;
 				for (int i = 1; i + 1 < decrypted.Length; i += 2) {
 					v0 = reader.ReadUInt32();
 					v1 = reader.ReadUInt32();
-					DeobUtils.xteaDecrypt(ref v0, ref v1, key, 32);
+					DeobUtils.XteaDecrypt(ref v0, ref v1, key, 32);
 					decrypted[i] = v0;
 					decrypted[i + 1] = v1;
 				}
@@ -112,12 +112,12 @@ namespace de4dot.code.deobfuscators.Rummage {
 				: base(RummageVersion.V1_1_445, decrypterMethod, fileDispl) {
 			}
 
-			public static DecrypterV11 create(MethodDef cctor) {
-				var method = checkType(cctor);
+			public static DecrypterV11 Create(MethodDef cctor) {
+				var method = CheckType(cctor);
 				if (method == null)
 					return null;
 				int fileDispl;
-				if (!getDispl(method, out fileDispl))
+				if (!GetDispl(method, out fileDispl))
 					return null;
 
 				return new DecrypterV11(method, fileDispl);
@@ -131,17 +131,17 @@ namespace de4dot.code.deobfuscators.Rummage {
 				"System.Int32",
 				"System.IO.FileStream",
 			};
-			static MethodDef checkType(MethodDef cctor) {
+			static MethodDef CheckType(MethodDef cctor) {
 				var type = cctor.DeclaringType;
-				if (!new FieldTypes(type).exactly(requiredFields))
+				if (!new FieldTypes(type).Exactly(requiredFields))
 					return null;
-				if (!new LocalTypes(cctor).all(requiredLocals))
+				if (!new LocalTypes(cctor).All(requiredLocals))
 					return null;
 
-				return findDecrypterMethod(type);
+				return FindDecrypterMethod(type);
 			}
 
-			static bool getDispl(MethodDef method, out int displ) {
+			static bool GetDispl(MethodDef method, out int displ) {
 				var instrs = method.Body.Instructions;
 				for (int i = 0; i < instrs.Count - 2; i++) {
 					var mul = instrs[i];
@@ -164,20 +164,20 @@ namespace de4dot.code.deobfuscators.Rummage {
 				return false;
 			}
 
-			protected override void initializeImpl() {
-				initKey();
+			protected override void InitializeImpl() {
+				InitKey();
 			}
 
-			void initKey() {
+			void InitKey() {
 				reader.BaseStream.Position = reader.BaseStream.Length - 48;
 				key = new uint[4];
 				for (int i = 0; i < key.Length; i++)
 					key[i] = reader.ReadUInt32();
 			}
 
-			public override string decrypt(int stringId) {
+			public override string Decrypt(int stringId) {
 				reader.BaseStream.Position = reader.BaseStream.Length + (stringId * 4 - fileDispl);
-				return decryptInternal(stringId);
+				return DecryptInternal(stringId);
 			}
 		}
 
@@ -188,12 +188,12 @@ namespace de4dot.code.deobfuscators.Rummage {
 				: base(RummageVersion.V2_1_729, decrypterMethod, fileDispl) {
 			}
 
-			public static DecrypterV21 create(MethodDef cctor) {
-				var method = checkType(cctor);
+			public static DecrypterV21 Create(MethodDef cctor) {
+				var method = CheckType(cctor);
 				if (method == null)
 					return null;
 				int fileDispl;
-				if (!getDispl(method, out fileDispl))
+				if (!GetDispl(method, out fileDispl))
 					return null;
 
 				return new DecrypterV21(method, fileDispl);
@@ -209,17 +209,17 @@ namespace de4dot.code.deobfuscators.Rummage {
 				"System.Int32",
 				"System.IO.FileStream",
 			};
-			static MethodDef checkType(MethodDef cctor) {
+			static MethodDef CheckType(MethodDef cctor) {
 				var type = cctor.DeclaringType;
-				if (!new FieldTypes(type).exactly(requiredFields))
+				if (!new FieldTypes(type).Exactly(requiredFields))
 					return null;
-				if (!new LocalTypes(cctor).all(requiredLocals))
+				if (!new LocalTypes(cctor).All(requiredLocals))
 					return null;
 
-				return findDecrypterMethod(type);
+				return FindDecrypterMethod(type);
 			}
 
-			static bool getDispl(MethodDef method, out int displ) {
+			static bool GetDispl(MethodDef method, out int displ) {
 				var instrs = method.Body.Instructions;
 				for (int i = 0; i < instrs.Count - 6; i++) {
 					var ldci4_1 = instrs[i];
@@ -256,19 +256,19 @@ namespace de4dot.code.deobfuscators.Rummage {
 				0x61, 0xE3, 0xAA, 0xBC, 0xE4, 0xB1, 0xF0, 0x92,
 			};
 
-			protected override void initializeImpl() {
-				baseOffs = initializeBaseOffs();
-				initKey();
+			protected override void InitializeImpl() {
+				baseOffs = InitializeBaseOffs();
+				InitKey();
 			}
 
-			void initKey() {
+			void InitKey() {
 				reader.BaseStream.Position = baseOffs - 16;
 				key = new uint[4];
 				for (int i = 0; i < key.Length; i++)
 					key[i] = reader.ReadUInt32();
 			}
 
-			long initializeBaseOffs() {
+			long InitializeBaseOffs() {
 				byte[] buf = new byte[0x1000];	// Must be 4096 bytes
 				reader.BaseStream.Position = reader.BaseStream.Length - buf.Length;
 				while (true) {
@@ -292,9 +292,9 @@ namespace de4dot.code.deobfuscators.Rummage {
 				}
 			}
 
-			public override string decrypt(int stringId) {
+			public override string Decrypt(int stringId) {
 				reader.BaseStream.Position = baseOffs + stringId * 4 - fileDispl;
-				return decryptInternal(stringId);
+				return DecryptInternal(stringId);
 			}
 		}
 
@@ -310,7 +310,7 @@ namespace de4dot.code.deobfuscators.Rummage {
 
 			public override string ToString() {
 				if (decrypted != null)
-					return string.Format("{0:X8} - {1}", stringId, Utils.toCsharpString(decrypted));
+					return string.Format("{0:X8} - {1}", stringId, Utils.ToCsharpString(decrypted));
 				return string.Format("{0:X8}", stringId);
 			}
 		}
@@ -326,7 +326,7 @@ namespace de4dot.code.deobfuscators.Rummage {
 		public IEnumerable<TypeDef> OtherTypes {
 			get {
 				var list = new List<TypeDef>(stringInfos.Count);
-				foreach (var info in stringInfos.getValues())
+				foreach (var info in stringInfos.GetValues())
 					list.Add(info.field.DeclaringType);
 				return list;
 			}
@@ -340,43 +340,43 @@ namespace de4dot.code.deobfuscators.Rummage {
 			this.module = module;
 		}
 
-		public void find() {
+		public void Find() {
 			foreach (var type in module.GetTypes()) {
 				var cctor = type.FindStaticConstructor();
 				if (cctor == null)
 					continue;
 
-				decrypter = DecrypterV11.create(cctor);
+				decrypter = DecrypterV11.Create(cctor);
 				if (decrypter != null)
 					break;
 
-				decrypter = DecrypterV21.create(cctor);
+				decrypter = DecrypterV21.Create(cctor);
 				if (decrypter != null)
 					break;
 			}
 		}
 
-		public void initialize() {
+		public void Initialize() {
 			if (decrypter == null)
 				return;
 
-			decrypter.initialize();
+			decrypter.Initialize();
 			foreach (var type in module.Types)
-				initType(type);
+				InitType(type);
 		}
 
-		void initType(TypeDef type) {
+		void InitType(TypeDef type) {
 			var cctor = type.FindStaticConstructor();
 			if (cctor == null)
 				return;
-			var info = getStringInfo(cctor);
+			var info = GetStringInfo(cctor);
 			if (info == null)
 				return;
 
-			stringInfos.add(info.field, info);
+			stringInfos.Add(info.field, info);
 		}
 
-		StringInfo getStringInfo(MethodDef method) {
+		StringInfo GetStringInfo(MethodDef method) {
 			if (method == null || method.Body == null)
 				return null;
 			var instrs = method.Body.Instructions;
@@ -406,10 +406,10 @@ namespace de4dot.code.deobfuscators.Rummage {
 			return null;
 		}
 
-		public void deobfuscate(Blocks blocks) {
+		public void Deobfuscate(Blocks blocks) {
 			if (decrypter == null)
 				return;
-			foreach (var block in blocks.MethodBlocks.getAllBlocks()) {
+			foreach (var block in blocks.MethodBlocks.GetAllBlocks()) {
 				var instrs = block.Instructions;
 				for (int i = 0; i < instrs.Count; i++) {
 					var instr = instrs[i];
@@ -420,20 +420,20 @@ namespace de4dot.code.deobfuscators.Rummage {
 					var field = instr.Operand as IField;
 					if (field == null)
 						continue;
-					var info = stringInfos.find(field);
+					var info = stringInfos.Find(field);
 					if (info == null)
 						continue;
-					var decrypted = decrypt(info);
+					var decrypted = Decrypt(info);
 
 					instrs[i] = new Instr(OpCodes.Ldstr.ToInstruction(decrypted));
-					Logger.v("Decrypted string: {0}", Utils.toCsharpString(decrypted));
+					Logger.v("Decrypted string: {0}", Utils.ToCsharpString(decrypted));
 				}
 			}
 		}
 
-		string decrypt(StringInfo info) {
+		string Decrypt(StringInfo info) {
 			if (info.decrypted == null)
-				info.decrypted = decrypter.decrypt(info.stringId);
+				info.decrypted = decrypter.Decrypt(info.stringId);
 
 			return info.decrypted;
 		}
diff --git a/de4dot.code/deobfuscators/Skater_NET/Deobfuscator.cs b/de4dot.code/deobfuscators/Skater_NET/Deobfuscator.cs
index 387c0a7b..c787abda 100644
--- a/de4dot.code/deobfuscators/Skater_NET/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/Skater_NET/Deobfuscator.cs
@@ -39,7 +39,7 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 			get { return THE_TYPE; }
 		}
 
-		public override IDeobfuscator createDeobfuscator() {
+		public override IDeobfuscator CreateDeobfuscator() {
 			return new Deobfuscator(new Deobfuscator.Options {
 				ValidNameRegex = validNameRegex.get(),
 			});
@@ -73,7 +73,7 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 			StringFeatures = StringFeatures.AllowNoDecryption | StringFeatures.AllowStaticDecryption;
 		}
 
-		protected override int detectInternal() {
+		protected override int DetectInternal() {
 			int val = 0;
 
 			if (stringDecrypter.Detected)
@@ -82,14 +82,14 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 			return val;
 		}
 
-		protected override void scanForObfuscator() {
+		protected override void ScanForObfuscator() {
 			stringDecrypter = new StringDecrypter(module);
 
-			if (hasAssemblyRef("Microsoft.VisualBasic"))
-				stringDecrypter.find();
+			if (HasAssemblyRef("Microsoft.VisualBasic"))
+				stringDecrypter.Find();
 		}
 
-		bool hasAssemblyRef(string name) {
+		bool HasAssemblyRef(string name) {
 			foreach (var asmRef in module.GetAssemblyRefs()) {
 				if (asmRef.Name == name)
 					return true;
@@ -97,30 +97,30 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 			return false;
 		}
 
-		public override void deobfuscateBegin() {
-			base.deobfuscateBegin();
+		public override void DeobfuscateBegin() {
+			base.DeobfuscateBegin();
 
 			enumClassFinder = new EnumClassFinder(module);
 
-			stringDecrypter.initialize(DeobfuscatedFile);
+			stringDecrypter.Initialize(DeobfuscatedFile);
 		}
 
-		public override void deobfuscateMethodEnd(Blocks blocks) {
+		public override void DeobfuscateMethodEnd(Blocks blocks) {
 			if (CanRemoveStringDecrypterType)
-				stringDecrypter.deobfuscate(blocks);
-			enumClassFinder.deobfuscate(blocks);
-			base.deobfuscateMethodEnd(blocks);
+				stringDecrypter.Deobfuscate(blocks);
+			enumClassFinder.Deobfuscate(blocks);
+			base.DeobfuscateMethodEnd(blocks);
 		}
 
-		public override void deobfuscateEnd() {
+		public override void DeobfuscateEnd() {
 			if (Operations.DecryptStrings != OpDecryptString.None && stringDecrypter.CanRemoveType)
-				addTypeToBeRemoved(stringDecrypter.Type, "String decrypter type");
-			fixEnumTypes();
+				AddTypeToBeRemoved(stringDecrypter.Type, "String decrypter type");
+			FixEnumTypes();
 
-			base.deobfuscateEnd();
+			base.DeobfuscateEnd();
 		}
 
-		public override IEnumerable<int> getStringDecrypterMethods() {
+		public override IEnumerable<int> GetStringDecrypterMethods() {
 			var list = new List<int>();
 			return list;
 		}
diff --git a/de4dot.code/deobfuscators/Skater_NET/EnumClassFinder.cs b/de4dot.code/deobfuscators/Skater_NET/EnumClassFinder.cs
index c59bb184..1f895500 100644
--- a/de4dot.code/deobfuscators/Skater_NET/EnumClassFinder.cs
+++ b/de4dot.code/deobfuscators/Skater_NET/EnumClassFinder.cs
@@ -28,10 +28,10 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 
 		public EnumClassFinder(ModuleDefMD module) {
 			this.module = module;
-			find();
+			Find();
 		}
 
-		void find() {
+		void Find() {
 			foreach (var type in module.Types) {
 				if (type.HasEvents || type.HasProperties)
 					continue;
@@ -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.FieldSig.GetFieldType());
+				var fieldType = DotNetUtils.GetType(module, field.FieldSig.GetFieldType());
 				if (fieldType == null)
 					continue;
 				if (!fieldType.IsEnum)
@@ -53,8 +53,8 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 			}
 		}
 
-		public void deobfuscate(Blocks blocks) {
-			foreach (var block in blocks.MethodBlocks.getAllBlocks()) {
+		public void Deobfuscate(Blocks blocks) {
+			foreach (var block in blocks.MethodBlocks.GetAllBlocks()) {
 				var instrs = block.Instructions;
 				for (int i = 0; i < instrs.Count - 2; i++) {
 					var ldsfld = instrs[i];
@@ -62,7 +62,7 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 						continue;
 
 					var ldci4 = instrs[i + 1];
-					if (!ldci4.isLdcI4())
+					if (!ldci4.IsLdcI4())
 						continue;
 
 					var stfld = instrs[i + 2];
@@ -72,7 +72,7 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 					var field = stfld.Operand as IField;
 					if (!FieldEqualityComparer.CompareDeclaringTypes.Equals(enumField, field))
 						continue;
-					block.remove(i, 3);
+					block.Remove(i, 3);
 					i--;
 				}
 			}
diff --git a/de4dot.code/deobfuscators/Skater_NET/StringDecrypter.cs b/de4dot.code/deobfuscators/Skater_NET/StringDecrypter.cs
index 97f205fc..31f5f9d5 100644
--- a/de4dot.code/deobfuscators/Skater_NET/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/Skater_NET/StringDecrypter.cs
@@ -37,7 +37,7 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 		IDecrypter decrypter;
 
 		interface IDecrypter {
-			string decrypt(string encrypted);
+			string Decrypt(string encrypted);
 		}
 
 		class DecrypterV1 : IDecrypter {
@@ -49,9 +49,9 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 				this.iv = iv;
 			}
 
-			public string decrypt(string encrypted) {
+			public string Decrypt(string encrypted) {
 				try {
-					return Encoding.Unicode.GetString(DeobUtils.des3Decrypt(Convert.FromBase64String(encrypted), key, iv));
+					return Encoding.Unicode.GetString(DeobUtils.Des3Decrypt(Convert.FromBase64String(encrypted), key, iv));
 				}
 				catch (FormatException) {
 					return "";
@@ -60,7 +60,7 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 		}
 
 		class DecrypterV2 : IDecrypter {
-			public string decrypt(string encrypted) {
+			public string Decrypt(string encrypted) {
 				var ints = encrypted.Split(' ');
 				if (ints.Length % 3 != 0)
 					throw new ApplicationException("Invalid encrypted string");
@@ -92,7 +92,7 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 			this.module = module;
 		}
 
-		public void find() {
+		public void Find() {
 			foreach (var type in module.Types) {
 				if (type.HasProperties || type.HasEvents)
 					continue;
@@ -101,7 +101,7 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 				if (cctor == null)
 					continue;
 
-				if (checkType(type)) {
+				if (CheckType(type)) {
 					canRemoveType = true;
 					decrypterType = type;
 					decrypterCctor = cctor;
@@ -110,11 +110,11 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 			}
 		}
 
-		public void initialize(ISimpleDeobfuscator deobfuscator) {
+		public void Initialize(ISimpleDeobfuscator deobfuscator) {
 			if (decrypterCctor == null)
 				return;
 
-			deobfuscator.deobfuscate(decrypterCctor);
+			deobfuscator.Deobfuscate(decrypterCctor);
 			var instrs = decrypterCctor.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 4; i++) {
 				var ldstr = instrs[i];
@@ -137,32 +137,32 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 				if (!new SigComparer().Equals(field.DeclaringType, decrypterType))
 					continue;
 
-				fieldToDecryptedString.add(field, decrypter.decrypt(encryptedString));
+				fieldToDecryptedString.Add(field, decrypter.Decrypt(encryptedString));
 			}
 		}
 
-		bool checkType(TypeDef type) {
+		bool CheckType(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
-				if (!DotNetUtils.isMethod(method, "System.String", "(System.String)"))
+				if (!DotNetUtils.IsMethod(method, "System.String", "(System.String)"))
 					continue;
 
-				if (checkMethodV1(method))
+				if (CheckMethodV1(method))
 					return true;
-				if (checkMethodV2(method))
+				if (CheckMethodV2(method))
 					return true;
 			}
 
 			return false;
 		}
 
-		bool checkMethodV1(MethodDef method) {
-			var salt = getSalt(method);
+		bool CheckMethodV1(MethodDef method) {
+			var salt = GetSalt(method);
 			if (salt == null)
 				return false;
 
-			var password = getPassword(method);
+			var password = GetPassword(method);
 			if (string.IsNullOrEmpty(password))
 				return false;
 
@@ -181,11 +181,11 @@ 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(MethodDef method) {
-			if (!DeobUtils.hasInteger(method, ' '))
+		bool CheckMethodV2(MethodDef method) {
+			if (!DeobUtils.HasInteger(method, ' '))
 				return false;
 			foreach (var calledMethodName in callsMethodsV2) {
-				if (!DotNetUtils.callsMethod(method, calledMethodName))
+				if (!DotNetUtils.CallsMethod(method, calledMethodName))
 					return false;
 			}
 
@@ -193,9 +193,9 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 			return true;
 		}
 
-		static byte[] getSalt(MethodDef method) {
-			foreach (var s in DotNetUtils.getCodeStrings(method)) {
-				var saltAry = fixSalt(s);
+		static byte[] GetSalt(MethodDef method) {
+			foreach (var s in DotNetUtils.GetCodeStrings(method)) {
+				var saltAry = FixSalt(s);
 				if (saltAry != null)
 					return saltAry;
 			}
@@ -203,7 +203,7 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 			return null;
 		}
 
-		static byte[] fixSalt(string s) {
+		static byte[] FixSalt(string s) {
 			if (s.Length < 10 || s.Length > 30 || s.Length / 2 * 2 != s.Length)
 				return null;
 
@@ -224,20 +224,20 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 			return saltAry;
 		}
 
-		string getPassword(MethodDef decryptMethod) {
-			foreach (var method in DotNetUtils.getCalledMethods(module, decryptMethod)) {
+		string GetPassword(MethodDef decryptMethod) {
+			foreach (var method in DotNetUtils.GetCalledMethods(module, decryptMethod)) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
 				if (!new SigComparer().Equals(method.DeclaringType, decryptMethod.DeclaringType))
 					continue;
-				if (!DotNetUtils.isMethod(method, "System.String", "()"))
+				if (!DotNetUtils.IsMethod(method, "System.String", "()"))
 					continue;
 
-				var hexChars = getPassword2(method);
+				var hexChars = GetPassword2(method);
 				if (string.IsNullOrEmpty(hexChars))
 					continue;
 
-				var password = fixPassword(hexChars);
+				var password = FixPassword(hexChars);
 				if (string.IsNullOrEmpty(password))
 					continue;
 
@@ -246,7 +246,7 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 			return null;
 		}
 
-		string fixPassword(string hexChars) {
+		string FixPassword(string hexChars) {
 			var ary = hexChars.Trim().Split(' ');
 			string password = "";
 			for (int i = 0; i < ary.Length; i++) {
@@ -258,10 +258,10 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 			return password;
 		}
 
-		string getPassword2(MethodDef method) {
+		string GetPassword2(MethodDef method) {
 			string password = "";
-			foreach (var calledMethod in DotNetUtils.getCalledMethods(module, method)) {
-				var s = getPassword3(calledMethod);
+			foreach (var calledMethod in DotNetUtils.GetCalledMethods(module, method)) {
+				var s = GetPassword3(calledMethod);
 				if (string.IsNullOrEmpty(s))
 					return null;
 
@@ -270,8 +270,8 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 			return password;
 		}
 
-		string getPassword3(MethodDef method) {
-			var strings = new List<string>(DotNetUtils.getCodeStrings(method));
+		string GetPassword3(MethodDef method) {
+			var strings = new List<string>(DotNetUtils.GetCodeStrings(method));
 			if (strings.Count != 1)
 				return null;
 
@@ -282,8 +282,8 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 			return s;
 		}
 
-		public void deobfuscate(Blocks blocks) {
-			foreach (var block in blocks.MethodBlocks.getAllBlocks()) {
+		public void Deobfuscate(Blocks blocks) {
+			foreach (var block in blocks.MethodBlocks.GetAllBlocks()) {
 				var instrs = block.Instructions;
 				for (int i = 0; i < instrs.Count; i++) {
 					var instr = instrs[i];
@@ -301,12 +301,12 @@ namespace de4dot.code.deobfuscators.Skater_NET {
 						var field = instr.Operand as IField;
 						if (field == null)
 							continue;
-						var decrypted = fieldToDecryptedString.find(field);
+						var decrypted = fieldToDecryptedString.Find(field);
 						if (decrypted == null)
 							continue;
 
 						instrs[i] = new Instr(OpCodes.Ldstr.ToInstruction(decrypted));
-						Logger.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 9dcae730..0451e176 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/AssemblyResolver.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/AssemblyResolver.cs
@@ -31,21 +31,21 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			this.assemblyResolverInfo = assemblyResolverInfo;
 		}
 
-		public bool resolveResources() {
-			return assemblyResolverInfo.resolveResources();
+		public bool ResolveResources() {
+			return assemblyResolverInfo.ResolveResources();
 		}
 
-		public bool canDecryptResource(EmbeddedAssemblyInfo info) {
+		public bool CanDecryptResource(EmbeddedAssemblyInfo info) {
 			if (info == null || !info.isCompressed)
 				return true;
 			return resourceDecrypter.CanDecrypt;
 		}
 
-		public IEnumerable<Tuple<EmbeddedAssemblyInfo, byte[]>> getDecryptedResources() {
+		public IEnumerable<Tuple<EmbeddedAssemblyInfo, byte[]>> GetDecryptedResources() {
 			var returned = new Dictionary<Resource, bool>();
 			foreach (var info in assemblyResolverInfo.EmbeddedAssemblyInfos) {
 				if (info.resource == null) {
-					Logger.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))
@@ -54,24 +54,24 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 
 				yield return new Tuple<EmbeddedAssemblyInfo, byte[]> {
 					Item1 = info,
-					Item2 = decryptResource(info),
+					Item2 = DecryptResource(info),
 				};
 			}
 		}
 
-		public byte[] removeDecryptedResource(EmbeddedAssemblyInfo info) {
+		public byte[] RemoveDecryptedResource(EmbeddedAssemblyInfo info) {
 			if (info == null)
 				return null;
 
-			var data = decryptResource(info);
-			if (!assemblyResolverInfo.removeEmbeddedAssemblyInfo(info))
-				throw new ApplicationException(string.Format("Could not remove resource {0}", Utils.toCsharpString(info.resourceName)));
+			var data = DecryptResource(info);
+			if (!assemblyResolverInfo.RemoveEmbeddedAssemblyInfo(info))
+				throw new ApplicationException(string.Format("Could not remove resource {0}", Utils.ToCsharpString(info.resourceName)));
 			return data;
 		}
 
-		byte[] decryptResource(EmbeddedAssemblyInfo info) {
+		byte[] DecryptResource(EmbeddedAssemblyInfo info) {
 			if (info.isCompressed)
-				return resourceDecrypter.decrypt(info.resource);
+				return resourceDecrypter.Decrypt(info.resource);
 			else
 				return info.resource.GetResourceData();
 		}
diff --git a/de4dot.code/deobfuscators/SmartAssembly/AssemblyResolverInfo.cs b/de4dot.code/deobfuscators/SmartAssembly/AssemblyResolverInfo.cs
index d856babe..668a76d0 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/AssemblyResolverInfo.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/AssemblyResolverInfo.cs
@@ -38,7 +38,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return assemblyName ?? base.ToString();
 		}
 
-		public static EmbeddedAssemblyInfo create(ModuleDefMD module, string encName, string rsrcName) {
+		public static EmbeddedAssemblyInfo Create(ModuleDefMD module, string encName, string rsrcName) {
 			var info = new EmbeddedAssemblyInfo();
 
 			try {
@@ -63,8 +63,8 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 
 			info.assemblyName = Encoding.UTF8.GetString(Convert.FromBase64String(encName));
 			info.resourceName = rsrcName;
-			info.resource = DotNetUtils.getResource(module, rsrcName) as EmbeddedResource;
-			info.simpleName = Utils.getAssemblySimpleName(info.assemblyName);
+			info.resource = DotNetUtils.GetResource(module, rsrcName) as EmbeddedResource;
+			info.simpleName = Utils.GetAssemblySimpleName(info.assemblyName);
 
 			return info;
 		}
@@ -86,13 +86,13 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			: base(module, simpleDeobfuscator, deob) {
 		}
 
-		public bool resolveResources() {
+		public bool ResolveResources() {
 			bool ok = true;
 
 			foreach (var info in embeddedAssemblyInfos) {
 				if (info.resource != null)
 					continue;
-				info.resource = DotNetUtils.getResource(module, info.resourceName) as EmbeddedResource;
+				info.resource = DotNetUtils.GetResource(module, info.resourceName) as EmbeddedResource;
 				if (info.resource == null)
 					ok = false;
 			}
@@ -100,12 +100,12 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return ok;
 		}
 
-		protected override bool checkResolverType(TypeDef type) {
-			if (DotNetUtils.findFieldType(type, "System.Collections.Hashtable", true) != null)
+		protected override bool CheckResolverType(TypeDef type) {
+			if (DotNetUtils.FindFieldType(type, "System.Collections.Hashtable", true) != null)
 				return true;
 
 			foreach (var field in type.Fields) {
-				if (DotNetUtils.derivesFromDelegate(DotNetUtils.getType(module, field.FieldType)))
+				if (DotNetUtils.DerivesFromDelegate(DotNetUtils.GetType(module, field.FieldType)))
 					continue;
 				if (field.IsLiteral && field.FieldType.ToString() == "System.String")
 					continue;
@@ -114,47 +114,47 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return true;
 		}
 
-		protected override bool checkHandlerMethod(MethodDef method) {
+		protected override bool CheckHandlerMethod(MethodDef method) {
 			if (!method.IsStatic || !method.HasBody)
 				return false;
 
 			var infos = new List<EmbeddedAssemblyInfo>();
-			foreach (var s in DotNetUtils.getCodeStrings(method)) {
+			foreach (var s in DotNetUtils.GetCodeStrings(method)) {
 				if (string.IsNullOrEmpty(s))
 					continue;
-				if (!initInfos(infos, s.Split(',')))
+				if (!InitInfos(infos, s.Split(',')))
 					continue;
 
 				embeddedAssemblyInfos = infos;
-				findSimpleZipType(method);
+				FindSimpleZipType(method);
 				return true;
 			}
 
 			return false;
 		}
 
-		bool initInfos(IList<EmbeddedAssemblyInfo> list, string[] strings) {
+		bool InitInfos(IList<EmbeddedAssemblyInfo> list, string[] strings) {
 			list.Clear();
 			if (strings.Length % 2 == 1)
 				return false;
 
 			for (int i = 0; i < strings.Length; i += 2) {
-				var info = EmbeddedAssemblyInfo.create(module, strings[i], strings[i + 1]);
+				var info = EmbeddedAssemblyInfo.Create(module, strings[i], strings[i + 1]);
 				if (info == null)
 					return false;
 				list.Add(info);
 			}
 
 			Logger.v("Found embedded assemblies:");
-			Logger.Instance.indent();
+			Logger.Instance.Indent();
 			foreach (var info in list)
 				Logger.v("{0}", info.assemblyName);
-			Logger.Instance.deIndent();
+			Logger.Instance.DeIndent();
 
 			return true;
 		}
 
-		void findSimpleZipType(MethodDef method) {
+		void FindSimpleZipType(MethodDef method) {
 			if (method == null || !method.HasBody)
 				return;
 			foreach (var call in method.Body.Instructions) {
@@ -163,14 +163,14 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				var calledMethod = call.Operand as IMethod;
 				if (calledMethod == null)
 					continue;
-				if (!SimpleZipInfo.isSimpleZipDecryptMethod_QuickCheck(module, calledMethod, out simpleZipTypeMethod))
+				if (!SimpleZipInfo.IsSimpleZipDecryptMethod_QuickCheck(module, calledMethod, out simpleZipTypeMethod))
 					continue;
 
 				return;
 			}
 		}
 
-		public EmbeddedAssemblyInfo find(string simpleName) {
+		public EmbeddedAssemblyInfo Find(string simpleName) {
 			foreach (var info in embeddedAssemblyInfos) {
 				if (info.simpleName == simpleName)
 					return info;
@@ -179,7 +179,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return null;
 		}
 
-		public bool removeEmbeddedAssemblyInfo(EmbeddedAssemblyInfo info) {
+		public bool RemoveEmbeddedAssemblyInfo(EmbeddedAssemblyInfo info) {
 			bool removed = false;
 			for (int i = 0; i < EmbeddedAssemblyInfos.Count; i++) {
 				var other = EmbeddedAssemblyInfos[i];
diff --git a/de4dot.code/deobfuscators/SmartAssembly/AutomatedErrorReportingFinder.cs b/de4dot.code/deobfuscators/SmartAssembly/AutomatedErrorReportingFinder.cs
index 2a55f620..ff1c2f2c 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/AutomatedErrorReportingFinder.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/AutomatedErrorReportingFinder.cs
@@ -36,8 +36,8 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			this.module = module;
 		}
 
-		protected override bool isExceptionLogger(IMethod method) {
-			return isExceptionLoggerMethod(method);
+		protected override bool IsExceptionLogger(IMethod method) {
+			return IsExceptionLoggerMethod(method);
 		}
 
 		public void find() {
@@ -46,11 +46,11 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				enabled = true;
 			else {
 				MethodDef exceptionMethod;
-				enabled = checkMethod(entryPoint, out exceptionMethod);
+				enabled = CheckMethod(entryPoint, out exceptionMethod);
 			}
 		}
 
-		bool checkMethod(MethodDef method, out MethodDef exceptionMethod) {
+		bool CheckMethod(MethodDef method, out MethodDef exceptionMethod) {
 			exceptionMethod = null;
 
 			var body = method.Body;
@@ -73,14 +73,14 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 
 			int handlerStart = instrs.IndexOf(eh.HandlerStart);
 			int handlerEnd = eh.HandlerEnd == null ? instrs.Count : instrs.IndexOf(eh.HandlerEnd);
-			exceptionMethod = DotNetUtils.getMethod(module, checkHandler(instrs, handlerStart, handlerEnd));
+			exceptionMethod = DotNetUtils.GetMethod(module, CheckHandler(instrs, handlerStart, handlerEnd));
 			if (exceptionMethod == null || !exceptionMethod.IsStatic || exceptionMethod.Body == null)
 				return false;
 
-			return isExceptionLoggerMethod(exceptionMethod);
+			return IsExceptionLoggerMethod(exceptionMethod);
 		}
 
-		IMethod checkHandler(IList<Instruction> instrs, int start, int end) {
+		IMethod CheckHandler(IList<Instruction> instrs, int start, int end) {
 			IMethod calledMethod = null;
 			for (int i = start; i < end; i++) {
 				var instr = instrs[i];
@@ -97,7 +97,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return calledMethod;
 		}
 
-		static bool isExceptionLoggerMethod(IMethod method) {
+		static bool IsExceptionLoggerMethod(IMethod method) {
 			if (method.Name == ".ctor" || method.Name == ".cctor")
 				return false;
 
diff --git a/de4dot.code/deobfuscators/SmartAssembly/Deobfuscator.cs b/de4dot.code/deobfuscators/SmartAssembly/Deobfuscator.cs
index 21925538..7db5025d 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/Deobfuscator.cs
@@ -35,9 +35,9 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 
 		public DeobfuscatorInfo()
 			: base() {
-			removeAutomatedErrorReporting = new BoolOption(null, makeArgName("error"), "Remove automated error reporting code", true);
-			removeTamperProtection = new BoolOption(null, makeArgName("tamper"), "Remove tamper protection code", true);
-			removeMemoryManager = new BoolOption(null, makeArgName("memory"), "Remove memory manager code", true);
+			removeAutomatedErrorReporting = new BoolOption(null, MakeArgName("error"), "Remove automated error reporting code", true);
+			removeTamperProtection = new BoolOption(null, MakeArgName("tamper"), "Remove tamper protection code", true);
+			removeMemoryManager = new BoolOption(null, MakeArgName("memory"), "Remove memory manager code", true);
 		}
 
 		public override string Name {
@@ -48,7 +48,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			get { return THE_TYPE; }
 		}
 
-		public override IDeobfuscator createDeobfuscator() {
+		public override IDeobfuscator CreateDeobfuscator() {
 			return new Deobfuscator(new Deobfuscator.Options {
 				ValidNameRegex = validNameRegex.get(),
 				RemoveAutomatedErrorReporting = removeAutomatedErrorReporting.get(),
@@ -57,7 +57,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			});
 		}
 
-		protected override IEnumerable<Option> getOptionsInternal() {
+		protected override IEnumerable<Option> GetOptionsInternal() {
 			return new List<Option>() {
 				removeAutomatedErrorReporting,
 				removeTamperProtection,
@@ -120,11 +120,11 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			StringFeatures = StringFeatures.AllowStaticDecryption;
 		}
 
-		public override void init(ModuleDefMD module) {
-			base.init(module);
+		public override void Initialize(ModuleDefMD module) {
+			base.Initialize(module);
 		}
 
-		protected override int detectInternal() {
+		protected override int DetectInternal() {
 			int val = 0;
 
 			if (memoryManagerInfo.Detected)
@@ -135,29 +135,29 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return val;
 		}
 
-		protected override void scanForObfuscator() {
-			findSmartAssemblyAttributes();
+		protected override void ScanForObfuscator() {
+			FindSmartAssemblyAttributes();
 			memoryManagerInfo = new MemoryManagerInfo(module);
-			memoryManagerInfo.find();
+			memoryManagerInfo.Find();
 			proxyCallFixer = new ProxyCallFixer(module, DeobfuscatedFile);
-			proxyCallFixer.findDelegateCreator(module);
+			proxyCallFixer.FindDelegateCreator(module);
 
 			if (!foundVersion)
-				guessVersion();
+				GuessVersion();
 		}
 
-		void findSmartAssemblyAttributes() {
+		void FindSmartAssemblyAttributes() {
 			foreach (var type in module.Types) {
 				if (Utils.StartsWith(type.FullName, "SmartAssembly.Attributes.PoweredByAttribute", StringComparison.Ordinal)) {
 					foundSmartAssemblyAttribute = true;
-					addAttributeToBeRemoved(type, "Obfuscator attribute");
-					initializeVersion(type);
+					AddAttributeToBeRemoved(type, "Obfuscator attribute");
+					InitializeVersion(type);
 				}
 			}
 		}
 
-		void initializeVersion(TypeDef attr) {
-			var s = DotNetUtils.getCustomArgAsString(getAssemblyAttribute(attr), 0);
+		void InitializeVersion(TypeDef attr) {
+			var s = DotNetUtils.GetCustomArgAsString(GetAssemblyAttribute(attr), 0);
 			if (s == null)
 				return;
 
@@ -174,7 +174,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return;
 		}
 
-		void guessVersion() {
+		void GuessVersion() {
 			if (poweredByAttributeString == "Powered by SmartAssembly") {
 				ObfuscatorName = "SmartAssembly 5.0/5.1";
 				approxVersion = new Version(5, 0, 0, 0);
@@ -184,13 +184,13 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			if (poweredByAttributeString == "Powered by {smartassembly}") {
 				// It's SA 1.x - 4.x
 
-				if (proxyCallFixer.Detected || hasEmptyClassesInEveryNamespace()) {
+				if (proxyCallFixer.Detected || HasEmptyClassesInEveryNamespace()) {
 					ObfuscatorName = "SmartAssembly 4.x";
 					approxVersion = new Version(4, 0, 0, 0);
 					return;
 				}
 
-				int ver = checkTypeIdAttribute();
+				int ver = CheckTypeIdAttribute();
 				if (ver == 2) {
 					ObfuscatorName = "SmartAssembly 2.x";
 					approxVersion = new Version(2, 0, 0, 0);
@@ -202,7 +202,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 					return;
 				}
 
-				if (hasModuleCctor()) {
+				if (HasModuleCctor()) {
 					ObfuscatorName = "SmartAssembly 3.x";
 					approxVersion = new Version(3, 0, 0, 0);
 					return;
@@ -214,8 +214,8 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			}
 		}
 
-		int checkTypeIdAttribute() {
-			var type = getTypeIdAttribute();
+		int CheckTypeIdAttribute() {
+			var type = GetTypeIdAttribute();
 			if (type == null)
 				return -1;
 
@@ -227,7 +227,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return -1;
 		}
 
-		TypeDef getTypeIdAttribute() {
+		TypeDef GetTypeIdAttribute() {
 			Dictionary<TypeDef, bool> attrs = null;
 			int counter = 0;
 			foreach (var type in module.GetTypes()) {
@@ -238,7 +238,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 
 				var attrs2 = new Dictionary<TypeDef, bool>();
 				foreach (var cattr in cattrs) {
-					if (!DotNetUtils.isMethod(cattr.Constructor as IMethod, "System.Void", "(System.Int32)"))
+					if (!DotNetUtils.IsMethod(cattr.Constructor as IMethod, "System.Void", "(System.Int32)"))
 						continue;
 					var attrType = cattr.AttributeType as TypeDef;
 					if (attrType == null)
@@ -262,13 +262,13 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return null;
 		}
 
-		bool hasModuleCctor() {
-			return DotNetUtils.getModuleTypeCctor(module) != null;
+		bool HasModuleCctor() {
+			return DotNetUtils.GetModuleTypeCctor(module) != null;
 		}
 
-		bool hasEmptyClassesInEveryNamespace() {
+		bool HasEmptyClassesInEveryNamespace() {
 			var namespaces = new Dictionary<string, int>(StringComparer.Ordinal);
-			var moduleType = DotNetUtils.getModuleType(module);
+			var moduleType = DotNetUtils.GetModuleType(module);
 			foreach (var type in module.Types) {
 				if (type == moduleType)
 					continue;
@@ -287,69 +287,69 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return true;
 		}
 
-		public override void deobfuscateBegin() {
-			base.deobfuscateBegin();
+		public override void DeobfuscateBegin() {
+			base.DeobfuscateBegin();
 
 			tamperProtectionRemover = new TamperProtectionRemover(module);
 			automatedErrorReportingFinder = new AutomatedErrorReportingFinder(module);
 			automatedErrorReportingFinder.find();
 
 			if (options.RemoveMemoryManager) {
-				addModuleCctorInitCallToBeRemoved(memoryManagerInfo.CctorInitMethod);
-				addCallToBeRemoved(module.EntryPoint, memoryManagerInfo.CctorInitMethod);
+				AddModuleCctorInitCallToBeRemoved(memoryManagerInfo.CctorInitMethod);
+				AddCallToBeRemoved(module.EntryPoint, memoryManagerInfo.CctorInitMethod);
 			}
 
-			initDecrypters();
-			proxyCallFixer.find();
+			InitDecrypters();
+			proxyCallFixer.Find();
 		}
 
-		void initDecrypters() {
+		void InitDecrypters() {
 			assemblyResolverInfo = new AssemblyResolverInfo(module, DeobfuscatedFile, this);
-			assemblyResolverInfo.findTypes();
+			assemblyResolverInfo.FindTypes();
 			resourceDecrypterInfo = new ResourceDecrypterInfo(module, assemblyResolverInfo.SimpleZipTypeMethod, DeobfuscatedFile);
 			resourceResolverInfo = new ResourceResolverInfo(module, DeobfuscatedFile, this, assemblyResolverInfo);
-			resourceResolverInfo.findTypes();
+			resourceResolverInfo.FindTypes();
 			resourceDecrypter = new ResourceDecrypter(resourceDecrypterInfo);
 			assemblyResolver = new AssemblyResolver(resourceDecrypter, assemblyResolverInfo);
 			resourceResolver = new ResourceResolver(module, assemblyResolver, resourceResolverInfo);
 
-			initStringDecrypterInfos();
-			assemblyResolverInfo.findTypes();
-			resourceResolverInfo.findTypes();
+			InitStringDecrypterInfos();
+			assemblyResolverInfo.FindTypes();
+			resourceResolverInfo.FindTypes();
 
-			addModuleCctorInitCallToBeRemoved(assemblyResolverInfo.CallResolverMethod);
-			addCallToBeRemoved(module.EntryPoint, assemblyResolverInfo.CallResolverMethod);
-			addModuleCctorInitCallToBeRemoved(resourceResolverInfo.CallResolverMethod);
-			addCallToBeRemoved(module.EntryPoint, resourceResolverInfo.CallResolverMethod);
+			AddModuleCctorInitCallToBeRemoved(assemblyResolverInfo.CallResolverMethod);
+			AddCallToBeRemoved(module.EntryPoint, assemblyResolverInfo.CallResolverMethod);
+			AddModuleCctorInitCallToBeRemoved(resourceResolverInfo.CallResolverMethod);
+			AddCallToBeRemoved(module.EntryPoint, resourceResolverInfo.CallResolverMethod);
 
-			resourceDecrypterInfo.setSimpleZipType(getGlobalSimpleZipTypeMethod(), DeobfuscatedFile);
+			resourceDecrypterInfo.SetSimpleZipType(GetGlobalSimpleZipTypeMethod(), DeobfuscatedFile);
 
-			if (!decryptResources())
+			if (!DecryptResources())
 				throw new ApplicationException("Could not decrypt resources");
 
-			dumpEmbeddedAssemblies();
+			DumpEmbeddedAssemblies();
 		}
 
-		void dumpEmbeddedAssemblies() {
-			assemblyResolver.resolveResources();
-			foreach (var tuple in assemblyResolver.getDecryptedResources()) {
-				DeobfuscatedFile.createAssemblyFile(tuple.Item2, tuple.Item1.simpleName, null);
-				addResourceToBeRemoved(tuple.Item1.resource, string.Format("Embedded assembly: {0}", tuple.Item1.assemblyName));
+		void DumpEmbeddedAssemblies() {
+			assemblyResolver.ResolveResources();
+			foreach (var tuple in assemblyResolver.GetDecryptedResources()) {
+				DeobfuscatedFile.CreateAssemblyFile(tuple.Item2, tuple.Item1.simpleName, null);
+				AddResourceToBeRemoved(tuple.Item1.resource, string.Format("Embedded assembly: {0}", tuple.Item1.assemblyName));
 			}
 		}
 
-		bool decryptResources() {
-			if (!resourceResolver.canDecryptResource())
+		bool DecryptResources() {
+			if (!resourceResolver.CanDecryptResource())
 				return false;
-			var info = resourceResolver.mergeResources();
+			var info = resourceResolver.MergeResources();
 			if (info == null)
 				return true;
-			addResourceToBeRemoved(info.resource, "Encrypted resources");
-			assemblyResolver.resolveResources();
+			AddResourceToBeRemoved(info.resource, "Encrypted resources");
+			assemblyResolver.ResolveResources();
 			return true;
 		}
 
-		MethodDef getGlobalSimpleZipTypeMethod() {
+		MethodDef GetGlobalSimpleZipTypeMethod() {
 			if (assemblyResolverInfo.SimpleZipTypeMethod != null)
 				return assemblyResolverInfo.SimpleZipTypeMethod;
 			foreach (var info in stringDecrypterInfos) {
@@ -359,9 +359,9 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return null;
 		}
 
-		void initStringDecrypterInfos() {
+		void InitStringDecrypterInfos() {
 			var stringEncoderClassFinder = new StringEncoderClassFinder(module, DeobfuscatedFile);
-			stringEncoderClassFinder.find();
+			stringEncoderClassFinder.Find();
 			foreach (var info in stringEncoderClassFinder.StringsEncoderInfos) {
 				var sinfo = new StringDecrypterInfo(module, info.StringDecrypterClass) {
 					GetStringDelegate = info.GetStringDelegate,
@@ -381,8 +381,8 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 					foreach (var info in stringDecrypterInfos) {
 						if (initd.ContainsKey(info))
 							continue;
-						if (info.init(this, DeobfuscatedFile)) {
-							resourceDecrypterInfo.setSimpleZipType(info.SimpleZipTypeMethod, DeobfuscatedFile);
+						if (info.Initialize(this, DeobfuscatedFile)) {
+							resourceDecrypterInfo.SetSimpleZipType(info.SimpleZipTypeMethod, DeobfuscatedFile);
 							initdInfo = info;
 							break;
 						}
@@ -390,16 +390,16 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 					if (initdInfo != null)
 						break;
 
-					assemblyResolverInfo.findTypes();
-					resourceResolverInfo.findTypes();
-					decryptResources();
+					assemblyResolverInfo.FindTypes();
+					resourceResolverInfo.FindTypes();
+					DecryptResources();
 				}
 
 				if (initdInfo == null)
 					break;
 
 				initd[initdInfo] = true;
-				initStringDecrypter(initdInfo);
+				InitStringDecrypter(initdInfo);
 			}
 
 			// Sometimes there could be a string decrypter present that isn't called by anyone.
@@ -410,49 +410,49 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			}
 		}
 
-		void initStringDecrypter(StringDecrypterInfo info) {
-			Logger.v("Adding string decrypter. Resource: {0}", Utils.toCsharpString(info.StringsResource.Name));
+		void InitStringDecrypter(StringDecrypterInfo info) {
+			Logger.v("Adding string decrypter. Resource: {0}", Utils.ToCsharpString(info.StringsResource.Name));
 			var decrypter = new StringDecrypter(info);
 			if (decrypter.CanDecrypt) {
 				var invokeMethod = info.GetStringDelegate == null ? null : info.GetStringDelegate.FindMethod("Invoke");
-				staticStringInliner.add(invokeMethod, (method, gim, args) => {
-					var fieldDef = DotNetUtils.getField(module, (IField)args[0]);
-					return decrypter.decrypt(fieldDef.MDToken.ToInt32(), (int)args[1]);
+				staticStringInliner.Add(invokeMethod, (method, gim, args) => {
+					var fieldDef = DotNetUtils.GetField(module, (IField)args[0]);
+					return decrypter.Decrypt(fieldDef.MDToken.ToInt32(), (int)args[1]);
 				});
-				staticStringInliner.add(info.StringDecrypterMethod, (method, gim, args) => {
-					return decrypter.decrypt(0, (int)args[0]);
+				staticStringInliner.Add(info.StringDecrypterMethod, (method, gim, args) => {
+					return decrypter.Decrypt(0, (int)args[0]);
 				});
 			}
 			stringDecrypters.Add(decrypter);
-			DeobfuscatedFile.stringDecryptersAdded();
+			DeobfuscatedFile.StringDecryptersAdded();
 		}
 
-		public override void deobfuscateMethodEnd(Blocks blocks) {
-			proxyCallFixer.deobfuscate(blocks);
-			removeAutomatedErrorReportingCode(blocks);
-			removeTamperProtection(blocks);
-			removeStringsInitCode(blocks);
-			base.deobfuscateMethodEnd(blocks);
+		public override void DeobfuscateMethodEnd(Blocks blocks) {
+			proxyCallFixer.Deobfuscate(blocks);
+			RemoveAutomatedErrorReportingCode(blocks);
+			RemoveTamperProtection(blocks);
+			RemoveStringsInitCode(blocks);
+			base.DeobfuscateMethodEnd(blocks);
 		}
 
-		public override void deobfuscateEnd() {
-			canRemoveTypes = findBigType() == null;
-			removeProxyDelegates(proxyCallFixer, canRemoveTypes);
-			removeMemoryManagerStuff();
-			removeTamperProtectionStuff();
-			removeStringDecryptionStuff();
-			removeResolverInfoTypes(assemblyResolverInfo, "Assembly");
-			removeResolverInfoTypes(resourceResolverInfo, "Resource");
-			base.deobfuscateEnd();
+		public override void DeobfuscateEnd() {
+			canRemoveTypes = FindBigType() == null;
+			RemoveProxyDelegates(proxyCallFixer, canRemoveTypes);
+			RemoveMemoryManagerStuff();
+			RemoveTamperProtectionStuff();
+			RemoveStringDecryptionStuff();
+			RemoveResolverInfoTypes(assemblyResolverInfo, "Assembly");
+			RemoveResolverInfoTypes(resourceResolverInfo, "Resource");
+			base.DeobfuscateEnd();
 		}
 
-		TypeDef findBigType() {
+		TypeDef FindBigType() {
 			if (approxVersion <= new Version(6, 5, 3, 53))
 				return null;
 
 			TypeDef bigType = null;
 			foreach (var type in module.Types) {
-				if (isBigType(type)) {
+				if (IsBigType(type)) {
 					if (bigType == null || type.Methods.Count > bigType.Methods.Count)
 						bigType = type;
 				}
@@ -460,7 +460,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return bigType;
 		}
 
-		bool isBigType(TypeDef type) {
+		bool IsBigType(TypeDef type) {
 			if (type.Methods.Count < 50)
 				return false;
 			if (type.HasProperties || type.HasEvents)
@@ -474,69 +474,69 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return true;
 		}
 
-		void removeResolverInfoTypes(ResolverInfoBase info, string typeName) {
+		void RemoveResolverInfoTypes(ResolverInfoBase info, string typeName) {
 			if (!canRemoveTypes)
 				return;
 			if (info.CallResolverType == null || info.Type == null)
 				return;
-			addTypeToBeRemoved(info.CallResolverType, string.Format("{0} resolver type #1", typeName));
-			addTypeToBeRemoved(info.Type, string.Format("{0} resolver type #2", typeName));
+			AddTypeToBeRemoved(info.CallResolverType, string.Format("{0} resolver type #1", typeName));
+			AddTypeToBeRemoved(info.Type, string.Format("{0} resolver type #2", typeName));
 		}
 
-		void removeAutomatedErrorReportingCode(Blocks blocks) {
+		void RemoveAutomatedErrorReportingCode(Blocks blocks) {
 			if (!options.RemoveAutomatedErrorReporting)
 				return;
-			if (automatedErrorReportingFinder.remove(blocks))
+			if (automatedErrorReportingFinder.Remove(blocks))
 				Logger.v("Removed Automated Error Reporting code");
 		}
 
-		void removeTamperProtection(Blocks blocks) {
+		void RemoveTamperProtection(Blocks blocks) {
 			if (!options.RemoveTamperProtection)
 				return;
-			if (tamperProtectionRemover.remove(blocks))
+			if (tamperProtectionRemover.Remove(blocks))
 				Logger.v("Removed Tamper Protection code");
 		}
 
-		void removeMemoryManagerStuff() {
+		void RemoveMemoryManagerStuff() {
 			if (!canRemoveTypes || !options.RemoveMemoryManager)
 				return;
-			addTypeToBeRemoved(memoryManagerInfo.Type, "Memory manager type");
+			AddTypeToBeRemoved(memoryManagerInfo.Type, "Memory manager type");
 		}
 
-		void removeTamperProtectionStuff() {
+		void RemoveTamperProtectionStuff() {
 			if (!options.RemoveTamperProtection)
 				return;
-			addMethodsToBeRemoved(tamperProtectionRemover.PinvokeMethods, "Tamper protection PInvoke method");
+			AddMethodsToBeRemoved(tamperProtectionRemover.PinvokeMethods, "Tamper protection PInvoke method");
 		}
 
-		void removeStringDecryptionStuff() {
+		void RemoveStringDecryptionStuff() {
 			if (!CanRemoveStringDecrypterType)
 				return;
 
 			foreach (var decrypter in stringDecrypters) {
 				var info = decrypter.StringDecrypterInfo;
-				addResourceToBeRemoved(info.StringsResource, "Encrypted strings");
-				addFieldsToBeRemoved(info.getAllStringDelegateFields(), "String decrypter delegate field");
+				AddResourceToBeRemoved(info.StringsResource, "Encrypted strings");
+				AddFieldsToBeRemoved(info.GetAllStringDelegateFields(), "String decrypter delegate field");
 
 				if (canRemoveTypes) {
-					addTypeToBeRemoved(info.StringsEncodingClass, "String decrypter type");
-					addTypeToBeRemoved(info.StringsType, "Creates the string decrypter delegates");
-					addTypeToBeRemoved(info.GetStringDelegate, "String decrypter delegate type");
+					AddTypeToBeRemoved(info.StringsEncodingClass, "String decrypter type");
+					AddTypeToBeRemoved(info.StringsType, "Creates the string decrypter delegates");
+					AddTypeToBeRemoved(info.GetStringDelegate, "String decrypter delegate type");
 				}
 			}
 		}
 
-		void removeStringsInitCode(Blocks blocks) {
+		void RemoveStringsInitCode(Blocks blocks) {
 			if (!CanRemoveStringDecrypterType)
 				return;
 
 			if (blocks.Method.Name == ".cctor") {
 				foreach (var decrypter in stringDecrypters)
-					decrypter.StringDecrypterInfo.removeInitCode(blocks);
+					decrypter.StringDecrypterInfo.RemoveInitCode(blocks);
 			}
 		}
 
-		public override IEnumerable<int> getStringDecrypterMethods() {
+		public override IEnumerable<int> GetStringDecrypterMethods() {
 			var list = new List<int>();
 			foreach (var method in staticStringInliner.Methods)
 				list.Add(method.MDToken.ToInt32());
diff --git a/de4dot.code/deobfuscators/SmartAssembly/MemoryManagerInfo.cs b/de4dot.code/deobfuscators/SmartAssembly/MemoryManagerInfo.cs
index 5b4a9b74..260cd8ba 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/MemoryManagerInfo.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/MemoryManagerInfo.cs
@@ -42,23 +42,23 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			this.module = module;
 		}
 
-		public bool find() {
-			if (checkCalledMethods(DotNetUtils.getModuleTypeCctor(module)))
+		public bool Find() {
+			if (CheckCalledMethods(DotNetUtils.GetModuleTypeCctor(module)))
 				return true;
-			if (checkCalledMethods(module.EntryPoint))
+			if (CheckCalledMethods(module.EntryPoint))
 				return true;
 			return false;
 		}
 
-		bool checkCalledMethods(MethodDef checkMethod) {
+		bool CheckCalledMethods(MethodDef checkMethod) {
 			if (checkMethod == null)
 				return false;
-			foreach (var method in DotNetUtils.getCalledMethods(module, checkMethod)) {
+			foreach (var method in DotNetUtils.GetCalledMethods(module, checkMethod)) {
 				if (method.Name == ".cctor" || method.Name == ".ctor")
 					continue;
-				if (!method.IsStatic || !DotNetUtils.isMethod(method, "System.Void", "()"))
+				if (!method.IsStatic || !DotNetUtils.IsMethod(method, "System.Void", "()"))
 					continue;
-				if (checkMemoryManagerType(method.DeclaringType, method)) {
+				if (CheckMemoryManagerType(method.DeclaringType, method)) {
 					memoryManagerType = method.DeclaringType;
 					attachAppMethod = method;
 					return true;
@@ -68,7 +68,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return false;
 		}
 
-		bool checkMemoryManagerType(TypeDef type, MethodDef method) {
+		bool CheckMemoryManagerType(TypeDef type, MethodDef method) {
 			// Only two fields: itself and a long
 			int fields = 0;
 			foreach (var field in type.Fields) {
@@ -77,7 +77,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 					fields++;
 					continue;
 				}
-				if (DotNetUtils.derivesFromDelegate(DotNetUtils.getType(module, field.FieldType)))
+				if (DotNetUtils.DerivesFromDelegate(DotNetUtils.GetType(module, field.FieldType)))
 					continue;
 
 				return false;
@@ -85,7 +85,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			if (fields != 2)
 				return false;
 
-			if (DotNetUtils.getPInvokeMethod(type, "kernel32", "SetProcessWorkingSetSize") == null)
+			if (DotNetUtils.GetPInvokeMethod(type, "kernel32", "SetProcessWorkingSetSize") == null)
 				return false;
 
 			return true;
diff --git a/de4dot.code/deobfuscators/SmartAssembly/ProxyCallFixer.cs b/de4dot.code/deobfuscators/SmartAssembly/ProxyCallFixer.cs
index 5227430e..7a5f2d5d 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/ProxyCallFixer.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/ProxyCallFixer.cs
@@ -49,17 +49,17 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			this.simpleDeobfuscator = simpleDeobfuscator;
 		}
 
-		protected override object checkCctor(ref TypeDef type, MethodDef cctor) {
+		protected override object CheckCctor(ref TypeDef type, MethodDef cctor) {
 			var instrs = cctor.Body.Instructions;
 			if (instrs.Count > 10)
 				return null;
 			if (instrs.Count != 3)
-				simpleDeobfuscator.deobfuscate(cctor);
+				simpleDeobfuscator.Deobfuscate(cctor);
 			if (instrs.Count != 3)
 				return null;
 			if (!instrs[0].IsLdcI4())
 				return null;
-			if (instrs[1].OpCode != OpCodes.Call || !isDelegateCreatorMethod(instrs[1].Operand as MethodDef))
+			if (instrs[1].OpCode != OpCodes.Call || !IsDelegateCreatorMethod(instrs[1].Operand as MethodDef))
 				return null;
 			if (instrs[2].OpCode != OpCodes.Ret)
 				return null;
@@ -73,7 +73,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return new object();
 		}
 
-		protected override void getCallInfo(object context, FieldDef field, out IMethod 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;
 
@@ -96,23 +96,23 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				Logger.w("Ignoring invalid method RID: {0:X8}, field: {1:X8}", memberRefRid, field.MDToken.ToInt32());
 		}
 
-		public void findDelegateCreator(ModuleDefMD module) {
+		public void FindDelegateCreator(ModuleDefMD module) {
 			var callCounter = new CallCounter();
 			foreach (var type in module.Types) {
-				if (type.Namespace != "" || !DotNetUtils.derivesFromDelegate(type))
+				if (type.Namespace != "" || !DotNetUtils.DerivesFromDelegate(type))
 					continue;
 				var cctor = type.FindStaticConstructor();
 				if (cctor == null)
 					continue;
-				foreach (var method in DotNetUtils.getMethodCalls(cctor))
-					callCounter.add(method);
+				foreach (var method in DotNetUtils.GetMethodCalls(cctor))
+					callCounter.Add(method);
 			}
 
-			var mostCalls = callCounter.most();
+			var mostCalls = callCounter.Most();
 			if (mostCalls == null)
 				return;
 
-			setDelegateCreatorMethod(DotNetUtils.getMethod(module, mostCalls));
+			SetDelegateCreatorMethod(DotNetUtils.GetMethod(module, mostCalls));
 		}
 	}
 }
diff --git a/de4dot.code/deobfuscators/SmartAssembly/ResolverInfoBase.cs b/de4dot.code/deobfuscators/SmartAssembly/ResolverInfoBase.cs
index 2a1fbc73..222bfca3 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/ResolverInfoBase.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/ResolverInfoBase.cs
@@ -38,7 +38,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			get {
 				if (callResolverMethod == null)
 					return null;
-				if (!hasOnlyThisMethod(callResolverMethod.DeclaringType, callResolverMethod))
+				if (!HasOnlyThisMethod(callResolverMethod.DeclaringType, callResolverMethod))
 					return null;
 				return callResolverMethod.DeclaringType;
 			}
@@ -54,62 +54,62 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			this.deob = deob;
 		}
 
-		public bool findTypes() {
+		public bool FindTypes() {
 			if (resolverType != null)
 				return true;
 
-			if (findTypes(DotNetUtils.getModuleTypeCctor(module)))
+			if (FindTypes(DotNetUtils.GetModuleTypeCctor(module)))
 				return true;
-			if (findTypes(module.EntryPoint))
+			if (FindTypes(module.EntryPoint))
 				return true;
 
 			return false;
 		}
 
-		bool findTypes(MethodDef initMethod) {
+		bool FindTypes(MethodDef initMethod) {
 			if (initMethod == null)
 				return false;
-			foreach (var method in DotNetUtils.getCalledMethods(module, initMethod)) {
+			foreach (var method in DotNetUtils.GetCalledMethods(module, initMethod)) {
 				if (method.Name == ".cctor" || method.Name == ".ctor")
 					continue;
-				if (!method.IsStatic || !DotNetUtils.isMethod(method, "System.Void", "()"))
+				if (!method.IsStatic || !DotNetUtils.IsMethod(method, "System.Void", "()"))
 					continue;
-				if (checkAttachAppMethod(method))
+				if (CheckAttachAppMethod(method))
 					return true;
 			}
 
 			return false;
 		}
 
-		bool checkAttachAppMethod(MethodDef attachAppMethod) {
+		bool CheckAttachAppMethod(MethodDef attachAppMethod) {
 			callResolverMethod = null;
 			if (!attachAppMethod.HasBody)
 				return false;
 
-			foreach (var method in DotNetUtils.getCalledMethods(module, attachAppMethod)) {
+			foreach (var method in DotNetUtils.GetCalledMethods(module, attachAppMethod)) {
 				if (attachAppMethod == method)
 					continue;
 				if (method.Name == ".cctor" || method.Name == ".ctor")
 					continue;
-				if (!method.IsStatic || !DotNetUtils.isMethod(method, "System.Void", "()"))
+				if (!method.IsStatic || !DotNetUtils.IsMethod(method, "System.Void", "()"))
 					continue;
-				if (!checkResolverInitMethod(method))
+				if (!CheckResolverInitMethod(method))
 					continue;
 
 				callResolverMethod = attachAppMethod;
 				return true;
 			}
 
-			if (hasLdftn(attachAppMethod)) {
-				simpleDeobfuscator.deobfuscate(attachAppMethod);
-				foreach (var resolverHandler in getResolverHandlers(attachAppMethod)) {
+			if (HasLdftn(attachAppMethod)) {
+				simpleDeobfuscator.Deobfuscate(attachAppMethod);
+				foreach (var resolverHandler in GetResolverHandlers(attachAppMethod)) {
 					if (!resolverHandler.HasBody)
 						continue;
-					var resolverTypeTmp = getResolverType(resolverHandler);
+					var resolverTypeTmp = GetResolverType(resolverHandler);
 					if (resolverTypeTmp == null)
 						continue;
-					deobfuscate(resolverHandler);
-					if (checkHandlerMethod(resolverHandler)) {
+					Deobfuscate(resolverHandler);
+					if (CheckHandlerMethod(resolverHandler)) {
 						callResolverMethod = attachAppMethod;
 						resolverType = resolverTypeTmp;
 						return true;
@@ -120,7 +120,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return false;
 		}
 
-		static bool hasLdftn(MethodDef method) {
+		static bool HasLdftn(MethodDef method) {
 			if (method == null || method.Body == null)
 				return false;
 			foreach (var instr in method.Body.Instructions) {
@@ -130,20 +130,20 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return false;
 		}
 
-		bool checkResolverInitMethod(MethodDef initMethod) {
+		bool CheckResolverInitMethod(MethodDef initMethod) {
 			resolverType = null;
 			if (!initMethod.HasBody)
 				return false;
 
-			deobfuscate(initMethod);
-			foreach (var handlerDef in getResolverHandlers(initMethod)) {
-				deobfuscate(handlerDef);
+			Deobfuscate(initMethod);
+			foreach (var handlerDef in GetResolverHandlers(initMethod)) {
+				Deobfuscate(handlerDef);
 
-				var resolverTypeTmp = getResolverType(handlerDef);
+				var resolverTypeTmp = GetResolverType(handlerDef);
 				if (resolverTypeTmp == null)
 					continue;
 
-				if (checkHandlerMethod(handlerDef)) {
+				if (CheckHandlerMethod(handlerDef)) {
 					resolverType = resolverTypeTmp;
 					return true;
 				}
@@ -152,58 +152,58 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return false;
 		}
 
-		void deobfuscate(MethodDef method) {
-			simpleDeobfuscator.deobfuscate(method);
-			simpleDeobfuscator.decryptStrings(method, deob);
+		void Deobfuscate(MethodDef method) {
+			simpleDeobfuscator.Deobfuscate(method);
+			simpleDeobfuscator.DecryptStrings(method, deob);
 		}
 
-		TypeDef getResolverType(MethodDef 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 IField);
+				var field = DotNetUtils.GetField(module, instr.Operand as IField);
 				if (field == null)
 					continue;
-				if (!checkResolverType(field.DeclaringType))
+				if (!CheckResolverType(field.DeclaringType))
 					continue;
 
 				return field.DeclaringType;
 			}
 
-			if (checkResolverType(resolveHandler.DeclaringType))
+			if (CheckResolverType(resolveHandler.DeclaringType))
 				return resolveHandler.DeclaringType;
 
 			return null;
 		}
 
-		protected abstract bool checkResolverType(TypeDef type);
-		protected abstract bool checkHandlerMethod(MethodDef handler);
+		protected abstract bool CheckResolverType(TypeDef type);
+		protected abstract bool CheckHandlerMethod(MethodDef handler);
 
-		IEnumerable<MethodDef> getResolverHandlers(MethodDef method) {
+		IEnumerable<MethodDef> GetResolverHandlers(MethodDef method) {
 			int numHandlers = 0;
 			var instructions = method.Body.Instructions;
 			for (int i = 0; i < instructions.Count; i++) {
-				var instrs = DotNetUtils.getInstructions(instructions, i, OpCodes.Call, OpCodes.Ldnull, OpCodes.Ldftn, OpCodes.Newobj, OpCodes.Callvirt);
+				var instrs = DotNetUtils.GetInstructions(instructions, i, OpCodes.Call, OpCodes.Ldnull, OpCodes.Ldftn, OpCodes.Newobj, OpCodes.Callvirt);
 				if (instrs == null)
 					continue;
 
 				var call = instrs[0];
-				if (!DotNetUtils.isMethod(call.Operand as IMethod, "System.AppDomain", "()"))
+				if (!DotNetUtils.IsMethod(call.Operand as IMethod, "System.AppDomain", "()"))
 					continue;
 
 				var ldftn = instrs[2];
-				var handlerDef = DotNetUtils.getMethod(module, ldftn.Operand as IMethod);
+				var handlerDef = DotNetUtils.GetMethod(module, ldftn.Operand as IMethod);
 				if (handlerDef == null)
 					continue;
 
 				var newobj = instrs[3];
-				if (!DotNetUtils.isMethod(newobj.Operand as IMethod, "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 IMethod, "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(TypeDef type, MethodDef 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 87d21d52..140c9085 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/ResourceDecrypter.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/ResourceDecrypter.cs
@@ -35,14 +35,14 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			get { return resourceDecrypterInfo != null && resourceDecrypterInfo.CanDecrypt; }
 		}
 
-		public byte[] decrypt(EmbeddedResource resource) {
+		public byte[] Decrypt(EmbeddedResource resource) {
 			if (!CanDecrypt)
 				throw new ApplicationException("Can't decrypt resources");
 			var encryptedData = resource.GetResourceData();
-			return decrypt(encryptedData);
+			return Decrypt(encryptedData);
 		}
 
-		byte[] decrypt(byte[] encryptedData) {
+		byte[] Decrypt(byte[] encryptedData) {
 			var reader = new BinaryReader(new MemoryStream(encryptedData));
 			int headerMagic = reader.ReadInt32();
 			if (headerMagic == 0x04034B50)
@@ -80,7 +80,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 					provider.Key = resourceDecrypterInfo.DES_Key;
 					provider.IV  = resourceDecrypterInfo.DES_IV;
 					using (var transform = provider.CreateDecryptor()) {
-						return decrypt(transform.TransformFinalBlock(encryptedData, 4, encryptedData.Length - 4));
+						return Decrypt(transform.TransformFinalBlock(encryptedData, 4, encryptedData.Length - 4));
 					}
 				}
 
@@ -91,7 +91,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 					provider.Key = resourceDecrypterInfo.AES_Key;
 					provider.IV  = resourceDecrypterInfo.AES_IV;
 					using (var transform = provider.CreateDecryptor()) {
-						return decrypt(transform.TransformFinalBlock(encryptedData, 4, encryptedData.Length - 4));
+						return Decrypt(transform.TransformFinalBlock(encryptedData, 4, encryptedData.Length - 4));
 					}
 				}
 
diff --git a/de4dot.code/deobfuscators/SmartAssembly/ResourceDecrypterInfo.cs b/de4dot.code/deobfuscators/SmartAssembly/ResourceDecrypterInfo.cs
index 858c303c..9904c1e1 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/ResourceDecrypterInfo.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/ResourceDecrypterInfo.cs
@@ -42,27 +42,27 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 
 		public ResourceDecrypterInfo(ModuleDefMD module, MethodDef simpleZipTypeDecryptMethod, ISimpleDeobfuscator simpleDeobfuscator)
 			: this(module) {
-			setSimpleZipType(simpleZipTypeDecryptMethod, simpleDeobfuscator);
+			SetSimpleZipType(simpleZipTypeDecryptMethod, simpleDeobfuscator);
 		}
 
-		public void setSimpleZipType(MethodDef method, ISimpleDeobfuscator simpleDeobfuscator) {
+		public void SetSimpleZipType(MethodDef method, ISimpleDeobfuscator simpleDeobfuscator) {
 			if (simpleZipTypeDecryptMethod != null || method == null)
 				return;
 			simpleZipTypeDecryptMethod = method;
-			init(simpleDeobfuscator, method);
+			Initialize(simpleDeobfuscator, method);
 		}
 
-		void init(ISimpleDeobfuscator simpleDeobfuscator, MethodDef method) {
+		void Initialize(ISimpleDeobfuscator simpleDeobfuscator, MethodDef method) {
 			var desList = new List<byte[]>(2);
 			var aesList = new List<byte[]>(2);
 
 			var instructions = method.Body.Instructions;
-			simpleDeobfuscator.deobfuscate(method);
+			simpleDeobfuscator.Deobfuscate(method);
 			for (int i = 0; i <= instructions.Count - 2; i++) {
 				var ldtoken = instructions[i];
 				if (ldtoken.OpCode.Code != Code.Ldtoken)
 					continue;
-				var field = DotNetUtils.getField(module, ldtoken.Operand as IField);
+				var field = DotNetUtils.GetField(module, ldtoken.Operand as IField);
 				if (field == null)
 					continue;
 				if (field.InitialValue == null)
@@ -72,7 +72,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				if (call.OpCode.Code != Code.Call)
 					continue;
 				var calledMethod = call.Operand as IMethod;
-				if (!DotNetUtils.isMethod(calledMethod, "System.Void", "(System.Array,System.RuntimeFieldHandle)"))
+				if (!DotNetUtils.IsMethod(calledMethod, "System.Void", "(System.Array,System.RuntimeFieldHandle)"))
 					continue;
 
 				if (field.InitialValue.Length == 8)
diff --git a/de4dot.code/deobfuscators/SmartAssembly/ResourceResolver.cs b/de4dot.code/deobfuscators/SmartAssembly/ResourceResolver.cs
index 9a8a18a1..4ca75e60 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/ResourceResolver.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/ResourceResolver.cs
@@ -35,11 +35,11 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			this.resourceResolverInfo = resourceResolverInfo;
 		}
 
-		public bool canDecryptResource() {
-			return assemblyResolver.canDecryptResource(resourceResolverInfo.ResourceInfo);
+		public bool CanDecryptResource() {
+			return assemblyResolver.CanDecryptResource(resourceResolverInfo.ResourceInfo);
 		}
 
-		public EmbeddedAssemblyInfo mergeResources() {
+		public EmbeddedAssemblyInfo MergeResources() {
 			if (mergedIt)
 				return null;
 
@@ -47,7 +47,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			if (info == null)
 				return null;
 
-			DeobUtils.decryptAndAddResources(module, info.resourceName, () => assemblyResolver.removeDecryptedResource(info));
+			DeobUtils.DecryptAndAddResources(module, info.resourceName, () => assemblyResolver.RemoveDecryptedResource(info));
 			mergedIt = true;
 			return info;
 		}
diff --git a/de4dot.code/deobfuscators/SmartAssembly/ResourceResolverInfo.cs b/de4dot.code/deobfuscators/SmartAssembly/ResourceResolverInfo.cs
index d8637dac..77d408ad 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/ResourceResolverInfo.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/ResourceResolverInfo.cs
@@ -35,18 +35,18 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			this.assemblyResolverInfo = assemblyResolverInfo;
 		}
 
-		protected override bool checkResolverType(TypeDef type) {
-			return DotNetUtils.findFieldType(type, "System.Reflection.Assembly", true) != null;
+		protected override bool CheckResolverType(TypeDef type) {
+			return DotNetUtils.FindFieldType(type, "System.Reflection.Assembly", true) != null;
 		}
 
-		protected override bool checkHandlerMethod(MethodDef method) {
+		protected override bool CheckHandlerMethod(MethodDef method) {
 			if (!method.IsStatic || !method.HasBody)
 				return false;
 
 			EmbeddedAssemblyInfo info = null;
 			var instructions = method.Body.Instructions;
 			for (int i = 0; i < instructions.Count; i++) {
-				var instrs = DotNetUtils.getInstructions(instructions, i, OpCodes.Ldstr, OpCodes.Call);
+				var instrs = DotNetUtils.GetInstructions(instructions, i, OpCodes.Ldstr, OpCodes.Call);
 				if (instrs == null)
 					continue;
 
@@ -55,7 +55,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				if (s == null || calledMethod == null)
 					continue;
 
-				info = assemblyResolverInfo.find(Utils.getAssemblySimpleName(s));
+				info = assemblyResolverInfo.Find(Utils.GetAssemblySimpleName(s));
 				if (info != null)
 					break;
 			}
@@ -63,7 +63,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				return false;
 
 			resourceInfo = info;
-			Logger.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 8c04695c..bdfe1b1d 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/SimpleZipInfo.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/SimpleZipInfo.cs
@@ -23,13 +23,13 @@ using de4dot.blocks;
 namespace de4dot.code.deobfuscators.SmartAssembly {
 	class SimpleZipInfo {
 
-		public static bool isSimpleZipDecryptMethod_QuickCheck(ModuleDefMD module, IMethod method, out MethodDef simpleZipTypeMethod) {
+		public static bool IsSimpleZipDecryptMethod_QuickCheck(ModuleDefMD module, IMethod method, out MethodDef simpleZipTypeMethod) {
 			simpleZipTypeMethod = null;
 
-			if (!DotNetUtils.isMethod(method, "System.Byte[]", "(System.Byte[])"))
+			if (!DotNetUtils.IsMethod(method, "System.Byte[]", "(System.Byte[])"))
 				return false;
 
-			var methodDef = DotNetUtils.getMethod(DotNetUtils.getType(module, method.DeclaringType), method);
+			var methodDef = DotNetUtils.GetMethod(DotNetUtils.GetType(module, method.DeclaringType), method);
 			if (methodDef == null)
 				return false;
 
diff --git a/de4dot.code/deobfuscators/SmartAssembly/StringDecrypter.cs b/de4dot.code/deobfuscators/SmartAssembly/StringDecrypter.cs
index ccb9b34a..3fd66fbf 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/StringDecrypter.cs
@@ -42,19 +42,19 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				}
 				else if (stringDecrypterInfo.CanDecrypt) {
 					stringOffset = stringDecrypterInfo.StringOffset;
-					decryptedData = stringDecrypterInfo.decrypt();
+					decryptedData = stringDecrypterInfo.Decrypt();
 				}
 
 				stringDecrypterVersion = StringDecrypterInfo.DecrypterVersion;
 			}
 		}
 
-		public string decrypt(int token, int id) {
+		public string Decrypt(int token, int id) {
 			if (!CanDecrypt)
 				throw new ApplicationException("Can't decrypt strings since decryptedData is null");
 
 			int index = id - (token & 0x00FFFFFF) - stringOffset;
-			int len = DeobUtils.readVariableLengthInt32(decryptedData, ref index);
+			int len = DeobUtils.ReadVariableLengthInt32(decryptedData, ref index);
 
 			switch (StringDecrypterInfo.DecrypterVersion) {
 			case StringDecrypterVersion.V1:
diff --git a/de4dot.code/deobfuscators/SmartAssembly/StringDecrypterInfo.cs b/de4dot.code/deobfuscators/SmartAssembly/StringDecrypterInfo.cs
index e8b25e7c..d8bf8de3 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/StringDecrypterInfo.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/StringDecrypterInfo.cs
@@ -91,28 +91,28 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			"System.Byte[]",
 			"System.Int32",
 		};
-		StringDecrypterVersion guessVersion(MethodDef cctor) {
+		StringDecrypterVersion GuessVersion(MethodDef cctor) {
 			var fieldTypes = new FieldTypes(stringsEncodingClass);
-			if (fieldTypes.exactly(fields2x))
+			if (fieldTypes.Exactly(fields2x))
 				return StringDecrypterVersion.V2;
 			if (cctor == null)
 				return StringDecrypterVersion.V1;
-			if (fieldTypes.exactly(fields3x))
+			if (fieldTypes.Exactly(fields3x))
 				return StringDecrypterVersion.V3;
 			return StringDecrypterVersion.Unknown;
 		}
 
-		public bool init(IDeobfuscator deob, ISimpleDeobfuscator simpleDeobfuscator) {
+		public bool Initialize(IDeobfuscator deob, ISimpleDeobfuscator simpleDeobfuscator) {
 			var cctor = stringsEncodingClass.FindStaticConstructor();
 			if (cctor != null)
-				simpleDeobfuscator.deobfuscate(cctor);
+				simpleDeobfuscator.Deobfuscate(cctor);
 
-			decrypterVersion = guessVersion(cctor);
+			decrypterVersion = GuessVersion(cctor);
 
-			if (!findDecrypterMethod())
+			if (!FindDecrypterMethod())
 				throw new ApplicationException("Could not find string decrypter method");
 
-			if (!findStringsResource(deob, simpleDeobfuscator, cctor))
+			if (!FindStringsResource(deob, simpleDeobfuscator, cctor))
 				return false;
 
 			if (decrypterVersion <= StringDecrypterVersion.V3) {
@@ -126,7 +126,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 
 				stringOffset = 0;
 				if (decrypterVersion != StringDecrypterVersion.V1) {
-					if (callsGetPublicKeyToken(initMethod)) {
+					if (CallsGetPublicKeyToken(initMethod)) {
 						var pkt = PublicKeyBase.ToPublicKeyToken(module.Assembly.PublicKeyToken);
 						if (!PublicKeyBase.IsNullOrEmpty2(pkt)) {
 							for (int i = 0; i < pkt.Data.Length - 1; i += 2)
@@ -134,81 +134,81 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 						}
 					}
 
-					if (DeobUtils.hasInteger(initMethod, 0xFFFFFF) &&
-						DeobUtils.hasInteger(initMethod, 0xFFFF)) {
+					if (DeobUtils.HasInteger(initMethod, 0xFFFFFF) &&
+						DeobUtils.HasInteger(initMethod, 0xFFFF)) {
 						stringOffset ^= ((stringDecrypterMethod.MDToken.ToInt32() & 0xFFFFFF) - 1) % 0xFFFF;
 					}
 				}
 			}
 			else {
-				var offsetVal = findOffsetValue(cctor);
+				var offsetVal = FindOffsetValue(cctor);
 				if (offsetVal == null)
 					throw new ApplicationException("Could not find string offset");
 				stringOffset = offsetVal.Value;
 				decrypterVersion = StringDecrypterVersion.V4;
 			}
 
-			simpleZipTypeMethod = findSimpleZipTypeMethod(cctor) ?? findSimpleZipTypeMethod(stringDecrypterMethod);
+			simpleZipTypeMethod = FindSimpleZipTypeMethod(cctor) ?? FindSimpleZipTypeMethod(stringDecrypterMethod);
 			if (simpleZipTypeMethod != null)
 				resourceDecrypter = new ResourceDecrypter(new ResourceDecrypterInfo(module, simpleZipTypeMethod, simpleDeobfuscator));
 
 			return true;
 		}
 
-		bool callsGetPublicKeyToken(MethodDef method) {
-			foreach (var calledMethod in DotNetUtils.getMethodCalls(method)) {
+		bool CallsGetPublicKeyToken(MethodDef method) {
+			foreach (var calledMethod in DotNetUtils.GetMethodCalls(method)) {
 				if (calledMethod.ToString() == "System.Byte[] System.Reflection.AssemblyName::GetPublicKeyToken()")
 					return true;
 			}
 			return false;
 		}
 
-		bool findStringsResource(IDeobfuscator deob, ISimpleDeobfuscator simpleDeobfuscator, MethodDef cctor) {
+		bool FindStringsResource(IDeobfuscator deob, ISimpleDeobfuscator simpleDeobfuscator, MethodDef cctor) {
 			if (stringsResource != null)
 				return true;
 
 			if (decrypterVersion <= StringDecrypterVersion.V3) {
-				stringsResource = DotNetUtils.getResource(module, (module.Mvid ?? Guid.NewGuid()).ToString("B")) as EmbeddedResource;
+				stringsResource = DotNetUtils.GetResource(module, (module.Mvid ?? Guid.NewGuid()).ToString("B")) as EmbeddedResource;
 				if (stringsResource != null)
 					return true;
 			}
 
-			if (findStringsResource2(deob, simpleDeobfuscator, cctor))
+			if (FindStringsResource2(deob, simpleDeobfuscator, cctor))
 				return true;
-			if (findStringsResource2(deob, simpleDeobfuscator, stringDecrypterMethod))
+			if (FindStringsResource2(deob, simpleDeobfuscator, stringDecrypterMethod))
 				return true;
 
 			return false;
 		}
 
-		bool findStringsResource2(IDeobfuscator deob, ISimpleDeobfuscator simpleDeobfuscator, MethodDef initMethod) {
+		bool FindStringsResource2(IDeobfuscator deob, ISimpleDeobfuscator simpleDeobfuscator, MethodDef initMethod) {
 			if (initMethod == null)
 				return false;
 
-			stringsResource = findStringResource(initMethod);
+			stringsResource = FindStringResource(initMethod);
 			if (stringsResource != null)
 				return true;
 
-			simpleDeobfuscator.decryptStrings(initMethod, deob);
-			stringsResource = findStringResource(initMethod);
+			simpleDeobfuscator.DecryptStrings(initMethod, deob);
+			stringsResource = FindStringResource(initMethod);
 			if (stringsResource != null)
 				return true;
 
 			return false;
 		}
 
-		public byte[] decrypt() {
+		public byte[] Decrypt() {
 			if (!CanDecrypt)
 				throw new ApplicationException("Can't decrypt strings");
-			return resourceDecrypter.decrypt(stringsResource);
+			return resourceDecrypter.Decrypt(stringsResource);
 		}
 
 		// Find the embedded resource where all the strings are encrypted
-		EmbeddedResource findStringResource(MethodDef method) {
-			foreach (var s in DotNetUtils.getCodeStrings(method)) {
+		EmbeddedResource FindStringResource(MethodDef method) {
+			foreach (var s in DotNetUtils.GetCodeStrings(method)) {
 				if (s == null)
 					continue;
-				var resource = DotNetUtils.getResource(module, s) as EmbeddedResource;
+				var resource = DotNetUtils.GetResource(module, s) as EmbeddedResource;
 				if (resource != null)
 					return resource;
 			}
@@ -216,19 +216,19 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 		}
 
 		// Find the string decrypter string offset value or null if none found
-		int? findOffsetValue(MethodDef method) {
+		int? FindOffsetValue(MethodDef method) {
 			var fieldDict = new FieldDefAndDeclaringTypeDict<IField>();
 			foreach (var field in method.DeclaringType.Fields)
-				fieldDict.add(field, field);
+				fieldDict.Add(field, field);
 
-			var offsetField = findOffsetField(method);
+			var offsetField = FindOffsetField(method);
 			if (offsetField == null)
 				return null;
 
-			return findOffsetValue(method, (FieldDef)fieldDict.find(offsetField), fieldDict);
+			return FindOffsetValue(method, (FieldDef)fieldDict.Find(offsetField), fieldDict);
 		}
 
-		IField findOffsetField(MethodDef method) {
+		IField FindOffsetField(MethodDef method) {
 			var instructions = method.Body.Instructions;
 			for (int i = 0; i <= instructions.Count - 2; i++) {
 				var ldsfld = instructions[i];
@@ -244,7 +244,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				if (call.OpCode.Code != Code.Call)
 					continue;
 				var calledMethod = call.Operand as IMethod;
-				if (!DotNetUtils.isMethod(calledMethod, "System.Int32", "(System.String)"))
+				if (!DotNetUtils.IsMethod(calledMethod, "System.Int32", "(System.String)"))
 					continue;
 
 				return field;
@@ -253,7 +253,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return null;
 		}
 
-		int? findOffsetValue(MethodDef method, FieldDef offsetField, FieldDefAndDeclaringTypeDict<IField> fields) {
+		int? FindOffsetValue(MethodDef method, FieldDef offsetField, FieldDefAndDeclaringTypeDict<IField> fields) {
 			var instructions = method.Body.Instructions;
 			for (int i = 0; i <= instructions.Count - 2; i++) {
 				var ldstr = instructions[i];
@@ -267,7 +267,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				if (stsfld.OpCode.Code != Code.Stsfld)
 					continue;
 				var field = stsfld.Operand as IField;
-				if (field == null || fields.find(field) != offsetField)
+				if (field == null || fields.Find(field) != offsetField)
 					continue;
 
 				int value;
@@ -280,11 +280,11 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return null;
 		}
 
-		bool findDecrypterMethod() {
+		bool FindDecrypterMethod() {
 			if (stringDecrypterMethod != null)
 				return true;
 
-			var methods = new List<MethodDef>(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;
 		}
 
-		MethodDef findSimpleZipTypeMethod(MethodDef method) {
+		MethodDef FindSimpleZipTypeMethod(MethodDef method) {
 			if (method == null || method.Body == null)
 				return null;
 			var instructions = method.Body.Instructions;
@@ -303,7 +303,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				var calledMethod = call.Operand as MethodDef;
 				if (calledMethod == null)
 					continue;
-				if (!DotNetUtils.isMethod(calledMethod, "System.Byte[]", "(System.Byte[])"))
+				if (!DotNetUtils.IsMethod(calledMethod, "System.Byte[]", "(System.Byte[])"))
 					continue;
 
 				var stsfld = instructions[i + 1];
@@ -321,7 +321,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return null;
 		}
 
-		public IEnumerable<FieldDef> getAllStringDelegateFields() {
+		public IEnumerable<FieldDef> GetAllStringDelegateFields() {
 			if (GetStringDelegate == null)
 				yield break;
 			foreach (var type in module.GetTypes()) {
@@ -332,18 +332,18 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			}
 		}
 
-		public void removeInitCode(Blocks blocks) {
+		public void RemoveInitCode(Blocks blocks) {
 			if (CreateStringDelegateMethod == null)
 				return;
 
 			if (CreateStringDelegateMethod.Parameters.Count != 0)
-				removeInitCode_v2(blocks);
+				RemoveInitCode_v2(blocks);
 			else
-				removeInitCode_v1(blocks);
+				RemoveInitCode_v1(blocks);
 		}
 
-		void removeInitCode_v1(Blocks blocks) {
-			foreach (var block in blocks.MethodBlocks.getAllBlocks()) {
+		void RemoveInitCode_v1(Blocks blocks) {
+			foreach (var block in blocks.MethodBlocks.GetAllBlocks()) {
 				var instructions = block.Instructions;
 				for (int i = 0; i < instructions.Count; i++) {
 					var call = instructions[i];
@@ -353,14 +353,14 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 					if (!MethodEqualityComparer.CompareDeclaringTypes.Equals(method, CreateStringDelegateMethod))
 						continue;
 
-					block.remove(i, 1);
+					block.Remove(i, 1);
 					break;
 				}
 			}
 		}
 
-		void removeInitCode_v2(Blocks blocks) {
-			foreach (var block in blocks.MethodBlocks.getAllBlocks()) {
+		void RemoveInitCode_v2(Blocks blocks) {
+			foreach (var block in blocks.MethodBlocks.GetAllBlocks()) {
 				var instructions = block.Instructions;
 				for (int i = 0; i <= instructions.Count - 3; i++) {
 					var ldtoken = instructions[i];
@@ -383,7 +383,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 					if (!MethodEqualityComparer.CompareDeclaringTypes.Equals(method2, CreateStringDelegateMethod))
 						continue;
 
-					block.remove(i, 3);
+					block.Remove(i, 3);
 					break;
 				}
 			}
diff --git a/de4dot.code/deobfuscators/SmartAssembly/StringEncoderClassFinder.cs b/de4dot.code/deobfuscators/SmartAssembly/StringEncoderClassFinder.cs
index b8b3b3b1..48430aa3 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/StringEncoderClassFinder.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/StringEncoderClassFinder.cs
@@ -48,50 +48,50 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			this.simpleDeobfuscator = simpleDeobfuscator;
 		}
 
-		TypeDef getType(ITypeDefOrRef typeRef) {
-			return DotNetUtils.getType(module, typeRef);
+		TypeDef GetType(ITypeDefOrRef typeRef) {
+			return DotNetUtils.GetType(module, typeRef);
 		}
 
-		public void find() {
-			findHouseOfCardsStrings_v2();
+		public void Find() {
+			FindHouseOfCardsStrings_v2();
 			if (stringsEncoderInfos.Count == 0)
-				findHouseOfCardsStrings_v1();
+				FindHouseOfCardsStrings_v1();
 
-			findStringDecrypterClasses();
+			FindStringDecrypterClasses();
 		}
 
 		// Finds SmartAssembly.HouseOfCards.Strings. It's the class that creates the string
 		// decrypter delegates.
-		void findHouseOfCardsStrings_v2() {
+		void FindHouseOfCardsStrings_v2() {
 			foreach (var type in module.Types) {
 				if (type.Methods.Count != 1)
 					continue;
-				foreach (var method in DotNetUtils.findMethods(type.Methods, "System.Void", new string[] { "System.Type" })) {
-					if (checkDelegateCreatorMethod(type, method))
+				foreach (var method in DotNetUtils.FindMethods(type.Methods, "System.Void", new string[] { "System.Type" })) {
+					if (CheckDelegateCreatorMethod(type, method))
 						break;
 				}
 			}
 		}
 
-		void findHouseOfCardsStrings_v1() {
+		void FindHouseOfCardsStrings_v1() {
 			foreach (var type in module.Types) {
 				if (type.Methods.Count != 1)
 					continue;
-				foreach (var method in DotNetUtils.findMethods(type.Methods, "System.Void", new string[] { })) {
-					if (checkDelegateCreatorMethod(type, method))
+				foreach (var method in DotNetUtils.FindMethods(type.Methods, "System.Void", new string[] { })) {
+					if (CheckDelegateCreatorMethod(type, method))
 						break;
 				}
 			}
 		}
 
-		bool checkDelegateCreatorMethod(TypeDef type, MethodDef method) {
-			simpleDeobfuscator.deobfuscate(method);
+		bool CheckDelegateCreatorMethod(TypeDef type, MethodDef method) {
+			simpleDeobfuscator.Deobfuscate(method);
 
-			var getStringDelegate = findGetStringDelegate(method);
+			var getStringDelegate = FindGetStringDelegate(method);
 			if (getStringDelegate == null)
 				return false;
 
-			var stringDecrypterClass = findStringDecrypterClass(method);
+			var stringDecrypterClass = FindStringDecrypterClass(method);
 			if (stringDecrypterClass == null)
 				return false;
 
@@ -106,7 +106,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 		}
 
 		// Finds the SmartAssembly.Delegates.GetString delegate
-		TypeDef findGetStringDelegate(MethodDef stringsCreateDelegateMethod) {
+		TypeDef FindGetStringDelegate(MethodDef stringsCreateDelegateMethod) {
 			if (!stringsCreateDelegateMethod.HasBody)
 				return null;
 
@@ -116,11 +116,11 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				var typeToken = ldtoken.Operand as ITypeDefOrRef;
 				if (typeToken == null)
 					continue;
-				var delegateType = getType(typeToken);
-				if (!DotNetUtils.derivesFromDelegate(delegateType))
+				var delegateType = GetType(typeToken);
+				if (!DotNetUtils.DerivesFromDelegate(delegateType))
 					continue;
 				var invoke = delegateType.FindMethod("Invoke");
-				if (invoke == null || !DotNetUtils.isMethod(invoke, "System.String", "(System.Int32)"))
+				if (invoke == null || !DotNetUtils.IsMethod(invoke, "System.String", "(System.Int32)"))
 					continue;
 
 				return delegateType;
@@ -132,7 +132,7 @@ 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.
-		TypeDef findStringDecrypterClass(MethodDef stringsCreateDelegateMethod) {
+		TypeDef FindStringDecrypterClass(MethodDef stringsCreateDelegateMethod) {
 			if (!stringsCreateDelegateMethod.HasBody)
 				return null;
 
@@ -142,10 +142,10 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				var typeToken = ldtoken.Operand as ITypeDefOrRef;
 				if (typeToken == null)
 					continue;
-				var type = getType(typeToken);
-				if (type == null || DotNetUtils.derivesFromDelegate(type))
+				var type = GetType(typeToken);
+				if (type == null || DotNetUtils.DerivesFromDelegate(type))
 					continue;
-				if (!couldBeStringDecrypterClass(type))
+				if (!CouldBeStringDecrypterClass(type))
 					continue;
 
 				return type;
@@ -154,13 +154,13 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return null;
 		}
 
-		void findStringDecrypterClasses() {
+		void FindStringDecrypterClasses() {
 			var foundClasses = new Dictionary<TypeDef, bool>();
 			foreach (var info in stringsEncoderInfos)
 				foundClasses[info.StringDecrypterClass] = true;
 
 			foreach (var type in module.Types) {
-				if (!foundClasses.ContainsKey(type) && couldBeStringDecrypterClass(type)) {
+				if (!foundClasses.ContainsKey(type) && CouldBeStringDecrypterClass(type)) {
 					stringsEncoderInfos.Add(new StringsEncoderInfo {
 						StringsType = null,
 						GetStringDelegate = null,
@@ -181,24 +181,24 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			"System.Byte[]",
 			"System.Int32",
 		};
-		bool couldBeStringDecrypterClass(TypeDef 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 (fields.Exists("System.Collections.Hashtable") ||
+				fields.Exists("System.Collections.Generic.Dictionary`2<System.Int32,System.String>") ||
+				fields.Exactly(fields3x)) {
 				if (type.FindStaticConstructor() == null)
 					return false;
 			}
-			else if (fields.exactly(fields1x) || fields.exactly(fields2x)) {
+			else if (fields.Exactly(fields1x) || fields.Exactly(fields2x)) {
 			}
 			else
 				return false;
 
-			var methods = new List<MethodDef>(DotNetUtils.getNormalMethods(type));
+			var methods = new List<MethodDef>(DotNetUtils.GetNormalMethods(type));
 			if (methods.Count != 1)
 				return false;
 			var method = methods[0];
-			if (!DotNetUtils.isMethod(method, "System.String", "(System.Int32)"))
+			if (!DotNetUtils.IsMethod(method, "System.String", "(System.Int32)"))
 				return false;
 			if (!method.IsStatic || !method.HasBody)
 				return false;
diff --git a/de4dot.code/deobfuscators/SmartAssembly/TamperProtectionRemover.cs b/de4dot.code/deobfuscators/SmartAssembly/TamperProtectionRemover.cs
index 778b8c2d..e314ba75 100644
--- a/de4dot.code/deobfuscators/SmartAssembly/TamperProtectionRemover.cs
+++ b/de4dot.code/deobfuscators/SmartAssembly/TamperProtectionRemover.cs
@@ -41,13 +41,13 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			this.module = module;
 		}
 
-		public bool remove(Blocks blocks) {
+		public bool Remove(Blocks blocks) {
 			if (blocks.Method.Name != ".cctor")
 				return false;
-			return removeTamperProtection(blocks);
+			return RemoveTamperProtection(blocks);
 		}
 
-		bool isTamperProtected(IEnumerable<Block> allBlocks) {
+		bool IsTamperProtected(IEnumerable<Block> allBlocks) {
 			foreach (var block in allBlocks) {
 				foreach (var instr in block.Instructions) {
 					if (instr.OpCode != OpCodes.Ldstr)
@@ -74,25 +74,25 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			public BlockInfo bad;
 		}
 
-		TamperBlocks findTamperBlocks(Blocks blocks, IList<Block> allBlocks) {
+		TamperBlocks FindTamperBlocks(Blocks blocks, IList<Block> allBlocks) {
 			var tamperBlocks = new TamperBlocks();
 
-			if (!findFirstBlocks(tamperBlocks, allBlocks, blocks.Locals))
+			if (!FindFirstBlocks(tamperBlocks, allBlocks, blocks.Locals))
 				return null;
 
 			var second = tamperBlocks.second;
-			var badBlock = second.Block.LastInstr.isBrfalse() ? second.Block.Targets[0] : second.Block.FallThrough;
-			tamperBlocks.bad = findBadBlock(badBlock);
+			var badBlock = second.Block.LastInstr.IsBrfalse() ? second.Block.Targets[0] : second.Block.FallThrough;
+			tamperBlocks.bad = FindBadBlock(badBlock);
 			if (tamperBlocks.bad == null)
 				return null;
 
 			return tamperBlocks;
 		}
 
-		bool findFirstBlocks(TamperBlocks tamperBlocks, IList<Block> allBlocks, IList<Local> locals) {
+		bool FindFirstBlocks(TamperBlocks tamperBlocks, IList<Block> allBlocks, IList<Local> locals) {
 			foreach (var b in allBlocks) {
 				try {
-					if (findFirstBlocks(b, tamperBlocks, allBlocks, locals))
+					if (FindFirstBlocks(b, tamperBlocks, allBlocks, locals))
 						return true;
 				}
 				catch (ArgumentOutOfRangeException) {
@@ -103,7 +103,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return false;
 		}
 
-		static int findCallMethod(Block block, int index, bool keepLooking, Func<IMethod, 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];
@@ -119,8 +119,8 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return -1;
 		}
 
-		bool findFirstBlocks(Block block, TamperBlocks tamperBlocks, IList<Block> allBlocks, IList<Local> locals) {
-			if (!block.LastInstr.isBrfalse())
+		bool FindFirstBlocks(Block block, TamperBlocks tamperBlocks, IList<Block> allBlocks, IList<Local> locals) {
+			if (!block.LastInstr.IsBrfalse())
 				return false;
 
 			/*
@@ -151,38 +151,38 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 
 			int index = 0;
 
-			int start = findCallMethod(block, index, true, (calledMethod) => calledMethod.ToString() == "System.Reflection.Assembly System.Reflection.Assembly::GetExecutingAssembly()");
+			int start = FindCallMethod(block, index, true, (calledMethod) => calledMethod.ToString() == "System.Reflection.Assembly System.Reflection.Assembly::GetExecutingAssembly()");
 			if (start < 0)
 				return false;
 			index = start + 1;
 			instr = instrs[--start];
-			if (!instr.isStloc())
+			if (!instr.IsStloc())
 				return false;
-			var loc0 = Instr.getLocalVar(locals, instr);
+			var loc0 = Instr.GetLocalVar(locals, instr);
 			instr = instrs[--start];
-			if (!instr.isLdcI4())
+			if (!instr.IsLdcI4())
 				return false;
 
-			index = findCallMethod(block, index, false, (calledMethod) => calledMethod.ToString() == "System.String System.Reflection.Assembly::get_Location()");
+			index = FindCallMethod(block, index, false, (calledMethod) => calledMethod.ToString() == "System.String System.Reflection.Assembly::get_Location()");
 			if (index < 0)
 				return false;
 			index++;
 
-			index = findCallMethod(block, index, false, (calledMethod) => {
-				tamperBlocks.pinvokeMethod = DotNetUtils.getMethod(module, calledMethod);
-				return DotNetUtils.isPinvokeMethod(tamperBlocks.pinvokeMethod, "mscorwks", "StrongNameSignatureVerificationEx");
+			index = FindCallMethod(block, index, false, (calledMethod) => {
+				tamperBlocks.pinvokeMethod = DotNetUtils.GetMethod(module, calledMethod);
+				return DotNetUtils.IsPinvokeMethod(tamperBlocks.pinvokeMethod, "mscorwks", "StrongNameSignatureVerificationEx");
 			});
 			if (index < 0)
 				return false;
 			index++;
 
-			if (!instrs[index].isBrfalse()) {
+			if (!instrs[index].IsBrfalse()) {
 				if (instrs[index].OpCode.Code != Code.Pop)
 					return false;
 				instr = instrs[index + 1];
-				if (!instr.isLdloc() || Instr.getLocalVar(locals, instr) != loc0)
+				if (!instr.IsLdloc() || Instr.GetLocalVar(locals, instr) != loc0)
 					return false;
-				if (!instrs[index + 2].isBrfalse())
+				if (!instrs[index + 2].IsBrfalse())
 					return false;
 
 				tamperBlocks.type = Type.V1;
@@ -206,9 +206,9 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				instrs = block.Instructions;
 				index = 0;
 				instr = instrs[index];
-				if (!instr.isLdloc() || Instr.getLocalVar(locals, instr) != loc0)
+				if (!instr.IsLdloc() || Instr.GetLocalVar(locals, instr) != loc0)
 					return false;
-				if (!instrs[index + 1].isBrfalse())
+				if (!instrs[index + 1].IsBrfalse())
 					return false;
 			}
 
@@ -217,7 +217,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			start = end = 0;
 
 			instr = instrs[end++];
-			if (!instr.isLdloc())
+			if (!instr.IsLdloc())
 				return false;
 
 			instr = instrs[end++];
@@ -239,7 +239,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 				return false;
 
 			instr = instrs[end++];
-			if (!instr.isBrfalse() && !instr.isBrtrue())
+			if (!instr.IsBrfalse() && !instr.IsBrtrue())
 				return false;
 
 			end--;
@@ -252,7 +252,7 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return true;
 		}
 
-		BlockInfo findBadBlock(Block last) {
+		BlockInfo FindBadBlock(Block last) {
 			/*
 			 * ldstr "........."
 			 * newobj	System.Security.SecurityException(string)
@@ -290,22 +290,22 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			};
 		}
 
-		bool removeTamperProtection(Blocks blocks) {
-			var allBlocks = blocks.MethodBlocks.getAllBlocks();
-			var tamperBlocks = findTamperBlocks(blocks, allBlocks);
+		bool RemoveTamperProtection(Blocks blocks) {
+			var allBlocks = blocks.MethodBlocks.GetAllBlocks();
+			var tamperBlocks = FindTamperBlocks(blocks, allBlocks);
 
 			if (tamperBlocks == null) {
-				if (isTamperProtected(allBlocks))
-					Logger.w("Could not remove tamper protection code: {0} ({1:X8})", Utils.removeNewlines(blocks.Method), blocks.Method.MDToken.ToUInt32());
+				if (IsTamperProtected(allBlocks))
+					Logger.w("Could not remove tamper protection code: {0} ({1:X8})", Utils.RemoveNewlines(blocks.Method), blocks.Method.MDToken.ToUInt32());
 				return false;
 			}
 
 			switch (tamperBlocks.type) {
 			case Type.V1:
-				removeTamperV1(tamperBlocks);
+				RemoveTamperV1(tamperBlocks);
 				break;
 			case Type.V2:
-				removeTamperV2(tamperBlocks);
+				RemoveTamperV2(tamperBlocks);
 				break;
 			default:
 				throw new ApplicationException("Unknown type");
@@ -315,42 +315,42 @@ namespace de4dot.code.deobfuscators.SmartAssembly {
 			return true;
 		}
 
-		void removeTamperV1(TamperBlocks tamperBlocks) {
+		void RemoveTamperV1(TamperBlocks tamperBlocks) {
 			var first = tamperBlocks.first;
 			var second = tamperBlocks.second;
 			var bad = tamperBlocks.bad;
-			var goodBlock = second.Block.LastInstr.isBrtrue() ? second.Block.Targets[0] : second.Block.FallThrough;
+			var goodBlock = second.Block.LastInstr.IsBrtrue() ? second.Block.Targets[0] : second.Block.FallThrough;
 
 			if (first.Block.Targets.Count != 1 || first.Block.Targets[0] != bad.Block)
 				throw new ApplicationException("Invalid state");
 
-			first.Block.remove(first.Start, first.End - first.Start + 1);
-			first.Block.replaceLastInstrsWithBranch(0, goodBlock);
-			removeDeadBlock(second.Block);
-			removeDeadBlock(bad.Block);
+			first.Block.Remove(first.Start, first.End - first.Start + 1);
+			first.Block.ReplaceLastInstrsWithBranch(0, goodBlock);
+			RemoveDeadBlock(second.Block);
+			RemoveDeadBlock(bad.Block);
 		}
 
-		void removeTamperV2(TamperBlocks tamperBlocks) {
+		void RemoveTamperV2(TamperBlocks tamperBlocks) {
 			var first = tamperBlocks.first;
 			var second = tamperBlocks.second.Block;
 			var bad = tamperBlocks.bad.Block;
 			var firstFallthrough = first.Block.FallThrough;
-			var goodBlock = second.LastInstr.isBrtrue() ? second.Targets[0] : second.FallThrough;
+			var goodBlock = second.LastInstr.IsBrtrue() ? second.Targets[0] : second.FallThrough;
 
 			if (first.Block.Targets.Count != 1 || first.Block.Targets[0] != bad)
 				throw new ApplicationException("Invalid state");
 
-			first.Block.remove(first.Start, first.End - first.Start + 1);
-			first.Block.replaceLastInstrsWithBranch(0, goodBlock);
-			removeDeadBlock(firstFallthrough);
-			removeDeadBlock(second);
-			removeDeadBlock(bad);
+			first.Block.Remove(first.Start, first.End - first.Start + 1);
+			first.Block.ReplaceLastInstrsWithBranch(0, goodBlock);
+			RemoveDeadBlock(firstFallthrough);
+			RemoveDeadBlock(second);
+			RemoveDeadBlock(bad);
 		}
 
-		void removeDeadBlock(Block block) {
+		void RemoveDeadBlock(Block block) {
 			var parent = block.Parent;
 			if (parent != null)	// null if already dead
-				parent.removeDeadBlock(block);
+				parent.RemoveDeadBlock(block);
 		}
 	}
 }
diff --git a/de4dot.code/deobfuscators/Spices_Net/Deobfuscator.cs b/de4dot.code/deobfuscators/Spices_Net/Deobfuscator.cs
index 67183fdc..775e3c20 100644
--- a/de4dot.code/deobfuscators/Spices_Net/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/Spices_Net/Deobfuscator.cs
@@ -34,10 +34,10 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 
 		public DeobfuscatorInfo()
 			: base(DEFAULT_REGEX) {
-			inlineMethods = new BoolOption(null, makeArgName("inline"), "Inline short methods", true);
-			removeInlinedMethods = new BoolOption(null, makeArgName("remove-inlined"), "Remove inlined methods", true);
-			removeNamespaces = new BoolOption(null, makeArgName("ns1"), "Clear namespace if there's only one class in it", true);
-			restoreResourceNames = new BoolOption(null, makeArgName("rsrc"), "Restore resource names", true);
+			inlineMethods = new BoolOption(null, MakeArgName("inline"), "Inline short methods", true);
+			removeInlinedMethods = new BoolOption(null, MakeArgName("remove-inlined"), "Remove inlined methods", true);
+			removeNamespaces = new BoolOption(null, MakeArgName("ns1"), "Clear namespace if there's only one class in it", true);
+			restoreResourceNames = new BoolOption(null, MakeArgName("rsrc"), "Restore resource names", true);
 		}
 
 		public override string Name {
@@ -48,7 +48,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			get { return THE_TYPE; }
 		}
 
-		public override IDeobfuscator createDeobfuscator() {
+		public override IDeobfuscator CreateDeobfuscator() {
 			return new Deobfuscator(new Deobfuscator.Options {
 				ValidNameRegex = validNameRegex.get(),
 				InlineMethods = inlineMethods.get(),
@@ -58,7 +58,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			});
 		}
 
-		protected override IEnumerable<Option> getOptionsInternal() {
+		protected override IEnumerable<Option> GetOptionsInternal() {
 			return new List<Option>() {
 				inlineMethods,
 				removeInlinedMethods,
@@ -119,10 +119,10 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 				this.RenamingOptions &= ~RenamingOptions.RemoveNamespaceIfOneType;
 		}
 
-		protected override int detectInternal() {
+		protected override int DetectInternal() {
 			int val = 0;
 
-			int sum = toInt32(stringDecrypter.Detected);
+			int sum = ToInt32(stringDecrypter.Detected);
 			if (sum > 0)
 				val += 100 + 10 * (sum - 1);
 			if (foundSpicesAttribute)
@@ -131,87 +131,87 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			return val;
 		}
 
-		protected override void scanForObfuscator() {
+		protected override void ScanForObfuscator() {
 			methodCallInliner = new SpicesMethodCallInliner(module);
 			stringDecrypter = new StringDecrypter(module);
-			stringDecrypter.find();
-			findSpicesAttributes();
+			stringDecrypter.Find();
+			FindSpicesAttributes();
 		}
 
-		void findSpicesAttributes() {
+		void FindSpicesAttributes() {
 			foreach (var type in module.Types) {
 				switch (type.FullName) {
 				case "NineRays.Decompiler.NotDecompile":
 				case "NineRays.Obfuscator.Evaluation":
 				case "NineRays.Obfuscator.SoftwareWatermarkAttribute":
-					addAttributeToBeRemoved(type, "Obfuscator attribute");
+					AddAttributeToBeRemoved(type, "Obfuscator attribute");
 					foundSpicesAttribute = true;
 					break;
 				}
 			}
 		}
 
-		public override void deobfuscateBegin() {
-			base.deobfuscateBegin();
+		public override void DeobfuscateBegin() {
+			base.DeobfuscateBegin();
 
-			methodCallInliner.initialize();
+			methodCallInliner.Initialize();
 
 			if (options.RestoreResourceNames) {
 				resourceNamesRestorer = new ResourceNamesRestorer(module);
-				resourceNamesRestorer.find();
-				resourceNamesRestorer.renameResources();
+				resourceNamesRestorer.Find();
+				resourceNamesRestorer.RenameResources();
 			}
 
-			stringDecrypter.initialize();
+			stringDecrypter.Initialize();
 			foreach (var info in stringDecrypter.DecrypterInfos) {
-				staticStringInliner.add(info.method, (method2, gim, args) => {
-					return stringDecrypter.decrypt(method2);
+				staticStringInliner.Add(info.method, (method2, gim, args) => {
+					return stringDecrypter.Decrypt(method2);
 				});
 			}
-			DeobfuscatedFile.stringDecryptersAdded();
+			DeobfuscatedFile.StringDecryptersAdded();
 
 			startedDeobfuscating = true;
 		}
 
-		public override void deobfuscateMethodEnd(Blocks blocks) {
-			methodCallInliner.deobfuscate(blocks);
+		public override void DeobfuscateMethodEnd(Blocks blocks) {
+			methodCallInliner.Deobfuscate(blocks);
 			if (options.RestoreResourceNames)
-				resourceNamesRestorer.deobfuscate(blocks);
-			base.deobfuscateMethodEnd(blocks);
+				resourceNamesRestorer.Deobfuscate(blocks);
+			base.DeobfuscateMethodEnd(blocks);
 		}
 
-		public override void deobfuscateEnd() {
-			removeInlinedMethods();
+		public override void DeobfuscateEnd() {
+			RemoveInlinedMethods();
 
 			if (options.RestoreResourceNames) {
-				addTypeToBeRemoved(resourceNamesRestorer.ResourceManagerType, "Obfuscator ResourceManager type");
-				addTypeToBeRemoved(resourceNamesRestorer.ComponentResourceManagerType, "Obfuscator ComponentResourceManager type");
+				AddTypeToBeRemoved(resourceNamesRestorer.ResourceManagerType, "Obfuscator ResourceManager type");
+				AddTypeToBeRemoved(resourceNamesRestorer.ComponentResourceManagerType, "Obfuscator ComponentResourceManager type");
 			}
 
 			if (Operations.DecryptStrings != OpDecryptString.None) {
-				addTypeToBeRemoved(stringDecrypter.Type, "String decrypter type");
-				addTypeToBeRemoved(stringDecrypter.EncryptedStringsType, "Encrypted strings field type");
-				stringDecrypter.cleanUp();
+				AddTypeToBeRemoved(stringDecrypter.Type, "String decrypter type");
+				AddTypeToBeRemoved(stringDecrypter.EncryptedStringsType, "Encrypted strings field type");
+				stringDecrypter.CleanUp();
 			}
 
-			base.deobfuscateEnd();
+			base.DeobfuscateEnd();
 		}
 
-		void removeInlinedMethods() {
+		void RemoveInlinedMethods() {
 			if (!options.InlineMethods || !options.RemoveInlinedMethods)
 				return;
 
-			var unusedMethods = new UnusedMethodsFinder(module, methodCallInliner.getInlinedMethods(), getRemovedMethods()).find();
-			var removedTypes = methodCallInliner.getInlinedTypes(unusedMethods);
+			var unusedMethods = new UnusedMethodsFinder(module, methodCallInliner.GetInlinedMethods(), GetRemovedMethods()).Find();
+			var removedTypes = methodCallInliner.GetInlinedTypes(unusedMethods);
 
-			addTypesToBeRemoved(removedTypes.getKeys(), "Obfuscator methods type");
+			AddTypesToBeRemoved(removedTypes.GetKeys(), "Obfuscator methods type");
 			foreach (var method in unusedMethods) {
-				if (!removedTypes.find(method.DeclaringType))
-					addMethodToBeRemoved(method, "Inlined method");
+				if (!removedTypes.Find(method.DeclaringType))
+					AddMethodToBeRemoved(method, "Inlined method");
 			}
 		}
 
-		public override IEnumerable<int> getStringDecrypterMethods() {
+		public override IEnumerable<int> GetStringDecrypterMethods() {
 			var list = new List<int>();
 			foreach (var info in stringDecrypter.DecrypterInfos)
 				list.Add(info.method.MDToken.ToInt32());
diff --git a/de4dot.code/deobfuscators/Spices_Net/QclzDecompressor.cs b/de4dot.code/deobfuscators/Spices_Net/QclzDecompressor.cs
index 6f10ecef..be9cf922 100644
--- a/de4dot.code/deobfuscators/Spices_Net/QclzDecompressor.cs
+++ b/de4dot.code/deobfuscators/Spices_Net/QclzDecompressor.cs
@@ -21,15 +21,15 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 	class QclzDecompressor : QuickLZBase {
 		static int SPICES_QCLZ_SIG = 0x3952534E;	// "9RSN"
 
-		public static byte[] decompress(byte[] data) {
-			if (read32(data, 0) == SPICES_QCLZ_SIG)
-				return QuickLZ.decompress(data, SPICES_QCLZ_SIG);
+		public static byte[] Decompress(byte[] data) {
+			if (Read32(data, 0) == SPICES_QCLZ_SIG)
+				return QuickLZ.Decompress(data, SPICES_QCLZ_SIG);
 
 			int headerLength, decompressedLength, compressedLength;
 			if ((data[0] & 2) != 0) {
 				headerLength = 9;
-				compressedLength = (int)read32(data, 1);
-				decompressedLength = (int)read32(data, 5);
+				compressedLength = (int)Read32(data, 1);
+				decompressedLength = (int)Read32(data, 5);
 			}
 			else {
 				headerLength = 3;
@@ -40,9 +40,9 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			bool isCompressed = (data[0] & 1) != 0;
 			byte[] decompressed = new byte[decompressedLength];
 			if (isCompressed)
-				decompress(data, headerLength, decompressed);
+				Decompress(data, headerLength, decompressed);
 			else
-				copy(data, headerLength, decompressed, 0, decompressed.Length);
+				Copy(data, headerLength, decompressed, 0, decompressed.Length);
 
 			return decompressed;
 		}
diff --git a/de4dot.code/deobfuscators/Spices_Net/ResourceNamesRestorer.cs b/de4dot.code/deobfuscators/Spices_Net/ResourceNamesRestorer.cs
index e9e7e87f..00121522 100644
--- a/de4dot.code/deobfuscators/Spices_Net/ResourceNamesRestorer.cs
+++ b/de4dot.code/deobfuscators/Spices_Net/ResourceNamesRestorer.cs
@@ -42,19 +42,19 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			this.module = module;
 		}
 
-		public void find() {
+		public void Find() {
 			foreach (var type in module.Types) {
-				if (isResourceType(type, "System.Resources.ResourceManager"))
+				if (IsResourceType(type, "System.Resources.ResourceManager"))
 					resourceManagerType = type;
-				else if (isResourceType(type, "System.ComponentModel.ComponentResourceManager"))
+				else if (IsResourceType(type, "System.ComponentModel.ComponentResourceManager"))
 					componentResourceManagerType = type;
 			}
 
-			initializeCtors(resourceManagerType, resourceManagerCtors);
-			initializeCtors(componentResourceManagerType, componentManagerCtors);
+			InitializeCtors(resourceManagerType, resourceManagerCtors);
+			InitializeCtors(componentResourceManagerType, componentManagerCtors);
 		}
 
-		void initializeCtors(TypeDef manager, MethodDefAndDeclaringTypeDict<IMethod> ctors) {
+		void InitializeCtors(TypeDef manager, MethodDefAndDeclaringTypeDict<IMethod> ctors) {
 			if (manager == null)
 				return;
 
@@ -64,11 +64,11 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 
 				var newCtor = new MemberRefUser(module, ctor.Name, ctor.MethodSig.Clone(), manager.BaseType);
 				module.UpdateRowId(newCtor);
-				ctors.add(ctor, newCtor);
+				ctors.Add(ctor, newCtor);
 			}
 		}
 
-		static bool isResourceType(TypeDef 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)
@@ -76,13 +76,13 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			if (type.Interfaces.Count > 0)
 				return false;
 			var method = type.FindMethod("GetResourceFileName");
-			if (!DotNetUtils.isMethod(method, "System.String", "(System.Globalization.CultureInfo)"))
+			if (!DotNetUtils.IsMethod(method, "System.String", "(System.Globalization.CultureInfo)"))
 				return false;
 
 			return true;
 		}
 
-		public void renameResources() {
+		public void RenameResources() {
 			if (resourceManagerType == null && componentResourceManagerType == null)
 				return;
 
@@ -102,19 +102,19 @@ 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.String, type.Name.String);
-				rename(numToResource, type.Namespace.String, type.Name.String + ".g");
+				Rename(numToResource, "", type.FullName);
+				Rename(numToResource, "", type.FullName + ".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.String + ".g");
+				Rename(numToResource, "", module.Assembly.Name.String + ".g");
 		}
 
-		static void rename(Dictionary<uint, Resource> numToResource, string ns, string name) {
+		static void Rename(Dictionary<uint, Resource> numToResource, string ns, string name) {
 			var resourceName = name + ".resources";
-			uint hash = getResourceHash(resourceName);
+			uint hash = GetResourceHash(resourceName);
 			Resource resource;
 			if (!numToResource.TryGetValue(hash, out resource))
 				return;
@@ -133,28 +133,28 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 				return;
 
 			Logger.v("Restoring resource name: '{0}' => '{1}'",
-								Utils.removeNewlines(resource.Name),
-								Utils.removeNewlines(newName));
+								Utils.RemoveNewlines(resource.Name),
+								Utils.RemoveNewlines(newName));
 			resource.Name = newName;
 			numToResource.Remove(hash);
 		}
 
-		static uint getResourceHash(string name) {
+		static uint GetResourceHash(string name) {
 			uint hash = 0;
 			foreach (var c in name)
-				hash = ror(hash ^ c, 1);
+				hash = Ror(hash ^ c, 1);
 			return hash;
 		}
 
-		static uint ror(uint val, int n) {
+		static uint Ror(uint val, int n) {
 			return (val << (32 - n)) + (val >> n);
 		}
 
-		public void deobfuscate(Blocks blocks) {
+		public void Deobfuscate(Blocks blocks) {
 			if (resourceManagerType == null && componentResourceManagerType == null)
 				return;
 
-			foreach (var block in blocks.MethodBlocks.getAllBlocks()) {
+			foreach (var block in blocks.MethodBlocks.GetAllBlocks()) {
 				var instrs = block.Instructions;
 				for (int i = 0; i < instrs.Count; i++) {
 					var instr = instrs[i];
@@ -163,9 +163,9 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 					var ctor = instr.Operand as IMethod;
 					if (ctor == null)
 						continue;
-					var newCtor = resourceManagerCtors.find(ctor);
+					var newCtor = resourceManagerCtors.Find(ctor);
 					if (newCtor == null)
-						newCtor = componentManagerCtors.find(ctor);
+						newCtor = componentManagerCtors.Find(ctor);
 					if (newCtor == null)
 						continue;
 					instr.Operand = newCtor;
diff --git a/de4dot.code/deobfuscators/Spices_Net/SpicesMethodCallInliner.cs b/de4dot.code/deobfuscators/Spices_Net/SpicesMethodCallInliner.cs
index 29f8f0b0..471ab57b 100644
--- a/de4dot.code/deobfuscators/Spices_Net/SpicesMethodCallInliner.cs
+++ b/de4dot.code/deobfuscators/Spices_Net/SpicesMethodCallInliner.cs
@@ -34,71 +34,71 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			this.module = module;
 		}
 
-		protected override bool isCompatibleType(int paramIndex, IType origType, IType 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 (isValueType(newType) || isValueType(origType))
+				if (IsValueType(newType) || IsValueType(origType))
 					return false;
 			}
 			return newType.FullName == "System.Object";
 		}
 
-		public bool checkCanInline(MethodDef method) {
-			return methodsTypes.find(method.DeclaringType);
+		public bool CheckCanInline(MethodDef method) {
+			return methodsTypes.Find(method.DeclaringType);
 		}
 
-		protected override bool canInline(MethodDef method) {
-			return checkCanInline(method);
+		protected override bool CanInline(MethodDef method) {
+			return CheckCanInline(method);
 		}
 
-		public void initialize() {
-			initializeMethodsTypes();
-			restoreMethodBodies();
+		public void Initialize() {
+			InitializeMethodsTypes();
+			RestoreMethodBodies();
 		}
 
-		void restoreMethodBodies() {
+		void RestoreMethodBodies() {
 			var methodToOrigMethods = new MethodDefAndDeclaringTypeDict<List<MethodDef>>();
 			foreach (var t in module.Types) {
 				var types = new List<TypeDef>(AllTypesHelper.Types(new List<TypeDef> { t }));
 				foreach (var type in types) {
-					if (methodsTypes.find(type))
+					if (methodsTypes.Find(type))
 						continue;
 					foreach (var method in type.Methods) {
 						if (method.Name == ".ctor" || method.Name == ".cctor")
 							continue;
 
 						MethodDef calledMethod;
-						if (!checkRestoreBody(method, out calledMethod))
+						if (!CheckRestoreBody(method, out calledMethod))
 							continue;
-						if (!checkSameMethods(method, calledMethod))
+						if (!CheckSameMethods(method, calledMethod))
 							continue;
-						if (!methodsTypes.find(calledMethod.DeclaringType))
+						if (!methodsTypes.Find(calledMethod.DeclaringType))
 							continue;
 						if (types.IndexOf(calledMethod.DeclaringType) < 0)
 							continue;
 
-						var list = methodToOrigMethods.find(calledMethod);
+						var list = methodToOrigMethods.Find(calledMethod);
 						if (list == null)
-							methodToOrigMethods.add(calledMethod, list = new List<MethodDef>());
+							methodToOrigMethods.Add(calledMethod, list = new List<MethodDef>());
 						list.Add(method);
 					}
 				}
 			}
 
-			foreach (var calledMethod in methodToOrigMethods.getKeys()) {
-				var list = methodToOrigMethods.find(calledMethod);
+			foreach (var calledMethod in methodToOrigMethods.GetKeys()) {
+				var list = methodToOrigMethods.Find(calledMethod);
 				var method = list[0];
 
 				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);
+				DotNetUtils.CopyBodyFromTo(calledMethod, method);
+				classMethods.Add(calledMethod, method);
 			}
 		}
 
-		bool checkRestoreBody(MethodDef method, out MethodDef calledMethod) {
+		bool CheckRestoreBody(MethodDef method, out MethodDef calledMethod) {
 			calledMethod = null;
 			if (method.Body == null)
 				return false;
@@ -107,7 +107,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			if (method.Body.ExceptionHandlers.Count > 0)
 				return false;
 
-			if (!checkRestoreBody2(method, out calledMethod))
+			if (!CheckRestoreBody2(method, out calledMethod))
 				return false;
 			if (calledMethod == method)
 				return false;
@@ -121,7 +121,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			return true;
 		}
 
-		bool checkRestoreBody2(MethodDef instanceMethod, out MethodDef calledMethod) {
+		bool CheckRestoreBody2(MethodDef instanceMethod, out MethodDef calledMethod) {
 			calledMethod = null;
 
 			var instrs = instanceMethod.Body.Instructions;
@@ -144,14 +144,14 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			return true;
 		}
 
-		void initializeMethodsTypes() {
+		void InitializeMethodsTypes() {
 			foreach (var type in module.GetTypes()) {
-				if (checkMethodsType(type))
-					methodsTypes.add(type, true);
+				if (CheckMethodsType(type))
+					methodsTypes.Add(type, true);
 			}
 		}
 
-		static bool checkMethodsType(TypeDef type) {
+		static bool CheckMethodsType(TypeDef type) {
 			if (!type.IsNested)
 				return false;
 			if ((type.Attributes & ~TypeAttributes.BeforeFieldInit) != TypeAttributes.NestedAssembly)
@@ -166,13 +166,13 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 				return false;
 			if (type.Interfaces.Count > 0)
 				return false;
-			if (!checkMethods(type))
+			if (!CheckMethods(type))
 				return false;
 
 			return true;
 		}
 
-		static bool checkMethods(TypeDef type) {
+		static bool CheckMethods(TypeDef type) {
 			bool foundCtor = false;
 			int numMethods = 0;
 
@@ -198,44 +198,44 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			return numMethods > 0 && foundCtor;
 		}
 
-		public List<MethodDef> getInlinedMethods() {
+		public List<MethodDef> GetInlinedMethods() {
 			var list = new List<MethodDef>();
 
-			foreach (var type in methodsTypes.getKeys())
+			foreach (var type in methodsTypes.GetKeys())
 				list.AddRange(type.Methods);
 
 			return list;
 		}
 
-		public TypeDefDict<bool> getInlinedTypes(IEnumerable<MethodDef> unusedMethods) {
+		public TypeDefDict<bool> GetInlinedTypes(IEnumerable<MethodDef> unusedMethods) {
 			var unused = new MethodDefAndDeclaringTypeDict<bool>();
 			foreach (var method in unusedMethods)
-				unused.add(method, true);
+				unused.Add(method, true);
 
 			var types = new TypeDefDict<bool>();
-			foreach (var type in methodsTypes.getKeys()) {
-				if (checkAllMethodsUnused(unused, type))
-					types.add(type, true);
+			foreach (var type in methodsTypes.GetKeys()) {
+				if (CheckAllMethodsUnused(unused, type))
+					types.Add(type, true);
 			}
 			return types;
 		}
 
-		static bool checkAllMethodsUnused(MethodDefAndDeclaringTypeDict<bool> unused, TypeDef type) {
+		static bool CheckAllMethodsUnused(MethodDefAndDeclaringTypeDict<bool> unused, TypeDef type) {
 			foreach (var method in type.Methods) {
-				if (!unused.find(method))
+				if (!unused.Find(method))
 					return false;
 			}
 			return true;
 		}
 
-		public void deobfuscate(Blocks blocks) {
-			foreach (var block in blocks.MethodBlocks.getAllBlocks()) {
+		public void Deobfuscate(Blocks blocks) {
+			foreach (var block in blocks.MethodBlocks.GetAllBlocks()) {
 				var instrs = block.Instructions;
 				for (int i = 0; i < instrs.Count; i++) {
 					var call = instrs[i];
 					if (call.OpCode.Code != Code.Call)
 						continue;
-					var realInstanceMethod = classMethods.find(call.Operand as IMethod);
+					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 f87a6ac8..a73699c5 100644
--- a/de4dot.code/deobfuscators/Spices_Net/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/Spices_Net/StringDecrypter.cs
@@ -80,14 +80,14 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 		}
 
 		public IEnumerable<DecrypterInfo> DecrypterInfos {
-			get { return methodToInfo.getValues(); }
+			get { return methodToInfo.GetValues(); }
 		}
 
 		public StringDecrypter(ModuleDefMD module) {
 			this.module = module;
 		}
 
-		public void find() {
+		public void Find() {
 			foreach (var type in module.Types) {
 				if (type.HasNestedTypes || type.HasInterfaces)
 					continue;
@@ -99,7 +99,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 					continue;
 				if (type.BaseType == null || type.BaseType.FullName != "System.Object")
 					continue;
-				if (hasInstanceMethods(type))
+				if (HasInstanceMethods(type))
 					continue;
 				var cctor = type.FindStaticConstructor();
 				if (cctor == null)
@@ -107,10 +107,10 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 
 				FieldDef encryptedDataFieldTmp;
 				StringDataFlags stringDataFlagsTmp;
-				if (!checkCctor(cctor, out encryptedDataFieldTmp, out stringDataFlagsTmp))
+				if (!CheckCctor(cctor, out encryptedDataFieldTmp, out stringDataFlagsTmp))
 					continue;
 
-				if (!initializeDecrypterInfos(type))
+				if (!InitializeDecrypterInfos(type))
 					continue;
 
 				encryptedDataField = encryptedDataFieldTmp;
@@ -120,7 +120,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			}
 		}
 
-		static bool hasInstanceMethods(TypeDef type) {
+		static bool HasInstanceMethods(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (!method.IsStatic)
 					return true;
@@ -130,7 +130,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			return false;
 		}
 
-		bool checkCctor(MethodDef cctor, out FieldDef 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++) {
@@ -138,7 +138,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 				if (!ldci4.IsLdcI4())
 					continue;
 
-				var instrs = DotNetUtils.getInstructions(instructions, i + 1, OpCodes.Newarr, OpCodes.Dup, OpCodes.Ldtoken, OpCodes.Call);
+				var instrs = DotNetUtils.GetInstructions(instructions, i + 1, OpCodes.Newarr, OpCodes.Dup, OpCodes.Ldtoken, OpCodes.Call);
 				if (instrs == null)
 					continue;
 
@@ -152,7 +152,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 
 				int index = i + 1 + instrs.Count;
 				if (index < instructions.Count && instructions[index].OpCode.Code == Code.Call)
-					flags = getStringDataFlags(instructions[index].Operand as MethodDef);
+					flags = GetStringDataFlags(instructions[index].Operand as MethodDef);
 
 				compressedDataField = field;
 				return true;
@@ -162,32 +162,32 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			return false;
 		}
 
-		StringDataFlags getStringDataFlags(MethodDef method) {
+		StringDataFlags GetStringDataFlags(MethodDef method) {
 			if (method == null || method.Body == null)
 				return 0;
 			var sig = method.MethodSig;
 			if (sig == null || sig.Params.Count != 1)
 				return 0;
-			if (!checkClass(sig.Params[0], "System.Byte[]"))
+			if (!CheckClass(sig.Params[0], "System.Byte[]"))
 				return 0;
-			if (!checkClass(sig.RetType, "System.Byte[]"))
+			if (!CheckClass(sig.RetType, "System.Byte[]"))
 				return 0;
 
 			StringDataFlags flags = 0;
 
-			if (hasInstruction(method, Code.Not))
+			if (HasInstruction(method, Code.Not))
 				flags |= StringDataFlags.Encrypted2;
-			else if (hasInstruction(method, Code.Xor))
+			else if (HasInstruction(method, Code.Xor))
 				flags |= StringDataFlags.Encrypted1;
-			else if (check3DesCreator(method))
+			else if (Check3DesCreator(method))
 				flags |= StringDataFlags.Encrypted3DES;
-			if (callsDecompressor(method))
+			if (CallsDecompressor(method))
 				flags |= StringDataFlags.Compressed;
 
 			return flags;
 		}
 
-		bool check3DesCreator(MethodDef method) {
+		bool Check3DesCreator(MethodDef method) {
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Call)
 					continue;
@@ -199,7 +199,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 					continue;
 				if (sig.Params.Count != 0)
 					continue;
-				if (!get3DesKeyIv(calledMethod, ref key, ref iv))
+				if (!Get3DesKeyIv(calledMethod, ref key, ref iv))
 					continue;
 
 				return true;
@@ -207,12 +207,12 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			return false;
 		}
 
-		bool get3DesKeyIv(MethodDef method, ref byte[] key, ref byte[] iv) {
-			if (!new LocalTypes(method).exists("System.Security.Cryptography.TripleDESCryptoServiceProvider"))
+		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.CorLibTypes.Byte);
+			var arrays = ArrayFinder.GetArrays(method, module.CorLibTypes.Byte);
 			if (arrays.Count != 1 && arrays.Count != 2)
 				return false;
 
@@ -226,7 +226,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			return true;
 		}
 
-		static bool callsDecompressor(MethodDef method) {
+		static bool CallsDecompressor(MethodDef method) {
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code != Code.Call)
 					continue;
@@ -241,11 +241,11 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 				var parameters = sig.Params;
 				if (parameters.Count != 4)
 					continue;
-				if (!checkClass(parameters[0], "System.Byte[]"))
+				if (!CheckClass(parameters[0], "System.Byte[]"))
 					continue;
 				if (parameters[1].GetElementType() != ElementType.I4)
 					continue;
-				if (!checkClass(parameters[2], "System.Byte[]"))
+				if (!CheckClass(parameters[2], "System.Byte[]"))
 					continue;
 				if (parameters[3].GetElementType() != ElementType.I4)
 					continue;
@@ -255,7 +255,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			return false;
 		}
 
-		static bool hasInstruction(MethodDef method, Code code) {
+		static bool HasInstruction(MethodDef method, Code code) {
 			foreach (var instr in method.Body.Instructions) {
 				if (instr.OpCode.Code == code)
 					return true;
@@ -263,15 +263,15 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			return false;
 		}
 
-		static bool checkClass(TypeSig type, string fullName) {
+		static bool CheckClass(TypeSig type, string fullName) {
 			return type != null && (type.ElementType == ElementType.Object || type.FullName == fullName);
 		}
 
-		static bool isStringType(TypeSig type) {
+		static bool IsStringType(TypeSig type) {
 			return type != null && (type.ElementType == ElementType.Object || type.ElementType == ElementType.String);
 		}
 
-		bool initializeDecrypterInfos(TypeDef type) {
+		bool InitializeDecrypterInfos(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
@@ -280,20 +280,20 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 					continue;
 				if (sig.Params.Count != 0)
 					continue;
-				if (!isStringType(sig.RetType))
+				if (!IsStringType(sig.RetType))
 					continue;
 
-				var info = createInfo(method);
+				var info = CreateInfo(method);
 				if (info == null)
 					continue;
 
-				methodToInfo.add(method, info);
+				methodToInfo.Add(method, info);
 			}
 
 			return methodToInfo.Count != 0;
 		}
 
-		DecrypterInfo createInfo(MethodDef method) {
+		DecrypterInfo CreateInfo(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 1; i++) {
 				var ldci4_1 = instrs[i];
@@ -309,7 +309,7 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			return null;
 		}
 
-		public void initialize() {
+		public void Initialize() {
 			if (decrypterType == null)
 				return;
 
@@ -329,13 +329,13 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			}
 
 			if ((stringDataFlags & StringDataFlags.Encrypted3DES) != 0)
-				decryptedData = DeobUtils.des3Decrypt(decryptedData, key, iv);
+				decryptedData = DeobUtils.Des3Decrypt(decryptedData, key, iv);
 
 			if ((stringDataFlags & StringDataFlags.Compressed) != 0)
-				decryptedData = QclzDecompressor.decompress(decryptedData);
+				decryptedData = QclzDecompressor.Decompress(decryptedData);
 		}
 
-		public void cleanUp() {
+		public void CleanUp() {
 			if (decrypterType == null)
 				return;
 
@@ -344,8 +344,8 @@ namespace de4dot.code.deobfuscators.Spices_Net {
 			encryptedDataField.RVA = 0;
 		}
 
-		public string decrypt(MethodDef method) {
-			var info = methodToInfo.find(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 b3fffe92..48b12660 100644
--- a/de4dot.code/deobfuscators/StringCounts.cs
+++ b/de4dot.code/deobfuscators/StringCounts.cs
@@ -34,31 +34,31 @@ namespace de4dot.code.deobfuscators {
 			get { return strings.Count; }
 		}
 
-		public void add(string s) {
+		public void Add(string s) {
 			int count;
 			strings.TryGetValue(s, out count);
 			strings[s] = count + 1;
 		}
 
-		public bool exists(string s) {
+		public bool Exists(string s) {
 			if (s == null)
 				return false;
 			return strings.ContainsKey(s);
 		}
 
-		public bool all(IList<string> list) {
+		public bool All(IList<string> list) {
 			foreach (var s in list) {
-				if (!exists(s))
+				if (!Exists(s))
 					return false;
 			}
 			return true;
 		}
 
-		public bool exactly(IList<string> list) {
-			return list.Count == strings.Count && all(list);
+		public bool Exactly(IList<string> list) {
+			return list.Count == strings.Count && All(list);
 		}
 
-		public int count(string s) {
+		public int Count(string s) {
 			int count;
 			strings.TryGetValue(s, out count);
 			return count;
@@ -67,20 +67,20 @@ namespace de4dot.code.deobfuscators {
 
 	class FieldTypes : StringCounts {
 		public FieldTypes(TypeDef type) {
-			init(type.Fields);
+			Initialize(type.Fields);
 		}
 
 		public FieldTypes(IEnumerable<FieldDef> fields) {
-			init(fields);
+			Initialize(fields);
 		}
 
-		void init(IEnumerable<FieldDef> fields) {
+		void Initialize(IEnumerable<FieldDef> fields) {
 			if (fields == null)
 				return;
 			foreach (var field in fields) {
 				var type = field.FieldSig.GetFieldType();
 				if (type != null)
-					add(type.FullName);
+					Add(type.FullName);
 			}
 		}
 	}
@@ -88,18 +88,18 @@ namespace de4dot.code.deobfuscators {
 	class LocalTypes : StringCounts {
 		public LocalTypes(MethodDef method) {
 			if (method != null && method.Body != null)
-				init(method.Body.Variables);
+				Initialize(method.Body.Variables);
 		}
 
 		public LocalTypes(IEnumerable<Local> locals) {
-			init(locals);
+			Initialize(locals);
 		}
 
-		void init(IEnumerable<Local> locals) {
+		void Initialize(IEnumerable<Local> locals) {
 			if (locals == null)
 				return;
 			foreach (var local in locals)
-				add(local.Type.FullName);
+				Add(local.Type.FullName);
 		}
 	}
 }
diff --git a/de4dot.code/deobfuscators/TypesRestorer.cs b/de4dot.code/deobfuscators/TypesRestorer.cs
index ac280df5..0e4da416 100644
--- a/de4dot.code/deobfuscators/TypesRestorer.cs
+++ b/de4dot.code/deobfuscators/TypesRestorer.cs
@@ -43,7 +43,7 @@ namespace de4dot.code.deobfuscators {
 
 			public UpdatedMethod(MethodDef method) {
 				token = method.MDToken.ToInt32();
-				newArgTypes = new TypeSig[DotNetUtils.getArgsCount(method)];
+				newArgTypes = new TypeSig[DotNetUtils.GetArgsCount(method)];
 			}
 		}
 
@@ -70,14 +70,14 @@ namespace de4dot.code.deobfuscators {
 				this.arg = arg;
 			}
 
-			public void add(TypeSig type) {
-				add(type, false);
+			public void Add(TypeSig type) {
+				Add(type, false);
 			}
 
-			public void add(TypeSig type, bool wasNewobj) {
+			public void Add(TypeSig type, bool wasNewobj) {
 				if (wasNewobj) {
 					if (!newobjTypes)
-						clear();
+						Clear();
 					newobjTypes = true;
 				}
 				else if (newobjTypes)
@@ -85,11 +85,11 @@ namespace de4dot.code.deobfuscators {
 				types[type] = true;
 			}
 
-			public void clear() {
+			public void Clear() {
 				types.Clear();
 			}
 
-			public bool updateNewType(ModuleDef module) {
+			public bool UpdateNewType(ModuleDef module) {
 				if (types.Count == 0)
 					return false;
 
@@ -99,7 +99,7 @@ namespace de4dot.code.deobfuscators {
 						theNewType = key;
 						continue;
 					}
-					theNewType = getCommonBaseClass(module, theNewType, key);
+					theNewType = GetCommonBaseClass(module, theNewType, key);
 					if (theNewType == null)
 						break;
 				}
@@ -117,7 +117,7 @@ namespace de4dot.code.deobfuscators {
 			this.module = module;
 		}
 
-		UpdatedMethod getUpdatedMethod(MethodDef method) {
+		UpdatedMethod GetUpdatedMethod(MethodDef method) {
 			int token = method.MDToken.ToInt32();
 			UpdatedMethod updatedMethod;
 			if (updatedMethods.TryGetValue(token, out updatedMethod))
@@ -125,7 +125,7 @@ namespace de4dot.code.deobfuscators {
 			return updatedMethods[token] = new UpdatedMethod(method);
 		}
 
-		UpdatedField getUpdatedField(FieldDef field) {
+		UpdatedField GetUpdatedField(FieldDef field) {
 			int token = field.MDToken.ToInt32();
 			UpdatedField updatedField;
 			if (updatedFields.TryGetValue(token, out updatedField))
@@ -133,35 +133,35 @@ namespace de4dot.code.deobfuscators {
 			return updatedFields[token] = new UpdatedField(field);
 		}
 
-		public void deobfuscate() {
+		public void Deobfuscate() {
 			allMethods = new List<MethodDef>();
 
-			addAllMethods();
-			addAllFields();
+			AddAllMethods();
+			AddAllFields();
 
-			deobfuscateLoop();
+			DeobfuscateLoop();
 
-			restoreFieldTypes();
-			restoreMethodTypes();
+			RestoreFieldTypes();
+			RestoreMethodTypes();
 		}
 
-		void addAllMethods() {
+		void AddAllMethods() {
 			foreach (var type in module.GetTypes())
-				addMethods(type.Methods);
+				AddMethods(type.Methods);
 		}
 
-		void addMethods(IEnumerable<MethodDef> methods) {
+		void AddMethods(IEnumerable<MethodDef> methods) {
 			allMethods.AddRange(methods);
 		}
 
-		void addMethod(MethodDef method) {
+		void AddMethod(MethodDef method) {
 			allMethods.Add(method);
 		}
 
-		void addAllFields() {
+		void AddAllFields() {
 			foreach (var type in module.GetTypes()) {
 				foreach (var field in type.Fields) {
-					if (!isUnknownType(field))
+					if (!IsUnknownType(field))
 						continue;
 
 					fieldWrites[field] = new TypeInfo<FieldDef>(field);
@@ -169,43 +169,43 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		void deobfuscateLoop() {
+		void DeobfuscateLoop() {
 			for (int i = 0; i < 10; i++) {
 				bool changed = false;
-				changed |= deobfuscateFields();
-				changed |= deobfuscateMethods();
+				changed |= DeobfuscateFields();
+				changed |= DeobfuscateMethods();
 				if (!changed)
 					break;
 			}
 		}
 
-		void restoreFieldTypes() {
+		void RestoreFieldTypes() {
 			var fields = new List<UpdatedField>(updatedFields.Values);
 			if (fields.Count == 0)
 				return;
 
 			Logger.v("Changing field types to real type");
 			fields.Sort((a, b) => a.token.CompareTo(b.token));
-			Logger.Instance.indent();
+			Logger.Instance.Indent();
 			foreach (var updatedField in fields)
-				Logger.v("Field {0:X8}: type {1} ({2:X8})", updatedField.token, Utils.removeNewlines(updatedField.newFieldType.FullName), updatedField.newFieldType.MDToken.ToInt32());
-			Logger.Instance.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() {
+		void RestoreMethodTypes() {
 			var methods = new List<UpdatedMethod>(updatedMethods.Values);
 			if (methods.Count == 0)
 				return;
 
 			Logger.v("Changing method args and return types to real type");
 			methods.Sort((a, b) => a.token.CompareTo(b.token));
-			Logger.Instance.indent();
+			Logger.Instance.Indent();
 			foreach (var updatedMethod in methods) {
 				Logger.v("Method {0:X8}", updatedMethod.token);
-				Logger.Instance.indent();
+				Logger.Instance.Indent();
 				if (updatedMethod.newReturnType != null) {
 					Logger.v("ret: {0} ({1:X8})",
-							Utils.removeNewlines(updatedMethod.newReturnType.FullName),
+							Utils.RemoveNewlines(updatedMethod.newReturnType.FullName),
 							updatedMethod.newReturnType.MDToken.ToInt32());
 				}
 				for (int i = 0; i < updatedMethod.newArgTypes.Length; i++) {
@@ -214,29 +214,29 @@ namespace de4dot.code.deobfuscators {
 						continue;
 					Logger.v("arg {0}: {1} ({2:X8})",
 							i,
-							Utils.removeNewlines(updatedArg.FullName),
+							Utils.RemoveNewlines(updatedArg.FullName),
 							updatedArg.MDToken.ToInt32());
 				}
-				Logger.Instance.deIndent();
+				Logger.Instance.DeIndent();
 			}
-			Logger.Instance.deIndent();
+			Logger.Instance.DeIndent();
 		}
 
-		bool deobfuscateMethods() {
+		bool DeobfuscateMethods() {
 			bool changed = false;
 			foreach (var method in allMethods) {
 				methodReturnInfo = new TypeInfo<Parameter>(method.Parameters.ReturnParameter);
-				deobfuscateMethod(method);
+				DeobfuscateMethod(method);
 
-				if (methodReturnInfo.updateNewType(module)) {
-					getUpdatedMethod(method).newReturnType = methodReturnInfo.newType;
+				if (methodReturnInfo.UpdateNewType(module)) {
+					GetUpdatedMethod(method).newReturnType = methodReturnInfo.newType;
 					method.MethodSig.RetType = methodReturnInfo.newType;
 					changed = true;
 				}
 
 				foreach (var info in argInfos.Values) {
-					if (info.updateNewType(module)) {
-						getUpdatedMethod(method).newArgTypes[info.arg.Index] = info.newType;
+					if (info.UpdateNewType(module)) {
+						GetUpdatedMethod(method).newArgTypes[info.arg.Index] = info.newType;
 						info.arg.Type = info.newType;
 						changed = true;
 					}
@@ -245,24 +245,24 @@ namespace de4dot.code.deobfuscators {
 			return changed;
 		}
 
-		static int sortTypeInfos(TypeInfo<Parameter> a, TypeInfo<Parameter> b) {
+		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 a.arg.Index.CompareTo(b.arg.Index);
 		}
 
-		void deobfuscateMethod(MethodDef method) {
+		void DeobfuscateMethod(MethodDef method) {
 			if (!method.IsStatic || method.Body == null)
 				return;
 
-			bool fixReturnType = isUnknownType(method.MethodSig.GetRetType());
+			bool fixReturnType = IsUnknownType(method.MethodSig.GetRetType());
 
 			argInfos.Clear();
 			foreach (var arg in method.Parameters) {
 				if (arg.IsHiddenThisParameter)
 					continue;
-				if (!isUnknownType(arg))
+				if (!IsUnknownType(arg))
 					continue;
 				argInfos[arg] = new TypeInfo<Parameter>(arg);
 			}
@@ -279,24 +279,24 @@ namespace de4dot.code.deobfuscators {
 					if (!fixReturnType)
 						break;
 					bool wasNewobj;
-					var type = getLoadedType(method, method, instructions, i, out wasNewobj);
+					var type = GetLoadedType(method, method, instructions, i, out wasNewobj);
 					if (type == null)
 						break;
-					methodReturnInfo.add(type);
+					methodReturnInfo.Add(type);
 					break;
 
 				case Code.Call:
 				case Code.Calli:
 				case Code.Callvirt:
 				case Code.Newobj:
-					pushedArgs = MethodStack.getPushedArgInstructions(instructions, i);
+					pushedArgs = MethodStack.GetPushedArgInstructions(instructions, i);
 					var calledMethod = instr.Operand as IMethod;
 					if (calledMethod == null)
 						break;
-					var calledMethodParams = DotNetUtils.getArgs(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);
+						var ldInstr = pushedArgs.GetEnd(j);
 						switch (ldInstr.OpCode.Code) {
 						case Code.Ldarg:
 						case Code.Ldarg_S:
@@ -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.getArg(calledMethodParams, calledMethodParamIndex));
+							AddMethodArgType(method, GetParameter(methodParams, ldInstr), DotNetUtils.GetArg(calledMethodParams, calledMethodParamIndex));
 							break;
 
 						default:
@@ -314,10 +314,10 @@ namespace de4dot.code.deobfuscators {
 					break;
 
 				case Code.Castclass:
-					pushedArgs = MethodStack.getPushedArgInstructions(instructions, i);
+					pushedArgs = MethodStack.GetPushedArgInstructions(instructions, i);
 					if (pushedArgs.NumValidArgs < 1)
 						break;
-					addMethodArgType(method, getParameter(methodParams, pushedArgs.getEnd(0)), instr.Operand as ITypeDefOrRef);
+					AddMethodArgType(method, GetParameter(methodParams, pushedArgs.GetEnd(0)), instr.Operand as ITypeDefOrRef);
 					break;
 
 				case Code.Stloc:
@@ -326,35 +326,35 @@ namespace de4dot.code.deobfuscators {
 				case Code.Stloc_1:
 				case Code.Stloc_2:
 				case Code.Stloc_3:
-					pushedArgs = MethodStack.getPushedArgInstructions(instructions, i);
+					pushedArgs = MethodStack.GetPushedArgInstructions(instructions, i);
 					if (pushedArgs.NumValidArgs < 1)
 						break;
-					addMethodArgType(method, getParameter(methodParams, pushedArgs.getEnd(0)), instr.GetLocal(method.Body.Variables));
+					AddMethodArgType(method, GetParameter(methodParams, pushedArgs.GetEnd(0)), instr.GetLocal(method.Body.Variables));
 					break;
 
 				case Code.Stsfld:
-					pushedArgs = MethodStack.getPushedArgInstructions(instructions, i);
+					pushedArgs = MethodStack.GetPushedArgInstructions(instructions, i);
 					if (pushedArgs.NumValidArgs < 1)
 						break;
-					addMethodArgType(method, getParameter(methodParams, pushedArgs.getEnd(0)), instr.Operand as IField);
+					AddMethodArgType(method, GetParameter(methodParams, pushedArgs.GetEnd(0)), instr.Operand as IField);
 					break;
 
 				case Code.Stfld:
-					pushedArgs = MethodStack.getPushedArgInstructions(instructions, i);
+					pushedArgs = MethodStack.GetPushedArgInstructions(instructions, i);
 					if (pushedArgs.NumValidArgs >= 1) {
 						var field = instr.Operand as IField;
-						addMethodArgType(method, getParameter(methodParams, pushedArgs.getEnd(0)), field);
+						AddMethodArgType(method, GetParameter(methodParams, pushedArgs.GetEnd(0)), field);
 						if (pushedArgs.NumValidArgs >= 2 && field != null)
-							addMethodArgType(method, getParameter(methodParams, pushedArgs.getEnd(1)), field.DeclaringType);
+							AddMethodArgType(method, GetParameter(methodParams, pushedArgs.GetEnd(1)), field.DeclaringType);
 					}
 					break;
 
 				case Code.Ldfld:
 				case Code.Ldflda:
-					pushedArgs = MethodStack.getPushedArgInstructions(instructions, i);
+					pushedArgs = MethodStack.GetPushedArgInstructions(instructions, i);
 					if (pushedArgs.NumValidArgs < 1)
 						break;
-					addMethodArgType(method, getParameter(methodParams, pushedArgs.getEnd(0)), instr.Operand as IField);
+					AddMethodArgType(method, GetParameter(methodParams, pushedArgs.GetEnd(0)), instr.Operand as IField);
 					break;
 
 				//TODO: For better results, these should be checked:
@@ -415,7 +415,7 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		static Parameter getParameter(IList<Parameter> parameters, Instruction instr) {
+		static Parameter GetParameter(IList<Parameter> parameters, Instruction instr) {
 			switch (instr.OpCode.Code) {
 			case Code.Ldarg:
 			case Code.Ldarg_S:
@@ -430,33 +430,33 @@ namespace de4dot.code.deobfuscators {
 			}
 		}
 
-		bool addMethodArgType(IGenericParameterProvider gpp, Parameter methodParam, IField field) {
+		bool AddMethodArgType(IGenericParameterProvider gpp, Parameter methodParam, IField field) {
 			if (field == null)
 				return false;
-			return addMethodArgType(gpp, methodParam, field.FieldSig.GetFieldType());
+			return AddMethodArgType(gpp, methodParam, field.FieldSig.GetFieldType());
 		}
 
-		bool addMethodArgType(IGenericParameterProvider gpp, Parameter methodParam, Local otherLocal) {
+		bool AddMethodArgType(IGenericParameterProvider gpp, Parameter methodParam, Local otherLocal) {
 			if (otherLocal == null)
 				return false;
-			return addMethodArgType(gpp, methodParam, otherLocal.Type);
+			return AddMethodArgType(gpp, methodParam, otherLocal.Type);
 		}
 
-		bool addMethodArgType(IGenericParameterProvider gpp, Parameter methodParam, Parameter otherParam) {
+		bool AddMethodArgType(IGenericParameterProvider gpp, Parameter methodParam, Parameter otherParam) {
 			if (otherParam == null)
 				return false;
-			return addMethodArgType(gpp, methodParam, otherParam.Type);
+			return AddMethodArgType(gpp, methodParam, otherParam.Type);
 		}
 
-		bool addMethodArgType(IGenericParameterProvider gpp, Parameter methodParam, ITypeDefOrRef type) {
-			return addMethodArgType(gpp, methodParam, type.ToTypeSig());
+		bool AddMethodArgType(IGenericParameterProvider gpp, Parameter methodParam, ITypeDefOrRef type) {
+			return AddMethodArgType(gpp, methodParam, type.ToTypeSig());
 		}
 
-		bool addMethodArgType(IGenericParameterProvider gpp, Parameter methodParam, TypeSig type) {
+		bool AddMethodArgType(IGenericParameterProvider gpp, Parameter methodParam, TypeSig type) {
 			if (methodParam == null || type == null)
 				return false;
 
-			if (!isValidType(gpp, type))
+			if (!IsValidType(gpp, type))
 				return false;
 
 			TypeInfo<Parameter> info;
@@ -465,13 +465,13 @@ namespace de4dot.code.deobfuscators {
 			if (info.Types.ContainsKey(type))
 				return false;
 
-			info.add(type);
+			info.Add(type);
 			return true;
 		}
 
-		bool deobfuscateFields() {
+		bool DeobfuscateFields() {
 			foreach (var info in fieldWrites.Values)
-				info.clear();
+				info.Clear();
 
 			foreach (var method in allMethods) {
 				if (method.Body == null)
@@ -491,17 +491,17 @@ namespace de4dot.code.deobfuscators {
 						if (!fieldWrites.TryGetValue(field, out info))
 							continue;
 						bool wasNewobj;
-						fieldType = getLoadedType(info.arg.DeclaringType, method, instructions, i, out wasNewobj);
+						fieldType = GetLoadedType(info.arg.DeclaringType, method, instructions, i, out wasNewobj);
 						if (fieldType == null)
 							continue;
-						info.add(fieldType, wasNewobj);
+						info.Add(fieldType, wasNewobj);
 						break;
 
 					case Code.Call:
 					case Code.Calli:
 					case Code.Callvirt:
 					case Code.Newobj:
-						var pushedArgs = MethodStack.getPushedArgInstructions(instructions, i);
+						var pushedArgs = MethodStack.GetPushedArgInstructions(instructions, i);
 						var calledMethod = instr.Operand as IMethod;
 						if (calledMethod == null)
 							continue;
@@ -512,10 +512,10 @@ namespace de4dot.code.deobfuscators {
 						if (calledMethodDefOrRef == null)
 							continue;
 
-						IList<TypeSig> calledMethodArgs = DotNetUtils.getArgs(calledMethodDefOrRef);
-						calledMethodArgs = DotNetUtils.replaceGenericParameters(calledMethodDefOrRef.DeclaringType.TryGetGenericInstSig(), calledMethodSpec, calledMethodArgs);
+						IList<TypeSig> calledMethodArgs = DotNetUtils.GetArgs(calledMethodDefOrRef);
+						calledMethodArgs = DotNetUtils.ReplaceGenericParameters(calledMethodDefOrRef.DeclaringType.TryGetGenericInstSig(), calledMethodSpec, calledMethodArgs);
 						for (int j = 0; j < pushedArgs.NumValidArgs; j++) {
-							var pushInstr = pushedArgs.getEnd(j);
+							var pushInstr = pushedArgs.GetEnd(j);
 							if (pushInstr.OpCode.Code != Code.Ldfld && pushInstr.OpCode.Code != Code.Ldsfld)
 								continue;
 
@@ -525,9 +525,9 @@ namespace de4dot.code.deobfuscators {
 							if (!fieldWrites.TryGetValue(field, out info))
 								continue;
 							fieldType = calledMethodArgs[calledMethodArgs.Count - 1 - j];
-							if (!isValidType(info.arg.DeclaringType, fieldType))
+							if (!IsValidType(info.arg.DeclaringType, fieldType))
 								continue;
-							info.add(fieldType);
+							info.Add(fieldType);
 						}
 						break;
 
@@ -540,9 +540,9 @@ namespace de4dot.code.deobfuscators {
 			bool changed = false;
 			var removeThese = new List<FieldDef>();
 			foreach (var info in fieldWrites.Values) {
-				if (info.updateNewType(module)) {
+				if (info.UpdateNewType(module)) {
 					removeThese.Add(info.arg);
-					getUpdatedField(info.arg).newFieldType = info.newType;
+					GetUpdatedField(info.arg).newFieldType = info.newType;
 					info.arg.FieldSig.Type = info.newType;
 					changed = true;
 				}
@@ -552,14 +552,14 @@ namespace de4dot.code.deobfuscators {
 			return changed;
 		}
 
-		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))
+		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, TypeSig type) {
+		protected virtual bool IsValidType(IGenericParameterProvider gpp, TypeSig type) {
 			if (type == null)
 				return false;
 			if (type.ElementType == ElementType.Void)
@@ -569,7 +569,7 @@ namespace de4dot.code.deobfuscators {
 				switch (type.ElementType) {
 				case ElementType.GenericInst:
 					foreach (var ga in ((GenericInstSig)type).GenericArguments) {
-						if (!isValidType(gpp, ga))
+						if (!IsValidType(gpp, ga))
 							return false;
 					}
 					break;
@@ -628,12 +628,12 @@ namespace de4dot.code.deobfuscators {
 			return type != null;
 		}
 
-		protected abstract bool isUnknownType(object o);
+		protected abstract bool IsUnknownType(object o);
 
-		static TypeSig getCommonBaseClass(ModuleDef module, TypeSig a, TypeSig b) {
-			if (DotNetUtils.isDelegate(a) && DotNetUtils.derivesFromDelegate(module.Find(b.ToTypeDefOrRef())))
+		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(module.Find(a.ToTypeDefOrRef())))
+			if (DotNetUtils.IsDelegate(b) && DotNetUtils.DerivesFromDelegate(module.Find(a.ToTypeDefOrRef())))
 				return a;
 			return null;	//TODO:
 		}
@@ -644,17 +644,17 @@ namespace de4dot.code.deobfuscators {
 			: base(module) {
 		}
 
-		protected override bool isValidType(IGenericParameterProvider gpp, TypeSig type) {
+		protected override bool IsValidType(IGenericParameterProvider gpp, TypeSig type) {
 			if (type == null)
 				return false;
 			if (type.IsValueType)
 				return false;
 			if (type.ElementType == ElementType.Object)
 				return false;
-			return base.isValidType(gpp, type);
+			return base.IsValidType(gpp, type);
 		}
 
-		protected override bool isUnknownType(object o) {
+		protected override bool IsUnknownType(object o) {
 			var arg = o as Parameter;
 			if (arg != null)
 				return arg.Type.GetElementType() == ElementType.Object;
diff --git a/de4dot.code/deobfuscators/Unknown/Deobfuscator.cs b/de4dot.code/deobfuscators/Unknown/Deobfuscator.cs
index 1da378ec..33e070ab 100644
--- a/de4dot.code/deobfuscators/Unknown/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/Unknown/Deobfuscator.cs
@@ -37,7 +37,7 @@ namespace de4dot.code.deobfuscators.Unknown {
 			get { return THE_TYPE; }
 		}
 
-		public override IDeobfuscator createDeobfuscator() {
+		public override IDeobfuscator CreateDeobfuscator() {
 			return new Deobfuscator(new Deobfuscator.Options {
 				RenameResourcesInCode = false,
 				ValidNameRegex = validNameRegex.get(),
@@ -68,20 +68,20 @@ namespace de4dot.code.deobfuscators.Unknown {
 			KeepTypes = true;
 		}
 
-		void setName(string name) {
+		void SetName(string name) {
 			if (obfuscatorName == null && name != null)
 				obfuscatorName = string.Format("{0} (not supported)", name);
 		}
 
-		protected override int detectInternal() {
-			setName(scanTypes());
+		protected override int DetectInternal() {
+			SetName(ScanTypes());
 			return 1;
 		}
 
-		protected override void scanForObfuscator() {
+		protected override void ScanForObfuscator() {
 		}
 
-		string scanTypes() {
+		string ScanTypes() {
 			foreach (var type in module.Types) {
 				var fn = type.FullName;
 				if (fn == "ConfusedByAttribute")
@@ -98,7 +98,7 @@ namespace de4dot.code.deobfuscators.Unknown {
 			return null;
 		}
 
-		public override IEnumerable<int> getStringDecrypterMethods() {
+		public override IEnumerable<int> GetStringDecrypterMethods() {
 			return new List<int>();
 		}
 	}
diff --git a/de4dot.code/deobfuscators/UnusedMethodsFinder.cs b/de4dot.code/deobfuscators/UnusedMethodsFinder.cs
index a6e1f16b..4ce59d2b 100644
--- a/de4dot.code/deobfuscators/UnusedMethodsFinder.cs
+++ b/de4dot.code/deobfuscators/UnusedMethodsFinder.cs
@@ -33,36 +33,36 @@ namespace de4dot.code.deobfuscators {
 			this.module = module;
 			this.removedMethods = removedMethods;
 			foreach (var method in possiblyUnusedMethods) {
-				if (method != module.ManagedEntryPoint && !removedMethods.exists(method))
+				if (method != module.ManagedEntryPoint && !removedMethods.Exists(method))
 					this.possiblyUnusedMethods[method] = true;
 			}
 		}
 
-		public IEnumerable<MethodDef> find() {
+		public IEnumerable<MethodDef> Find() {
 			if (possiblyUnusedMethods.Count == 0)
 				return possiblyUnusedMethods.Keys;
 
 			foreach (var type in module.GetTypes()) {
 				foreach (var method in type.Methods)
-					check(method);
+					Check(method);
 			}
 
 			while (notUnusedStack.Count > 0) {
 				var method = notUnusedStack.Pop();
 				if (!possiblyUnusedMethods.Remove(method))
 					continue;
-				check(method);
+				Check(method);
 			}
 
 			return possiblyUnusedMethods.Keys;
 		}
 
-		void check(MethodDef method) {
+		void Check(MethodDef method) {
 			if (method.Body == null)
 				return;
 			if (possiblyUnusedMethods.ContainsKey(method))
 				return;
-			if (removedMethods.exists(method))
+			if (removedMethods.Exists(method))
 				return;
 
 			foreach (var instr in method.Body.Instructions) {
@@ -79,7 +79,7 @@ namespace de4dot.code.deobfuscators {
 					continue;
 				}
 
-				var calledMethod = DotNetUtils.getMethod2(module, instr.Operand as IMethod);
+				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 c22af9b1..a8163a3b 100644
--- a/de4dot.code/deobfuscators/ValueInlinerBase.cs
+++ b/de4dot.code/deobfuscators/ValueInlinerBase.cs
@@ -48,33 +48,33 @@ namespace de4dot.code.deobfuscators {
 		}
 
 		public IEnumerable<MethodDef> Methods {
-			get { return decrypterMethods.getKeys(); }
+			get { return decrypterMethods.GetKeys(); }
 		}
 
-		public void add(MethodDef method, Func<MethodDef, MethodSpec, object[], object> handler) {
+		public void Add(MethodDef method, Func<MethodDef, MethodSpec, object[], object> handler) {
 			if (method == null)
 				return;
-			if (decrypterMethods.find(method) != null)
+			if (decrypterMethods.Find(method) != null)
 				throw new ApplicationException(string.Format("Handler for method {0:X8} has already been added", method.MDToken.ToInt32()));
 			if (method != null)
-				decrypterMethods.add(method, handler);
+				decrypterMethods.Add(method, handler);
 		}
 
-		protected override void inlineAllCalls() {
+		protected override void InlineAllCalls() {
 			foreach (var tmp in callResults) {
 				var callResult = (MyCallResult)tmp;
-				var handler = decrypterMethods.find(callResult.methodRef);
+				var handler = decrypterMethods.Find(callResult.methodRef);
 				callResult.returnValue = handler((MethodDef)callResult.methodRef, callResult.gim, callResult.args);
 			}
 		}
 
-		protected override CallResult createCallResult(IMethod method, MethodSpec gim, Block block, int callInstrIndex) {
-			if (decrypterMethods.find(method) == null)
+		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);
 		}
 
-		protected bool removeUnboxInstruction(Block block, int index, string unboxType) {
+		protected bool RemoveUnboxInstruction(Block block, int index, string unboxType) {
 			if (!removeUnbox)
 				return false;
 			var instrs = block.Instructions;
@@ -86,71 +86,71 @@ namespace de4dot.code.deobfuscators {
 			var type = unbox.Operand as ITypeDefOrRef;
 			if (type == null || type.FullName != unboxType)
 				return false;
-			block.remove(index, 1);
+			block.Remove(index, 1);
 			return true;
 		}
 	}
 
 	class BooleanValueInliner : ValueInlinerBase<bool> {
-		protected override void inlineReturnValues(IList<CallResult> callResults) {
+		protected override void InlineReturnValues(IList<CallResult> callResults) {
 			foreach (var callResult in callResults) {
 				var block = callResult.block;
 				int num = callResult.callEndIndex - callResult.callStartIndex + 1;
 
-				block.replace(callResult.callStartIndex, num, Instruction.CreateLdcI4((bool)callResult.returnValue ? 1 : 0));
-				removeUnboxInstruction(block, callResult.callStartIndex + 1, "System.Boolean");
+				block.Replace(callResult.callStartIndex, num, Instruction.CreateLdcI4((bool)callResult.returnValue ? 1 : 0));
+				RemoveUnboxInstruction(block, callResult.callStartIndex + 1, "System.Boolean");
 				Logger.v("Decrypted boolean: {0}", callResult.returnValue);
 			}
 		}
 	}
 
 	class Int32ValueInliner : ValueInlinerBase<int> {
-		protected override void inlineReturnValues(IList<CallResult> callResults) {
+		protected override void InlineReturnValues(IList<CallResult> callResults) {
 			foreach (var callResult in callResults) {
 				var block = callResult.block;
 				int num = callResult.callEndIndex - callResult.callStartIndex + 1;
 
-				block.replace(callResult.callStartIndex, num, Instruction.CreateLdcI4((int)callResult.returnValue));
-				removeUnboxInstruction(block, callResult.callStartIndex + 1, "System.Int32");
+				block.Replace(callResult.callStartIndex, num, Instruction.CreateLdcI4((int)callResult.returnValue));
+				RemoveUnboxInstruction(block, callResult.callStartIndex + 1, "System.Int32");
 				Logger.v("Decrypted int32: {0}", callResult.returnValue);
 			}
 		}
 	}
 
 	class Int64ValueInliner : ValueInlinerBase<long> {
-		protected override void inlineReturnValues(IList<CallResult> callResults) {
+		protected override void InlineReturnValues(IList<CallResult> callResults) {
 			foreach (var callResult in callResults) {
 				var block = callResult.block;
 				int num = callResult.callEndIndex - callResult.callStartIndex + 1;
 
-				block.replace(callResult.callStartIndex, num, OpCodes.Ldc_I8.ToInstruction((long)callResult.returnValue));
-				removeUnboxInstruction(block, callResult.callStartIndex + 1, "System.Int64");
+				block.Replace(callResult.callStartIndex, num, OpCodes.Ldc_I8.ToInstruction((long)callResult.returnValue));
+				RemoveUnboxInstruction(block, callResult.callStartIndex + 1, "System.Int64");
 				Logger.v("Decrypted int64: {0}", callResult.returnValue);
 			}
 		}
 	}
 
 	class SingleValueInliner : ValueInlinerBase<float> {
-		protected override void inlineReturnValues(IList<CallResult> callResults) {
+		protected override void InlineReturnValues(IList<CallResult> callResults) {
 			foreach (var callResult in callResults) {
 				var block = callResult.block;
 				int num = callResult.callEndIndex - callResult.callStartIndex + 1;
 
-				block.replace(callResult.callStartIndex, num, OpCodes.Ldc_R4.ToInstruction((float)callResult.returnValue));
-				removeUnboxInstruction(block, callResult.callStartIndex + 1, "System.Single");
+				block.Replace(callResult.callStartIndex, num, OpCodes.Ldc_R4.ToInstruction((float)callResult.returnValue));
+				RemoveUnboxInstruction(block, callResult.callStartIndex + 1, "System.Single");
 				Logger.v("Decrypted single: {0}", callResult.returnValue);
 			}
 		}
 	}
 
 	class DoubleValueInliner : ValueInlinerBase<double> {
-		protected override void inlineReturnValues(IList<CallResult> callResults) {
+		protected override void InlineReturnValues(IList<CallResult> callResults) {
 			foreach (var callResult in callResults) {
 				var block = callResult.block;
 				int num = callResult.callEndIndex - callResult.callStartIndex + 1;
 
-				block.replace(callResult.callStartIndex, num, OpCodes.Ldc_R8.ToInstruction((double)callResult.returnValue));
-				removeUnboxInstruction(block, callResult.callStartIndex + 1, "System.Double");
+				block.Replace(callResult.callStartIndex, num, OpCodes.Ldc_R8.ToInstruction((double)callResult.returnValue));
+				RemoveUnboxInstruction(block, callResult.callStartIndex + 1, "System.Double");
 				Logger.v("Decrypted double: {0}", callResult.returnValue);
 			}
 		}
diff --git a/de4dot.code/deobfuscators/Xenocode/Deobfuscator.cs b/de4dot.code/deobfuscators/Xenocode/Deobfuscator.cs
index 76e156fa..eac785f5 100644
--- a/de4dot.code/deobfuscators/Xenocode/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/Xenocode/Deobfuscator.cs
@@ -37,7 +37,7 @@ namespace de4dot.code.deobfuscators.Xenocode {
 			get { return THE_TYPE; }
 		}
 
-		public override IDeobfuscator createDeobfuscator() {
+		public override IDeobfuscator CreateDeobfuscator() {
 			return new Deobfuscator(new Deobfuscator.Options {
 				ValidNameRegex = validNameRegex.get(),
 			});
@@ -67,7 +67,7 @@ namespace de4dot.code.deobfuscators.Xenocode {
 			: base(options) {
 		}
 
-		protected override int detectInternal() {
+		protected override int DetectInternal() {
 			int val = 0;
 
 			if (stringDecrypter.Detected)
@@ -78,54 +78,54 @@ namespace de4dot.code.deobfuscators.Xenocode {
 			return val;
 		}
 
-		protected override void scanForObfuscator() {
-			findXenocodeAttribute();
+		protected override void ScanForObfuscator() {
+			FindXenocodeAttribute();
 			stringDecrypter = new StringDecrypter(module);
-			stringDecrypter.find();
+			stringDecrypter.Find();
 		}
 
-		void findXenocodeAttribute() {
+		void FindXenocodeAttribute() {
 			foreach (var type in module.Types) {
 				switch (type.FullName) {
 				case "Xenocode.Client.Attributes.AssemblyAttributes.ProcessedByXenocode":
 				case "Xenocode.Client.Attributes.AssemblyAttributes.SuppressDisassembly":
 				case "Xenocode.User.Attributes.AssemblyAttributes.ProcessedByXenoCode":
 				case "Xenocode.User.Attributes.AssemblyAttributes.SuppressDisassembly":
-					addAttributeToBeRemoved(type, "Obfuscator attribute");
+					AddAttributeToBeRemoved(type, "Obfuscator attribute");
 					foundXenocodeAttribute = true;
 					break;
 				}
 			}
 		}
 
-		public override void deobfuscateBegin() {
-			base.deobfuscateBegin();
+		public override void DeobfuscateBegin() {
+			base.DeobfuscateBegin();
 
-			staticStringInliner.add(stringDecrypter.Method, (method, gim, args) => stringDecrypter.decrypt((string)args[0], (int)args[1]));
-			DeobfuscatedFile.stringDecryptersAdded();
+			staticStringInliner.Add(stringDecrypter.Method, (method, gim, args) => stringDecrypter.Decrypt((string)args[0], (int)args[1]));
+			DeobfuscatedFile.StringDecryptersAdded();
 		}
 
-		public override void deobfuscateEnd() {
+		public override void DeobfuscateEnd() {
 			if (CanRemoveStringDecrypterType)
-				addTypeToBeRemoved(stringDecrypter.Type, "String decrypter type");
-			var obfType = findTypeWithThousandsOfMethods();
+				AddTypeToBeRemoved(stringDecrypter.Type, "String decrypter type");
+			var obfType = FindTypeWithThousandsOfMethods();
 			if (obfType != null)
-				addTypeToBeRemoved(obfType, "Obfuscator type with thousands of empty methods");
-			removeInvalidAttributes(module);
-			removeInvalidAttributes(module.Assembly);
-			base.deobfuscateEnd();
+				AddTypeToBeRemoved(obfType, "Obfuscator type with thousands of empty methods");
+			RemoveInvalidAttributes(module);
+			RemoveInvalidAttributes(module.Assembly);
+			base.DeobfuscateEnd();
 		}
 
-		TypeDef findTypeWithThousandsOfMethods() {
+		TypeDef FindTypeWithThousandsOfMethods() {
 			foreach (var type in module.Types) {
-				if (isTypeWithThousandsOfMethods(type))
+				if (IsTypeWithThousandsOfMethods(type))
 					return type;
 			}
 
 			return null;
 		}
 
-		bool isTypeWithThousandsOfMethods(TypeDef type) {
+		bool IsTypeWithThousandsOfMethods(TypeDef type) {
 			if (!type.IsNotPublic)
 				return false;
 			if (type.HasFields || type.HasEvents || type.HasProperties)
@@ -153,7 +153,7 @@ namespace de4dot.code.deobfuscators.Xenocode {
 		}
 
 		// Remove the attribute Xenocode adds that has an invalid ctor
-		void removeInvalidAttributes(IHasCustomAttribute hca) {
+		void RemoveInvalidAttributes(IHasCustomAttribute hca) {
 			if (!CanRemoveTypes)
 				return;
 			if (hca == null)
@@ -165,7 +165,7 @@ namespace de4dot.code.deobfuscators.Xenocode {
 			}
 		}
 
-		public override IEnumerable<int> getStringDecrypterMethods() {
+		public override IEnumerable<int> GetStringDecrypterMethods() {
 			var list = new List<int>();
 			if (stringDecrypter.Method != null)
 				list.Add(stringDecrypter.Method.MDToken.ToInt32());
diff --git a/de4dot.code/deobfuscators/Xenocode/StringDecrypter.cs b/de4dot.code/deobfuscators/Xenocode/StringDecrypter.cs
index 13df0559..6142e2ae 100644
--- a/de4dot.code/deobfuscators/Xenocode/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/Xenocode/StringDecrypter.cs
@@ -44,7 +44,7 @@ namespace de4dot.code.deobfuscators.Xenocode {
 			this.module = module;
 		}
 
-		public void find() {
+		public void Find() {
 			foreach (var type in module.Types) {
 				if (type.HasFields)
 					continue;
@@ -57,7 +57,7 @@ namespace de4dot.code.deobfuscators.Xenocode {
 				foreach (var m in type.Methods) {
 					if (m.Name == ".ctor" || m.Name == ".cctor")
 						continue;
-					if (DotNetUtils.isMethod(m, "System.String", "(System.String,System.Int32)")) {
+					if (DotNetUtils.IsMethod(m, "System.String", "(System.String,System.Int32)")) {
 						method = m;
 						continue;
 					}
@@ -83,7 +83,7 @@ namespace de4dot.code.deobfuscators.Xenocode {
 			}
 		}
 
-		public string decrypt(string es, int magic) {
+		public string Decrypt(string es, int magic) {
 			int newLen = es.Length / 4;
 			var sb = new StringBuilder(newLen);
 			for (int i = 0; i < newLen * 4; i += 4) {
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v3/AntiStrongName.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v3/AntiStrongName.cs
index 37061e95..4359f7f4 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v3/AntiStrongName.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v3/AntiStrongName.cs
@@ -24,17 +24,17 @@ using de4dot.blocks;
 
 namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 	class AntiStrongName {
-		public bool remove(Blocks blocks) {
-			var allBlocks = blocks.MethodBlocks.getAllBlocks();
+		public bool Remove(Blocks blocks) {
+			var allBlocks = blocks.MethodBlocks.GetAllBlocks();
 			foreach (var block in allBlocks) {
-				if (remove(blocks, block))
+				if (Remove(blocks, block))
 					return true;
 			}
 
 			return false;
 		}
 
-		bool remove(Blocks blocks, Block block) {
+		bool Remove(Blocks blocks, Block block) {
 			var instrs = block.Instructions;
 			const int numInstrsToRemove = 11;
 			if (instrs.Count < numInstrsToRemove)
@@ -44,25 +44,25 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 
 			if (instrs[index++].OpCode.Code != Code.Ldtoken)
 				return false;
-			if (!checkCall(instrs[index++], "System.Type System.Type::GetTypeFromHandle(System.RuntimeTypeHandle)"))
+			if (!CheckCall(instrs[index++], "System.Type System.Type::GetTypeFromHandle(System.RuntimeTypeHandle)"))
 				return false;
-			if (!checkCall(instrs[index++], "System.Reflection.Assembly System.Type::get_Assembly()"))
+			if (!CheckCall(instrs[index++], "System.Reflection.Assembly System.Type::get_Assembly()"))
 				return false;
-			if (!checkCall(instrs[index++], "System.Reflection.AssemblyName System.Reflection.Assembly::GetName()"))
+			if (!CheckCall(instrs[index++], "System.Reflection.AssemblyName System.Reflection.Assembly::GetName()"))
 				return false;
-			if (!checkCall(instrs[index++], "System.Byte[] System.Reflection.AssemblyName::GetPublicKeyToken()"))
+			if (!CheckCall(instrs[index++], "System.Byte[] System.Reflection.AssemblyName::GetPublicKeyToken()"))
 				return false;
-			if (!checkCall(instrs[index++], "System.String System.Convert::ToBase64String(System.Byte[])"))
+			if (!CheckCall(instrs[index++], "System.String System.Convert::ToBase64String(System.Byte[])"))
 				return false;
 			if (instrs[index++].OpCode.Code != Code.Ldstr)
 				return false;
-			if (!checkCall(instrs[index++], "System.String", "(System.String,System.String)"))
+			if (!CheckCall(instrs[index++], "System.String", "(System.String,System.String)"))
 				return false;
 			if (instrs[index++].OpCode.Code != Code.Ldstr)
 				return false;
-			if (!checkCall(instrs[index++], "System.Boolean System.String::op_Inequality(System.String,System.String)"))
+			if (!CheckCall(instrs[index++], "System.Boolean System.String::op_Inequality(System.String,System.String)"))
 				return false;
-			if (!instrs[index++].isBrfalse())
+			if (!instrs[index++].IsBrfalse())
 				return false;
 
 			var badBlock = block.FallThrough;
@@ -73,43 +73,43 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			if (badBlock == goodblock) {
 				// All of the bad block was removed by the cflow deobfuscator. It was just a useless
 				// calculation (div by zero).
-				block.replaceLastInstrsWithBranch(numInstrsToRemove, goodblock);
+				block.ReplaceLastInstrsWithBranch(numInstrsToRemove, goodblock);
 			}
 			else if (badBlock.Sources.Count == 1) {
 				instrs = badBlock.Instructions;
 				if (instrs.Count != 12)
 					return false;
 				index = 0;
-				if (!instrs[index++].isLdcI4())
+				if (!instrs[index++].IsLdcI4())
 					return false;
-				if (!instrs[index].isStloc())
+				if (!instrs[index].IsStloc())
 					return false;
-				var local = Instr.getLocalVar(blocks.Locals, instrs[index++]);
+				var local = Instr.GetLocalVar(blocks.Locals, instrs[index++]);
 				if (local == null)
 					return false;
-				if (!checkLdloc(blocks.Locals, instrs[index++], local))
+				if (!CheckLdloc(blocks.Locals, instrs[index++], local))
 					return false;
-				if (!checkLdloc(blocks.Locals, instrs[index++], local))
+				if (!CheckLdloc(blocks.Locals, instrs[index++], local))
 					return false;
 				if (instrs[index++].OpCode.Code != Code.Sub)
 					return false;
 				if (instrs[index++].OpCode.Code != Code.Conv_U1)
 					return false;
-				if (!checkStloc(blocks.Locals, instrs[index++], local))
+				if (!CheckStloc(blocks.Locals, instrs[index++], local))
 					return false;
-				if (!checkLdloc(blocks.Locals, instrs[index++], local))
+				if (!CheckLdloc(blocks.Locals, instrs[index++], local))
 					return false;
-				if (!checkLdloc(blocks.Locals, instrs[index++], local))
+				if (!CheckLdloc(blocks.Locals, instrs[index++], local))
 					return false;
 				if (instrs[index++].OpCode.Code != Code.Div)
 					return false;
 				if (instrs[index++].OpCode.Code != Code.Conv_U1)
 					return false;
-				if (!checkStloc(blocks.Locals, instrs[index++], local))
+				if (!CheckStloc(blocks.Locals, instrs[index++], local))
 					return false;
 
-				block.replaceLastInstrsWithBranch(numInstrsToRemove, goodblock);
-				badBlock.Parent.removeDeadBlock(badBlock);
+				block.ReplaceLastInstrsWithBranch(numInstrsToRemove, goodblock);
+				badBlock.Parent.RemoveDeadBlock(badBlock);
 			}
 			else
 				return false;
@@ -117,7 +117,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			return true;
 		}
 
-		static bool checkCall(Instr instr, string methodFullname) {
+		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 IMethod;
@@ -126,27 +126,27 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			return calledMethod.ToString() == methodFullname;
 		}
 
-		static bool checkCall(Instr instr, string returnType, string parameters) {
+		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 IMethod;
 			if (calledMethod == null)
 				return false;
-			return DotNetUtils.isMethod(calledMethod, returnType, parameters);
+			return DotNetUtils.IsMethod(calledMethod, returnType, parameters);
 		}
 
-		static bool checkLdloc(IList<Local> locals, Instr instr, Local local) {
-			if (!instr.isLdloc())
+		static bool CheckLdloc(IList<Local> locals, Instr instr, Local local) {
+			if (!instr.IsLdloc())
 				return false;
-			if (Instr.getLocalVar(locals, instr) != local)
+			if (Instr.GetLocalVar(locals, instr) != local)
 				return false;
 			return true;
 		}
 
-		static bool checkStloc(IList<Local> locals, Instr instr, Local local) {
-			if (!instr.isStloc())
+		static bool CheckStloc(IList<Local> locals, Instr instr, Local local) {
+			if (!instr.IsStloc())
 				return false;
-			if (Instr.getLocalVar(locals, instr) != local)
+			if (Instr.GetLocalVar(locals, instr) != local)
 				return false;
 			return true;
 		}
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v3/ApplicationModeDecrypter.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v3/ApplicationModeDecrypter.cs
index 27cbae1f..5f10ccef 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v3/ApplicationModeDecrypter.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v3/ApplicationModeDecrypter.cs
@@ -45,14 +45,14 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 
 		public ApplicationModeDecrypter(ModuleDefMD module) {
 			this.module = module;
-			find();
+			Find();
 		}
 
-		void find() {
+		void Find() {
 			var cflowDeobfuscator = new CflowDeobfuscator(new MethodCallInliner(true));
 
 			foreach (var type in module.Types) {
-				if (DotNetUtils.getPInvokeMethod(type, "kernel32", "CloseHandle") == null)
+				if (DotNetUtils.GetPInvokeMethod(type, "kernel32", "CloseHandle") == null)
 					continue;
 
 				var resolver = new AssemblyResolver(type, cflowDeobfuscator);
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v3/ApplicationModeUnpacker.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v3/ApplicationModeUnpacker.cs
index 0fc0011f..e3111412 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v3/ApplicationModeUnpacker.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v3/ApplicationModeUnpacker.cs
@@ -93,12 +93,12 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			this.peImage = peImage;
 		}
 
-		public byte[] unpack() {
+		public byte[] Unpack() {
 			byte[] data = null;
 			MyPEImage myPeImage = null;
 			try {
 				myPeImage = new MyPEImage(peImage);
-				data = unpack2(myPeImage);
+				data = Unpack2(myPeImage);
 			}
 			catch {
 			}
@@ -114,25 +114,25 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			return null;
 		}
 
-		byte[] unpack2(MyPEImage peImage) {
+		byte[] Unpack2(MyPEImage peImage) {
 			shouldUnpack = false;
 			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);
+			uint offsetEncryptedAssembly = CheckOffset(peImage, peImage.OffsetReadUInt32(headerOffset));
+			uint ezencryptionLibLength = peImage.OffsetReadUInt32(headerOffset + 4);
+			uint iniFileLength = peImage.OffsetReadUInt32(headerOffset + 8);
 
 			uint offsetClrVersionNumber = checked(offsetEncryptedAssembly - 12);
 			uint iniFileOffset = checked(headerOffset - iniFileLength);
 			uint ezencryptionLibOffset = checked(iniFileOffset - ezencryptionLibLength);
 
-			uint clrVerMajor = peImage.offsetReadUInt32(offsetClrVersionNumber);
-			uint clrVerMinor = peImage.offsetReadUInt32(offsetClrVersionNumber + 4);
-			uint clrVerBuild = peImage.offsetReadUInt32(offsetClrVersionNumber + 8);
+			uint clrVerMajor = peImage.OffsetReadUInt32(offsetClrVersionNumber);
+			uint clrVerMinor = peImage.OffsetReadUInt32(offsetClrVersionNumber + 4);
+			uint clrVerBuild = peImage.OffsetReadUInt32(offsetClrVersionNumber + 8);
 			if (clrVerMajor <= 0 || clrVerMajor >= 20 || clrVerMinor >= 20 || clrVerBuild >= 1000000)
 				return null;
 
-			var settings = new IniFile(decompress2(peImage.offsetReadBytes(iniFileOffset, (int)iniFileLength)));
-			sizes = getSizes(settings["General_App_Satellite_Assemblies_Sizes"]);
+			var settings = new IniFile(Decompress2(peImage.OffsetReadBytes(iniFileOffset, (int)iniFileLength)));
+			sizes = GetSizes(settings["General_App_Satellite_Assemblies_Sizes"]);
 			if (sizes == null || sizes.Length <= 1)
 				return null;
 			shouldUnpack = true;
@@ -142,43 +142,43 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			if (sizes.Length - 1 != filenames.Length)
 				return null;
 
-			byte[] ezencryptionLibData = decompress1(peImage.offsetReadBytes(ezencryptionLibOffset, (int)ezencryptionLibLength));
+			byte[] ezencryptionLibData = Decompress1(peImage.OffsetReadBytes(ezencryptionLibOffset, (int)ezencryptionLibLength));
 			var ezencryptionLibModule = ModuleDefMD.Load(ezencryptionLibData);
 			var decrypter = new ApplicationModeDecrypter(ezencryptionLibModule);
 			if (!decrypter.Detected)
 				return null;
 
-			var mainAssembly = unpackEmbeddedFile(peImage, 0, decrypter);
-			decrypter.MemoryPatcher.patch(mainAssembly.data);
+			var mainAssembly = UnpackEmbeddedFile(peImage, 0, decrypter);
+			decrypter.MemoryPatcher.Patch(mainAssembly.data);
 			for (int i = 1; i < filenames.Length; i++)
-				satelliteAssemblies.Add(unpackEmbeddedFile(peImage, i, decrypter));
+				satelliteAssemblies.Add(UnpackEmbeddedFile(peImage, i, decrypter));
 
-			clearDllBit(mainAssembly.data);
+			ClearDllBit(mainAssembly.data);
 			return mainAssembly.data;
 		}
 
-		static void clearDllBit(byte[] peImageData) {
+		static void ClearDllBit(byte[] peImageData) {
 			using (var mainPeImage = new MyPEImage(peImageData)) {
 				uint characteristicsOffset = (uint)mainPeImage.PEImage.ImageNTHeaders.FileHeader.StartOffset + 18;
-				ushort characteristics = mainPeImage.offsetReadUInt16(characteristicsOffset);
+				ushort characteristics = mainPeImage.OffsetReadUInt16(characteristicsOffset);
 				characteristics &= 0xDFFF;
 				characteristics |= 2;
-				mainPeImage.offsetWriteUInt16(characteristicsOffset, characteristics);
+				mainPeImage.OffsetWriteUInt16(characteristicsOffset, characteristics);
 			}
 		}
 
-		UnpackedFile unpackEmbeddedFile(MyPEImage peImage, 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];
 			string filename = Win32Path.GetFileName(filenames[index]);
-			var data = peImage.offsetReadBytes(offset, (int)sizes[index + 1]);
-			data = DeobUtils.aesDecrypt(data, decrypter.AssemblyKey, decrypter.AssemblyIv);
-			data = decompress(data);
+			var data = peImage.OffsetReadBytes(offset, (int)sizes[index + 1]);
+			data = DeobUtils.AesDecrypt(data, decrypter.AssemblyKey, decrypter.AssemblyIv);
+			data = Decompress(data);
 			return new UnpackedFile(filename, data);
 		}
 
-		static uint[] getSizes(string sizes) {
+		static uint[] GetSizes(string sizes) {
 			if (sizes == null)
 				return null;
 			var list = new List<uint>();
@@ -187,32 +187,32 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			return list.ToArray();
 		}
 
-		uint checkOffset(MyPEImage peImage, uint offset) {
+		uint CheckOffset(MyPEImage peImage, uint offset) {
 			if (offset >= peImage.Length)
 				throw new Exception();
 			return offset;
 		}
 
-		static byte[] decompress1(byte[] data) {
-			return decompress(decrypt1(data));
+		static byte[] Decompress1(byte[] data) {
+			return Decompress(Decrypt1(data));
 		}
 
-		static byte[] decompress2(byte[] data) {
-			return decompress(decrypt2(data));
+		static byte[] Decompress2(byte[] data) {
+			return Decompress(Decrypt2(data));
 		}
 
-		static byte[] decompress(byte[] data) {
-			if (!QuickLZ.isCompressed(data))
+		static byte[] Decompress(byte[] data) {
+			if (!QuickLZ.IsCompressed(data))
 				return data;
-			return QuickLZ.decompress(data);
+			return QuickLZ.Decompress(data);
 		}
 
-		static byte[] decrypt1(byte[] data) {
-			return DeobUtils.aesDecrypt(data, key1, iv1);
+		static byte[] Decrypt1(byte[] data) {
+			return DeobUtils.AesDecrypt(data, key1, iv1);
 		}
 
-		static byte[] decrypt2(byte[] data) {
-			return DeobUtils.aesDecrypt(data, key2, iv2);
+		static byte[] Decrypt2(byte[] data) {
+			return DeobUtils.AesDecrypt(data, key2, iv2);
 		}
 	}
 }
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v3/AssemblyResolver.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v3/AssemblyResolver.cs
index 5eb59f32..4a1dbc69 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v3/AssemblyResolver.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v3/AssemblyResolver.cs
@@ -39,10 +39,10 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 		}
 
 		public AssemblyResolver(TypeDef type, ICflowDeobfuscator cflowDeobfuscator) {
-			find(type, cflowDeobfuscator);
+			Find(type, cflowDeobfuscator);
 		}
 
-		void find(TypeDef type, ICflowDeobfuscator cflowDeobfuscator) {
+		void Find(TypeDef type, ICflowDeobfuscator cflowDeobfuscator) {
 			var additionalTypes = new List<string> {
 				"System.IO.BinaryReader",
 				"System.IO.FileStream",
@@ -51,12 +51,12 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 				"System.String",
 			};
 			foreach (var method in type.Methods) {
-				if (!DotNetUtils.isMethod(method, "System.Reflection.Assembly", "(System.Object,System.ResolveEventArgs)"))
+				if (!DotNetUtils.IsMethod(method, "System.Reflection.Assembly", "(System.Object,System.ResolveEventArgs)"))
 					continue;
-				if (!DecryptMethod.couldBeDecryptMethod(method, additionalTypes))
+				if (!DecryptMethod.CouldBeDecryptMethod(method, additionalTypes))
 					continue;
-				cflowDeobfuscator.deobfuscate(method);
-				if (!decryptMethod.getKey(method))
+				cflowDeobfuscator.Deobfuscate(method);
+				if (!decryptMethod.GetKey(method))
 					continue;
 
 				return;
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v3/DecryptMethod.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v3/DecryptMethod.cs
index 2f33b129..02ec1857 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v3/DecryptMethod.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v3/DecryptMethod.cs
@@ -39,7 +39,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			get { return decryptionMethod != null; }
 		}
 
-		public static bool couldBeDecryptMethod(MethodDef method, IEnumerable<string> additionalTypes) {
+		public static bool CouldBeDecryptMethod(MethodDef method, IEnumerable<string> additionalTypes) {
 			if (method.Body == null)
 				return false;
 
@@ -51,20 +51,20 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 				"System.Security.Cryptography.ICryptoTransform",
 			};
 			requiredTypes.AddRange(additionalTypes);
-			if (!localTypes.all(requiredTypes))
+			if (!localTypes.All(requiredTypes))
 				return false;
-			if (!localTypes.exists("System.Security.Cryptography.RijndaelManaged") &&
-				!localTypes.exists("System.Security.Cryptography.AesManaged"))
+			if (!localTypes.Exists("System.Security.Cryptography.RijndaelManaged") &&
+				!localTypes.Exists("System.Security.Cryptography.AesManaged"))
 				return false;
 
 			return true;
 		}
 
-		public bool getKey(MethodDef method) {
-			var tmpKey = ArrayFinder.getInitializedByteArray(method, 32);
+		public bool GetKey(MethodDef method) {
+			var tmpKey = ArrayFinder.GetInitializedByteArray(method, 32);
 			if (tmpKey == null)
 				return false;
-			var tmpIv = ArrayFinder.getInitializedByteArray(method, 16);
+			var tmpIv = ArrayFinder.GetInitializedByteArray(method, 16);
 			if (tmpIv == null)
 				return false;
 
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v3/DecrypterType.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v3/DecrypterType.cs
index d2e648e3..ba911b93 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v3/DecrypterType.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v3/DecrypterType.cs
@@ -73,36 +73,36 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 
 		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");
-			this.stringDecrypter2 = lookup(oldOne.stringDecrypter2, "Could not find stringDecrypter2");
+			this.decrypterType = Lookup(oldOne.decrypterType, "Could not find decrypterType");
+			this.stringDecrypter1 = Lookup(oldOne.stringDecrypter1, "Could not find stringDecrypter1");
+			this.stringDecrypter2 = Lookup(oldOne.stringDecrypter2, "Could not find stringDecrypter2");
 			foreach (var method in oldOne.initMethods)
-				initMethods.Add(lookup(method, "Could not find initMethod"));
-			updateModuleRefs();
+				initMethods.Add(Lookup(method, "Could not find initMethod"));
+			UpdateModuleRefs();
 		}
 
-		T lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
-			return DeobUtils.lookup(module, def, errorMessage);
+		T Lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
+			return DeobUtils.Lookup(module, def, errorMessage);
 		}
 
-		public void find() {
+		public void Find() {
 			foreach (var type in module.Types) {
 				if (type.FullName != "<PrivateImplementationDetails>{B4838DC1-AC79-43d1-949F-41B518B904A8}")
 					continue;
 
 				decrypterType = type;
-				stringDecrypter1 = getStringDecrypter(type, "CS$0$0004");
-				stringDecrypter2 = getStringDecrypter(type, "CS$0$0005");
+				stringDecrypter1 = GetStringDecrypter(type, "CS$0$0004");
+				stringDecrypter2 = GetStringDecrypter(type, "CS$0$0005");
 				foreach (var method in type.Methods) {
-					if (DotNetUtils.isMethod(method, "System.Void", "()"))
+					if (DotNetUtils.IsMethod(method, "System.Void", "()"))
 						initMethods.Add(method);
 				}
-				updateModuleRefs();
+				UpdateModuleRefs();
 				return;
 			}
 		}
 
-		void updateModuleRefs() {
+		void UpdateModuleRefs() {
 			foreach (var method in decrypterType.Methods) {
 				if (method.ImplMap != null) {
 					switch (method.ImplMap.Name.String) {
@@ -113,12 +113,12 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 					}
 				}
 			}
-			updateLinkedResource();
+			UpdateLinkedResource();
 		}
 
-		void updateLinkedResource() {
+		void UpdateLinkedResource() {
 			foreach (var modref in moduleRefs) {
-				var resource = DotNetUtils.getResource(module, modref.Name.String) as LinkedResource;
+				var resource = DotNetUtils.GetResource(module, modref.Name.String) as LinkedResource;
 				if (resource == null)
 					continue;
 
@@ -127,30 +127,30 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			}
 		}
 
-		MethodDef getStringDecrypter(TypeDef type, string 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)"))
+			if (!DotNetUtils.IsMethod(method, "System.String", "(System.String)"))
 				return null;
 			return method;
 		}
 
-		public string decrypt1(string s) {
+		public string Decrypt1(string s) {
 			var sb = new StringBuilder(s.Length);
 			foreach (var c in s)
 				sb.Append((char)(0xFF - (byte)c));
 			return sb.ToString();
 		}
 
-		public string decrypt2(string s) {
+		public string Decrypt2(string s) {
 			return Encoding.Unicode.GetString(Convert.FromBase64String(s));
 		}
 
-		public bool patch(byte[] peData) {
+		public bool Patch(byte[] peData) {
 			try {
 				using (var peImage = new MyPEImage(peData))
-					return patch2(peImage);
+					return Patch2(peImage);
 			}
 			catch {
 				Logger.w("Could not patch the file");
@@ -158,36 +158,36 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			}
 		}
 
-		bool patch2(MyPEImage peImage) {
-			uint numPatches = peImage.offsetReadUInt32(peImage.Length - 4);
+		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) {
-				uint rva = getValue(peImage.offsetReadUInt32(offset));
-				var value = peImage.offsetReadUInt32(offset + 4);
+				uint rva = GetValue(peImage.OffsetReadUInt32(offset));
+				var value = peImage.OffsetReadUInt32(offset + 4);
 
 				if (value == 4) {
 					i++;
 					offset += 8;
-					rva = getValue(peImage.offsetReadUInt32(offset));
-					value = peImage.offsetReadUInt32(offset + 4);
+					rva = GetValue(peImage.OffsetReadUInt32(offset));
+					value = peImage.OffsetReadUInt32(offset + 4);
 				}
 				else
-					value = getValue(value);
+					value = GetValue(value);
 
 				// Seems there's a bug in their code where they sometimes overwrite valid data
 				// with invalid data.
 				if (startedPatchingBadData && value == 0x3115)
 					continue;
 
-				startedPatchingBadData |= !peImage.dotNetSafeWrite(rva, BitConverter.GetBytes(value));
+				startedPatchingBadData |= !peImage.DotNetSafeWrite(rva, BitConverter.GetBytes(value));
 			}
 
 			return true;
 		}
 
-		static uint getValue(uint value) {
+		static uint GetValue(uint value) {
 			const uint magic = 2749;
 			value = checked(value - magic);
 			if (value % 3 != 0)
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v3/Deobfuscator.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v3/Deobfuscator.cs
index 30878b18..b3bb4080 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v3/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v3/Deobfuscator.cs
@@ -40,11 +40,11 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 
 		public DeobfuscatorInfo()
 			: base(DEFAULT_REGEX) {
-			restoreTypes = new BoolOption(null, makeArgName("types"), "Restore types (object -> real type)", true);
-			inlineMethods = new BoolOption(null, makeArgName("inline"), "Inline short methods", true);
-			removeInlinedMethods = new BoolOption(null, makeArgName("remove-inlined"), "Remove inlined methods", true);
-			removeNamespaces = new BoolOption(null, makeArgName("ns1"), "Clear namespace if there's only one class in it", true);
-			removeAntiStrongName = new BoolOption(null, makeArgName("sn"), "Remove anti strong name code", true);
+			restoreTypes = new BoolOption(null, MakeArgName("types"), "Restore types (object -> real type)", true);
+			inlineMethods = new BoolOption(null, MakeArgName("inline"), "Inline short methods", true);
+			removeInlinedMethods = new BoolOption(null, MakeArgName("remove-inlined"), "Remove inlined methods", true);
+			removeNamespaces = new BoolOption(null, MakeArgName("ns1"), "Clear namespace if there's only one class in it", true);
+			removeAntiStrongName = new BoolOption(null, MakeArgName("sn"), "Remove anti strong name code", true);
 		}
 
 		public override string Name {
@@ -55,7 +55,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			get { return THE_TYPE; }
 		}
 
-		public override IDeobfuscator createDeobfuscator() {
+		public override IDeobfuscator CreateDeobfuscator() {
 			return new Deobfuscator(new Deobfuscator.Options {
 				ValidNameRegex = validNameRegex.get(),
 				RestoreTypes = restoreTypes.get(),
@@ -66,7 +66,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			});
 		}
 
-		protected override IEnumerable<Option> getOptionsInternal() {
+		protected override IEnumerable<Option> GetOptionsInternal() {
 			return new List<Option>() {
 				restoreTypes,
 				inlineMethods,
@@ -125,9 +125,9 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 				this.RenamingOptions &= ~RenamingOptions.RemoveNamespaceIfOneType;
 		}
 
-		public override byte[] unpackNativeFile(IPEImage peImage) {
+		public override byte[] UnpackNativeFile(IPEImage peImage) {
 			var unpacker = new ApplicationModeUnpacker(peImage);
-			var data = unpacker.unpack();
+			var data = unpacker.Unpack();
 			if (data == null)
 				return null;
 
@@ -137,205 +137,205 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			return data;
 		}
 
-		bool needsPatching() {
+		bool NeedsPatching() {
 			return decrypterType.LinkedResource != null || nativeLibSaver.Resource != null;
 		}
 
-		public override bool getDecryptedModule(int count, ref byte[] newFileData, ref DumpedMethods dumpedMethods) {
-			if (count != 0 || !needsPatching())
+		public override bool GetDecryptedModule(int count, ref byte[] newFileData, ref DumpedMethods dumpedMethods) {
+			if (count != 0 || !NeedsPatching())
 				return false;
 
-			var fileData = ModuleBytes ?? DeobUtils.readModule(module);
-			if (!decrypterType.patch(fileData))
+			var fileData = ModuleBytes ?? DeobUtils.ReadModule(module);
+			if (!decrypterType.Patch(fileData))
 				return false;
 
 			newFileData = fileData;
 			return true;
 		}
 
-		public override IDeobfuscator moduleReloaded(ModuleDefMD module) {
+		public override IDeobfuscator ModuleReloaded(ModuleDefMD module) {
 			var newOne = new Deobfuscator(options);
-			newOne.setModule(module);
+			newOne.SetModule(module);
 			newOne.decrypterType = new DecrypterType(module, decrypterType);
 			newOne.nativeLibSaver = new NativeLibSaver(module, nativeLibSaver);
 			return newOne;
 		}
 
-		public override void init(ModuleDefMD module) {
-			base.init(module);
+		public override void Initialize(ModuleDefMD module) {
+			base.Initialize(module);
 		}
 
 		static Regex isRandomName = new Regex(@"^[A-Z]{30,40}$");
 		static Regex isRandomNameMembers = new Regex(@"^[a-zA-Z0-9]{9,11}$");	// methods, fields, props, events
 		static Regex isRandomNameTypes = new Regex(@"^[a-zA-Z0-9]{18,19}(?:`\d+)?$");	// types, namespaces
 
-		bool checkValidName(string name, Regex regex) {
+		bool CheckValidName(string name, Regex regex) {
 			if (isRandomName.IsMatch(name))
 				return false;
 			if (regex.IsMatch(name)) {
-				if (RandomNameChecker.isRandom(name))
+				if (RandomNameChecker.IsRandom(name))
 					return false;
-				if (!RandomNameChecker.isNonRandom(name))
+				if (!RandomNameChecker.IsNonRandom(name))
 					return false;
 			}
-			return checkValidName(name);
+			return CheckValidName(name);
 		}
 
-		public override bool isValidNamespaceName(string ns) {
+		public override bool IsValidNamespaceName(string ns) {
 			if (ns == null)
 				return false;
 			if (ns.Contains("."))
-				return base.isValidNamespaceName(ns);
-			return checkValidName(ns, isRandomNameTypes);
+				return base.IsValidNamespaceName(ns);
+			return CheckValidName(ns, isRandomNameTypes);
 		}
 
-		public override bool isValidTypeName(string name) {
-			return name != null && checkValidName(name, isRandomNameTypes);
+		public override bool IsValidTypeName(string name) {
+			return name != null && CheckValidName(name, isRandomNameTypes);
 		}
 
-		public override bool isValidMethodName(string name) {
-			return name != null && checkValidName(name, isRandomNameMembers);
+		public override bool IsValidMethodName(string name) {
+			return name != null && CheckValidName(name, isRandomNameMembers);
 		}
 
-		public override bool isValidPropertyName(string name) {
-			return name != null && checkValidName(name, isRandomNameMembers);
+		public override bool IsValidPropertyName(string name) {
+			return name != null && CheckValidName(name, isRandomNameMembers);
 		}
 
-		public override bool isValidEventName(string name) {
-			return name != null && checkValidName(name, isRandomNameMembers);
+		public override bool IsValidEventName(string name) {
+			return name != null && CheckValidName(name, isRandomNameMembers);
 		}
 
-		public override bool isValidFieldName(string name) {
-			return name != null && checkValidName(name, isRandomNameMembers);
+		public override bool IsValidFieldName(string name) {
+			return name != null && CheckValidName(name, isRandomNameMembers);
 		}
 
-		public override bool isValidGenericParamName(string name) {
-			return name != null && checkValidName(name, isRandomNameMembers);
+		public override bool IsValidGenericParamName(string name) {
+			return name != null && CheckValidName(name, isRandomNameMembers);
 		}
 
-		public override bool isValidMethodArgName(string name) {
-			return name != null && checkValidName(name, isRandomNameMembers);
+		public override bool IsValidMethodArgName(string name) {
+			return name != null && CheckValidName(name, isRandomNameMembers);
 		}
 
-		public override bool isValidMethodReturnArgName(string name) {
-			return string.IsNullOrEmpty(name) || 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);
+		public override bool IsValidResourceKeyName(string name) {
+			return name != null && CheckValidName(name, isRandomNameMembers);
 		}
 
-		protected override int detectInternal() {
+		protected override int DetectInternal() {
 			int val = 0;
 
-			int sum = toInt32(unpackedNativeFile) +
-					toInt32(decrypterType.Detected) +
-					toInt32(nativeLibSaver.Detected);
+			int sum = ToInt32(unpackedNativeFile) +
+					ToInt32(decrypterType.Detected) +
+					ToInt32(nativeLibSaver.Detected);
 			if (sum > 0)
 				val += 100 + 10 * (sum - 1);
 
 			return val;
 		}
 
-		protected override void scanForObfuscator() {
+		protected override void ScanForObfuscator() {
 			decrypterType = new DecrypterType(module);
-			decrypterType.find();
+			decrypterType.Find();
 			nativeLibSaver = new NativeLibSaver(module);
-			nativeLibSaver.find();
-			obfuscatorName = detectVersion();
+			nativeLibSaver.Find();
+			obfuscatorName = DetectVersion();
 			if (unpackedNativeFile)
 				obfuscatorName += " (native)";
 		}
 
-		string detectVersion() {
+		string DetectVersion() {
 			return DeobfuscatorInfo.THE_NAME + " 3.x";
 		}
 
-		public override void deobfuscateBegin() {
-			base.deobfuscateBegin();
+		public override void DeobfuscateBegin() {
+			base.DeobfuscateBegin();
 
 			antiStrongName = new AntiStrongName();
 
-			staticStringInliner.add(decrypterType.StringDecrypter1, (method2, gim, args) => {
-				return decrypterType.decrypt1((string)args[0]);
+			staticStringInliner.Add(decrypterType.StringDecrypter1, (method2, gim, args) => {
+				return decrypterType.Decrypt1((string)args[0]);
 			});
-			staticStringInliner.add(decrypterType.StringDecrypter2, (method2, gim, args) => {
-				return decrypterType.decrypt2((string)args[0]);
+			staticStringInliner.Add(decrypterType.StringDecrypter2, (method2, gim, args) => {
+				return decrypterType.Decrypt2((string)args[0]);
 			});
-			DeobfuscatedFile.stringDecryptersAdded();
+			DeobfuscatedFile.StringDecryptersAdded();
 
 			libAssemblyResolver = new LibAssemblyResolver(module);
-			libAssemblyResolver.find(DeobfuscatedFile, this);
+			libAssemblyResolver.Find(DeobfuscatedFile, this);
 
 			if (Operations.DecryptStrings == OpDecryptString.None)
 				canRemoveDecrypterType = false;
 
-			removeInitCall(nativeLibSaver.InitMethod);
-			addResourceToBeRemoved(nativeLibSaver.Resource, "Native lib resource");
-			addTypeToBeRemoved(nativeLibSaver.Type, "Native lib saver type");
+			RemoveInitCall(nativeLibSaver.InitMethod);
+			AddResourceToBeRemoved(nativeLibSaver.Resource, "Native lib resource");
+			AddTypeToBeRemoved(nativeLibSaver.Type, "Native lib saver type");
 
 			foreach (var initMethod in decrypterType.InitMethods)
-				removeInitCall(initMethod);
+				RemoveInitCall(initMethod);
 
-			dumpUnpackedFiles();
-			dumpResourceFiles();
+			DumpUnpackedFiles();
+			DumpResourceFiles();
 
 			startedDeobfuscating = true;
 		}
 
-		void removeInitCall(MethodDef initMethod) {
-			addCctorInitCallToBeRemoved(initMethod);
-			addCtorInitCallToBeRemoved(initMethod);
+		void RemoveInitCall(MethodDef initMethod) {
+			AddCctorInitCallToBeRemoved(initMethod);
+			AddCtorInitCallToBeRemoved(initMethod);
 		}
 
-		void dumpUnpackedFiles() {
+		void DumpUnpackedFiles() {
 			foreach (var unpackedFile in unpackedFiles)
-				DeobfuscatedFile.createAssemblyFile(unpackedFile.data,
+				DeobfuscatedFile.CreateAssemblyFile(unpackedFile.data,
 							Win32Path.GetFileNameWithoutExtension(unpackedFile.filename),
 							Win32Path.GetExtension(unpackedFile.filename));
 		}
 
-		void dumpResourceFiles() {
+		void DumpResourceFiles() {
 			foreach (var resource in libAssemblyResolver.Resources) {
 				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),
-							DeobUtils.getExtension(mod.Kind));
+				AddResourceToBeRemoved(resource, string.Format("Embedded assembly: {0}", mod.Assembly.FullName));
+				DeobfuscatedFile.CreateAssemblyFile(resource.GetResourceData(),
+							Utils.GetAssemblySimpleName(mod.Assembly.FullName),
+							DeobUtils.GetExtension(mod.Kind));
 			}
-			removeInitCall(libAssemblyResolver.InitMethod);
-			addCallToBeRemoved(module.EntryPoint, libAssemblyResolver.InitMethod);
-			addTypeToBeRemoved(libAssemblyResolver.Type, "Assembly resolver type (library mode)");
+			RemoveInitCall(libAssemblyResolver.InitMethod);
+			AddCallToBeRemoved(module.EntryPoint, libAssemblyResolver.InitMethod);
+			AddTypeToBeRemoved(libAssemblyResolver.Type, "Assembly resolver type (library mode)");
 		}
 
-		public override void deobfuscateMethodEnd(Blocks blocks) {
+		public override void DeobfuscateMethodEnd(Blocks blocks) {
 			if (options.RemoveAntiStrongName) {
-				if (antiStrongName.remove(blocks))
+				if (antiStrongName.Remove(blocks))
 					Logger.v("Removed Anti Strong Name code");
 			}
-			base.deobfuscateMethodEnd(blocks);
+			base.DeobfuscateMethodEnd(blocks);
 		}
 
-		public override void deobfuscateEnd() {
-			removeInlinedMethods();
+		public override void DeobfuscateEnd() {
+			RemoveInlinedMethods();
 			if (options.RestoreTypes)
-				new TypesRestorer(module).deobfuscate();
+				new TypesRestorer(module).Deobfuscate();
 
-			if (canRemoveDecrypterType && !isTypeCalled(decrypterType.Type)) {
-				addTypeToBeRemoved(decrypterType.Type, "Decrypter type");
-				addResourceToBeRemoved(decrypterType.LinkedResource, "Native lib linked resource");
+			if (canRemoveDecrypterType && !IsTypeCalled(decrypterType.Type)) {
+				AddTypeToBeRemoved(decrypterType.Type, "Decrypter type");
+				AddResourceToBeRemoved(decrypterType.LinkedResource, "Native lib linked resource");
 			}
 
-			base.deobfuscateEnd();
+			base.DeobfuscateEnd();
 		}
 
-		void removeInlinedMethods() {
+		void RemoveInlinedMethods() {
 			if (!options.InlineMethods || !options.RemoveInlinedMethods)
 				return;
-			findAndRemoveInlinedMethods();
+			FindAndRemoveInlinedMethods();
 		}
 
-		public override IEnumerable<int> getStringDecrypterMethods() {
+		public override IEnumerable<int> GetStringDecrypterMethods() {
 			var list = new List<int>();
 			foreach (var method in decrypterType.StringDecrypters)
 				list.Add(method.MDToken.ToInt32());
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v3/LibAssemblyResolver.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v3/LibAssemblyResolver.cs
index 057c686b..262e6bdb 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v3/LibAssemblyResolver.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v3/LibAssemblyResolver.cs
@@ -45,43 +45,43 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			this.module = module;
 		}
 
-		public void find(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
-			if (checkInitMethod(DotNetUtils.getModuleTypeCctor(module), simpleDeobfuscator, deob))
+		public void Find(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
+			if (CheckInitMethod(DotNetUtils.GetModuleTypeCctor(module), simpleDeobfuscator, deob))
 				return;
-			if (checkInitMethod(module.EntryPoint, simpleDeobfuscator, deob))
+			if (CheckInitMethod(module.EntryPoint, simpleDeobfuscator, deob))
 				return;
 		}
 
-		bool checkInitMethod(MethodDef checkMethod, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
+		bool CheckInitMethod(MethodDef checkMethod, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
 			var requiredFields = new string[] {
 				"System.Collections.Hashtable",
 				"System.Boolean",
 			};
 
-			foreach (var method in DotNetUtils.getCalledMethods(module, checkMethod)) {
+			foreach (var method in DotNetUtils.GetCalledMethods(module, checkMethod)) {
 				if (method.Body == null)
 					continue;
 				if (!method.IsStatic)
 					continue;
-				if (!DotNetUtils.isMethod(method, "System.Void", "()"))
+				if (!DotNetUtils.IsMethod(method, "System.Void", "()"))
 					continue;
 
 				var type = method.DeclaringType;
-				if (!new FieldTypes(type).exactly(requiredFields))
+				if (!new FieldTypes(type).Exactly(requiredFields))
 					continue;
 				var ctor = type.FindMethod(".ctor");
 				if (ctor == null)
 					continue;
-				var handler = DeobUtils.getResolveMethod(ctor);
+				var handler = DeobUtils.GetResolveMethod(ctor);
 				if (handler == null)
 					continue;
-				simpleDeobfuscator.decryptStrings(handler, deob);
-				var resourcePrefix = getResourcePrefix(handler);
+				simpleDeobfuscator.DecryptStrings(handler, deob);
+				var resourcePrefix = GetResourcePrefix(handler);
 				if (resourcePrefix == null)
 					continue;
 
 				for (int i = 0; ; i++) {
-					var resource = DotNetUtils.getResource(module, resourcePrefix + i.ToString("D5")) as EmbeddedResource;
+					var resource = DotNetUtils.GetResource(module, resourcePrefix + i.ToString("D5")) as EmbeddedResource;
 					if (resource == null)
 						break;
 					resources.Add(resource);
@@ -94,9 +94,9 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			return false;
 		}
 
-		string getResourcePrefix(MethodDef handler) {
-			foreach (var s in DotNetUtils.getCodeStrings(handler)) {
-				var resource = DotNetUtils.getResource(module, s + "00000") as EmbeddedResource;
+		string GetResourcePrefix(MethodDef handler) {
+			foreach (var s in DotNetUtils.GetCodeStrings(handler)) {
+				var resource = DotNetUtils.GetResource(module, s + "00000") as EmbeddedResource;
 				if (resource != null)
 					return s;
 			}
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v3/MemoryPatcher.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v3/MemoryPatcher.cs
index 87a9a17d..08f592dc 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v3/MemoryPatcher.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v3/MemoryPatcher.cs
@@ -43,28 +43,28 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 		}
 
 		public MemoryPatcher(TypeDef type, ICflowDeobfuscator cflowDeobfuscator) {
-			find(type, cflowDeobfuscator);
+			Find(type, cflowDeobfuscator);
 		}
 
-		void find(TypeDef type, ICflowDeobfuscator cflowDeobfuscator) {
+		void Find(TypeDef type, ICflowDeobfuscator cflowDeobfuscator) {
 			var additionalTypes = new List<string> {
 				"System.IO.BinaryWriter",
 			};
 			foreach (var method in type.Methods) {
-				if (!DotNetUtils.isMethod(method, "System.Void", "(System.Int32[],System.UInt32[])"))
+				if (!DotNetUtils.IsMethod(method, "System.Void", "(System.Int32[],System.UInt32[])"))
 					continue;
-				if (!DecryptMethod.couldBeDecryptMethod(method, additionalTypes))
+				if (!DecryptMethod.CouldBeDecryptMethod(method, additionalTypes))
 					continue;
-				cflowDeobfuscator.deobfuscate(method);
-				if (!decryptMethod.getKey(method))
+				cflowDeobfuscator.Deobfuscate(method);
+				if (!decryptMethod.GetKey(method))
 					continue;
 
-				findPatchData(type, cflowDeobfuscator);
+				FindPatchData(type, cflowDeobfuscator);
 				return;
 			}
 		}
 
-		void findPatchData(TypeDef type, ICflowDeobfuscator cflowDeobfuscator) {
+		void FindPatchData(TypeDef type, ICflowDeobfuscator cflowDeobfuscator) {
 			var locals = new List<string> {
 				"System.Int32[]",
 				"System.UInt32[]",
@@ -72,12 +72,12 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			foreach (var method in type.Methods) {
 				if (method.Attributes != MethodAttributes.Private)
 					continue;
-				if (!DotNetUtils.isMethod(method, "System.Void", "()"))
+				if (!DotNetUtils.IsMethod(method, "System.Void", "()"))
 					continue;
-				if (!new LocalTypes(method).exactly(locals))
+				if (!new LocalTypes(method).Exactly(locals))
 					continue;
-				cflowDeobfuscator.deobfuscate(method);
-				var patchInfo = getPatchInfo(method);
+				cflowDeobfuscator.Deobfuscate(method);
+				var patchInfo = GetPatchInfo(method);
 				if (patchInfo == null)
 					continue;
 
@@ -85,25 +85,25 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			}
 		}
 
-		PatchInfo getPatchInfo(MethodDef method) {
+		PatchInfo GetPatchInfo(MethodDef method) {
 			int index1 = 0, index2, index3, size1, size2, size3;
-			if (!ArrayFinder.findNewarr(method, ref index1, out size1))
+			if (!ArrayFinder.FindNewarr(method, ref index1, out size1))
 				return null;
 			index2 = index1 + 1;
-			if (!ArrayFinder.findNewarr(method, ref index2, out size2))
+			if (!ArrayFinder.FindNewarr(method, ref index2, out size2))
 				return null;
 			index3 = index2 + 1;
-			if (ArrayFinder.findNewarr(method, ref index3, out size3))
+			if (ArrayFinder.FindNewarr(method, ref index3, out size3))
 				return null;
 
 			if (size1 <= 0 || size1 > 35)
 				return null;
 
-			var ary1 = ArrayFinder.getInitializedInt32Array(size1, method, ref index1);
-			var ary2 = ArrayFinder.getInitializedInt32Array(size2, method, ref index2);
+			var ary1 = ArrayFinder.GetInitializedInt32Array(size1, method, ref index1);
+			var ary2 = ArrayFinder.GetInitializedInt32Array(size2, method, ref index2);
 			if (ary1 == null || ary2 == null)
 				return null;
-			ary2 = decrypt(ary2);
+			ary2 = Decrypt(ary2);
 			if (ary2 == null || ary1.Length != ary2.Length)
 				return null;
 
@@ -113,14 +113,14 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			return new PatchInfo(ary1, ary2);
 		}
 
-		int[] decrypt(int[] data) {
+		int[] Decrypt(int[] data) {
 			var memStream = new MemoryStream();
 			var writer = new BinaryWriter(memStream);
 			foreach (var value in data)
 				writer.Write(value);
 			byte[] decrypted;
 			try {
-				decrypted = DeobUtils.aesDecrypt(memStream.ToArray(), decryptMethod.Key, decryptMethod.Iv);
+				decrypted = DeobUtils.AesDecrypt(memStream.ToArray(), decryptMethod.Key, decryptMethod.Iv);
 			}
 			catch {
 				return null;
@@ -133,11 +133,11 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 			return newData;
 		}
 
-		public void patch(byte[] peImageData) {
+		public void Patch(byte[] peImageData) {
 			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]));
+						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 1da86bc6..82fc1653 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v3/NativeLibSaver.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v3/NativeLibSaver.cs
@@ -51,30 +51,30 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v3 {
 
 		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");
+			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.String);
+				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 : class, ICodedToken {
-			return DeobUtils.lookup(module, def, errorMessage);
+		T Lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
+			return DeobUtils.Lookup(module, def, errorMessage);
 		}
 
-		public void find() {
-			foreach (var calledMethod in DotNetUtils.getCalledMethods(module, DotNetUtils.getModuleTypeCctor(module))) {
-				if (!DotNetUtils.isMethod(calledMethod, "System.Void", "()"))
+		public void Find() {
+			foreach (var calledMethod in DotNetUtils.GetCalledMethods(module, DotNetUtils.GetModuleTypeCctor(module))) {
+				if (!DotNetUtils.IsMethod(calledMethod, "System.Void", "()"))
 					continue;
 				if (calledMethod.DeclaringType.FullName != "<PrivateImplementationDetails>{F1C5056B-0AFC-4423-9B83-D13A26B48869}")
 					continue;
 
 				nativeLibCallerType = calledMethod.DeclaringType;
 				initMethod = calledMethod;
-				foreach (var s in DotNetUtils.getCodeStrings(initMethod)) {
-					nativeFileResource = DotNetUtils.getResource(module, s);
+				foreach (var s in DotNetUtils.GetCodeStrings(initMethod)) {
+					nativeFileResource = DotNetUtils.GetResource(module, s);
 					if (nativeFileResource != null)
 						break;
 				}
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v4/AntiStrongname.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v4/AntiStrongname.cs
index d93a3511..987e5a82 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v4/AntiStrongname.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v4/AntiStrongname.cs
@@ -29,23 +29,23 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 
 		public AntiStrongName(TypeDef decrypterType) {
 			this.decrypterType = decrypterType;
-			find();
+			Find();
 		}
 
-		public void find() {
+		public void Find() {
 			if (decrypterType == null)
 				return;
 
-			if (checkType(decrypterType))
+			if (CheckType(decrypterType))
 				return;
 
 			foreach (var type in decrypterType.NestedTypes) {
-				if (checkType(type))
+				if (CheckType(type))
 					return;
 			}
 		}
 
-		bool checkType(TypeDef type) {
+		bool CheckType(TypeDef type) {
 			var requiredTypes = new string[] {
 				"System.Byte[]",
 				"System.IO.MemoryStream",
@@ -60,15 +60,15 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				var sig = method.MethodSig;
 				if (sig == null || sig.Params.Count != 2)
 					continue;
-				if (!checkType(sig.RetType, ElementType.String))
+				if (!CheckType(sig.RetType, ElementType.String))
 					continue;
-				if (!checkType(sig.Params[0], ElementType.String))
+				if (!CheckType(sig.Params[0], ElementType.String))
 					continue;
-				if (!checkType(sig.Params[1], ElementType.String))
+				if (!CheckType(sig.Params[1], ElementType.String))
 					continue;
 
 				var localTypes = new LocalTypes(method);
-				if (!localTypes.all(requiredTypes))
+				if (!localTypes.All(requiredTypes))
 					continue;
 
 				antiStrongNameMethod = method;
@@ -78,17 +78,17 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			return false;
 		}
 
-		static bool checkType(TypeSig type, ElementType expectedType) {
+		static bool CheckType(TypeSig type, ElementType expectedType) {
 			return type != null && (type.ElementType == ElementType.Object || type.ElementType == expectedType);
 		}
 
-		public bool remove(Blocks blocks) {
+		public bool Remove(Blocks blocks) {
 			if (antiStrongNameMethod == null)
 				return false;
 
 			Block antiSnBlock;
 			int numInstructions;
-			if (!findBlock(blocks, out antiSnBlock, out numInstructions))
+			if (!FindBlock(blocks, out antiSnBlock, out numInstructions))
 				return false;
 
 			if (antiSnBlock.FallThrough == null || antiSnBlock.Targets == null || antiSnBlock.Targets.Count != 1)
@@ -97,18 +97,18 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			var goodBlock = antiSnBlock.Targets[0];
 			var badBlock = antiSnBlock.FallThrough;
 
-			antiSnBlock.replaceLastInstrsWithBranch(numInstructions, goodBlock);
+			antiSnBlock.ReplaceLastInstrsWithBranch(numInstructions, goodBlock);
 
 			if (badBlock.FallThrough == badBlock && badBlock.Sources.Count == 1 && badBlock.Targets == null) {
-				badBlock.Parent.removeGuaranteedDeadBlock(badBlock);
+				badBlock.Parent.RemoveGuaranteedDeadBlock(badBlock);
 				return true;
 			}
 			if (badBlock.Instructions.Count <= 1 && badBlock.LastInstr.OpCode.Code == Code.Nop) {
 				if (badBlock.FallThrough != null && badBlock.Targets == null && badBlock.Sources.Count == 0) {
 					var badBlock2 = badBlock.FallThrough;
 					if (badBlock2.FallThrough == badBlock2 && badBlock2.Sources.Count == 2 && badBlock2.Targets == null) {
-						badBlock.Parent.removeGuaranteedDeadBlock(badBlock);
-						badBlock2.Parent.removeGuaranteedDeadBlock(badBlock2);
+						badBlock.Parent.RemoveGuaranteedDeadBlock(badBlock);
+						badBlock2.Parent.RemoveGuaranteedDeadBlock(badBlock2);
 						return true;
 					}
 				}
@@ -117,11 +117,11 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			throw new ApplicationException("Invalid state");
 		}
 
-		bool findBlock(Blocks blocks, out Block foundBlock, out int numInstructions) {
+		bool FindBlock(Blocks blocks, out Block foundBlock, out int numInstructions) {
 			const int NUM_INSTRS = 11;
 
-			foreach (var block in blocks.MethodBlocks.getAllBlocks()) {
-				if (!block.LastInstr.isBrfalse())
+			foreach (var block in blocks.MethodBlocks.GetAllBlocks()) {
+				if (!block.LastInstr.IsBrfalse())
 					continue;
 
 				var instructions = block.Instructions;
@@ -132,23 +132,23 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 					continue;
 				if (!(instructions[i].Operand is ITypeDefOrRef))
 					continue;
-				if (!checkCall(instructions[i + 1], "System.Type System.Type::GetTypeFromHandle(System.RuntimeTypeHandle)"))
+				if (!CheckCall(instructions[i + 1], "System.Type System.Type::GetTypeFromHandle(System.RuntimeTypeHandle)"))
 					continue;
-				if (!checkCall(instructions[i + 2], "System.Reflection.Assembly System.Type::get_Assembly()"))
+				if (!CheckCall(instructions[i + 2], "System.Reflection.Assembly System.Type::get_Assembly()"))
 					continue;
-				if (!checkCall(instructions[i + 3], "System.Reflection.AssemblyName System.Reflection.Assembly::GetName()"))
+				if (!CheckCall(instructions[i + 3], "System.Reflection.AssemblyName System.Reflection.Assembly::GetName()"))
 					continue;
-				if (!checkCall(instructions[i + 4], "System.Byte[] System.Reflection.AssemblyName::GetPublicKeyToken()"))
+				if (!CheckCall(instructions[i + 4], "System.Byte[] System.Reflection.AssemblyName::GetPublicKeyToken()"))
 					continue;
-				if (!checkCall(instructions[i + 5], "System.String System.Convert::ToBase64String(System.Byte[])"))
+				if (!CheckCall(instructions[i + 5], "System.String System.Convert::ToBase64String(System.Byte[])"))
 					continue;
 				if (instructions[i + 6].OpCode.Code != Code.Ldstr)
 					continue;
-				if (!checkCall(instructions[i + 7], antiStrongNameMethod))
+				if (!CheckCall(instructions[i + 7], antiStrongNameMethod))
 					continue;
 				if (instructions[i + 8].OpCode.Code != Code.Ldstr)
 					continue;
-				if (!checkCall(instructions[i + 9], "System.Boolean System.String::op_Inequality(System.String,System.String)"))
+				if (!CheckCall(instructions[i + 9], "System.Boolean System.String::op_Inequality(System.String,System.String)"))
 					continue;
 
 				numInstructions = NUM_INSTRS;
@@ -161,7 +161,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			return false;
 		}
 
-		static bool checkCall(Instr instr, string methodFullName) {
+		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 IMethod;
@@ -170,7 +170,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			return calledMethod.FullName == methodFullName;
 		}
 
-		static bool checkCall(Instr instr, IMethod 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 IMethod;
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v4/AssemblyResolver.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v4/AssemblyResolver.cs
index aa0b72fb..08f3ba8b 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v4/AssemblyResolver.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v4/AssemblyResolver.cs
@@ -34,7 +34,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 		}
 
 		public override string ToString() {
-			return string.Format("{0} (rsrc: {1})", name, Utils.toCsharpString(resource.Name));
+			return string.Format("{0} (rsrc: {1})", name, Utils.ToCsharpString(resource.Name));
 		}
 	}
 
@@ -62,25 +62,25 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 
 		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");
+			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 : class, ICodedToken {
-			return DeobUtils.lookup(module, def, errorMessage);
+		T Lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
+			return DeobUtils.Lookup(module, def, errorMessage);
 		}
 
-		public void find(ISimpleDeobfuscator simpleDeobfuscator) {
-			if (checkMethod(simpleDeobfuscator, module.EntryPoint))
+		public void Find(ISimpleDeobfuscator simpleDeobfuscator) {
+			if (CheckMethod(simpleDeobfuscator, module.EntryPoint))
 				return;
 			if (module.EntryPoint != null) {
-				if (checkMethod(simpleDeobfuscator, module.EntryPoint.DeclaringType.FindStaticConstructor()))
+				if (CheckMethod(simpleDeobfuscator, module.EntryPoint.DeclaringType.FindStaticConstructor()))
 					return;
 			}
 		}
 
-		bool checkMethod(ISimpleDeobfuscator simpleDeobfuscator, MethodDef methodToCheck) {
+		bool CheckMethod(ISimpleDeobfuscator simpleDeobfuscator, MethodDef methodToCheck) {
 			if (methodToCheck == null)
 				return false;
 
@@ -93,10 +93,10 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				"System.IO.Stream",
 			};
 
-			simpleDeobfuscator.deobfuscate(methodToCheck);
-			foreach (var method in DotNetUtils.getCalledMethods(module, methodToCheck)) {
+			simpleDeobfuscator.Deobfuscate(methodToCheck);
+			foreach (var method in DotNetUtils.GetCalledMethods(module, methodToCheck)) {
 				var type = method.DeclaringType;
-				if (!DotNetUtils.isMethod(method, "System.Void", "()"))
+				if (!DotNetUtils.IsMethod(method, "System.Void", "()"))
 					continue;
 				if (!method.IsStatic)
 					continue;
@@ -107,15 +107,15 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 					continue;
 				if (type.HasEvents || type.HasProperties)
 					continue;
-				if (!checkFields(type.Fields))
+				if (!CheckFields(type.Fields))
 					continue;
 
-				var resolverMethod = findAssemblyResolveMethod(type);
+				var resolverMethod = FindAssemblyResolveMethod(type);
 				if (resolverMethod == null)
 					continue;
 
 				var localTypes = new LocalTypes(resolverMethod);
-				if (!localTypes.all(resolverLocals))
+				if (!localTypes.All(resolverLocals))
 					continue;
 
 				assemblyResolverType = type;
@@ -127,51 +127,51 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			return false;
 		}
 
-		static bool checkFields(IList<FieldDef> fields) {
+		static bool CheckFields(IList<FieldDef> fields) {
 			if (fields.Count != 2)
 				return false;
 
 			var fieldTypes = new FieldTypes(fields);
-			return fieldTypes.count("System.Boolean") == 1 &&
-				(fieldTypes.count("System.Collections.Hashtable") == 1 ||
-				 fieldTypes.count("System.Object") == 1);
+			return fieldTypes.Count("System.Boolean") == 1 &&
+				(fieldTypes.Count("System.Collections.Hashtable") == 1 ||
+				 fieldTypes.Count("System.Object") == 1);
 		}
 
-		static MethodDef findAssemblyResolveMethod(TypeDef type) {
+		static MethodDef FindAssemblyResolveMethod(TypeDef type) {
 			foreach (var method in type.Methods) {
-				if (DotNetUtils.isMethod(method, "System.Reflection.Assembly", "(System.Object,System.ResolveEventArgs)"))
+				if (DotNetUtils.IsMethod(method, "System.Reflection.Assembly", "(System.Object,System.ResolveEventArgs)"))
 					return method;
 			}
 			foreach (var method in type.Methods) {
-				if (DotNetUtils.isMethod(method, "System.Reflection.Assembly", "(System.Object,System.Object)"))
+				if (DotNetUtils.IsMethod(method, "System.Reflection.Assembly", "(System.Object,System.Object)"))
 					return method;
 			}
 			return null;
 		}
 
-		public List<ResourceInfo> getEmbeddedAssemblies(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
+		public List<ResourceInfo> GetEmbeddedAssemblies(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
 			var infos = new List<ResourceInfo>();
 			if (assemblyResolverMethod == null)
 				return infos;
-			simpleDeobfuscator.deobfuscate(assemblyResolverMethod);
-			simpleDeobfuscator.decryptStrings(assemblyResolverMethod, deob);
+			simpleDeobfuscator.Deobfuscate(assemblyResolverMethod);
+			simpleDeobfuscator.DecryptStrings(assemblyResolverMethod, deob);
 
-			foreach (var resourcePrefix in DotNetUtils.getCodeStrings(assemblyResolverMethod))
-				infos.AddRange(getResourceInfos(resourcePrefix));
+			foreach (var resourcePrefix in DotNetUtils.GetCodeStrings(assemblyResolverMethod))
+				infos.AddRange(GetResourceInfos(resourcePrefix));
 
 			return infos;
 		}
 
-		List<ResourceInfo> getResourceInfos(string prefix) {
+		List<ResourceInfo> GetResourceInfos(string prefix) {
 			var infos = new List<ResourceInfo>();
 
-			foreach (var resource in findResources(prefix))
-				infos.Add(new ResourceInfo(resource, getAssemblyName(resource)));
+			foreach (var resource in FindResources(prefix))
+				infos.Add(new ResourceInfo(resource, GetAssemblyName(resource)));
 
 			return infos;
 		}
 
-		List<EmbeddedResource> findResources(string prefix) {
+		List<EmbeddedResource> FindResources(string prefix) {
 			var result = new List<EmbeddedResource>();
 
 			if (string.IsNullOrEmpty(prefix))
@@ -191,7 +191,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 		}
 
 		static int unknownNameCounter = 0;
-		static string getAssemblyName(EmbeddedResource resource) {
+		static string GetAssemblyName(EmbeddedResource resource) {
 			try {
 				var resourceModule = ModuleDefMD.Load(resource.Data.ReadAllBytes());
 				return resourceModule.Assembly.FullName;
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v4/BooleanDecrypter.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v4/BooleanDecrypter.cs
index 1b30ec81..f6f7f132 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v4/BooleanDecrypter.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v4/BooleanDecrypter.cs
@@ -54,7 +54,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			this.encryptedResource = new EncryptedResource(module, oldOne.encryptedResource);
 		}
 
-		public void find() {
+		public void Find() {
 			var additionalTypes = new string[] {
 				"System.Boolean",
 			};
@@ -64,9 +64,9 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				foreach (var method in type.Methods) {
 					if (!method.IsStatic || !method.HasBody)
 						continue;
-					if (!DotNetUtils.isMethod(method, "System.Boolean", "(System.Int32)"))
+					if (!DotNetUtils.IsMethod(method, "System.Boolean", "(System.Int32)"))
 						continue;
-					if (!encryptedResource.couldBeResourceDecrypter(method, additionalTypes))
+					if (!encryptedResource.CouldBeResourceDecrypter(method, additionalTypes))
 						continue;
 
 					encryptedResource.Method = method;
@@ -75,20 +75,20 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			}
 		}
 
-		public void init(byte[] fileData, ISimpleDeobfuscator simpleDeobfuscator) {
+		public void Initialize(byte[] fileData, ISimpleDeobfuscator simpleDeobfuscator) {
 			if (encryptedResource.Method == null)
 				return;
 			this.fileData = fileData;
 
-			encryptedResource.init(simpleDeobfuscator);
+			encryptedResource.Initialize(simpleDeobfuscator);
 			if (!encryptedResource.FoundResource)
 				return;
 
-			Logger.v("Adding boolean decrypter. Resource: {0}", Utils.toCsharpString(encryptedResource.Resource.Name));
-			decryptedData = encryptedResource.decrypt();
+			Logger.v("Adding boolean decrypter. Resource: {0}", Utils.ToCsharpString(encryptedResource.Resource.Name));
+			decryptedData = encryptedResource.Decrypt();
 		}
 
-		public bool decrypt(int offset) {
+		public bool Decrypt(int offset) {
 			uint byteOffset = BitConverter.ToUInt32(decryptedData, offset);
 			return fileData[byteOffset] == 0x80;
 		}
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v4/Deobfuscator.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v4/Deobfuscator.cs
index d4f56d3a..85526e2a 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v4/Deobfuscator.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v4/Deobfuscator.cs
@@ -44,15 +44,15 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 
 		public DeobfuscatorInfo()
 			: base(DEFAULT_REGEX) {
-			decryptMethods = new BoolOption(null, makeArgName("methods"), "Decrypt methods", true);
-			decryptBools = new BoolOption(null, makeArgName("bools"), "Decrypt booleans", true);
-			restoreTypes = new BoolOption(null, makeArgName("types"), "Restore types (object -> real type)", true);
-			inlineMethods = new BoolOption(null, makeArgName("inline"), "Inline short methods", true);
-			removeInlinedMethods = new BoolOption(null, makeArgName("remove-inlined"), "Remove inlined methods", true);
-			dumpEmbeddedAssemblies = new BoolOption(null, makeArgName("embedded"), "Dump embedded assemblies", true);
-			decryptResources = new BoolOption(null, makeArgName("rsrc"), "Decrypt resources", true);
-			removeNamespaces = new BoolOption(null, makeArgName("ns1"), "Clear namespace if there's only one class in it", true);
-			removeAntiStrongName = new BoolOption(null, makeArgName("sn"), "Remove anti strong name code", true);
+			decryptMethods = new BoolOption(null, MakeArgName("methods"), "Decrypt methods", true);
+			decryptBools = new BoolOption(null, MakeArgName("bools"), "Decrypt booleans", true);
+			restoreTypes = new BoolOption(null, MakeArgName("types"), "Restore types (object -> real type)", true);
+			inlineMethods = new BoolOption(null, MakeArgName("inline"), "Inline short methods", true);
+			removeInlinedMethods = new BoolOption(null, MakeArgName("remove-inlined"), "Remove inlined methods", true);
+			dumpEmbeddedAssemblies = new BoolOption(null, MakeArgName("embedded"), "Dump embedded assemblies", true);
+			decryptResources = new BoolOption(null, MakeArgName("rsrc"), "Decrypt resources", true);
+			removeNamespaces = new BoolOption(null, MakeArgName("ns1"), "Clear namespace if there's only one class in it", true);
+			removeAntiStrongName = new BoolOption(null, MakeArgName("sn"), "Remove anti strong name code", true);
 		}
 
 		public override string Name {
@@ -63,7 +63,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			get { return THE_TYPE; }
 		}
 
-		public override IDeobfuscator createDeobfuscator() {
+		public override IDeobfuscator CreateDeobfuscator() {
 			return new Deobfuscator(new Deobfuscator.Options {
 				ValidNameRegex = validNameRegex.get(),
 				DecryptMethods = decryptMethods.get(),
@@ -78,7 +78,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			});
 		}
 
-		protected override IEnumerable<Option> getOptionsInternal() {
+		protected override IEnumerable<Option> GetOptionsInternal() {
 			return new List<Option>() {
 				decryptMethods,
 				decryptBools,
@@ -152,8 +152,8 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				this.RenamingOptions &= ~RenamingOptions.RemoveNamespaceIfOneType;
 		}
 
-		public override byte[] unpackNativeFile(IPEImage peImage) {
-			var data = new NativeImageUnpacker(peImage).unpack();
+		public override byte[] UnpackNativeFile(IPEImage peImage) {
+			var data = new NativeImageUnpacker(peImage).Unpack();
 			if (data == null)
 				return null;
 
@@ -162,106 +162,106 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			return data;
 		}
 
-		public override void init(ModuleDefMD module) {
-			base.init(module);
+		public override void Initialize(ModuleDefMD module) {
+			base.Initialize(module);
 		}
 
 		static Regex isRandomName = new Regex(@"^[A-Z]{30,40}$");
 		static Regex isRandomNameMembers = new Regex(@"^[a-zA-Z0-9]{9,11}$");	// methods, fields, props, events
 		static Regex isRandomNameTypes = new Regex(@"^[a-zA-Z0-9]{18,19}(?:`\d+)?$");	// types, namespaces
 
-		bool checkValidName(string name, Regex regex) {
+		bool CheckValidName(string name, Regex regex) {
 			if (isRandomName.IsMatch(name))
 				return false;
 			if (regex.IsMatch(name)) {
-				if (RandomNameChecker.isRandom(name))
+				if (RandomNameChecker.IsRandom(name))
 					return false;
-				if (!RandomNameChecker.isNonRandom(name))
+				if (!RandomNameChecker.IsNonRandom(name))
 					return false;
 			}
-			return checkValidName(name);
+			return CheckValidName(name);
 		}
 
-		public override bool isValidNamespaceName(string ns) {
+		public override bool IsValidNamespaceName(string ns) {
 			if (ns == null)
 				return false;
 			if (ns.Contains("."))
-				return base.isValidNamespaceName(ns);
-			return checkValidName(ns, isRandomNameTypes);
+				return base.IsValidNamespaceName(ns);
+			return CheckValidName(ns, isRandomNameTypes);
 		}
 
-		public override bool isValidTypeName(string name) {
-			return name != null && checkValidName(name, isRandomNameTypes);
+		public override bool IsValidTypeName(string name) {
+			return name != null && CheckValidName(name, isRandomNameTypes);
 		}
 
-		public override bool isValidMethodName(string name) {
-			return name != null && checkValidName(name, isRandomNameMembers);
+		public override bool IsValidMethodName(string name) {
+			return name != null && CheckValidName(name, isRandomNameMembers);
 		}
 
-		public override bool isValidPropertyName(string name) {
-			return name != null && checkValidName(name, isRandomNameMembers);
+		public override bool IsValidPropertyName(string name) {
+			return name != null && CheckValidName(name, isRandomNameMembers);
 		}
 
-		public override bool isValidEventName(string name) {
-			return name != null && checkValidName(name, isRandomNameMembers);
+		public override bool IsValidEventName(string name) {
+			return name != null && CheckValidName(name, isRandomNameMembers);
 		}
 
-		public override bool isValidFieldName(string name) {
-			return name != null && checkValidName(name, isRandomNameMembers);
+		public override bool IsValidFieldName(string name) {
+			return name != null && CheckValidName(name, isRandomNameMembers);
 		}
 
-		public override bool isValidGenericParamName(string name) {
-			return name != null && checkValidName(name, isRandomNameMembers);
+		public override bool IsValidGenericParamName(string name) {
+			return name != null && CheckValidName(name, isRandomNameMembers);
 		}
 
-		public override bool isValidMethodArgName(string name) {
-			return name != null && checkValidName(name, isRandomNameMembers);
+		public override bool IsValidMethodArgName(string name) {
+			return name != null && CheckValidName(name, isRandomNameMembers);
 		}
 
-		public override bool isValidMethodReturnArgName(string name) {
-			return string.IsNullOrEmpty(name) || 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);
+		public override bool IsValidResourceKeyName(string name) {
+			return name != null && CheckValidName(name, isRandomNameMembers);
 		}
 
-		protected override int detectInternal() {
+		protected override int DetectInternal() {
 			int val = 0;
 
-			int sum = toInt32(methodsDecrypter.Detected) +
-					toInt32(stringDecrypter.Detected) +
-					toInt32(booleanDecrypter.Detected) +
-					toInt32(assemblyResolver.Detected) +
-					toInt32(resourceResolver.Detected);
+			int sum = ToInt32(methodsDecrypter.Detected) +
+					ToInt32(stringDecrypter.Detected) +
+					ToInt32(booleanDecrypter.Detected) +
+					ToInt32(assemblyResolver.Detected) +
+					ToInt32(resourceResolver.Detected);
 			if (sum > 0)
 				val += 100 + 10 * (sum - 1);
 
 			if (sum == 0) {
-				if (hasMetadataStream("#GUlD") && hasMetadataStream("#Blop"))
+				if (HasMetadataStream("#GUlD") && HasMetadataStream("#Blop"))
 					val += 10;
 			}
 
 			return val;
 		}
 
-		protected override void scanForObfuscator() {
+		protected override void ScanForObfuscator() {
 			methodsDecrypter = new MethodsDecrypter(module);
-			methodsDecrypter.find();
+			methodsDecrypter.Find();
 			stringDecrypter = new StringDecrypter(module);
-			stringDecrypter.find(DeobfuscatedFile);
+			stringDecrypter.Find(DeobfuscatedFile);
 			booleanDecrypter = new BooleanDecrypter(module);
-			booleanDecrypter.find();
+			booleanDecrypter.Find();
 			assemblyResolver = new AssemblyResolver(module);
-			assemblyResolver.find(DeobfuscatedFile);
-			obfuscatorName = detectVersion();
+			assemblyResolver.Find(DeobfuscatedFile);
+			obfuscatorName = DetectVersion();
 			if (unpackedNativeFile)
 				obfuscatorName += " (native)";
 			resourceResolver = new ResourceResolver(module);
-			resourceResolver.find(DeobfuscatedFile);
+			resourceResolver.Find(DeobfuscatedFile);
 		}
 
-		string detectVersion() {
+		string DetectVersion() {
 			/*
 			Methods decrypter locals (not showing its own types):
 			3.7.0.3:
@@ -309,7 +309,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				if (info.key == null)
 					continue;
 				localTypes = new LocalTypes(info.method);
-				if (!localTypes.exists("System.IntPtr"))
+				if (!localTypes.Exists("System.IntPtr"))
 					return DeobfuscatorInfo.THE_NAME + " <= 3.7";
 				minVer = 3800;
 				break;
@@ -322,23 +322,23 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			}
 			localTypes = new LocalTypes(methodsDecrypter.Method);
 
-			if (localTypes.exists("System.Int32[]")) {
+			if (localTypes.Exists("System.Int32[]")) {
 				if (minVer >= 3800)
 					return DeobfuscatorInfo.THE_NAME + " 3.8.4.1 - 3.9.0.1";
 				return DeobfuscatorInfo.THE_NAME + " <= 3.9.0.1";
 			}
-			if (!localTypes.exists("System.Diagnostics.Process")) {	// If < 4.0
-				if (localTypes.exists("System.Diagnostics.StackFrame"))
+			if (!localTypes.Exists("System.Diagnostics.Process")) {	// If < 4.0
+				if (localTypes.Exists("System.Diagnostics.StackFrame"))
 					return DeobfuscatorInfo.THE_NAME + " 3.9.8.0";
 			}
 
-			var compileMethod = MethodsDecrypter.findDnrCompileMethod(methodsDecrypter.Method.DeclaringType);
+			var compileMethod = MethodsDecrypter.FindDnrCompileMethod(methodsDecrypter.Method.DeclaringType);
 			if (compileMethod == null)
 				return DeobfuscatorInfo.THE_NAME + " < 4.0";
-			DeobfuscatedFile.deobfuscate(compileMethod);
-			bool compileMethodHasConstant_0x70000000 = DeobUtils.hasInteger(compileMethod, 0x70000000);	// 4.0-4.1
-			DeobfuscatedFile.deobfuscate(methodsDecrypter.Method);
-			bool hasCorEnableProfilingString = findString(methodsDecrypter.Method, "Cor_Enable_Profiling");	// 4.1-4.4
+			DeobfuscatedFile.Deobfuscate(compileMethod);
+			bool compileMethodHasConstant_0x70000000 = DeobUtils.HasInteger(compileMethod, 0x70000000);	// 4.0-4.1
+			DeobfuscatedFile.Deobfuscate(methodsDecrypter.Method);
+			bool hasCorEnableProfilingString = FindString(methodsDecrypter.Method, "Cor_Enable_Profiling");	// 4.1-4.4
 
 			if (compileMethodHasConstant_0x70000000) {
 				if (hasCorEnableProfilingString)
@@ -347,7 +347,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			}
 			if (!hasCorEnableProfilingString) {
 				// 4.x or 4.5
-				bool callsReverse = DotNetUtils.callsMethod(methodsDecrypter.Method, "System.Void System.Array::Reverse(System.Array)");
+				bool callsReverse = DotNetUtils.CallsMethod(methodsDecrypter.Method, "System.Void System.Array::Reverse(System.Array)");
 				if (!callsReverse)
 					return DeobfuscatorInfo.THE_NAME + " 4.x";
 				return DeobfuscatorInfo.THE_NAME + " 4.5";
@@ -355,44 +355,44 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 
 			// 4.2-4.4
 
-			if (!localTypes.exists("System.Byte&"))
+			if (!localTypes.Exists("System.Byte&"))
 				return DeobfuscatorInfo.THE_NAME + " 4.2";
 
 			localTypes = new LocalTypes(compileMethod);
-			if (localTypes.exists("System.Object"))
+			if (localTypes.Exists("System.Object"))
 				return DeobfuscatorInfo.THE_NAME + " 4.4";
 			return DeobfuscatorInfo.THE_NAME + " 4.3";
 		}
 
-		static bool findString(MethodDef method, string s) {
-			foreach (var cs in DotNetUtils.getCodeStrings(method)) {
+		static bool FindString(MethodDef method, string s) {
+			foreach (var cs in DotNetUtils.GetCodeStrings(method)) {
 				if (cs == s)
 					return true;
 			}
 			return false;
 		}
 
-		public override bool getDecryptedModule(int count, ref byte[] newFileData, ref DumpedMethods dumpedMethods) {
+		public override bool GetDecryptedModule(int count, ref byte[] newFileData, ref DumpedMethods dumpedMethods) {
 			if (count != 0)
 				return false;
-			fileData = ModuleBytes ?? DeobUtils.readModule(module);
+			fileData = ModuleBytes ?? DeobUtils.ReadModule(module);
 			peImage = new MyPEImage(fileData);
 
 			if (!options.DecryptMethods)
 				return false;
 
 			var tokenToNativeCode = new Dictionary<uint,byte[]>();
-			if (!methodsDecrypter.decrypt(peImage, DeobfuscatedFile, ref dumpedMethods, tokenToNativeCode, unpackedNativeFile))
+			if (!methodsDecrypter.Decrypt(peImage, DeobfuscatedFile, ref dumpedMethods, tokenToNativeCode, unpackedNativeFile))
 				return false;
 
 			newFileData = fileData;
 			return true;
 		}
 
-		public override IDeobfuscator moduleReloaded(ModuleDefMD module) {
-			freePEImage();
+		public override IDeobfuscator ModuleReloaded(ModuleDefMD module) {
+			FreePEImage();
 			var newOne = new Deobfuscator(options);
-			newOne.setModule(module);
+			newOne.SetModule(module);
 			newOne.fileData = fileData;
 			newOne.peImage = new MyPEImage(fileData);
 			newOne.methodsDecrypter = new MethodsDecrypter(module, methodsDecrypter);
@@ -400,79 +400,79 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			newOne.booleanDecrypter = new BooleanDecrypter(module, booleanDecrypter);
 			newOne.assemblyResolver = new AssemblyResolver(module, assemblyResolver);
 			newOne.resourceResolver = new ResourceResolver(module, resourceResolver);
-			newOne.methodsDecrypter.reloaded();
+			newOne.methodsDecrypter.Reloaded();
 			return newOne;
 		}
 
-		void freePEImage() {
+		void FreePEImage() {
 			if (peImage != null)
 				peImage.Dispose();
 			peImage = null;
 		}
 
-		public override void deobfuscateBegin() {
-			base.deobfuscateBegin();
+		public override void DeobfuscateBegin() {
+			base.DeobfuscateBegin();
 
 			proxyCallFixer = new ProxyCallFixer(module, DeobfuscatedFile);
-			proxyCallFixer.findDelegateCreator();
-			proxyCallFixer.find();
+			proxyCallFixer.FindDelegateCreator();
+			proxyCallFixer.Find();
 
-			stringDecrypter.init(peImage, fileData, DeobfuscatedFile);
+			stringDecrypter.Initialize(peImage, fileData, DeobfuscatedFile);
 			if (!stringDecrypter.Detected)
-				freePEImage();
-			booleanDecrypter.init(fileData, DeobfuscatedFile);
+				FreePEImage();
+			booleanDecrypter.Initialize(fileData, DeobfuscatedFile);
 			booleanValueInliner = new BooleanValueInliner();
 			emptyClass = new EmptyClass(module);
 
 			if (options.DecryptBools) {
-				booleanValueInliner.add(booleanDecrypter.Method, (method, gim, args) => {
-					return booleanDecrypter.decrypt((int)args[0]);
+				booleanValueInliner.Add(booleanDecrypter.Method, (method, gim, args) => {
+					return booleanDecrypter.Decrypt((int)args[0]);
 				});
 			}
 
 			foreach (var info in stringDecrypter.DecrypterInfos) {
-				staticStringInliner.add(info.method, (method2, gim, args) => {
-					return stringDecrypter.decrypt(method2, (int)args[0]);
+				staticStringInliner.Add(info.method, (method2, gim, args) => {
+					return stringDecrypter.Decrypt(method2, (int)args[0]);
 				});
 			}
 			if (stringDecrypter.OtherStringDecrypter != null) {
-				staticStringInliner.add(stringDecrypter.OtherStringDecrypter, (method2, gim, args) => {
-					return stringDecrypter.decrypt((string)args[0]);
+				staticStringInliner.Add(stringDecrypter.OtherStringDecrypter, (method2, gim, args) => {
+					return stringDecrypter.Decrypt((string)args[0]);
 				});
 			}
-			DeobfuscatedFile.stringDecryptersAdded();
+			DeobfuscatedFile.StringDecryptersAdded();
 
 			metadataTokenObfuscator = new MetadataTokenObfuscator(module);
-			antiStrongname = new AntiStrongName(getDecrypterType());
+			antiStrongname = new AntiStrongName(GetDecrypterType());
 
 			bool removeResourceResolver = false;
 			if (options.DecryptResources) {
-				resourceResolver.init(DeobfuscatedFile, this);
-				decryptResources();
+				resourceResolver.Initialize(DeobfuscatedFile, this);
+				DecryptResources();
 				if (options.InlineMethods) {
-					addTypeToBeRemoved(resourceResolver.Type, "Resource decrypter type");
+					AddTypeToBeRemoved(resourceResolver.Type, "Resource decrypter type");
 					removeResourceResolver = true;
 				}
-				addEntryPointCallToBeRemoved(resourceResolver.InitMethod);
-				addCctorInitCallToBeRemoved(resourceResolver.InitMethod);
+				AddEntryPointCallToBeRemoved(resourceResolver.InitMethod);
+				AddCctorInitCallToBeRemoved(resourceResolver.InitMethod);
 			}
 			if (resourceResolver.Detected && !removeResourceResolver && !resourceResolver.FoundResource)
 				canRemoveDecrypterType = false;	// There may be calls to its .ctor
 
 			if (Operations.DecryptStrings != OpDecryptString.None)
-				addResourceToBeRemoved(stringDecrypter.Resource, "Encrypted strings");
+				AddResourceToBeRemoved(stringDecrypter.Resource, "Encrypted strings");
 			else
 				canRemoveDecrypterType = false;
 
 			if (options.DecryptMethods && !methodsDecrypter.HasNativeMethods) {
-				addResourceToBeRemoved(methodsDecrypter.Resource, "Encrypted methods");
-				addCctorInitCallToBeRemoved(methodsDecrypter.Method);
+				AddResourceToBeRemoved(methodsDecrypter.Resource, "Encrypted methods");
+				AddCctorInitCallToBeRemoved(methodsDecrypter.Method);
 			}
 			else
 				canRemoveDecrypterType = false;
 
 			if (options.DecryptBools)
-				addResourceToBeRemoved(booleanDecrypter.Resource, "Encrypted booleans");
+				AddResourceToBeRemoved(booleanDecrypter.Resource, "Encrypted booleans");
 			else
 				canRemoveDecrypterType = false;
 
@@ -485,77 +485,77 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 
 			if (options.DumpEmbeddedAssemblies) {
 				if (options.InlineMethods)
-					addTypeToBeRemoved(assemblyResolver.Type, "Assembly resolver");
-				addEntryPointCallToBeRemoved(assemblyResolver.InitMethod);
-				addCctorInitCallToBeRemoved(assemblyResolver.InitMethod);
-				dumpEmbeddedAssemblies();
+					AddTypeToBeRemoved(assemblyResolver.Type, "Assembly resolver");
+				AddEntryPointCallToBeRemoved(assemblyResolver.InitMethod);
+				AddCctorInitCallToBeRemoved(assemblyResolver.InitMethod);
+				DumpEmbeddedAssemblies();
 			}
 
 			if (options.InlineMethods)
-				addTypeToBeRemoved(metadataTokenObfuscator.Type, "Metadata token obfuscator");
+				AddTypeToBeRemoved(metadataTokenObfuscator.Type, "Metadata token obfuscator");
 
-			addCctorInitCallToBeRemoved(emptyClass.Method);
-			addCtorInitCallToBeRemoved(emptyClass.Method);
-			addEntryPointCallToBeRemoved(emptyClass.Method);
+			AddCctorInitCallToBeRemoved(emptyClass.Method);
+			AddCtorInitCallToBeRemoved(emptyClass.Method);
+			AddEntryPointCallToBeRemoved(emptyClass.Method);
 			if (options.InlineMethods)
-				addTypeToBeRemoved(emptyClass.Type, "Empty class");
+				AddTypeToBeRemoved(emptyClass.Type, "Empty class");
 
 			startedDeobfuscating = true;
 		}
 
-		void addEntryPointCallToBeRemoved(MethodDef methodToBeRemoved) {
+		void AddEntryPointCallToBeRemoved(MethodDef methodToBeRemoved) {
 			var entryPoint = module.EntryPoint;
-			addCallToBeRemoved(entryPoint, methodToBeRemoved);
-			foreach (var calledMethod in DotNetUtils.getCalledMethods(module, entryPoint))
-				addCallToBeRemoved(calledMethod, methodToBeRemoved);
+			AddCallToBeRemoved(entryPoint, methodToBeRemoved);
+			foreach (var calledMethod in DotNetUtils.GetCalledMethods(module, entryPoint))
+				AddCallToBeRemoved(calledMethod, methodToBeRemoved);
 		}
 
-		void decryptResources() {
-			var rsrc = resourceResolver.mergeResources();
+		void DecryptResources() {
+			var rsrc = resourceResolver.MergeResources();
 			if (rsrc == null)
 				return;
-			addResourceToBeRemoved(rsrc, "Encrypted resources");
+			AddResourceToBeRemoved(rsrc, "Encrypted resources");
 		}
 
-		void dumpEmbeddedAssemblies() {
+		void DumpEmbeddedAssemblies() {
 			if (!options.DumpEmbeddedAssemblies)
 				return;
-			foreach (var info in assemblyResolver.getEmbeddedAssemblies(DeobfuscatedFile, this)) {
-				var simpleName = Utils.getAssemblySimpleName(info.name);
-				DeobfuscatedFile.createAssemblyFile(info.resource.GetResourceData(), simpleName, null);
-				addResourceToBeRemoved(info.resource, string.Format("Embedded assembly: {0}", info.name));
+			foreach (var info in assemblyResolver.GetEmbeddedAssemblies(DeobfuscatedFile, this)) {
+				var simpleName = Utils.GetAssemblySimpleName(info.name);
+				DeobfuscatedFile.CreateAssemblyFile(info.resource.GetResourceData(), simpleName, null);
+				AddResourceToBeRemoved(info.resource, string.Format("Embedded assembly: {0}", info.name));
 			}
 		}
 
-		public override bool deobfuscateOther(Blocks blocks) {
-			return booleanValueInliner.decrypt(blocks) > 0;
+		public override bool DeobfuscateOther(Blocks blocks) {
+			return booleanValueInliner.Decrypt(blocks) > 0;
 		}
 
-		public override void deobfuscateMethodEnd(Blocks blocks) {
-			proxyCallFixer.deobfuscate(blocks);
-			metadataTokenObfuscator.deobfuscate(blocks);
-			fixTypeofDecrypterInstructions(blocks);
-			removeAntiStrongNameCode(blocks);
-			base.deobfuscateMethodEnd(blocks);
+		public override void DeobfuscateMethodEnd(Blocks blocks) {
+			proxyCallFixer.Deobfuscate(blocks);
+			metadataTokenObfuscator.Deobfuscate(blocks);
+			FixTypeofDecrypterInstructions(blocks);
+			RemoveAntiStrongNameCode(blocks);
+			base.DeobfuscateMethodEnd(blocks);
 		}
 
-		void removeAntiStrongNameCode(Blocks blocks) {
+		void RemoveAntiStrongNameCode(Blocks blocks) {
 			if (!options.RemoveAntiStrongName)
 				return;
-			if (antiStrongname.remove(blocks))
+			if (antiStrongname.Remove(blocks))
 				Logger.v("Removed anti strong name code");
 		}
 
-		TypeDef getDecrypterType() {
+		TypeDef GetDecrypterType() {
 			return methodsDecrypter.DecrypterType ?? stringDecrypter.DecrypterType ?? booleanDecrypter.DecrypterType;
 		}
 
-		void fixTypeofDecrypterInstructions(Blocks blocks) {
-			var type = getDecrypterType();
+		void FixTypeofDecrypterInstructions(Blocks blocks) {
+			var type = GetDecrypterType();
 			if (type == null)
 				return;
 
-			foreach (var block in blocks.MethodBlocks.getAllBlocks()) {
+			foreach (var block in blocks.MethodBlocks.GetAllBlocks()) {
 				var instructions = block.Instructions;
 				for (int i = 0; i < instructions.Count; i++) {
 					var instr = instructions[i];
@@ -568,28 +568,28 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			}
 		}
 
-		public override void deobfuscateEnd() {
-			freePEImage();
-			removeProxyDelegates(proxyCallFixer);
-			removeInlinedMethods();
+		public override void DeobfuscateEnd() {
+			FreePEImage();
+			RemoveProxyDelegates(proxyCallFixer);
+			RemoveInlinedMethods();
 			if (options.RestoreTypes)
-				new TypesRestorer(module).deobfuscate();
+				new TypesRestorer(module).Deobfuscate();
 
-			var decrypterType = getDecrypterType();
-			if (canRemoveDecrypterType && isTypeCalled(decrypterType))
+			var decrypterType = GetDecrypterType();
+			if (canRemoveDecrypterType && IsTypeCalled(decrypterType))
 				canRemoveDecrypterType = false;
 
 			if (canRemoveDecrypterType)
-				addTypeToBeRemoved(decrypterType, "Decrypter type");
+				AddTypeToBeRemoved(decrypterType, "Decrypter type");
 			else
 				Logger.v("Could not remove decrypter type");
 
-			fixEntryPoint();
+			FixEntryPoint();
 
-			base.deobfuscateEnd();
+			base.DeobfuscateEnd();
 		}
 
-		void fixEntryPoint() {
+		void FixEntryPoint() {
 			if (!module.IsClr1x)
 				return;
 
@@ -604,13 +604,13 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			ep.Parameters.UpdateParameterTypes();
 		}
 
-		void removeInlinedMethods() {
+		void RemoveInlinedMethods() {
 			if (!options.InlineMethods || !options.RemoveInlinedMethods)
 				return;
-			findAndRemoveInlinedMethods();
+			FindAndRemoveInlinedMethods();
 		}
 
-		public override IEnumerable<int> getStringDecrypterMethods() {
+		public override IEnumerable<int> GetStringDecrypterMethods() {
 			var list = new List<int>();
 			foreach (var info in stringDecrypter.DecrypterInfos)
 				list.Add(info.method.MDToken.ToInt32());
@@ -629,18 +629,18 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				break;
 
 			case ModuleWriterEvent.MDBeginAddResources:
-				methodsDecrypter.prepareEncryptNativeMethods(writer);
+				methodsDecrypter.PrepareEncryptNativeMethods(writer);
 				break;
 
 			case ModuleWriterEvent.BeginWriteChunks:
-				methodsDecrypter.encryptNativeMethods(writer);
+				methodsDecrypter.EncryptNativeMethods(writer);
 				break;
 			}
 		}
 
 		protected override void Dispose(bool disposing) {
 			if (disposing)
-				freePEImage();
+				FreePEImage();
 			base.Dispose(disposing);
 		}
 	}
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v4/EmptyClass.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v4/EmptyClass.cs
index db9979cc..61b23bf3 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v4/EmptyClass.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v4/EmptyClass.cs
@@ -36,10 +36,10 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 
 		public EmptyClass(ModuleDefMD module) {
 			this.module = module;
-			init();
+			Initialize();
 		}
 
-		void init() {
+		void Initialize() {
 			var callCounter = new CallCounter();
 			int count = 0;
 			foreach (var type in module.GetTypes()) {
@@ -48,13 +48,13 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				foreach (var method in type.Methods) {
 					if (method.Name != ".ctor" && method.Name != ".cctor" && module.EntryPoint != method)
 						continue;
-					foreach (var calledMethod in DotNetUtils.getCalledMethods(module, method)) {
+					foreach (var calledMethod in DotNetUtils.GetCalledMethods(module, method)) {
 						if (!calledMethod.IsStatic || calledMethod.Body == null)
 							continue;
-						if (!DotNetUtils.isMethod(calledMethod, "System.Void", "()"))
+						if (!DotNetUtils.IsMethod(calledMethod, "System.Void", "()"))
 							continue;
-						if (isEmptyClass(calledMethod)) {
-							callCounter.add(calledMethod);
+						if (IsEmptyClass(calledMethod)) {
+							callCounter.Add(calledMethod);
 							count++;
 						}
 					}
@@ -62,13 +62,13 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			}
 
 			int numCalls;
-			var theMethod = (MethodDef)callCounter.most(out numCalls);
+			var theMethod = (MethodDef)callCounter.Most(out numCalls);
 			if (numCalls >= 10)
 				emptyMethod = theMethod;
 		}
 
-		bool isEmptyClass(MethodDef emptyMethod) {
-			if (!DotNetUtils.isEmptyObfuscated(emptyMethod))
+		bool IsEmptyClass(MethodDef emptyMethod) {
+			if (!DotNetUtils.IsEmptyObfuscated(emptyMethod))
 				return false;
 
 			var type = emptyMethod.DeclaringType;
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v4/EncryptedResource.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v4/EncryptedResource.cs
index 5ab9ecdf..c9f59963 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v4/EncryptedResource.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v4/EncryptedResource.cs
@@ -55,9 +55,9 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 
 		public EncryptedResource(ModuleDefMD module, EncryptedResource oldOne) {
 			this.module = module;
-			resourceDecrypterMethod = lookup(oldOne.resourceDecrypterMethod, "Could not find resource decrypter method");
+			resourceDecrypterMethod = Lookup(oldOne.resourceDecrypterMethod, "Could not find resource decrypter method");
 			if (oldOne.encryptedDataResource != null)
-				encryptedDataResource = DotNetUtils.getResource(module, oldOne.encryptedDataResource.Name.String) 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 : class, ICodedToken {
-			return DeobUtils.lookup(module, def, errorMessage);
+		T Lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
+			return DeobUtils.Lookup(module, def, errorMessage);
 		}
 
-		public bool couldBeResourceDecrypter(MethodDef method, IEnumerable<string> additionalTypes) {
-			return couldBeResourceDecrypter(method, additionalTypes, true);
+		public bool CouldBeResourceDecrypter(MethodDef method, IEnumerable<string> additionalTypes) {
+			return CouldBeResourceDecrypter(method, additionalTypes, true);
 		}
 
-		public bool couldBeResourceDecrypter(MethodDef 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)
@@ -88,37 +88,37 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				"System.Security.Cryptography.ICryptoTransform",
 			};
 			requiredTypes.AddRange(additionalTypes);
-			if (!localTypes.all(requiredTypes))
+			if (!localTypes.All(requiredTypes))
 				return false;
-			if (!localTypes.exists("System.Security.Cryptography.RijndaelManaged") &&
-				!localTypes.exists("System.Security.Cryptography.AesManaged"))
+			if (!localTypes.Exists("System.Security.Cryptography.RijndaelManaged") &&
+				!localTypes.Exists("System.Security.Cryptography.AesManaged"))
 				return false;
 
-			if (checkResource && findMethodsDecrypterResource(method) == null)
+			if (checkResource && FindMethodsDecrypterResource(method) == null)
 				return false;
 
 			return true;
 		}
 
-		public void init(ISimpleDeobfuscator simpleDeobfuscator) {
+		public void Initialize(ISimpleDeobfuscator simpleDeobfuscator) {
 			if (resourceDecrypterMethod == null)
 				return;
 
-			simpleDeobfuscator.deobfuscate(resourceDecrypterMethod);
+			simpleDeobfuscator.Deobfuscate(resourceDecrypterMethod);
 
-			encryptedDataResource = findMethodsDecrypterResource(resourceDecrypterMethod);
+			encryptedDataResource = FindMethodsDecrypterResource(resourceDecrypterMethod);
 			if (encryptedDataResource == null)
 				return;
 
-			key = ArrayFinder.getInitializedByteArray(resourceDecrypterMethod, 32);
+			key = ArrayFinder.GetInitializedByteArray(resourceDecrypterMethod, 32);
 			if (key == null)
 				throw new ApplicationException("Could not find resource decrypter key");
-			iv = ArrayFinder.getInitializedByteArray(resourceDecrypterMethod, 16);
+			iv = ArrayFinder.GetInitializedByteArray(resourceDecrypterMethod, 16);
 			if (iv == null)
 				throw new ApplicationException("Could not find resource decrypter IV");
-			if (needReverse())
+			if (NeedReverse())
 				Array.Reverse(iv);	// DNR 4.5.0.0
-			if (usesPublicKeyToken()) {
+			if (UsesPublicKeyToken()) {
 				var publicKeyToken = module.Assembly.PublicKeyToken;
 				if (publicKeyToken != null && publicKeyToken.Data.Length > 0) {
 					for (int i = 0; i < 8; i++)
@@ -128,7 +128,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 		}
 
 		static int[] pktIndexes = new int[16] { 1, 0, 3, 1, 5, 2, 7, 3, 9, 4, 11, 5, 13, 6, 15, 7 };
-		bool usesPublicKeyToken() {
+		bool UsesPublicKeyToken() {
 			int pktIndex = 0;
 			foreach (var instr in resourceDecrypterMethod.Body.Instructions) {
 				if (instr.OpCode.FlowControl != FlowControl.Next) {
@@ -148,27 +148,27 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			return false;
 		}
 
-		bool needReverse() {
-			return DotNetUtils.callsMethod(resourceDecrypterMethod, "System.Void System.Array::Reverse(System.Array)");
+		bool NeedReverse() {
+			return DotNetUtils.CallsMethod(resourceDecrypterMethod, "System.Void System.Array::Reverse(System.Array)");
 		}
 
-		EmbeddedResource findMethodsDecrypterResource(MethodDef method) {
-			foreach (var s in DotNetUtils.getCodeStrings(method)) {
-				var resource = DotNetUtils.getResource(module, s) as EmbeddedResource;
+		EmbeddedResource FindMethodsDecrypterResource(MethodDef method) {
+			foreach (var s in DotNetUtils.GetCodeStrings(method)) {
+				var resource = DotNetUtils.GetResource(module, s) as EmbeddedResource;
 				if (resource != null)
 					return resource;
 			}
 			return null;
 		}
 
-		public byte[] decrypt() {
+		public byte[] Decrypt() {
 			if (encryptedDataResource == null || key == null || iv == null)
 				throw new ApplicationException("Can't decrypt resource");
 
-			return DeobUtils.aesDecrypt(encryptedDataResource.GetResourceData(), key, iv);
+			return DeobUtils.AesDecrypt(encryptedDataResource.GetResourceData(), key, iv);
 		}
 
-		public byte[] encrypt(byte[] data) {
+		public byte[] Encrypt(byte[] data) {
 			if (key == null || iv == null)
 				throw new ApplicationException("Can't encrypt resource");
 
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v4/MetadataTokenObfuscator.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v4/MetadataTokenObfuscator.cs
index 55e4dfdf..4ee649ef 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v4/MetadataTokenObfuscator.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v4/MetadataTokenObfuscator.cs
@@ -36,10 +36,10 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 
 		public MetadataTokenObfuscator(ModuleDefMD module) {
 			this.module = module;
-			find();
+			Find();
 		}
 
-		void find() {
+		void Find() {
 			foreach (var type in module.Types) {
 				var fields = type.Fields;
 				if (fields.Count != 1)
@@ -72,11 +72,11 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			}
 		}
 
-		public void deobfuscate(Blocks blocks) {
+		public void Deobfuscate(Blocks blocks) {
 			if (type == null)
 				return;
 
-			foreach (var block in blocks.MethodBlocks.getAllBlocks()) {
+			foreach (var block in blocks.MethodBlocks.GetAllBlocks()) {
 				var instrs = block.Instructions;
 				for (int i = 0; i < instrs.Count - 1; i++) {
 					var instr = instrs[i];
@@ -90,7 +90,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 						continue;
 					if (!new SigComparer().Equals(type, method.DeclaringType))
 						continue;
-					var methodDef = DotNetUtils.getMethod(module, method);
+					var methodDef = DotNetUtils.GetMethod(module, method);
 					if (methodDef == null)
 						continue;
 					if (methodDef != typeMethod && methodDef != fieldMethod)
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v4/MethodsDecrypter.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v4/MethodsDecrypter.cs
index 5e3eeba7..8d538834 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v4/MethodsDecrypter.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v4/MethodsDecrypter.cs
@@ -70,7 +70,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			this.xorKey = oldOne.xorKey;
 		}
 
-		public void find() {
+		public void Find() {
 			var additionalTypes = new string[] {
 				"System.IntPtr",
 //				"System.Reflection.Assembly",		//TODO: Not in unknown DNR version with jitter support
@@ -85,27 +85,27 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				if (typesLeft-- <= 0)
 					break;
 
-				foreach (var method in DotNetUtils.getCalledMethods(module, cctor)) {
+				foreach (var method in DotNetUtils.GetCalledMethods(module, cctor)) {
 					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", "()"))
+						if (!DotNetUtils.IsMethod(method, "System.Void", "()"))
 							continue;
-						if (!encryptedResource.couldBeResourceDecrypter(method, additionalTypes))
+						if (!encryptedResource.CouldBeResourceDecrypter(method, additionalTypes))
 							continue;
 						checkedMethods[method] = true;
 					}
 					else if (!checkedMethods[method])
 						continue;
-					callCounter.add(method);
+					callCounter.Add(method);
 				}
 			}
 
-			encryptedResource.Method = (MethodDef)callCounter.most();
+			encryptedResource.Method = (MethodDef)callCounter.Most();
 		}
 
-		void xorEncrypt(byte[] data) {
+		void XorEncrypt(byte[] data) {
 			if (xorKey == 0)
 				return;
 
@@ -123,19 +123,19 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 
 		static short[] nativeLdci4 = new short[] { 0x55, 0x8B, 0xEC, 0xB8, -1, -1, -1, -1, 0x5D, 0xC3 };
 		static short[] nativeLdci4_0 = new short[] { 0x55, 0x8B, 0xEC, 0x33, 0xC0, 0x5D, 0xC3 };
-		public bool decrypt(MyPEImage peImage, ISimpleDeobfuscator simpleDeobfuscator, ref DumpedMethods dumpedMethods, Dictionary<uint, byte[]> tokenToNativeCode, bool unpackedNativeFile) {
+		public bool Decrypt(MyPEImage peImage, ISimpleDeobfuscator simpleDeobfuscator, ref DumpedMethods dumpedMethods, Dictionary<uint, byte[]> tokenToNativeCode, bool unpackedNativeFile) {
 			if (encryptedResource.Method == null)
 				return false;
 
-			encryptedResource.init(simpleDeobfuscator);
+			encryptedResource.Initialize(simpleDeobfuscator);
 			if (!encryptedResource.FoundResource)
 				return false;
-			var methodsData = encryptedResource.decrypt();
+			var methodsData = encryptedResource.Decrypt();
 
-			bool hooksJitter = findDnrCompileMethod(encryptedResource.Method.DeclaringType) != null;
+			bool hooksJitter = FindDnrCompileMethod(encryptedResource.Method.DeclaringType) != null;
 
-			xorKey = getXorKey();
-			xorEncrypt(methodsData);
+			xorKey = GetXorKey();
+			XorEncrypt(methodsData);
 
 			var methodsDataReader = MemoryImageStream.Create(methodsData);
 			int patchCount = methodsDataReader.ReadInt32();
@@ -149,11 +149,11 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				patchCount = methodsDataReader.ReadInt32();
 				mode = methodsDataReader.ReadInt32();
 
-				patchDwords(peImage, methodsDataReader, patchCount);
+				PatchDwords(peImage, methodsDataReader, patchCount);
 				while (methodsDataReader.Position < methodsData.Length - 1) {
 					uint token = methodsDataReader.ReadUInt32();
 					int numDwords = methodsDataReader.ReadInt32();
-					patchDwords(peImage, methodsDataReader, numDwords / 2);
+					PatchDwords(peImage, methodsDataReader, numDwords / 2);
 				}
 			}
 			else if (!hooksJitter || mode == 1) {
@@ -162,7 +162,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				// If it's .NET 1.x, then offsets are used, not RVAs.
 				bool useOffsets = unpackedNativeFile && module.IsClr1x;
 
-				patchDwords(peImage, methodsDataReader, patchCount);
+				PatchDwords(peImage, methodsDataReader, patchCount);
 				while (methodsDataReader.Position < methodsData.Length - 1) {
 					uint rva = methodsDataReader.ReadUInt32();
 					uint token = methodsDataReader.ReadUInt32();	// token, unknown, or index
@@ -170,9 +170,9 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 					if (size > 0) {
 						var newData = methodsDataReader.ReadBytes(size);
 						if (useOffsets)
-							peImage.dotNetSafeWriteOffset(rva, newData);
+							peImage.DotNetSafeWriteOffset(rva, newData);
 						else
-							peImage.dotNetSafeWrite(rva, newData);
+							peImage.DotNetSafeWrite(rva, newData);
 					}
 				}
 			}
@@ -183,19 +183,19 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				var rvaToIndex = new Dictionary<uint, int>((int)methodDef.Rows);
 				uint offset = (uint)methodDef.StartOffset;
 				for (int i = 0; i < methodDef.Rows; i++) {
-					uint rva = peImage.offsetReadUInt32(offset);
+					uint rva = peImage.OffsetReadUInt32(offset);
 					offset += methodDef.RowSize;
 					if (rva == 0)
 						continue;
 
-					if ((peImage.readByte(rva) & 3) == 2)
+					if ((peImage.ReadByte(rva) & 3) == 2)
 						rva++;
 					else
-						rva += (uint)(4 * (peImage.readByte(rva + 1) >> 4));
+						rva += (uint)(4 * (peImage.ReadByte(rva + 1) >> 4));
 					rvaToIndex[rva] = i;
 				}
 
-				patchDwords(peImage, methodsDataReader, patchCount);
+				PatchDwords(peImage, methodsDataReader, patchCount);
 				int count = methodsDataReader.ReadInt32();
 				dumpedMethods = new DumpedMethods();
 				while (methodsDataReader.Position < methodsData.Length - 1) {
@@ -220,7 +220,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 
 						// Convert return true / false methods. The others are converted to
 						// throw 0xDEADCODE.
-						if (DeobUtils.isCode(nativeLdci4, methodData)) {
+						if (DeobUtils.IsCode(nativeLdci4, methodData)) {
 							uint val = BitConverter.ToUInt32(methodData, 4);
 							// ldc.i4 XXXXXXXXh / ret
 							methodData = new byte[] { 0x20, 0, 0, 0, 0, 0x2A };
@@ -229,7 +229,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 							methodData[3] = (byte)(val >> 16);
 							methodData[4] = (byte)(val >> 24);
 						}
-						else if (DeobUtils.isCode(nativeLdci4_0, methodData)) {
+						else if (DeobUtils.IsCode(nativeLdci4_0, methodData)) {
 							// ldc.i4.0 / ret
 							methodData = new byte[] { 0x16, 0x2A };
 						}
@@ -242,31 +242,31 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 					}
 
 					var dm = new DumpedMethod();
-					peImage.readMethodTableRowTo(dm, MDToken.ToRID(methodToken));
+					peImage.ReadMethodTableRowTo(dm, MDToken.ToRID(methodToken));
 					dm.code = methodData;
 
 					var codeReader = peImage.Reader;
-					codeReader.Position = peImage.rvaToOffset(dm.mdRVA);
+					codeReader.Position = peImage.RvaToOffset(dm.mdRVA);
 					byte[] code;
-					var mbHeader = MethodBodyParser.parseMethodBody(codeReader, out code, out dm.extraSections);
-					peImage.updateMethodHeaderInfo(dm, mbHeader);
+					var mbHeader = MethodBodyParser.ParseMethodBody(codeReader, out code, out dm.extraSections);
+					peImage.UpdateMethodHeaderInfo(dm, mbHeader);
 
-					dumpedMethods.add(dm);
+					dumpedMethods.Add(dm);
 				}
 			}
 
 			return true;
 		}
 
-		static void patchDwords(MyPEImage peImage, IBinaryReader reader, int count) {
+		static void PatchDwords(MyPEImage peImage, IBinaryReader reader, int count) {
 			for (int i = 0; i < count; i++) {
 				uint rva = reader.ReadUInt32();
 				uint data = reader.ReadUInt32();
-				peImage.dotNetSafeWrite(rva, BitConverter.GetBytes(data));
+				peImage.DotNetSafeWrite(rva, BitConverter.GetBytes(data));
 			}
 		}
 
-		long getXorKey() {
+		long GetXorKey() {
 			var instructions = encryptedResource.Method.Body.Instructions;
 			for (int i = 0; i < instructions.Count - 1; i++) {
 				if (instructions[i].OpCode.Code != Code.Ldind_I8)
@@ -280,7 +280,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			return 0;
 		}
 
-		public void reloaded() {
+		public void Reloaded() {
 			foreach (var pair in tokenToNativeMethod) {
 				int token = (int)pair.Key;
 				var method = module.ResolveToken(token) as MethodDef;
@@ -291,7 +291,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			tokenToNativeMethod = null;
 		}
 
-		public void prepareEncryptNativeMethods(ModuleWriterBase moduleWriter) {
+		public void PrepareEncryptNativeMethods(ModuleWriterBase moduleWriter) {
 			if (methodToNativeMethod.Count == 0)
 				return;
 
@@ -312,7 +312,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			encryptedResource.Resource.Data = MemoryImageStream.Create(new byte[len]);
 		}
 
-		public void encryptNativeMethods(ModuleWriterBase moduleWriter) {
+		public void EncryptNativeMethods(ModuleWriterBase moduleWriter) {
 			if (validNativeMethods == null || validNativeMethods.Count == 0)
 				return;
 
@@ -355,22 +355,22 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			var resourceData = resourceChunk.Data;
 
 			var encrypted = stream.ToArray();
-			xorEncrypt(encrypted);
+			XorEncrypt(encrypted);
 
-			encrypted = encryptedResource.encrypt(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 MethodDef findDnrCompileMethod(TypeDef type) {
+		public static MethodDef FindDnrCompileMethod(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (!method.IsStatic || method.Body == null)
 					continue;
 				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&)"))
+				if (!DotNetUtils.IsMethod(method, "System.UInt32", "(System.UInt64&,System.IntPtr,System.IntPtr,System.UInt32,System.IntPtr&,System.UInt32&)"))
 					continue;
 				return method;
 			}
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v4/NativeFileDecrypter.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v4/NativeFileDecrypter.cs
index 84c898df..d809b161 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v4/NativeFileDecrypter.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v4/NativeFileDecrypter.cs
@@ -82,7 +82,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			}
 		}
 
-		public void decrypt(byte[] data, int offset, int count) {
+		public void Decrypt(byte[] data, int offset, int count) {
 			for (int i = 0; i < count; i += 1024, offset += 1024) {
 				int blockLen = Math.Min(1024, count - i);
 
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v4/NativeImageUnpacker.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v4/NativeImageUnpacker.cs
index 215d750f..1edb590a 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v4/NativeImageUnpacker.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v4/NativeImageUnpacker.cs
@@ -34,7 +34,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			this.peImage = new MyPEImage(peImage);
 		}
 
-		public byte[] unpack() {
+		public byte[] Unpack() {
 			if (peImage.PEImage.Win32Resources == null)
 				return null;
 			var dataEntry = peImage.PEImage.Win32Resources.Find(10, "__", 0);
@@ -43,15 +43,15 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 
 			var encryptedData = dataEntry.Data.ReadAllBytes();
 
-			var keyData = getKeyData();
+			var keyData = GetKeyData();
 			if (keyData == null)
 				return null;
 			var decrypter = new NativeFileDecrypter(keyData);
-			decrypter.decrypt(encryptedData, 0, encryptedData.Length);
+			decrypter.Decrypt(encryptedData, 0, encryptedData.Length);
 
 			byte[] inflatedData;
 			if (isNet1x)
-				inflatedData = DeobUtils.inflate(encryptedData, false);
+				inflatedData = DeobUtils.Inflate(encryptedData, false);
 			else {
 				int inflatedSize = BitConverter.ToInt32(encryptedData, 0);
 				inflatedData = new byte[inflatedSize];
@@ -68,12 +68,12 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 
 			// DNR v4.5
 			if (BitConverter.ToInt16(inflatedData, loaderHeaderSizeV45) == 0x5A4D)
-				return unpackLoader(inflatedData);
+				return UnpackLoader(inflatedData);
 
 			return null;
 		}
 
-		static byte[] unpackLoader(byte[] loaderData) {
+		static byte[] UnpackLoader(byte[] loaderData) {
 			var loaderBytes = new byte[loaderData.Length - loaderHeaderSizeV45];
 			Array.Copy(loaderData, loaderHeaderSizeV45, loaderBytes, 0, loaderBytes.Length);
 
@@ -126,16 +126,16 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			/* 12 */ 0xB8, -1, -1, -1, -1,		// mov     eax, offset XXXXXXXX
 			/* 17 */ 0xE8, -1, -1, -1, -1,		// call    YYYYYYYY
 		};
-		byte[] getKeyData() {
+		byte[] GetKeyData() {
 			isNet1x = false;
 			for (int i = 0; i < baseOffsets.Length; i++) {
-				var code = peImage.offsetReadBytes(baseOffsets[i], decryptMethodPattern.Length);
-				if (DeobUtils.isCode(decryptMethodPattern, code))
-					return getKeyData(baseOffsets[i]);
+				var code = peImage.OffsetReadBytes(baseOffsets[i], decryptMethodPattern.Length);
+				if (DeobUtils.IsCode(decryptMethodPattern, code))
+					return GetKeyData(baseOffsets[i]);
 			}
 
-			var net1xCode = peImage.offsetReadBytes(0x207E0, startMethodNet1xPattern.Length);
-			if (DeobUtils.isCode(startMethodNet1xPattern, net1xCode)) {
+			var net1xCode = peImage.OffsetReadBytes(0x207E0, startMethodNet1xPattern.Length);
+			if (DeobUtils.IsCode(startMethodNet1xPattern, net1xCode)) {
 				isNet1x = true;
 				return new byte[6] { 0x34, 0x38, 0x63, 0x65, 0x7A, 0x35 };
 			}
@@ -143,14 +143,14 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			return null;
 		}
 
-		byte[] getKeyData(uint baseOffset) {
+		byte[] GetKeyData(uint baseOffset) {
 			return new byte[6] {
-				peImage.offsetReadByte(baseOffset + 5),
-				peImage.offsetReadByte(baseOffset + 0xF),
-				peImage.offsetReadByte(baseOffset + 0x58),
-				peImage.offsetReadByte(baseOffset + 0x6D),
-				peImage.offsetReadByte(baseOffset + 0x98),
-				peImage.offsetReadByte(baseOffset + 0xA6),
+				peImage.OffsetReadByte(baseOffset + 5),
+				peImage.OffsetReadByte(baseOffset + 0xF),
+				peImage.OffsetReadByte(baseOffset + 0x58),
+				peImage.OffsetReadByte(baseOffset + 0x6D),
+				peImage.OffsetReadByte(baseOffset + 0x98),
+				peImage.OffsetReadByte(baseOffset + 0xA6),
 			};
 		}
 	}
diff --git a/de4dot.code/deobfuscators/dotNET_Reactor/v4/ProxyCallFixer.cs b/de4dot.code/deobfuscators/dotNET_Reactor/v4/ProxyCallFixer.cs
index e0730eaf..88d9321c 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v4/ProxyCallFixer.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v4/ProxyCallFixer.cs
@@ -30,13 +30,13 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			this.simpleDeobfuscator = simpleDeobfuscator;
 		}
 
-		public void findDelegateCreator() {
+		public void FindDelegateCreator() {
 			foreach (var type in module.Types) {
-				var creatorMethod = checkType(type);
+				var creatorMethod = CheckType(type);
 				if (creatorMethod == null)
 					continue;
 
-				setDelegateCreatorMethod(creatorMethod);
+				SetDelegateCreatorMethod(creatorMethod);
 				return;
 			}
 		}
@@ -44,36 +44,36 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 		static readonly string[] requiredFields = new string[] {
 			"System.Reflection.Module",
 		};
-		static MethodDef checkType(TypeDef type) {
-			if (!new FieldTypes(type).exactly(requiredFields))
+		static MethodDef CheckType(TypeDef type) {
+			if (!new FieldTypes(type).Exactly(requiredFields))
 				return null;
 			if (type.FindStaticConstructor() == null)
 				return null;
 
-			return checkMethods(type);
+			return CheckMethods(type);
 		}
 
-		static MethodDef checkMethods(TypeDef type) {
+		static MethodDef CheckMethods(TypeDef type) {
 			MethodDef creatorMethod = null;
 			foreach (var method in type.Methods) {
 				if (method.Body == null)
 					return null;
 				if (method.Name == ".cctor" || method.Name == ".ctor")
 					continue;
-				if (!DotNetUtils.isMethod(method, "System.Void", "(System.Int32)"))
+				if (!DotNetUtils.IsMethod(method, "System.Void", "(System.Int32)"))
 					return null;
-				if (!DeobUtils.hasInteger(method, 0x02000000))
+				if (!DeobUtils.HasInteger(method, 0x02000000))
 					return null;
-				if (!DeobUtils.hasInteger(method, 0x06000000))
+				if (!DeobUtils.HasInteger(method, 0x06000000))
 					return null;
 				creatorMethod = method;
 			}
 			return creatorMethod;
 		}
 
-		protected override object checkCctor(ref TypeDef type, MethodDef cctor) {
-			simpleDeobfuscator.deobfuscate(cctor);
-			var realType = getDelegateType(cctor);
+		protected override object CheckCctor(ref TypeDef type, MethodDef cctor) {
+			simpleDeobfuscator.Deobfuscate(cctor);
+			var realType = GetDelegateType(cctor);
 			if (realType == null)
 				return null;
 			type = realType;
@@ -81,7 +81,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			return this;
 		}
 
-		TypeDef getDelegateType(MethodDef method) {
+		TypeDef GetDelegateType(MethodDef method) {
 			var instrs = method.Body.Instructions;
 			for (int i = 0; i < instrs.Count - 1; i++) {
 				var ldci4 = instrs[i];
@@ -92,7 +92,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				if (call.OpCode.Code != Code.Call)
 					continue;
 				var calledMethod = call.Operand as MethodDef;
-				if (calledMethod == null || !isDelegateCreatorMethod(calledMethod))
+				if (calledMethod == null || !IsDelegateCreatorMethod(calledMethod))
 					continue;
 
 				return module.ResolveToken(0x02000000 + ldci4.GetLdcI4Value()) as TypeDef;
@@ -100,7 +100,7 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			return null;
 		}
 
-		protected override void getCallInfo(object context, FieldDef field, out IMethod calledMethod, out OpCode callOpcode) {
+		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 197bab3e..11a03668 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v4/ResourceResolver.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v4/ResourceResolver.cs
@@ -55,22 +55,22 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			this.encryptedResource = new EncryptedResource(module, oldOne.encryptedResource);
 		}
 
-		public void find(ISimpleDeobfuscator simpleDeobfuscator) {
+		public void Find(ISimpleDeobfuscator simpleDeobfuscator) {
 			var additionalTypes = new string[] {
 				"System.String",
 			};
 			foreach (var type in module.Types) {
 				if (type.BaseType == null || type.BaseType.FullName != "System.Object")
 					continue;
-				if (!checkFields(type.Fields))
+				if (!CheckFields(type.Fields))
 					continue;
 				foreach (var method in type.Methods) {
 					if (!method.IsStatic || !method.HasBody)
 						continue;
-					if (!DotNetUtils.isMethod(method, "System.Reflection.Assembly", "(System.Object,System.ResolveEventArgs)") &&
-						!DotNetUtils.isMethod(method, "System.Reflection.Assembly", "(System.Object,System.Object)"))
+					if (!DotNetUtils.IsMethod(method, "System.Reflection.Assembly", "(System.Object,System.ResolveEventArgs)") &&
+						!DotNetUtils.IsMethod(method, "System.Reflection.Assembly", "(System.Object,System.Object)"))
 						continue;
-					if (!encryptedResource.couldBeResourceDecrypter(method, additionalTypes, false))
+					if (!encryptedResource.CouldBeResourceDecrypter(method, additionalTypes, false))
 						continue;
 
 					encryptedResource.Method = method;
@@ -79,43 +79,43 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			}
 		}
 
-		bool checkFields(IList<FieldDef> fields) {
+		bool CheckFields(IList<FieldDef> fields) {
 			if (fields.Count != 3)
 				return false;
 
 			var fieldTypes = new FieldTypes(fields);
-			if (fieldTypes.count("System.Boolean") != 1)
+			if (fieldTypes.Count("System.Boolean") != 1)
 				return false;
-			if (fieldTypes.count("System.Object") == 2)
+			if (fieldTypes.Count("System.Object") == 2)
 				return true;
-			return fieldTypes.count("System.Reflection.Assembly") == 1 &&
-				fieldTypes.count("System.String[]") == 1;
+			return fieldTypes.Count("System.Reflection.Assembly") == 1 &&
+				fieldTypes.Count("System.String[]") == 1;
 		}
 
-		public void init(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
+		public void Initialize(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) {
 			if (encryptedResource.Method == null)
 				return;
 
-			initMethod = findInitMethod(simpleDeobfuscator);
+			initMethod = FindInitMethod(simpleDeobfuscator);
 			if (initMethod == null)
 				throw new ApplicationException("Could not find resource resolver init method");
 
-			simpleDeobfuscator.deobfuscate(encryptedResource.Method);
-			simpleDeobfuscator.decryptStrings(encryptedResource.Method, deob);
-			encryptedResource.init(simpleDeobfuscator);
+			simpleDeobfuscator.Deobfuscate(encryptedResource.Method);
+			simpleDeobfuscator.DecryptStrings(encryptedResource.Method, deob);
+			encryptedResource.Initialize(simpleDeobfuscator);
 		}
 
-		MethodDef findInitMethod(ISimpleDeobfuscator simpleDeobfuscator) {
+		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", "()"))
+				if (!DotNetUtils.IsMethod(method, "System.Void", "()"))
 					continue;
 				if (method.Body.Variables.Count > 1)
 					continue;
 
-				simpleDeobfuscator.deobfuscate(method);
+				simpleDeobfuscator.Deobfuscate(method);
 				bool stsfldUsed = false, newobjUsed = false;
 				foreach (var instr in method.Body.Instructions) {
 					if (instr.OpCode.Code == Code.Stsfld) {
@@ -143,11 +143,11 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			return null;
 		}
 
-		public EmbeddedResource mergeResources() {
+		public EmbeddedResource MergeResources() {
 			if (encryptedResource.Resource == null)
 				return null;
-			DeobUtils.decryptAndAddResources(module, encryptedResource.Resource.Name.String, () => {
-				return QuickLZ.decompress(encryptedResource.decrypt());
+			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 c67edc9a..0b53ff8b 100644
--- a/de4dot.code/deobfuscators/dotNET_Reactor/v4/StringDecrypter.cs
+++ b/de4dot.code/deobfuscators/dotNET_Reactor/v4/StringDecrypter.cs
@@ -84,17 +84,17 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			this.stringDecrypterVersion = oldOne.stringDecrypterVersion;
 			this.encryptedResource = new EncryptedResource(module, oldOne.encryptedResource);
 			foreach (var oldInfo in oldOne.decrypterInfos) {
-				var method = lookup(oldInfo.method, "Could not find string decrypter method");
+				var method = Lookup(oldInfo.method, "Could not find string decrypter method");
 				decrypterInfos.Add(new DecrypterInfo(method, oldInfo.key, oldInfo.iv));
 			}
-			otherStringDecrypter = lookup(oldOne.otherStringDecrypter, "Could not find string decrypter method");
+			otherStringDecrypter = Lookup(oldOne.otherStringDecrypter, "Could not find string decrypter method");
 		}
 
-		T lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
-			return DeobUtils.lookup(module, def, errorMessage);
+		T Lookup<T>(T def, string errorMessage) where T : class, ICodedToken {
+			return DeobUtils.Lookup(module, def, errorMessage);
 		}
 
-		public void find(ISimpleDeobfuscator simpleDeobfuscator) {
+		public void Find(ISimpleDeobfuscator simpleDeobfuscator) {
 			var additionalTypes = new string[] {
 				"System.String",
 			};
@@ -107,12 +107,12 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				foreach (var method in type.Methods) {
 					if (!method.IsStatic || !method.HasBody)
 						continue;
-					if (!DotNetUtils.isMethod(method, "System.String", "(System.Int32)"))
+					if (!DotNetUtils.IsMethod(method, "System.String", "(System.Int32)"))
 						continue;
-					if (!encryptedResource.couldBeResourceDecrypter(method, additionalTypes))
+					if (!encryptedResource.CouldBeResourceDecrypter(method, additionalTypes))
 						continue;
 
-					var resource = DotNetUtils.getResource(module, DotNetUtils.getCodeStrings(method)) as EmbeddedResource;
+					var resource = DotNetUtils.GetResource(module, DotNetUtils.GetCodeStrings(method)) as EmbeddedResource;
 					if (resource == null)
 						throw new ApplicationException("Could not find strings resource");
 					if (stringsResource != null && stringsResource != resource)
@@ -122,18 +122,18 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 					encryptedResource.Method = method;
 
 					var info = new DecrypterInfo(method, null, null);
-					simpleDeobfuscator.deobfuscate(info.method);
-					findKeyIv(info.method, out info.key, out info.iv);
+					simpleDeobfuscator.Deobfuscate(info.method);
+					FindKeyIv(info.method, out info.key, out info.iv);
 
 					decrypterInfos.Add(info);
 				}
 			}
 
 			if (decrypterInfos.Count > 0)
-				findOtherStringDecrypter(decrypterInfos[0].method.DeclaringType);
+				FindOtherStringDecrypter(decrypterInfos[0].method.DeclaringType);
 		}
 
-		void findOtherStringDecrypter(TypeDef type) {
+		void FindOtherStringDecrypter(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (!method.IsStatic || !method.HasBody)
 					continue;
@@ -153,20 +153,20 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			}
 		}
 
-		public void init(MyPEImage peImage, byte[] fileData, ISimpleDeobfuscator simpleDeobfuscator) {
+		public void Initialize(MyPEImage peImage, byte[] fileData, ISimpleDeobfuscator simpleDeobfuscator) {
 			if (encryptedResource.Method == null)
 				return;
 			this.peImage = peImage;
 			this.fileData = fileData;
 
-			encryptedResource.init(simpleDeobfuscator);
+			encryptedResource.Initialize(simpleDeobfuscator);
 			if (!encryptedResource.FoundResource)
 				return;
-			Logger.v("Adding string decrypter. Resource: {0}", Utils.toCsharpString(encryptedResource.Resource.Name));
-			decryptedData = encryptedResource.decrypt();
+			Logger.v("Adding string decrypter. Resource: {0}", Utils.ToCsharpString(encryptedResource.Resource.Name));
+			decryptedData = encryptedResource.Decrypt();
 		}
 
-		void findKeyIv(MethodDef method, out byte[] key, out byte[] iv) {
+		void FindKeyIv(MethodDef method, out byte[] key, out byte[] iv) {
 			key = null;
 			iv = null;
 
@@ -176,13 +176,13 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				"System.Security.Cryptography.CryptoStream",
 				"System.Security.Cryptography.Rijndael",
 			};
-			foreach (var calledMethod in DotNetUtils.getCalledMethods(module, method)) {
+			foreach (var calledMethod in DotNetUtils.GetCalledMethods(module, method)) {
 				if (calledMethod.DeclaringType != method.DeclaringType)
 					continue;
 				if (calledMethod.MethodSig.GetRetType().GetFullName() != "System.Byte[]")
 					continue;
 				var localTypes = new LocalTypes(calledMethod);
-				if (!localTypes.all(requiredTypes))
+				if (!localTypes.All(requiredTypes))
 					continue;
 
 				var instructions = calledMethod.Body.Instructions;
@@ -204,22 +204,22 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				if (newKey == null || newIv == null)
 					continue;
 
-				initializeStringDecrypterVersion(method);
+				InitializeStringDecrypterVersion(method);
 				key = newKey;
 				iv = newIv;
 				return;
 			}
 		}
 
-		void initializeStringDecrypterVersion(MethodDef method) {
+		void InitializeStringDecrypterVersion(MethodDef method) {
 			var localTypes = new LocalTypes(method);
-			if (localTypes.exists("System.IntPtr"))
+			if (localTypes.Exists("System.IntPtr"))
 				stringDecrypterVersion = StringDecrypterVersion.VER_38;
 			else
 				stringDecrypterVersion = StringDecrypterVersion.VER_37;
 		}
 
-		DecrypterInfo getDecrypterInfo(MethodDef method) {
+		DecrypterInfo GetDecrypterInfo(MethodDef method) {
 			foreach (var info in decrypterInfos) {
 				if (info.method == method)
 					return info;
@@ -227,8 +227,8 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 			throw new ApplicationException("Invalid string decrypter method");
 		}
 
-		public string decrypt(MethodDef method, int offset) {
-			var info = getDecrypterInfo(method);
+		public string Decrypt(MethodDef method, int offset) {
+			var info = GetDecrypterInfo(method);
 
 			if (info.key == null) {
 				int length = BitConverter.ToInt32(decryptedData, offset);
@@ -244,17 +244,17 @@ namespace de4dot.code.deobfuscators.dotNET_Reactor.v4 {
 				}
 				else if (stringDecrypterVersion == StringDecrypterVersion.VER_38) {
 					uint rva = BitConverter.ToUInt32(decryptedData, offset);
-					int length = peImage.readInt32(rva);
-					encryptedStringData = peImage.readBytes(rva + 4, length);
+					int length = peImage.ReadInt32(rva);
+					encryptedStringData = peImage.ReadBytes(rva + 4, length);
 				}
 				else
 					throw new ApplicationException("Unknown string decrypter version");
 
-				return Encoding.Unicode.GetString(DeobUtils.aesDecrypt(encryptedStringData, info.key, info.iv));
+				return Encoding.Unicode.GetString(DeobUtils.AesDecrypt(encryptedStringData, info.key, info.iv));
 			}
 		}
 
-		public string decrypt(string s) {
+		public string Decrypt(string s) {
 			return Encoding.Unicode.GetString(Convert.FromBase64String(s));
 		}
 	}
diff --git a/de4dot.code/renamer/DerivedFrom.cs b/de4dot.code/renamer/DerivedFrom.cs
index 41e00cb5..177b40a8 100644
--- a/de4dot.code/renamer/DerivedFrom.cs
+++ b/de4dot.code/renamer/DerivedFrom.cs
@@ -27,19 +27,19 @@ namespace de4dot.code.renamer {
 		Dictionary<MTypeDef, bool> results = new Dictionary<MTypeDef, bool>();
 
 		public DerivedFrom(string className) {
-			addName(className);
+			AddName(className);
 		}
 
 		public DerivedFrom(string[] classNames) {
 			foreach (var className in classNames)
-				addName(className);
+				AddName(className);
 		}
 
-		void addName(string className) {
+		void AddName(string className) {
 			classNames[className] = true;
 		}
 
-		public bool check(MTypeDef type) {
+		public bool Check(MTypeDef type) {
 			if (results.ContainsKey(type))
 				return results[type];
 
@@ -53,7 +53,7 @@ namespace de4dot.code.renamer {
 					val = false;
 			}
 			else
-				val = check(type.baseType.typeDef);
+				val = Check(type.baseType.typeDef);
 
 			results[type] = val;
 			return val;
diff --git a/de4dot.code/renamer/ExistingNames.cs b/de4dot.code/renamer/ExistingNames.cs
index 6081a7d0..167a89e9 100644
--- a/de4dot.code/renamer/ExistingNames.cs
+++ b/de4dot.code/renamer/ExistingNames.cs
@@ -25,34 +25,34 @@ namespace de4dot.code.renamer {
 	class ExistingNames {
 		Dictionary<string, bool> allNames = new Dictionary<string, bool>(StringComparer.Ordinal);
 
-		public void add(string name) {
+		public void Add(string name) {
 			allNames[name] = true;
 		}
 
-		public bool exists(string name) {
+		public bool Exists(string name) {
 			return allNames.ContainsKey(name);
 		}
 
-		public string getName(UTF8String oldName, INameCreator nameCreator) {
-			return getName(UTF8String.ToSystemStringOrEmpty(oldName), nameCreator);
+		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(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(UTF8String oldName, Func<string> createNewName) {
+			return GetName(UTF8String.ToSystemStringOrEmpty(oldName), createNewName);
 		}
 
-		public string getName(string oldName, Func<string> createNewName) {
+		public string GetName(string oldName, Func<string> createNewName) {
 			string prevName = null;
 			while (true) {
 				var name = createNewName();
 				if (name == prevName)
-					throw new ApplicationException(string.Format("Could not rename symbol to {0}", Utils.toCsharpString(name)));
+					throw new ApplicationException(string.Format("Could not rename symbol to {0}", Utils.ToCsharpString(name)));
 
-				if (!exists(name) || name == oldName) {
+				if (!Exists(name) || name == oldName) {
 					allNames[name] = true;
 					return name;
 				}
@@ -61,7 +61,7 @@ namespace de4dot.code.renamer {
 			}
 		}
 
-		public void merge(ExistingNames other) {
+		public void Merge(ExistingNames other) {
 			foreach (var key in other.allNames.Keys)
 				allNames[key] = true;
 		}
diff --git a/de4dot.code/renamer/INameChecker.cs b/de4dot.code/renamer/INameChecker.cs
index 5860849a..211c9a9f 100644
--- a/de4dot.code/renamer/INameChecker.cs
+++ b/de4dot.code/renamer/INameChecker.cs
@@ -19,15 +19,15 @@
 
 namespace de4dot.code.renamer {
 	public interface INameChecker {
-		bool isValidNamespaceName(string ns);
-		bool isValidTypeName(string name);
-		bool isValidMethodName(string name);
-		bool isValidPropertyName(string name);
-		bool isValidEventName(string name);
-		bool isValidFieldName(string name);
-		bool isValidGenericParamName(string name);
-		bool isValidMethodArgName(string name);
-		bool isValidMethodReturnArgName(string name);
-		bool isValidResourceKeyName(string name);
+		bool IsValidNamespaceName(string ns);
+		bool IsValidTypeName(string name);
+		bool IsValidMethodName(string name);
+		bool IsValidPropertyName(string name);
+		bool IsValidEventName(string name);
+		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 7f333ae1..fd052fe0 100644
--- a/de4dot.code/renamer/MemberInfos.cs
+++ b/de4dot.code/renamer/MemberInfos.cs
@@ -36,12 +36,12 @@ namespace de4dot.code.renamer {
 			newName = memberRef.memberRef.Name.String;
 		}
 
-		public void rename(string newTypeName) {
+		public void Rename(string newTypeName) {
 			renamed = true;
 			newName = newTypeName;
 		}
 
-		public bool gotNewName() {
+		public bool GotNewName() {
 			return oldName != newName;
 		}
 
@@ -95,7 +95,7 @@ namespace de4dot.code.renamer {
 			this.newName = paramDef.ParameterDef.Name;
 		}
 
-		public bool gotNewName() {
+		public bool GotNewName() {
 			return oldName != newName;
 		}
 	}
@@ -210,59 +210,59 @@ namespace de4dot.code.renamer {
 			checkWinFormsClass = new DerivedFrom(WINFORMS_CLASSES);
 		}
 
-		public bool isWinFormsClass(MTypeDef type) {
-			return checkWinFormsClass.check(type);
+		public bool IsWinFormsClass(MTypeDef type) {
+			return checkWinFormsClass.Check(type);
 		}
 
-		public TypeInfo type(MTypeDef t) {
+		public TypeInfo Type(MTypeDef t) {
 			return allTypeInfos[t];
 		}
 
-		public bool tryGetType(MTypeDef t, out TypeInfo info) {
+		public bool TryGetType(MTypeDef t, out TypeInfo info) {
 			return allTypeInfos.TryGetValue(t, out info);
 		}
 
-		public bool tryGetEvent(MEventDef e, out EventInfo info) {
+		public bool TryGetEvent(MEventDef e, out EventInfo info) {
 			return allEventInfos.TryGetValue(e, out info);
 		}
 
-		public bool tryGetProperty(MPropertyDef p, out PropertyInfo info) {
+		public bool TryGetProperty(MPropertyDef p, out PropertyInfo info) {
 			return allPropertyInfos.TryGetValue(p, out info);
 		}
 
-		public PropertyInfo prop(MPropertyDef prop) {
+		public PropertyInfo Property(MPropertyDef prop) {
 			return allPropertyInfos[prop];
 		}
 
-		public EventInfo evt(MEventDef evt) {
+		public EventInfo Event(MEventDef evt) {
 			return allEventInfos[evt];
 		}
 
-		public FieldInfo field(MFieldDef field) {
+		public FieldInfo Field(MFieldDef field) {
 			return allFieldInfos[field];
 		}
 
-		public MethodInfo method(MMethodDef method) {
+		public MethodInfo Method(MMethodDef method) {
 			return allMethodInfos[method];
 		}
 
-		public GenericParamInfo gparam(MGenericParamDef gparam) {
+		public GenericParamInfo GenericParam(MGenericParamDef gparam) {
 			return allGenericParamInfos[gparam];
 		}
 
-		public ParamInfo param(MParamDef param) {
+		public ParamInfo Param(MParamDef param) {
 			return allParamInfos[param];
 		}
 
-		public void add(MPropertyDef prop) {
+		public void Add(MPropertyDef prop) {
 			allPropertyInfos[prop] = new PropertyInfo(prop);
 		}
 
-		public void add(MEventDef evt) {
+		public void Add(MEventDef evt) {
 			allEventInfos[evt] = new EventInfo(evt);
 		}
 
-		public void initialize(Modules modules) {
+		public void Initialize(Modules modules) {
 			foreach (var type in modules.AllTypes) {
 				allTypeInfos[type] = new TypeInfo(type, this);
 
@@ -273,10 +273,10 @@ namespace de4dot.code.renamer {
 					allFieldInfos[field] = new FieldInfo(field);
 
 				foreach (var evt in type.AllEvents)
-					add(evt);
+					Add(evt);
 
 				foreach (var prop in type.AllProperties)
-					add(prop);
+					Add(prop);
 
 				foreach (var method in type.AllMethods) {
 					allMethodInfos[method] = new MethodInfo(method);
diff --git a/de4dot.code/renamer/NameCreators.cs b/de4dot.code/renamer/NameCreators.cs
index 0ca780c6..36186e4c 100644
--- a/de4dot.code/renamer/NameCreators.cs
+++ b/de4dot.code/renamer/NameCreators.cs
@@ -23,7 +23,7 @@ using de4dot.blocks;
 
 namespace de4dot.code.renamer {
 	interface INameCreator {
-		string create();
+		string Create();
 	}
 
 	class OneNameCreator : INameCreator {
@@ -33,7 +33,7 @@ namespace de4dot.code.renamer {
 			this.name = name;
 		}
 
-		public string create() {
+		public string Create() {
 			return name;
 		}
 	}
@@ -41,9 +41,9 @@ namespace de4dot.code.renamer {
 	abstract class NameCreatorCounter : INameCreator {
 		protected int num;
 
-		public abstract string create();
+		public abstract string Create();
 
-		public NameCreatorCounter merge(NameCreatorCounter other) {
+		public NameCreatorCounter Merge(NameCreatorCounter other) {
 			if (num < other.num)
 				num = other.num;
 			return this;
@@ -53,7 +53,7 @@ namespace de4dot.code.renamer {
 	class GenericParamNameCreator : NameCreatorCounter {
 		static string[] names = new string[] { "T", "U", "V", "W", "X", "Y", "Z" };
 
-		public override string create() {
+		public override string Create() {
 			if (num < names.Length)
 				return names[num++];
 			return string.Format("T{0}", num++);
@@ -72,11 +72,11 @@ namespace de4dot.code.renamer {
 			this.num = num;
 		}
 
-		public NameCreator clone() {
+		public NameCreator Clone() {
 			return new NameCreator(prefix, num);
 		}
 
-		public override string create() {
+		public override string Create() {
 			return prefix + num++;
 		}
 	}
@@ -95,7 +95,7 @@ namespace de4dot.code.renamer {
 			this.num = num;
 		}
 
-		public override string create() {
+		public override string Create() {
 			string rv;
 			if (num == 0)
 				rv = prefix;
@@ -107,7 +107,7 @@ namespace de4dot.code.renamer {
 	}
 
 	interface ITypeNameCreator {
-		string create(TypeDef typeDef, string newBaseTypeName);
+		string Create(TypeDef typeDef, string newBaseTypeName);
 	}
 
 	class NameInfos {
@@ -122,11 +122,11 @@ namespace de4dot.code.renamer {
 			}
 		}
 
-		public void add(string name, NameCreator nameCreator) {
+		public void Add(string name, NameCreator nameCreator) {
 			nameInfos.Add(new NameInfo(name, nameCreator));
 		}
 
-		public NameCreator find(string typeName) {
+		public NameCreator Find(string typeName) {
 			foreach (var nameInfo in nameInfos) {
 				if (typeName.Contains(nameInfo.name))
 					return nameInfo.nameCreator;
@@ -148,12 +148,12 @@ namespace de4dot.code.renamer {
 
 		public TypeNameCreator(ExistingNames existingNames) {
 			this.existingNames = existingNames;
-			createUnknownTypeName = createNameCreator("Type");
-			createEnumName = createNameCreator("Enum");
-			createStructName = createNameCreator("Struct");
-			createDelegateName = createNameCreator("Delegate");
-			createClassName = createNameCreator("Class");
-			createInterfaceName = createNameCreator("Interface");
+			createUnknownTypeName = CreateNameCreator("Type");
+			createEnumName = CreateNameCreator("Enum");
+			createStructName = CreateNameCreator("Struct");
+			createDelegateName = CreateNameCreator("Delegate");
+			createClassName = CreateNameCreator("Class");
+			createInterfaceName = CreateNameCreator("Interface");
 
 			var names = new string[] {
 				"Exception",
@@ -165,19 +165,19 @@ namespace de4dot.code.renamer {
 				"Stream",
 			};
 			foreach (var name in names)
-				nameInfos.add(name, createNameCreator(name));
+				nameInfos.Add(name, CreateNameCreator(name));
 		}
 
-		protected virtual NameCreator createNameCreator(string prefix) {
+		protected virtual NameCreator CreateNameCreator(string prefix) {
 			return new NameCreator(prefix);
 		}
 
-		public string create(TypeDef typeDef, string newBaseTypeName) {
-			var nameCreator = getNameCreator(typeDef, newBaseTypeName);
-			return existingNames.getName(typeDef.Name.String, nameCreator);
+		public string Create(TypeDef typeDef, string newBaseTypeName) {
+			var nameCreator = GetNameCreator(typeDef, newBaseTypeName);
+			return existingNames.GetName(typeDef.Name.String, nameCreator);
 		}
 
-		NameCreator getNameCreator(TypeDef typeDef, string newBaseTypeName) {
+		NameCreator GetNameCreator(TypeDef typeDef, string newBaseTypeName) {
 			var nameCreator = createUnknownTypeName;
 			if (typeDef.IsEnum)
 				nameCreator = createEnumName;
@@ -191,7 +191,7 @@ namespace de4dot.code.renamer {
 					else if (fn == "System.MulticastDelegate")
 						nameCreator = createDelegateName;
 					else {
-						nameCreator = nameInfos.find(newBaseTypeName ?? typeDef.BaseType.Name.String);
+						nameCreator = nameInfos.Find(newBaseTypeName ?? typeDef.BaseType.Name.String);
 						if (nameCreator == null)
 							nameCreator = createClassName;
 					}
@@ -210,8 +210,8 @@ namespace de4dot.code.renamer {
 			: base(existingNames) {
 		}
 
-		protected override NameCreator createNameCreator(string prefix) {
-			return base.createNameCreator("G" + prefix);
+		protected override NameCreator CreateNameCreator(string prefix) {
+			return base.CreateNameCreator("G" + prefix);
 		}
 	}
 }
diff --git a/de4dot.code/renamer/Renamer.cs b/de4dot.code/renamer/Renamer.cs
index ca08e3e0..d5bd9634 100644
--- a/de4dot.code/renamer/Renamer.cs
+++ b/de4dot.code/renamer/Renamer.cs
@@ -192,45 +192,45 @@ namespace de4dot.code.renamer {
 			mergeStateHelper = new MergeStateHelper(memberInfos);
 
 			foreach (var file in files)
-				modules.add(new Module(file));
+				modules.Add(new Module(file));
 		}
 
-		public void rename() {
+		public void Rename() {
 			if (modules.Empty)
 				return;
 			isVerbose = !Logger.Instance.IgnoresEvent(LoggerEvent.Verbose);
 			Logger.n("Renaming all obfuscated symbols");
 
-			modules.initialize();
-			renameResourceKeys();
-			var groups = modules.initializeVirtualMembers();
-			memberInfos.initialize(modules);
-			renameTypeDefs();
-			renameTypeRefs();
-			modules.onTypesRenamed();
-			restorePropertiesAndEvents(groups);
-			prepareRenameMemberDefs(groups);
-			renameMemberDefs();
-			renameMemberRefs();
-			removeUselessOverrides(groups);
-			renameResources();
-			modules.cleanUp();
+			modules.Initialize();
+			RenameResourceKeys();
+			var groups = modules.InitializeVirtualMembers();
+			memberInfos.Initialize(modules);
+			RenameTypeDefs();
+			RenameTypeRefs();
+			modules.OnTypesRenamed();
+			RestorePropertiesAndEvents(groups);
+			PrepareRenameMemberDefs(groups);
+			RenameMemberDefs();
+			RenameMemberRefs();
+			RemoveUselessOverrides(groups);
+			RenameResources();
+			modules.CleanUp();
 		}
 
-		void renameResourceKeys() {
+		void RenameResourceKeys() {
 			foreach (var module in modules.TheModules) {
 				if (!module.ObfuscatedFile.RenameResourceKeys)
 					continue;
-				new ResourceKeysRenamer(module.ModuleDefMD, module.ObfuscatedFile.NameChecker).rename();
+				new ResourceKeysRenamer(module.ModuleDefMD, module.ObfuscatedFile.NameChecker).Rename();
 			}
 		}
 
-		void removeUselessOverrides(MethodNameGroups groups) {
-			foreach (var group in groups.getAllGroups()) {
+		void RemoveUselessOverrides(MethodNameGroups groups) {
+			foreach (var group in groups.GetAllGroups()) {
 				foreach (var method in group.Methods) {
 					if (!method.Owner.HasModule)
 						continue;
-					if (!method.isPublic())
+					if (!method.IsPublic())
 						continue;
 					var overrides = method.MethodDef.Overrides;
 					for (int i = 0; i < overrides.Count; i++) {
@@ -239,7 +239,7 @@ namespace de4dot.code.renamer {
 							continue;
 						if (isVerbose)
 							Logger.v("Removed useless override from method {0} ({1:X8}), override: {2:X8}",
-									Utils.removeNewlines(method.MethodDef),
+									Utils.RemoveNewlines(method.MethodDef),
 									method.MethodDef.MDToken.ToInt32(),
 									overrideMethod.MDToken.ToInt32());
 						overrides.RemoveAt(i);
@@ -249,32 +249,32 @@ namespace de4dot.code.renamer {
 			}
 		}
 
-		void renameTypeDefs() {
+		void RenameTypeDefs() {
 			if (isVerbose)
 				Logger.v("Renaming obfuscated type definitions");
 
 			foreach (var module in modules.TheModules) {
 				if (module.ObfuscatedFile.RemoveNamespaceWithOneType)
-					removeOneClassNamespaces(module);
+					RemoveOneClassNamespaces(module);
 			}
 
 			var state = new TypeRenamerState();
 			foreach (var type in modules.AllTypes)
-				state.addTypeName(memberInfos.type(type).oldName);
-			prepareRenameTypes(modules.BaseTypes, state);
-			fixClsTypeNames();
-			renameTypeDefs(modules.NonNestedTypes);
+				state.AddTypeName(memberInfos.Type(type).oldName);
+			PrepareRenameTypes(modules.BaseTypes, state);
+			FixClsTypeNames();
+			RenameTypeDefs(modules.NonNestedTypes);
 		}
 
-		void removeOneClassNamespaces(Module module) {
+		void RemoveOneClassNamespaces(Module module) {
 			var nsToTypes = new Dictionary<string, List<MTypeDef>>(StringComparer.Ordinal);
 
-			foreach (var typeDef in module.getAllTypes()) {
+			foreach (var typeDef in module.GetAllTypes()) {
 				List<MTypeDef> list;
 				var ns = typeDef.TypeDef.Namespace.String;
 				if (string.IsNullOrEmpty(ns))
 					continue;
-				if (module.ObfuscatedFile.NameChecker.isValidNamespaceName(ns))
+				if (module.ObfuscatedFile.NameChecker.IsValidNamespaceName(ns))
 					continue;
 				if (!nsToTypes.TryGetValue(ns, out list))
 					nsToTypes[ns] = list = new List<MTypeDef>();
@@ -290,161 +290,161 @@ namespace de4dot.code.renamer {
 				if (list.Count != maxClasses)
 					continue;
 				if (isVerbose)
-					Logger.v("Removing namespace: {0}", Utils.removeNewlines(list[0].TypeDef.Namespace));
+					Logger.v("Removing namespace: {0}", Utils.RemoveNewlines(list[0].TypeDef.Namespace));
 				foreach (var type in list)
-					memberInfos.type(type).newNamespace = "";
+					memberInfos.Type(type).newNamespace = "";
 			}
 		}
 
-		void renameTypeDefs(IEnumerable<MTypeDef> typeDefs) {
-			Logger.Instance.indent();
+		void RenameTypeDefs(IEnumerable<MTypeDef> typeDefs) {
+			Logger.Instance.Indent();
 			foreach (var typeDef in typeDefs) {
-				rename(typeDef);
-				renameTypeDefs(typeDef.NestedTypes);
+				Rename(typeDef);
+				RenameTypeDefs(typeDef.NestedTypes);
 			}
-			Logger.Instance.deIndent();
+			Logger.Instance.DeIndent();
 		}
 
-		void rename(MTypeDef type) {
+		void Rename(MTypeDef type) {
 			var typeDef = type.TypeDef;
-			var info = memberInfos.type(type);
+			var info = memberInfos.Type(type);
 
 			if (isVerbose)
-				Logger.v("Type: {0} ({1:X8})", Utils.removeNewlines(typeDef.FullName), typeDef.MDToken.ToUInt32());
-			Logger.Instance.indent();
+				Logger.v("Type: {0} ({1:X8})", Utils.RemoveNewlines(typeDef.FullName), typeDef.MDToken.ToUInt32());
+			Logger.Instance.Indent();
 
-			renameGenericParams(type.GenericParams);
+			renameGenericParams2(type.GenericParams);
 
-			if (RenameTypes && info.gotNewName()) {
+			if (RenameTypes && info.GotNewName()) {
 				var old = typeDef.Name;
 				typeDef.Name = info.newName;
 				if (isVerbose)
-					Logger.v("Name: {0} => {1}", Utils.removeNewlines(old), Utils.removeNewlines(typeDef.Name));
+					Logger.v("Name: {0} => {1}", Utils.RemoveNewlines(old), Utils.RemoveNewlines(typeDef.Name));
 			}
 
 			if (RenameNamespaces && info.newNamespace != null) {
 				var old = typeDef.Namespace;
 				typeDef.Namespace = info.newNamespace;
 				if (isVerbose)
-					Logger.v("Namespace: {0} => {1}", Utils.removeNewlines(old), Utils.removeNewlines(typeDef.Namespace));
+					Logger.v("Namespace: {0} => {1}", Utils.RemoveNewlines(old), Utils.RemoveNewlines(typeDef.Namespace));
 			}
 
-			Logger.Instance.deIndent();
+			Logger.Instance.DeIndent();
 		}
 
-		void renameGenericParams(IEnumerable<MGenericParamDef> genericParams) {
+		void renameGenericParams2(IEnumerable<MGenericParamDef> genericParams) {
 			if (!RenameGenericParams)
 				return;
 			foreach (var param in genericParams) {
-				var info = memberInfos.gparam(param);
-				if (!info.gotNewName())
+				var info = memberInfos.GenericParam(param);
+				if (!info.GotNewName())
 					continue;
 				param.GenericParam.Name = info.newName;
 				if (isVerbose)
-					Logger.v("GenParam: {0} => {1}", Utils.removeNewlines(info.oldFullName), Utils.removeNewlines(param.GenericParam.FullName));
+					Logger.v("GenParam: {0} => {1}", Utils.RemoveNewlines(info.oldFullName), Utils.RemoveNewlines(param.GenericParam.FullName));
 			}
 		}
 
-		void renameMemberDefs() {
+		void RenameMemberDefs() {
 			if (isVerbose)
 				Logger.v("Renaming member definitions #2");
 
 			var allTypes = new List<MTypeDef>(modules.AllTypes);
 			allTypes.Sort((a, b) => a.Index.CompareTo(b.Index));
 
-			Logger.Instance.indent();
+			Logger.Instance.Indent();
 			foreach (var typeDef in allTypes)
-				renameMembers(typeDef);
-			Logger.Instance.deIndent();
+				RenameMembers(typeDef);
+			Logger.Instance.DeIndent();
 		}
 
-		void renameMembers(MTypeDef type) {
-			var info = memberInfos.type(type);
+		void RenameMembers(MTypeDef type) {
+			var info = memberInfos.Type(type);
 
 			if (isVerbose)
-				Logger.v("Type: {0}", Utils.removeNewlines(info.type.TypeDef.FullName));
-			Logger.Instance.indent();
+				Logger.v("Type: {0}", Utils.RemoveNewlines(info.type.TypeDef.FullName));
+			Logger.Instance.Indent();
 
-			renameFields(info);
-			renameProperties(info);
-			renameEvents(info);
-			renameMethods(info);
+			RenameFields2(info);
+			RenameProperties2(info);
+			RenameEvents2(info);
+			RenameMethods2(info);
 
-			Logger.Instance.deIndent();
+			Logger.Instance.DeIndent();
 		}
 
-		void renameFields(TypeInfo info) {
+		void RenameFields2(TypeInfo info) {
 			if (!RenameFields)
 				return;
-			bool isDelegateType = isDelegateClass.check(info.type);
+			bool isDelegateType = isDelegateClass.Check(info.type);
 			foreach (var fieldDef in info.type.AllFieldsSorted) {
-				var fieldInfo = memberInfos.field(fieldDef);
-				if (!fieldInfo.gotNewName())
+				var fieldInfo = memberInfos.Field(fieldDef);
+				if (!fieldInfo.GotNewName())
 					continue;
 				if (isDelegateType && DontRenameDelegateFields)
 					continue;
 				fieldDef.FieldDef.Name = fieldInfo.newName;
 				if (isVerbose)
 					Logger.v("Field: {0} ({1:X8}) => {2}",
-							Utils.removeNewlines(fieldInfo.oldFullName),
+							Utils.RemoveNewlines(fieldInfo.oldFullName),
 							fieldDef.FieldDef.MDToken.ToUInt32(),
-							Utils.removeNewlines(fieldDef.FieldDef.FullName));
+							Utils.RemoveNewlines(fieldDef.FieldDef.FullName));
 			}
 		}
 
-		void renameProperties(TypeInfo info) {
+		void RenameProperties2(TypeInfo info) {
 			if (!RenameProperties)
 				return;
 			foreach (var propDef in info.type.AllPropertiesSorted) {
-				var propInfo = memberInfos.prop(propDef);
-				if (!propInfo.gotNewName())
+				var propInfo = memberInfos.Property(propDef);
+				if (!propInfo.GotNewName())
 					continue;
 				propDef.PropertyDef.Name = propInfo.newName;
 				if (isVerbose)
 					Logger.v("Property: {0} ({1:X8}) => {2}",
-							Utils.removeNewlines(propInfo.oldFullName),
+							Utils.RemoveNewlines(propInfo.oldFullName),
 							propDef.PropertyDef.MDToken.ToUInt32(),
-							Utils.removeNewlines(propDef.PropertyDef.FullName));
+							Utils.RemoveNewlines(propDef.PropertyDef.FullName));
 			}
 		}
 
-		void renameEvents(TypeInfo info) {
+		void RenameEvents2(TypeInfo info) {
 			if (!RenameEvents)
 				return;
 			foreach (var eventDef in info.type.AllEventsSorted) {
-				var eventInfo = memberInfos.evt(eventDef);
-				if (!eventInfo.gotNewName())
+				var eventInfo = memberInfos.Event(eventDef);
+				if (!eventInfo.GotNewName())
 					continue;
 				eventDef.EventDef.Name = eventInfo.newName;
 				if (isVerbose)
 					Logger.v("Event: {0} ({1:X8}) => {2}",
-							Utils.removeNewlines(eventInfo.oldFullName),
+							Utils.RemoveNewlines(eventInfo.oldFullName),
 							eventDef.EventDef.MDToken.ToUInt32(),
-							Utils.removeNewlines(eventDef.EventDef.FullName));
+							Utils.RemoveNewlines(eventDef.EventDef.FullName));
 			}
 		}
 
-		void renameMethods(TypeInfo info) {
+		void RenameMethods2(TypeInfo info) {
 			if (!RenameMethods && !RenameMethodArgs && !RenameGenericParams)
 				return;
 			foreach (var methodDef in info.type.AllMethodsSorted) {
-				var methodInfo = memberInfos.method(methodDef);
+				var methodInfo = memberInfos.Method(methodDef);
 				if (isVerbose)
-					Logger.v("Method {0} ({1:X8})", Utils.removeNewlines(methodInfo.oldFullName), methodDef.MethodDef.MDToken.ToUInt32());
-				Logger.Instance.indent();
+					Logger.v("Method {0} ({1:X8})", Utils.RemoveNewlines(methodInfo.oldFullName), methodDef.MethodDef.MDToken.ToUInt32());
+				Logger.Instance.Indent();
 
-				renameGenericParams(methodDef.GenericParams);
+				renameGenericParams2(methodDef.GenericParams);
 
-				if (RenameMethods && methodInfo.gotNewName()) {
+				if (RenameMethods && methodInfo.GotNewName()) {
 					methodDef.MethodDef.Name = methodInfo.newName;
 					if (isVerbose)
-						Logger.v("Name: {0} => {1}", Utils.removeNewlines(methodInfo.oldFullName), Utils.removeNewlines(methodDef.MethodDef.FullName));
+						Logger.v("Name: {0} => {1}", Utils.RemoveNewlines(methodInfo.oldFullName), Utils.RemoveNewlines(methodDef.MethodDef.FullName));
 				}
 
 				if (RenameMethodArgs) {
 					foreach (var param in methodDef.AllParamDefs) {
-						var paramInfo = memberInfos.param(param);
-						if (!paramInfo.gotNewName())
+						var paramInfo = memberInfos.Param(param);
+						if (!paramInfo.GotNewName())
 							continue;
 						if (!param.ParameterDef.HasParamDef) {
 							if (DontCreateNewParamDefs)
@@ -454,24 +454,24 @@ namespace de4dot.code.renamer {
 						param.ParameterDef.Name = paramInfo.newName;
 						if (isVerbose) {
 							if (param.IsReturnParameter)
-								Logger.v("RetParam: {0} => {1}", Utils.removeNewlines(paramInfo.oldName), Utils.removeNewlines(paramInfo.newName));
+								Logger.v("RetParam: {0} => {1}", Utils.RemoveNewlines(paramInfo.oldName), Utils.RemoveNewlines(paramInfo.newName));
 							else
-								Logger.v("Param ({0}/{1}): {2} => {3}", param.ParameterDef.MethodSigIndex + 1, methodDef.MethodDef.MethodSig.GetParamCount(), Utils.removeNewlines(paramInfo.oldName), Utils.removeNewlines(paramInfo.newName));
+								Logger.v("Param ({0}/{1}): {2} => {3}", param.ParameterDef.MethodSigIndex + 1, methodDef.MethodDef.MethodSig.GetParamCount(), Utils.RemoveNewlines(paramInfo.oldName), Utils.RemoveNewlines(paramInfo.newName));
 						}
 					}
 				}
 
-				Logger.Instance.deIndent();
+				Logger.Instance.DeIndent();
 			}
 		}
 
-		void renameMemberRefs() {
+		void RenameMemberRefs() {
 			if (isVerbose)
 				Logger.v("Renaming references to other definitions");
 			foreach (var module in modules.TheModules) {
 				if (modules.TheModules.Count > 1 && isVerbose)
 					Logger.v("Renaming references to other definitions ({0})", module.Filename);
-				Logger.Instance.indent();
+				Logger.Instance.Indent();
 				foreach (var refToDef in module.MethodRefsToRename)
 					refToDef.reference.Name = refToDef.definition.Name;
 				foreach (var refToDef in module.FieldRefsToRename)
@@ -480,87 +480,87 @@ namespace de4dot.code.renamer {
 					info.cattr.NamedArguments[info.index].Name = info.reference.Name;
 				foreach (var info in module.CustomAttributePropertyRefs)
 					info.cattr.NamedArguments[info.index].Name = info.reference.Name;
-				Logger.Instance.deIndent();
+				Logger.Instance.DeIndent();
 			}
 		}
 
-		void renameResources() {
+		void RenameResources() {
 			if (isVerbose)
 				Logger.v("Renaming resources");
 			foreach (var module in modules.TheModules) {
 				if (modules.TheModules.Count > 1 && isVerbose)
 					Logger.v("Renaming resources ({0})", module.Filename);
-				Logger.Instance.indent();
-				renameResources(module);
-				Logger.Instance.deIndent();
+				Logger.Instance.Indent();
+				RenameResources(module);
+				Logger.Instance.DeIndent();
 			}
 		}
 
-		void renameResources(Module module) {
+		void RenameResources(Module module) {
 			var renamedTypes = new List<TypeInfo>();
-			foreach (var type in module.getAllTypes()) {
-				var info = memberInfos.type(type);
+			foreach (var type in module.GetAllTypes()) {
+				var info = memberInfos.Type(type);
 				if (info.oldFullName != info.type.TypeDef.FullName)
 					renamedTypes.Add(info);
 			}
 			if (renamedTypes.Count == 0)
 				return;
 
-			new ResourceRenamer(module).rename(renamedTypes);
+			new ResourceRenamer(module).Rename(renamedTypes);
 		}
 
 		// Make sure the renamed types are using valid CLS names. That means renaming all
 		// generic types from eg. Class1 to Class1`2. If we don't do this, some decompilers
 		// (eg. ILSpy v1.0) won't produce correct output.
-		void fixClsTypeNames() {
+		void FixClsTypeNames() {
 			foreach (var type in modules.NonNestedTypes)
-				fixClsTypeNames(null, type);
+				FixClsTypeNames(null, type);
 		}
 
-		void fixClsTypeNames(MTypeDef nesting, MTypeDef 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);
+			var nestedInfo = memberInfos.Type(nested);
 			if (nestedInfo.renamed && arity > 0)
 				nestedInfo.newName += "`" + arity;
 			foreach (var nestedType in nested.NestedTypes)
-				fixClsTypeNames(nested, nestedType);
+				FixClsTypeNames(nested, nestedType);
 		}
 
-		void prepareRenameTypes(IEnumerable<MTypeDef> types, TypeRenamerState state) {
+		void PrepareRenameTypes(IEnumerable<MTypeDef> types, TypeRenamerState state) {
 			foreach (var typeDef in types) {
-				memberInfos.type(typeDef).prepareRenameTypes(state);
-				prepareRenameTypes(typeDef.derivedTypes, state);
+				memberInfos.Type(typeDef).PrepareRenameTypes(state);
+				PrepareRenameTypes(typeDef.derivedTypes, state);
 			}
 		}
 
-		void renameTypeRefs() {
+		void RenameTypeRefs() {
 			if (isVerbose)
 				Logger.v("Renaming references to type definitions");
 			var theModules = modules.TheModules;
 			foreach (var module in theModules) {
 				if (theModules.Count > 1 && isVerbose)
 					Logger.v("Renaming references to type definitions ({0})", module.Filename);
-				Logger.Instance.indent();
+				Logger.Instance.Indent();
 				foreach (var refToDef in module.TypeRefsToRename) {
 					refToDef.reference.Name = refToDef.definition.Name;
 					refToDef.reference.Namespace = refToDef.definition.Namespace;
 				}
-				Logger.Instance.deIndent();
+				Logger.Instance.DeIndent();
 			}
 		}
 
-		void restorePropertiesAndEvents(MethodNameGroups groups) {
-			var allGroups = groups.getAllGroups();
-			restoreVirtualProperties(allGroups);
-			restorePropertiesFromNames(allGroups);
-			resetVirtualPropertyNames(allGroups);
-			restoreVirtualEvents(allGroups);
-			restoreEventsFromNames(allGroups);
-			resetVirtualEventNames(allGroups);
+		void RestorePropertiesAndEvents(MethodNameGroups groups) {
+			var allGroups = groups.GetAllGroups();
+			RestoreVirtualProperties(allGroups);
+			RestorePropertiesFromNames2(allGroups);
+			ResetVirtualPropertyNames(allGroups);
+			RestoreVirtualEvents(allGroups);
+			RestoreEventsFromNames2(allGroups);
+			ResetVirtualEventNames(allGroups);
 		}
 
-		void resetVirtualPropertyNames(IEnumerable<MethodNameGroup> allGroups) {
+		void ResetVirtualPropertyNames(IEnumerable<MethodNameGroup> allGroups) {
 			if (!this.RenameProperties)
 				return;
 			foreach (var group in allGroups) {
@@ -580,12 +580,12 @@ namespace de4dot.code.renamer {
 						continue;
 					if (method.Property == null)
 						continue;
-					memberInfos.prop(method.Property).rename(prop.PropertyDef.Name.String);
+					memberInfos.Property(method.Property).Rename(prop.PropertyDef.Name.String);
 				}
 			}
 		}
 
-		void resetVirtualEventNames(IEnumerable<MethodNameGroup> allGroups) {
+		void ResetVirtualEventNames(IEnumerable<MethodNameGroup> allGroups) {
 			if (!this.RenameEvents)
 				return;
 			foreach (var group in allGroups) {
@@ -605,21 +605,21 @@ namespace de4dot.code.renamer {
 						continue;
 					if (method.Event == null)
 						continue;
-					memberInfos.evt(method.Event).rename(evt.EventDef.Name.String);
+					memberInfos.Event(method.Event).Rename(evt.EventDef.Name.String);
 				}
 			}
 		}
 
-		void restoreVirtualProperties(IEnumerable<MethodNameGroup> allGroups) {
+		void RestoreVirtualProperties(IEnumerable<MethodNameGroup> allGroups) {
 			if (!RestoreProperties)
 				return;
 			foreach (var group in allGroups) {
-				restoreVirtualProperties(group);
-				restoreExplicitVirtualProperties(group);
+				RestoreVirtualProperties(group);
+				RestoreExplicitVirtualProperties(group);
 			}
 		}
 
-		void restoreExplicitVirtualProperties(MethodNameGroup group) {
+		void RestoreExplicitVirtualProperties(MethodNameGroup group) {
 			if (group.Methods.Count != 1)
 				return;
 			var propMethod = group.Methods[0];
@@ -628,15 +628,15 @@ namespace de4dot.code.renamer {
 			if (propMethod.MethodDef.Overrides.Count == 0)
 				return;
 
-			var theProperty = getOverriddenProperty(propMethod);
+			var theProperty = GetOverriddenProperty(propMethod);
 			if (theProperty == null)
 				return;
 
-			createProperty(theProperty, propMethod, getOverridePrefix(group, propMethod));
+			CreateProperty(theProperty, propMethod, GetOverridePrefix(group, propMethod));
 		}
 
-		void restoreVirtualProperties(MethodNameGroup group) {
-			if (group.Methods.Count <= 1 || !group.hasProperty())
+		void RestoreVirtualProperties(MethodNameGroup group) {
+			if (group.Methods.Count <= 1 || !group.HasProperty())
 				return;
 
 			MPropertyDef prop = null;
@@ -656,63 +656,63 @@ namespace de4dot.code.renamer {
 				return;
 
 			foreach (var method in missingProps)
-				createProperty(prop, method, "");
+				CreateProperty(prop, method, "");
 		}
 
-		void createProperty(MPropertyDef propDef, MMethodDef methodDef, string overridePrefix) {
+		void CreateProperty(MPropertyDef propDef, MMethodDef methodDef, string overridePrefix) {
 			if (!methodDef.Owner.HasModule)
 				return;
 
 			var newPropertyName = overridePrefix + propDef.PropertyDef.Name;
-			if (!DotNetUtils.hasReturnValue(methodDef.MethodDef))
-				createPropertySetter(newPropertyName, methodDef);
+			if (!DotNetUtils.HasReturnValue(methodDef.MethodDef))
+				CreatePropertySetter(newPropertyName, methodDef);
 			else
-				createPropertyGetter(newPropertyName, methodDef);
+				CreatePropertyGetter(newPropertyName, methodDef);
 		}
 
-		void restorePropertiesFromNames(IEnumerable<MethodNameGroup> allGroups) {
+		void RestorePropertiesFromNames2(IEnumerable<MethodNameGroup> allGroups) {
 			if (!RestorePropertiesFromNames)
 				return;
 
 			foreach (var group in allGroups) {
 				var groupMethod = group.Methods[0];
 				var methodName = groupMethod.MethodDef.Name.String;
-				bool onlyRenamableMethods = !group.hasNonRenamableMethod();
+				bool onlyRenamableMethods = !group.HasNonRenamableMethod();
 
 				if (Utils.StartsWith(methodName, "get_", StringComparison.Ordinal)) {
 					var propName = methodName.Substring(4);
 					foreach (var method in group.Methods) {
-						if (onlyRenamableMethods && !memberInfos.type(method.Owner).NameChecker.isValidPropertyName(propName))
+						if (onlyRenamableMethods && !memberInfos.Type(method.Owner).NameChecker.IsValidPropertyName(propName))
 							continue;
-						createPropertyGetter(propName, method);
+						CreatePropertyGetter(propName, method);
 					}
 				}
 				else if (Utils.StartsWith(methodName, "set_", StringComparison.Ordinal)) {
 					var propName = methodName.Substring(4);
 					foreach (var method in group.Methods) {
-						if (onlyRenamableMethods && !memberInfos.type(method.Owner).NameChecker.isValidPropertyName(propName))
+						if (onlyRenamableMethods && !memberInfos.Type(method.Owner).NameChecker.IsValidPropertyName(propName))
 							continue;
-						createPropertySetter(propName, method);
+						CreatePropertySetter(propName, method);
 					}
 				}
 			}
 
 			foreach (var type in modules.AllTypes) {
 				foreach (var method in type.AllMethodsSorted) {
-					if (method.isVirtual())
+					if (method.IsVirtual())
 						continue;	// Virtual methods are in allGroups, so already fixed above
 					if (method.Property != null)
 						continue;
 					var methodName = method.MethodDef.Name.String;
 					if (Utils.StartsWith(methodName, "get_", StringComparison.Ordinal))
-						createPropertyGetter(methodName.Substring(4), method);
+						CreatePropertyGetter(methodName.Substring(4), method);
 					else if (Utils.StartsWith(methodName, "set_", StringComparison.Ordinal))
-						createPropertySetter(methodName.Substring(4), method);
+						CreatePropertySetter(methodName.Substring(4), method);
 				}
 			}
 		}
 
-		MPropertyDef createPropertyGetter(string name, MMethodDef propMethod) {
+		MPropertyDef CreatePropertyGetter(string name, MMethodDef propMethod) {
 			if (string.IsNullOrEmpty(name))
 				return null;
 			var ownerType = propMethod.Owner;
@@ -725,16 +725,16 @@ namespace de4dot.code.renamer {
 			if (sig == null)
 				return null;
 			var propType = sig.RetType;
-			var propDef = createProperty(ownerType, name, propType, propMethod.MethodDef, null);
+			var propDef = CreateProperty(ownerType, name, propType, propMethod.MethodDef, null);
 			if (propDef == null)
 				return null;
 			if (propDef.GetMethod != null)
 				return null;
 			if (isVerbose)
 				Logger.v("Restoring property getter {0} ({1:X8}), Property: {2} ({3:X8})",
-						Utils.removeNewlines(propMethod),
+						Utils.RemoveNewlines(propMethod),
 						propMethod.MethodDef.MDToken.ToInt32(),
-						Utils.removeNewlines(propDef.PropertyDef),
+						Utils.RemoveNewlines(propDef.PropertyDef),
 						propDef.PropertyDef.MDToken.ToInt32());
 			propDef.PropertyDef.GetMethod = propMethod.MethodDef;
 			propDef.GetMethod = propMethod;
@@ -742,7 +742,7 @@ namespace de4dot.code.renamer {
 			return propDef;
 		}
 
-		MPropertyDef createPropertySetter(string name, MMethodDef propMethod) {
+		MPropertyDef CreatePropertySetter(string name, MMethodDef propMethod) {
 			if (string.IsNullOrEmpty(name))
 				return null;
 			var ownerType = propMethod.Owner;
@@ -755,16 +755,16 @@ namespace de4dot.code.renamer {
 			if (sig == null || sig.Params.Count == 0)
 				return null;
 			var propType = sig.Params[sig.Params.Count - 1];
-			var propDef = createProperty(ownerType, name, propType, null, propMethod.MethodDef);
+			var propDef = CreateProperty(ownerType, name, propType, null, propMethod.MethodDef);
 			if (propDef == null)
 				return null;
 			if (propDef.SetMethod != null)
 				return null;
 			if (isVerbose)
 				Logger.v("Restoring property setter {0} ({1:X8}), Property: {2} ({3:X8})",
-						Utils.removeNewlines(propMethod),
+						Utils.RemoveNewlines(propMethod),
 						propMethod.MethodDef.MDToken.ToInt32(),
-						Utils.removeNewlines(propDef.PropertyDef),
+						Utils.RemoveNewlines(propDef.PropertyDef),
 						propDef.PropertyDef.MDToken.ToInt32());
 			propDef.PropertyDef.SetMethod = propMethod.MethodDef;
 			propDef.SetMethod = propMethod;
@@ -772,27 +772,27 @@ namespace de4dot.code.renamer {
 			return propDef;
 		}
 
-		MPropertyDef createProperty(MTypeDef ownerType, string name, TypeSig propType, MethodDef getter, MethodDef setter) {
+		MPropertyDef CreateProperty(MTypeDef ownerType, string name, TypeSig propType, MethodDef getter, MethodDef setter) {
 			if (string.IsNullOrEmpty(name) || propType.ElementType == ElementType.Void)
 				return null;
-			var newSig = createPropertySig(getter, propType, true) ?? createPropertySig(setter, propType, false);
+			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);
+			var propDef = ownerType.FindAny(newProp);
 			if (propDef != null)
 				return propDef;
 
-			propDef = ownerType.create(newProp);
-			memberInfos.add(propDef);
+			propDef = ownerType.Create(newProp);
+			memberInfos.Add(propDef);
 			if (isVerbose)
-				Logger.v("Restoring property: {0}", Utils.removeNewlines(newProp));
+				Logger.v("Restoring property: {0}", Utils.RemoveNewlines(newProp));
 			return propDef;
 		}
 
-		static PropertySig createPropertySig(MethodDef method, TypeSig propType, bool isGetter) {
+		static PropertySig CreatePropertySig(MethodDef method, TypeSig propType, bool isGetter) {
 			if (method == null)
 				return null;
 			var sig = method.MethodSig;
@@ -811,12 +811,12 @@ namespace de4dot.code.renamer {
 			return newSig;
 		}
 
-		void restoreVirtualEvents(IEnumerable<MethodNameGroup> allGroups) {
+		void RestoreVirtualEvents(IEnumerable<MethodNameGroup> allGroups) {
 			if (!RestoreEvents)
 				return;
 			foreach (var group in allGroups) {
-				restoreVirtualEvents(group);
-				restoreExplicitVirtualEvents(group);
+				RestoreVirtualEvents(group);
+				RestoreExplicitVirtualEvents(group);
 			}
 		}
 
@@ -828,7 +828,7 @@ namespace de4dot.code.renamer {
 			Raiser,
 		}
 
-		void restoreExplicitVirtualEvents(MethodNameGroup group) {
+		void RestoreExplicitVirtualEvents(MethodNameGroup group) {
 			if (group.Methods.Count != 1)
 				return;
 			var eventMethod = group.Methods[0];
@@ -838,15 +838,15 @@ namespace de4dot.code.renamer {
 				return;
 
 			MMethodDef overriddenMethod;
-			var theEvent = getOverriddenEvent(eventMethod, out overriddenMethod);
+			var theEvent = GetOverriddenEvent(eventMethod, out overriddenMethod);
 			if (theEvent == null)
 				return;
 
-			createEvent(theEvent, eventMethod, getEventMethodType(overriddenMethod), getOverridePrefix(group, eventMethod));
+			CreateEvent(theEvent, eventMethod, GetEventMethodType(overriddenMethod), GetOverridePrefix(group, eventMethod));
 		}
 
-		void restoreVirtualEvents(MethodNameGroup group) {
-			if (group.Methods.Count <= 1 || !group.hasEvent())
+		void RestoreVirtualEvents(MethodNameGroup group) {
+			if (group.Methods.Count <= 1 || !group.HasEvent())
 				return;
 
 			EventMethodType methodType = EventMethodType.None;
@@ -860,7 +860,7 @@ namespace de4dot.code.renamer {
 				}
 				else if (evt == null || !method.Owner.HasModule) {
 					evt = method.Event;
-					methodType = getEventMethodType(method);
+					methodType = GetEventMethodType(method);
 				}
 			}
 			if (evt == null)
@@ -869,25 +869,25 @@ namespace de4dot.code.renamer {
 				return;
 
 			foreach (var method in missingEvents)
-				createEvent(evt, method, methodType, "");
+				CreateEvent(evt, method, methodType, "");
 		}
 
-		void createEvent(MEventDef eventDef, MMethodDef methodDef, EventMethodType methodType, string overridePrefix) {
+		void CreateEvent(MEventDef eventDef, MMethodDef methodDef, EventMethodType methodType, string overridePrefix) {
 			if (!methodDef.Owner.HasModule)
 				return;
 
 			var newEventName = overridePrefix + eventDef.EventDef.Name;
 			switch (methodType) {
 			case EventMethodType.Adder:
-				createEventAdder(newEventName, methodDef);
+				CreateEventAdder(newEventName, methodDef);
 				break;
 			case EventMethodType.Remover:
-				createEventRemover(newEventName, methodDef);
+				CreateEventRemover(newEventName, methodDef);
 				break;
 			}
 		}
 
-		static EventMethodType getEventMethodType(MMethodDef method) {
+		static EventMethodType GetEventMethodType(MMethodDef method) {
 			var evt = method.Event;
 			if (evt == null)
 				return EventMethodType.None;
@@ -900,49 +900,49 @@ namespace de4dot.code.renamer {
 			return EventMethodType.Other;
 		}
 
-		void restoreEventsFromNames(IEnumerable<MethodNameGroup> allGroups) {
+		void RestoreEventsFromNames2(IEnumerable<MethodNameGroup> allGroups) {
 			if (!RestoreEventsFromNames)
 				return;
 
 			foreach (var group in allGroups) {
 				var groupMethod = group.Methods[0];
 				var methodName = groupMethod.MethodDef.Name.String;
-				bool onlyRenamableMethods = !group.hasNonRenamableMethod();
+				bool onlyRenamableMethods = !group.HasNonRenamableMethod();
 
 				if (Utils.StartsWith(methodName, "add_", StringComparison.Ordinal)) {
 					var eventName = methodName.Substring(4);
 					foreach (var method in group.Methods) {
-						if (onlyRenamableMethods && !memberInfos.type(method.Owner).NameChecker.isValidEventName(eventName))
+						if (onlyRenamableMethods && !memberInfos.Type(method.Owner).NameChecker.IsValidEventName(eventName))
 							continue;
-						createEventAdder(eventName, method);
+						CreateEventAdder(eventName, method);
 					}
 				}
 				else if (Utils.StartsWith(methodName, "remove_", StringComparison.Ordinal)) {
 					var eventName = methodName.Substring(7);
 					foreach (var method in group.Methods) {
-						if (onlyRenamableMethods && !memberInfos.type(method.Owner).NameChecker.isValidEventName(eventName))
+						if (onlyRenamableMethods && !memberInfos.Type(method.Owner).NameChecker.IsValidEventName(eventName))
 							continue;
-						createEventRemover(eventName, method);
+						CreateEventRemover(eventName, method);
 					}
 				}
 			}
 
 			foreach (var type in modules.AllTypes) {
 				foreach (var method in type.AllMethodsSorted) {
-					if (method.isVirtual())
+					if (method.IsVirtual())
 						continue;	// Virtual methods are in allGroups, so already fixed above
 					if (method.Event != null)
 						continue;
 					var methodName = method.MethodDef.Name.String;
 					if (Utils.StartsWith(methodName, "add_", StringComparison.Ordinal))
-						createEventAdder(methodName.Substring(4), method);
+						CreateEventAdder(methodName.Substring(4), method);
 					else if (Utils.StartsWith(methodName, "remove_", StringComparison.Ordinal))
-						createEventRemover(methodName.Substring(7), method);
+						CreateEventRemover(methodName.Substring(7), method);
 				}
 			}
 		}
 
-		MEventDef createEventAdder(string name, MMethodDef eventMethod) {
+		MEventDef CreateEventAdder(string name, MMethodDef eventMethod) {
 			if (string.IsNullOrEmpty(name))
 				return null;
 			var ownerType = eventMethod.Owner;
@@ -952,16 +952,16 @@ namespace de4dot.code.renamer {
 				return null;
 
 			var method = eventMethod.MethodDef;
-			var eventDef = createEvent(ownerType, name, getEventType(method));
+			var eventDef = CreateEvent(ownerType, name, GetEventType(method));
 			if (eventDef == null)
 				return null;
 			if (eventDef.AddMethod != null)
 				return null;
 			if (isVerbose)
 				Logger.v("Restoring event adder {0} ({1:X8}), Event: {2} ({3:X8})",
-						Utils.removeNewlines(eventMethod),
+						Utils.RemoveNewlines(eventMethod),
 						eventMethod.MethodDef.MDToken.ToInt32(),
-						Utils.removeNewlines(eventDef.EventDef),
+						Utils.RemoveNewlines(eventDef.EventDef),
 						eventDef.EventDef.MDToken.ToInt32());
 			eventDef.EventDef.AddMethod = eventMethod.MethodDef;
 			eventDef.AddMethod = eventMethod;
@@ -969,7 +969,7 @@ namespace de4dot.code.renamer {
 			return eventDef;
 		}
 
-		MEventDef createEventRemover(string name, MMethodDef eventMethod) {
+		MEventDef CreateEventRemover(string name, MMethodDef eventMethod) {
 			if (string.IsNullOrEmpty(name))
 				return null;
 			var ownerType = eventMethod.Owner;
@@ -979,16 +979,16 @@ namespace de4dot.code.renamer {
 				return null;
 
 			var method = eventMethod.MethodDef;
-			var eventDef = createEvent(ownerType, name, getEventType(method));
+			var eventDef = CreateEvent(ownerType, name, GetEventType(method));
 			if (eventDef == null)
 				return null;
 			if (eventDef.RemoveMethod != null)
 				return null;
 			if (isVerbose)
 				Logger.v("Restoring event remover {0} ({1:X8}), Event: {2} ({3:X8})",
-						Utils.removeNewlines(eventMethod),
+						Utils.RemoveNewlines(eventMethod),
 						eventMethod.MethodDef.MDToken.ToInt32(),
-						Utils.removeNewlines(eventDef.EventDef),
+						Utils.RemoveNewlines(eventDef.EventDef),
 						eventDef.EventDef.MDToken.ToInt32());
 			eventDef.EventDef.RemoveMethod = eventMethod.MethodDef;
 			eventDef.RemoveMethod = eventMethod;
@@ -996,8 +996,8 @@ namespace de4dot.code.renamer {
 			return eventDef;
 		}
 
-		TypeSig getEventType(IMethod method) {
-			if (DotNetUtils.hasReturnValue(method))
+		TypeSig GetEventType(IMethod method) {
+			if (DotNetUtils.HasReturnValue(method))
 				return null;
 			var sig = method.MethodSig;
 			if (sig == null || sig.Params.Count != 1)
@@ -1005,74 +1005,74 @@ namespace de4dot.code.renamer {
 			return sig.Params[0];
 		}
 
-		MEventDef createEvent(MTypeDef ownerType, string name, TypeSig eventType) {
+		MEventDef CreateEvent(MTypeDef ownerType, string name, TypeSig eventType) {
 			if (string.IsNullOrEmpty(name) || eventType == null || eventType.ElementType == ElementType.Void)
 				return null;
 			var newEvent = ownerType.Module.ModuleDefMD.UpdateRowId(new EventDefUser(name, eventType.ToTypeDefOrRef(), 0));
-			var eventDef = ownerType.findAny(newEvent);
+			var eventDef = ownerType.FindAny(newEvent);
 			if (eventDef != null)
 				return eventDef;
 
-			eventDef = ownerType.create(newEvent);
-			memberInfos.add(eventDef);
+			eventDef = ownerType.Create(newEvent);
+			memberInfos.Add(eventDef);
 			if (isVerbose)
-				Logger.v("Restoring event: {0}", Utils.removeNewlines(newEvent));
+				Logger.v("Restoring event: {0}", Utils.RemoveNewlines(newEvent));
 			return eventDef;
 		}
 
-		void prepareRenameMemberDefs(MethodNameGroups groups) {
+		void PrepareRenameMemberDefs(MethodNameGroups groups) {
 			if (isVerbose)
 				Logger.v("Renaming member definitions #1");
 
-			prepareRenameEntryPoints();
+			PrepareRenameEntryPoints();
 
 			var virtualMethods = new GroupHelper(memberInfos, modules.AllTypes);
 			var ifaceMethods = new GroupHelper(memberInfos, modules.AllTypes);
 			var propMethods = new GroupHelper(memberInfos, modules.AllTypes);
 			var eventMethods = new GroupHelper(memberInfos, modules.AllTypes);
-			foreach (var group in getSorted(groups)) {
-				if (group.hasNonRenamableMethod())
+			foreach (var group in GetSorted(groups)) {
+				if (group.HasNonRenamableMethod())
 					continue;
-				else if (group.hasGetterOrSetterPropertyMethod() && getPropertyMethodType(group.Methods[0]) != PropertyMethodType.Other)
-					propMethods.add(group);
-				else if (group.hasAddRemoveOrRaiseEventMethod())
-					eventMethods.add(group);
-				else if (group.hasInterfaceMethod())
-					ifaceMethods.add(group);
+				else if (group.HasGetterOrSetterPropertyMethod() && GetPropertyMethodType(group.Methods[0]) != PropertyMethodType.Other)
+					propMethods.Add(group);
+				else if (group.HasAddRemoveOrRaiseEventMethod())
+					eventMethods.Add(group);
+				else if (group.HasInterfaceMethod())
+					ifaceMethods.Add(group);
 				else
-					virtualMethods.add(group);
+					virtualMethods.Add(group);
 			}
 
 			var prepareHelper = new PrepareHelper(memberInfos, modules.AllTypes);
-			prepareHelper.prepare((info) => info.prepareRenameMembers());
+			prepareHelper.Prepare((info) => info.PrepareRenameMembers());
 
-			prepareHelper.prepare((info) => info.prepareRenamePropsAndEvents());
-			propMethods.visitAll((group) => prepareRenameProperty(group, false));
-			eventMethods.visitAll((group) => prepareRenameEvent(group, false));
-			propMethods.visitAll((group) => prepareRenameProperty(group, true));
-			eventMethods.visitAll((group) => prepareRenameEvent(group, true));
+			prepareHelper.Prepare((info) => info.PrepareRenamePropsAndEvents());
+			propMethods.VisitAll((group) => PrepareRenameProperty(group, false));
+			eventMethods.VisitAll((group) => PrepareRenameEvent(group, false));
+			propMethods.VisitAll((group) => PrepareRenameProperty(group, true));
+			eventMethods.VisitAll((group) => PrepareRenameEvent(group, true));
 
 			foreach (var typeDef in modules.AllTypes)
-				memberInfos.type(typeDef).initializeEventHandlerNames();
+				memberInfos.Type(typeDef).InitializeEventHandlerNames();
 
-			prepareHelper.prepare((info) => info.prepareRenameMethods());
-			ifaceMethods.visitAll((group) => prepareRenameVirtualMethods(group, "imethod_", false));
-			virtualMethods.visitAll((group) => prepareRenameVirtualMethods(group, "vmethod_", false));
-			ifaceMethods.visitAll((group) => prepareRenameVirtualMethods(group, "imethod_", true));
-			virtualMethods.visitAll((group) => prepareRenameVirtualMethods(group, "vmethod_", true));
+			prepareHelper.Prepare((info) => info.PrepareRenameMethods());
+			ifaceMethods.VisitAll((group) => PrepareRenameVirtualMethods(group, "imethod_", false));
+			virtualMethods.VisitAll((group) => PrepareRenameVirtualMethods(group, "vmethod_", false));
+			ifaceMethods.VisitAll((group) => PrepareRenameVirtualMethods(group, "imethod_", true));
+			virtualMethods.VisitAll((group) => PrepareRenameVirtualMethods(group, "vmethod_", true));
 
-			restoreMethodArgs(groups);
+			RestoreMethodArgs(groups);
 
 			foreach (var typeDef in modules.AllTypes)
-				memberInfos.type(typeDef).prepareRenameMethods2();
+				memberInfos.Type(typeDef).PrepareRenameMethods2();
 		}
 
-		void restoreMethodArgs(MethodNameGroups groups) {
-			foreach (var group in groups.getAllGroups()) {
+		void RestoreMethodArgs(MethodNameGroups groups) {
+			foreach (var group in groups.GetAllGroups()) {
 				if (group.Methods[0].VisibleParameterCount == 0)
 					continue;
 
-				var argNames = getValidArgNames(group);
+				var argNames = GetValidArgNames(group);
 
 				foreach (var method in group.Methods) {
 					if (!method.Owner.HasModule)
@@ -1081,10 +1081,10 @@ namespace de4dot.code.renamer {
 
 					for (int i = 0; i < argNames.Length; i++) {
 						var argName = argNames[i];
-						if (argName == null || !nameChecker.isValidMethodArgName(argName))
+						if (argName == null || !nameChecker.IsValidMethodArgName(argName))
 							continue;
-						var info = memberInfos.param(method.ParamDefs[i]);
-						if (nameChecker.isValidMethodArgName(info.oldName))
+						var info = memberInfos.Param(method.ParamDefs[i]);
+						if (nameChecker.IsValidMethodArgName(info.oldName))
 							continue;
 						info.newName = argName;
 					}
@@ -1092,17 +1092,17 @@ namespace de4dot.code.renamer {
 			}
 		}
 
-		string[] getValidArgNames(MethodNameGroup group) {
+		string[] GetValidArgNames(MethodNameGroup group) {
 			var methods = new List<MMethodDef>(group.Methods);
 			foreach (var method in group.Methods) {
 				foreach (var ovrd in method.MethodDef.Overrides) {
 					var overrideRef = ovrd.MethodDeclaration;
-					var overrideDef = modules.resolveMethod(overrideRef);
+					var overrideDef = modules.ResolveMethod(overrideRef);
 					if (overrideDef == null) {
-						var typeDef = modules.resolveType(overrideRef.DeclaringType) ?? modules.resolveOther(overrideRef.DeclaringType);
+						var typeDef = modules.ResolveType(overrideRef.DeclaringType) ?? modules.ResolveOther(overrideRef.DeclaringType);
 						if (typeDef == null)
 							continue;
-						overrideDef = typeDef.findMethod(overrideRef);
+						overrideDef = typeDef.FindMethod(overrideRef);
 						if (overrideDef == null)
 							continue;
 					}
@@ -1117,7 +1117,7 @@ namespace de4dot.code.renamer {
 				var nameChecker = !method.Owner.HasModule ? null : method.Owner.Module.ObfuscatedFile.NameChecker;
 				for (int i = 0; i < argNames.Length; i++) {
 					var argName = method.ParamDefs[i].ParameterDef.Name;
-					if (nameChecker == null || nameChecker.isValidMethodArgName(argName))
+					if (nameChecker == null || nameChecker.IsValidMethodArgName(argName))
 						argNames[i] = argName;
 				}
 			}
@@ -1135,31 +1135,31 @@ namespace de4dot.code.renamer {
 				this.allTypes = allTypes;
 			}
 
-			public void prepare(Action<TypeInfo> func) {
+			public void Prepare(Action<TypeInfo> func) {
 				this.func = func;
 				prepareMethodCalled.Clear();
 				foreach (var typeDef in allTypes)
-					prepare(typeDef);
+					Prepare(typeDef);
 			}
 
-			void prepare(MTypeDef type) {
+			void Prepare(MTypeDef type) {
 				if (prepareMethodCalled.ContainsKey(type))
 					return;
 				prepareMethodCalled[type] = true;
 
 				foreach (var ifaceInfo in type.interfaces)
-					prepare(ifaceInfo.typeDef);
+					Prepare(ifaceInfo.typeDef);
 				if (type.baseType != null)
-					prepare(type.baseType.typeDef);
+					Prepare(type.baseType.typeDef);
 
 				TypeInfo info;
-				if (memberInfos.tryGetType(type, out info))
+				if (memberInfos.TryGetType(type, out info))
 					func(info);
 			}
 		}
 
-		static List<MethodNameGroup> getSorted(MethodNameGroups groups) {
-			var allGroups = new List<MethodNameGroup>(groups.getAllGroups());
+		static List<MethodNameGroup> GetSorted(MethodNameGroups groups) {
+			var allGroups = new List<MethodNameGroup>(groups.GetAllGroups());
 			allGroups.Sort((a, b) => b.Count.CompareTo(a.Count));
 			return allGroups;
 		}
@@ -1177,11 +1177,11 @@ namespace de4dot.code.renamer {
 				this.allTypes = allTypes;
 			}
 
-			public void add(MethodNameGroup group) {
+			public void Add(MethodNameGroup group) {
 				groups.Add(group);
 			}
 
-			public void visitAll(Action<MethodNameGroup> func) {
+			public void VisitAll(Action<MethodNameGroup> func) {
 				this.func = func;
 				visited.Clear();
 
@@ -1192,21 +1192,21 @@ namespace de4dot.code.renamer {
 				}
 
 				foreach (var type in allTypes)
-					visit(type);
+					Visit(type);
 			}
 
-			void visit(MTypeDef type) {
+			void Visit(MTypeDef type) {
 				if (visited.ContainsKey(type))
 					return;
 				visited[type] = true;
 
 				if (type.baseType != null)
-					visit(type.baseType.typeDef);
+					Visit(type.baseType.typeDef);
 				foreach (var ifaceInfo in type.interfaces)
-					visit(ifaceInfo.typeDef);
+					Visit(ifaceInfo.typeDef);
 
 				TypeInfo info;
-				if (!memberInfos.tryGetType(type, out info))
+				if (!memberInfos.TryGetType(type, out info))
 					return;
 
 				foreach (var method in type.AllMethodsSorted) {
@@ -1221,7 +1221,7 @@ namespace de4dot.code.renamer {
 		}
 
 		static readonly Regex removeGenericsArityRegex = new Regex(@"`[0-9]+");
-		static string getOverridePrefix(MethodNameGroup group, MMethodDef method) {
+		static string GetOverridePrefix(MethodNameGroup group, MMethodDef method) {
 			if (method == null || method.MethodDef.Overrides.Count == 0)
 				return "";
 			if (group.Methods.Count > 1) {
@@ -1237,26 +1237,26 @@ namespace de4dot.code.renamer {
 			return name + ".";
 		}
 
-		static string getRealName(string name) {
+		static string GetRealName(string name) {
 			int index = name.LastIndexOf('.');
 			if (index < 0)
 				return name;
 			return name.Substring(index + 1);
 		}
 
-		void prepareRenameEvent(MethodNameGroup group, bool renameOverrides) {
+		void PrepareRenameEvent(MethodNameGroup group, bool renameOverrides) {
 			string methodPrefix, overridePrefix;
-			var eventName = prepareRenameEvent(group, renameOverrides, out overridePrefix, out methodPrefix);
+			var eventName = PrepareRenameEvent(group, renameOverrides, out overridePrefix, out methodPrefix);
 			if (eventName == null)
 				return;
 
 			var methodName = overridePrefix + methodPrefix + eventName;
 			foreach (var method in group.Methods)
-				memberInfos.method(method).rename(methodName);
+				memberInfos.Method(method).Rename(methodName);
 		}
 
-		string prepareRenameEvent(MethodNameGroup group, bool renameOverrides, out string overridePrefix, out string methodPrefix) {
-			var eventMethod = getEventMethod(group);
+		string PrepareRenameEvent(MethodNameGroup group, bool renameOverrides, out string overridePrefix, out string methodPrefix) {
+			var eventMethod = GetEventMethod(group);
 			if (eventMethod == null)
 				throw new ApplicationException("No events found");
 
@@ -1270,79 +1270,79 @@ namespace de4dot.code.renamer {
 			else
 				methodPrefix = "";
 
-			overridePrefix = getOverridePrefix(group, eventMethod);
+			overridePrefix = GetOverridePrefix(group, eventMethod);
 			if (renameOverrides && overridePrefix == "")
 				return null;
 			if (!renameOverrides && overridePrefix != "")
 				return null;
 
 			string newEventName, oldEventName;
-			var eventInfo = memberInfos.evt(eventDef);
+			var eventInfo = memberInfos.Event(eventDef);
 
 			bool mustUseOldEventName = false;
 			if (overridePrefix == "")
 				oldEventName = eventInfo.oldName;
 			else {
-				var overriddenEventDef = getOverriddenEvent(eventMethod);
+				var overriddenEventDef = GetOverriddenEvent(eventMethod);
 				if (overriddenEventDef == null)
-					oldEventName = getRealName(eventInfo.oldName);
+					oldEventName = GetRealName(eventInfo.oldName);
 				else {
 					mustUseOldEventName = true;
 					EventInfo info;
-					if (memberInfos.tryGetEvent(overriddenEventDef, out info))
-						oldEventName = getRealName(info.newName);
+					if (memberInfos.TryGetEvent(overriddenEventDef, out info))
+						oldEventName = GetRealName(info.newName);
 					else
-						oldEventName = getRealName(overriddenEventDef.EventDef.Name.String);
+						oldEventName = GetRealName(overriddenEventDef.EventDef.Name.String);
 				}
 			}
 
 			if (eventInfo.renamed)
-				newEventName = getRealName(eventInfo.newName);
-			else if (mustUseOldEventName || eventDef.Owner.Module.ObfuscatedFile.NameChecker.isValidEventName(oldEventName))
+				newEventName = GetRealName(eventInfo.newName);
+			else if (mustUseOldEventName || eventDef.Owner.Module.ObfuscatedFile.NameChecker.IsValidEventName(oldEventName))
 				newEventName = oldEventName;
 			else {
-				mergeStateHelper.merge(MergeStateFlags.Events, group);
-				newEventName = getAvailableName("Event_", false, group, (group2, newName) => isEventAvailable(group2, newName));
+				mergeStateHelper.Merge(MergeStateFlags.Events, group);
+				newEventName = GetAvailableName("Event_", false, group, (group2, newName) => IsEventAvailable(group2, newName));
 			}
 
 			var newEventNameWithPrefix = overridePrefix + newEventName;
 			foreach (var method in group.Methods) {
 				if (method.Event != null) {
-					memberInfos.evt(method.Event).rename(newEventNameWithPrefix);
-					var ownerInfo = memberInfos.type(method.Owner);
-					ownerInfo.variableNameState.addEventName(newEventName);
-					ownerInfo.variableNameState.addEventName(newEventNameWithPrefix);
+					memberInfos.Event(method.Event).Rename(newEventNameWithPrefix);
+					var ownerInfo = memberInfos.Type(method.Owner);
+					ownerInfo.variableNameState.AddEventName(newEventName);
+					ownerInfo.variableNameState.AddEventName(newEventNameWithPrefix);
 				}
 			}
 
 			return newEventName;
 		}
 
-		MEventDef getOverriddenEvent(MMethodDef overrideMethod) {
+		MEventDef GetOverriddenEvent(MMethodDef overrideMethod) {
 			MMethodDef overriddenMethod;
-			return getOverriddenEvent(overrideMethod, out overriddenMethod);
+			return GetOverriddenEvent(overrideMethod, out overriddenMethod);
 		}
 
-		MEventDef getOverriddenEvent(MMethodDef overrideMethod, out MMethodDef overriddenMethod) {
+		MEventDef GetOverriddenEvent(MMethodDef overrideMethod, out MMethodDef overriddenMethod) {
 			var theMethod = overrideMethod.MethodDef.Overrides[0].MethodDeclaration;
-			overriddenMethod = modules.resolveMethod(theMethod);
+			overriddenMethod = modules.ResolveMethod(theMethod);
 			if (overriddenMethod != null)
 				return overriddenMethod.Event;
 
 			var extType = theMethod.DeclaringType;
 			if (extType == null)
 				return null;
-			var extTypeDef = modules.resolveOther(extType);
+			var extTypeDef = modules.ResolveOther(extType);
 			if (extTypeDef == null)
 				return null;
-			overriddenMethod = extTypeDef.findMethod(theMethod);
+			overriddenMethod = extTypeDef.FindMethod(theMethod);
 			if (overriddenMethod != null)
 				return overriddenMethod.Event;
 
 			return null;
 		}
 
-		MMethodDef getEventMethod(MethodNameGroup group) {
+		MMethodDef GetEventMethod(MethodNameGroup group) {
 			foreach (var method in group.Methods) {
 				if (method.Event != null)
 					return method;
@@ -1350,14 +1350,14 @@ namespace de4dot.code.renamer {
 			return null;
 		}
 
-		void prepareRenameProperty(MethodNameGroup group, bool renameOverrides) {
+		void PrepareRenameProperty(MethodNameGroup group, bool renameOverrides) {
 			string overridePrefix;
-			var propName = prepareRenameProperty(group, renameOverrides, out overridePrefix);
+			var propName = PrepareRenameProperty(group, renameOverrides, out overridePrefix);
 			if (propName == null)
 				return;
 
 			string methodPrefix;
-			switch (getPropertyMethodType(group.Methods[0])) {
+			switch (GetPropertyMethodType(group.Methods[0])) {
 			case PropertyMethodType.Getter:
 				methodPrefix = "get_";
 				break;
@@ -1370,15 +1370,15 @@ namespace de4dot.code.renamer {
 
 			var methodName = overridePrefix + methodPrefix + propName;
 			foreach (var method in group.Methods)
-				memberInfos.method(method).rename(methodName);
+				memberInfos.Method(method).Rename(methodName);
 		}
 
-		string prepareRenameProperty(MethodNameGroup group, bool renameOverrides, out string overridePrefix) {
-			var propMethod = getPropertyMethod(group);
+		string PrepareRenameProperty(MethodNameGroup group, bool renameOverrides, out string overridePrefix) {
+			var propMethod = GetPropertyMethod(group);
 			if (propMethod == null)
 				throw new ApplicationException("No properties found");
 
-			overridePrefix = getOverridePrefix(group, propMethod);
+			overridePrefix = GetOverridePrefix(group, propMethod);
 
 			if (renameOverrides && overridePrefix == "")
 				return null;
@@ -1387,83 +1387,83 @@ namespace de4dot.code.renamer {
 
 			string newPropName, oldPropName;
 			var propDef = propMethod.Property;
-			var propInfo = memberInfos.prop(propDef);
+			var propInfo = memberInfos.Property(propDef);
 
 			bool mustUseOldPropName = false;
 			if (overridePrefix == "")
 				oldPropName = propInfo.oldName;
 			else {
-				var overriddenPropDef = getOverriddenProperty(propMethod);
+				var overriddenPropDef = GetOverriddenProperty(propMethod);
 				if (overriddenPropDef == null)
-					oldPropName = getRealName(propInfo.oldName);
+					oldPropName = GetRealName(propInfo.oldName);
 				else {
 					mustUseOldPropName = true;
 					PropertyInfo info;
-					if (memberInfos.tryGetProperty(overriddenPropDef, out info))
-						oldPropName = getRealName(info.newName);
+					if (memberInfos.TryGetProperty(overriddenPropDef, out info))
+						oldPropName = GetRealName(info.newName);
 					else
-						oldPropName = getRealName(overriddenPropDef.PropertyDef.Name.String);
+						oldPropName = GetRealName(overriddenPropDef.PropertyDef.Name.String);
 				}
 			}
 
 			if (propInfo.renamed)
-				newPropName = getRealName(propInfo.newName);
-			else if (mustUseOldPropName || propDef.Owner.Module.ObfuscatedFile.NameChecker.isValidPropertyName(oldPropName))
+				newPropName = GetRealName(propInfo.newName);
+			else if (mustUseOldPropName || propDef.Owner.Module.ObfuscatedFile.NameChecker.IsValidPropertyName(oldPropName))
 				newPropName = oldPropName;
-			else if (isItemProperty(group))
+			else if (IsItemProperty(group))
 				newPropName = "Item";
 			else {
 				bool trySameName = true;
-				var propPrefix = getSuggestedPropertyName(group);
+				var propPrefix = GetSuggestedPropertyName(group);
 				if (propPrefix == null) {
 					trySameName = false;
-					propPrefix = getNewPropertyNamePrefix(group);
+					propPrefix = GetNewPropertyNamePrefix(group);
 				}
-				mergeStateHelper.merge(MergeStateFlags.Properties, group);
-				newPropName = getAvailableName(propPrefix, trySameName, group, (group2, newName) => isPropertyAvailable(group2, newName));
+				mergeStateHelper.Merge(MergeStateFlags.Properties, group);
+				newPropName = GetAvailableName(propPrefix, trySameName, group, (group2, newName) => IsPropertyAvailable(group2, newName));
 			}
 
 			var newPropNameWithPrefix = overridePrefix + newPropName;
 			foreach (var method in group.Methods) {
 				if (method.Property != null) {
-					memberInfos.prop(method.Property).rename(newPropNameWithPrefix);
-					var ownerInfo = memberInfos.type(method.Owner);
-					ownerInfo.variableNameState.addPropertyName(newPropName);
-					ownerInfo.variableNameState.addPropertyName(newPropNameWithPrefix);
+					memberInfos.Property(method.Property).Rename(newPropNameWithPrefix);
+					var ownerInfo = memberInfos.Type(method.Owner);
+					ownerInfo.variableNameState.AddPropertyName(newPropName);
+					ownerInfo.variableNameState.AddPropertyName(newPropNameWithPrefix);
 				}
 			}
 
 			return newPropName;
 		}
 
-		bool isItemProperty(MethodNameGroup group) {
+		bool IsItemProperty(MethodNameGroup group) {
 			foreach (var method in group.Methods) {
-				if (method.Property != null && method.Property.isItemProperty())
+				if (method.Property != null && method.Property.IsItemProperty())
 					return true;
 			}
 			return false;
 		}
 
-		MPropertyDef getOverriddenProperty(MMethodDef overrideMethod) {
+		MPropertyDef GetOverriddenProperty(MMethodDef overrideMethod) {
 			var theMethod = overrideMethod.MethodDef.Overrides[0].MethodDeclaration;
-			var overriddenMethod = modules.resolveMethod(theMethod);
+			var overriddenMethod = modules.ResolveMethod(theMethod);
 			if (overriddenMethod != null)
 				return overriddenMethod.Property;
 
 			var extType = theMethod.DeclaringType;
 			if (extType == null)
 				return null;
-			var extTypeDef = modules.resolveOther(extType);
+			var extTypeDef = modules.ResolveOther(extType);
 			if (extTypeDef == null)
 				return null;
-			var theMethodDef = extTypeDef.findMethod(theMethod);
+			var theMethodDef = extTypeDef.FindMethod(theMethod);
 			if (theMethodDef != null)
 				return theMethodDef.Property;
 
 			return null;
 		}
 
-		MMethodDef getPropertyMethod(MethodNameGroup group) {
+		MMethodDef GetPropertyMethod(MethodNameGroup group) {
 			foreach (var method in group.Methods) {
 				if (method.Property != null)
 					return method;
@@ -1471,21 +1471,21 @@ namespace de4dot.code.renamer {
 			return null;
 		}
 
-		string getSuggestedPropertyName(MethodNameGroup group) {
+		string GetSuggestedPropertyName(MethodNameGroup group) {
 			foreach (var method in group.Methods) {
 				if (method.Property == null)
 					continue;
-				var info = memberInfos.prop(method.Property);
+				var info = memberInfos.Property(method.Property);
 				if (info.suggestedName != null)
 					return info.suggestedName;
 			}
 			return null;
 		}
 
-		string getNewPropertyNamePrefix(MethodNameGroup group) {
+		string GetNewPropertyNamePrefix(MethodNameGroup group) {
 			const string defaultVal = "Prop_";
 
-			var propType = getPropertyType(group);
+			var propType = GetPropertyType(group);
 			if (propType == null)
 				return defaultVal;
 
@@ -1493,7 +1493,7 @@ namespace de4dot.code.renamer {
 			if (propType is GenericInstSig || elementType is GenericSig)
 				return defaultVal;
 
-			var prefix = getPrefix(propType);
+			var prefix = GetPrefix(propType);
 
 			string name = elementType.TypeName;
 			int i;
@@ -1504,14 +1504,14 @@ namespace de4dot.code.renamer {
 			if (name == "")
 				return defaultVal;
 
-			return prefix.ToUpperInvariant() + upperFirst(name) + "_";
+			return prefix.ToUpperInvariant() + UpperFirst(name) + "_";
 		}
 
-		static string upperFirst(string s) {
+		static string UpperFirst(string s) {
 			return s.Substring(0, 1).ToUpperInvariant() + s.Substring(1);
 		}
 
-		static string getPrefix(TypeSig typeRef) {
+		static string GetPrefix(TypeSig typeRef) {
 			string prefix = "";
 			typeRef = typeRef.RemovePinnedAndModifiers();
 			while (typeRef is PtrSig) {
@@ -1527,8 +1527,8 @@ namespace de4dot.code.renamer {
 			Setter,
 		}
 
-		static PropertyMethodType getPropertyMethodType(MMethodDef method) {
-			if (DotNetUtils.hasReturnValue(method.MethodDef))
+		static PropertyMethodType GetPropertyMethodType(MMethodDef method) {
+			if (DotNetUtils.HasReturnValue(method.MethodDef))
 				return PropertyMethodType.Getter;
 			if (method.VisibleParameterCount > 0)
 				return PropertyMethodType.Setter;
@@ -1536,8 +1536,8 @@ namespace de4dot.code.renamer {
 		}
 
 		// Returns property type, or null if not all methods have the same type
-		TypeSig getPropertyType(MethodNameGroup group) {
-			var methodType = getPropertyMethodType(group.Methods[0]);
+		TypeSig GetPropertyType(MethodNameGroup group) {
+			var methodType = GetPropertyMethodType(group.Methods[0]);
 			if (methodType == PropertyMethodType.Other)
 				return null;
 
@@ -1556,7 +1556,7 @@ namespace de4dot.code.renamer {
 			return type;
 		}
 
-		MMethodDef getOverrideMethod(MethodNameGroup group) {
+		MMethodDef GetOverrideMethod(MethodNameGroup group) {
 			foreach (var method in group.Methods) {
 				if (method.MethodDef.Overrides.Count > 0)
 					return method;
@@ -1564,11 +1564,11 @@ namespace de4dot.code.renamer {
 			return null;
 		}
 
-		void prepareRenameVirtualMethods(MethodNameGroup group, string namePrefix, bool renameOverrides) {
-			if (!hasInvalidMethodName(group))
+		void PrepareRenameVirtualMethods(MethodNameGroup group, string namePrefix, bool renameOverrides) {
+			if (!HasInvalidMethodName(group))
 				return;
 
-			if (hasDelegateOwner(group)) {
+			if (HasDelegateOwner(group)) {
 				switch (group.Methods[0].MethodDef.Name.String) {
 				case "Invoke":
 				case "BeginInvoke":
@@ -1577,8 +1577,8 @@ namespace de4dot.code.renamer {
 				}
 			}
 
-			var overrideMethod = getOverrideMethod(group);
-			var overridePrefix = getOverridePrefix(group, overrideMethod);
+			var overrideMethod = GetOverrideMethod(group);
+			var overridePrefix = GetOverridePrefix(group, overrideMethod);
 			if (renameOverrides && overridePrefix == "")
 				return;
 			if (!renameOverrides && overridePrefix != "")
@@ -1586,24 +1586,24 @@ namespace de4dot.code.renamer {
 
 			string newMethodName;
 			if (overridePrefix != "") {
-				var overrideInfo = memberInfos.method(overrideMethod);
-				var overriddenMethod = getOverriddenMethod(overrideMethod);
+				var overrideInfo = memberInfos.Method(overrideMethod);
+				var overriddenMethod = GetOverriddenMethod(overrideMethod);
 				if (overriddenMethod == null)
-					newMethodName = getRealName(overrideMethod.MethodDef.Overrides[0].MethodDeclaration.Name.String);
+					newMethodName = GetRealName(overrideMethod.MethodDef.Overrides[0].MethodDeclaration.Name.String);
 				else
-					newMethodName = getRealName(memberInfos.method(overriddenMethod).newName);
+					newMethodName = GetRealName(memberInfos.Method(overriddenMethod).newName);
 			}
 			else {
-				newMethodName = getSuggestedMethodName(group);
+				newMethodName = GetSuggestedMethodName(group);
 				if (newMethodName == null) {
-					mergeStateHelper.merge(MergeStateFlags.Methods, group);
-					newMethodName = getAvailableName(namePrefix, false, group, (group2, newName) => isMethodAvailable(group2, newName));
+					mergeStateHelper.Merge(MergeStateFlags.Methods, group);
+					newMethodName = GetAvailableName(namePrefix, false, group, (group2, newName) => IsMethodAvailable(group2, newName));
 				}
 			}
 
 			var newMethodNameWithPrefix = overridePrefix + newMethodName;
 			foreach (var method in group.Methods)
-				memberInfos.type(method.Owner).renameMethod(method, newMethodNameWithPrefix);
+				memberInfos.Type(method.Owner).RenameMethod(method, newMethodNameWithPrefix);
 		}
 
 		[Flags]
@@ -1623,71 +1623,71 @@ namespace de4dot.code.renamer {
 				this.memberInfos = memberInfos;
 			}
 
-			public void merge(MergeStateFlags flags, MethodNameGroup group) {
+			public void Merge(MergeStateFlags flags, MethodNameGroup group) {
 				this.flags = flags;
 				visited.Clear();
 				foreach (var method in group.Methods)
-					merge(method.Owner);
+					Merge(method.Owner);
 			}
 
-			void merge(MTypeDef type) {
+			void Merge(MTypeDef type) {
 				if (visited.ContainsKey(type))
 					return;
 				visited[type] = true;
 
 				TypeInfo info;
-				if (!memberInfos.tryGetType(type, out info))
+				if (!memberInfos.TryGetType(type, out info))
 					return;
 
 				if (type.baseType != null)
-					merge(type.baseType.typeDef);
+					Merge(type.baseType.typeDef);
 				foreach (var ifaceInfo in type.interfaces)
-					merge(ifaceInfo.typeDef);
+					Merge(ifaceInfo.typeDef);
 
 				if (type.baseType != null)
-					merge(info, type.baseType.typeDef);
+					Merge(info, type.baseType.typeDef);
 				foreach (var ifaceInfo in type.interfaces)
-					merge(info, ifaceInfo.typeDef);
+					Merge(info, ifaceInfo.typeDef);
 			}
 
-			void merge(TypeInfo info, MTypeDef other) {
+			void Merge(TypeInfo info, MTypeDef other) {
 				TypeInfo otherInfo;
-				if (!memberInfos.tryGetType(other, out otherInfo))
+				if (!memberInfos.TryGetType(other, out otherInfo))
 					return;
 
 				if ((flags & MergeStateFlags.Methods) != MergeStateFlags.None)
-					info.variableNameState.mergeMethods(otherInfo.variableNameState);
+					info.variableNameState.MergeMethods(otherInfo.variableNameState);
 				if ((flags & MergeStateFlags.Properties) != MergeStateFlags.None)
-					info.variableNameState.mergeProperties(otherInfo.variableNameState);
+					info.variableNameState.MergeProperties(otherInfo.variableNameState);
 				if ((flags & MergeStateFlags.Events) != MergeStateFlags.None)
-					info.variableNameState.mergeEvents(otherInfo.variableNameState);
+					info.variableNameState.MergeEvents(otherInfo.variableNameState);
 			}
 		}
 
-		MMethodDef getOverriddenMethod(MMethodDef overrideMethod) {
-			return modules.resolveMethod(overrideMethod.MethodDef.Overrides[0].MethodDeclaration);
+		MMethodDef GetOverriddenMethod(MMethodDef overrideMethod) {
+			return modules.ResolveMethod(overrideMethod.MethodDef.Overrides[0].MethodDeclaration);
 		}
 
-		string getSuggestedMethodName(MethodNameGroup group) {
+		string GetSuggestedMethodName(MethodNameGroup group) {
 			foreach (var method in group.Methods) {
-				var info = memberInfos.method(method);
+				var info = memberInfos.Method(method);
 				if (info.suggestedName != null)
 					return info.suggestedName;
 			}
 			return null;
 		}
 
-		bool hasInvalidMethodName(MethodNameGroup group) {
+		bool HasInvalidMethodName(MethodNameGroup group) {
 			foreach (var method in group.Methods) {
-				var typeInfo = memberInfos.type(method.Owner);
-				var methodInfo = memberInfos.method(method);
-				if (!typeInfo.NameChecker.isValidMethodName(methodInfo.oldName))
+				var typeInfo = memberInfos.Type(method.Owner);
+				var methodInfo = memberInfos.Method(method);
+				if (!typeInfo.NameChecker.IsValidMethodName(methodInfo.oldName))
 					return true;
 			}
 			return false;
 		}
 
-		static string getAvailableName(string prefix, bool tryWithoutZero, MethodNameGroup group, Func<MethodNameGroup, string, bool> checkAvailable) {
+		static string GetAvailableName(string prefix, bool tryWithoutZero, MethodNameGroup group, Func<MethodNameGroup, string, bool> checkAvailable) {
 			for (int i = 0; ; i++) {
 				string newName = i == 0 && tryWithoutZero ? prefix : prefix + i;
 				if (checkAvailable(group, newName))
@@ -1695,56 +1695,56 @@ namespace de4dot.code.renamer {
 			}
 		}
 
-		bool isMethodAvailable(MethodNameGroup group, string methodName) {
+		bool IsMethodAvailable(MethodNameGroup group, string methodName) {
 			foreach (var method in group.Methods) {
-				if (memberInfos.type(method.Owner).variableNameState.isMethodNameUsed(methodName))
+				if (memberInfos.Type(method.Owner).variableNameState.IsMethodNameUsed(methodName))
 					return false;
 			}
 			return true;
 		}
 
-		bool isPropertyAvailable(MethodNameGroup group, string methodName) {
+		bool IsPropertyAvailable(MethodNameGroup group, string methodName) {
 			foreach (var method in group.Methods) {
-				if (memberInfos.type(method.Owner).variableNameState.isPropertyNameUsed(methodName))
+				if (memberInfos.Type(method.Owner).variableNameState.IsPropertyNameUsed(methodName))
 					return false;
 			}
 			return true;
 		}
 
-		bool isEventAvailable(MethodNameGroup group, string methodName) {
+		bool IsEventAvailable(MethodNameGroup group, string methodName) {
 			foreach (var method in group.Methods) {
-				if (memberInfos.type(method.Owner).variableNameState.isEventNameUsed(methodName))
+				if (memberInfos.Type(method.Owner).variableNameState.IsEventNameUsed(methodName))
 					return false;
 			}
 			return true;
 		}
 
-		bool hasDelegateOwner(MethodNameGroup group) {
+		bool HasDelegateOwner(MethodNameGroup group) {
 			foreach (var method in group.Methods) {
-				if (isDelegateClass.check(method.Owner))
+				if (isDelegateClass.Check(method.Owner))
 					return true;
 			}
 			return false;
 		}
 
-		void prepareRenameEntryPoints() {
+		void PrepareRenameEntryPoints() {
 			foreach (var module in modules.TheModules) {
 				var entryPoint = module.ModuleDefMD.EntryPoint;
 				if (entryPoint == null)
 					continue;
-				var methodDef = modules.resolveMethod(entryPoint);
+				var methodDef = modules.ResolveMethod(entryPoint);
 				if (methodDef == null) {
-					Logger.w(string.Format("Could not find entry point. Module: {0}, Method: {1}", module.ModuleDefMD.Location, 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())
+				if (!methodDef.IsStatic())
 					continue;
-				memberInfos.method(methodDef).suggestedName = "Main";
+				memberInfos.Method(methodDef).suggestedName = "Main";
 				if (methodDef.ParamDefs.Count == 1) {
 					var paramDef = methodDef.ParamDefs[0];
 					var type = paramDef.ParameterDef.Type;
 					if (type.FullName == "System.String[]")
-						memberInfos.param(paramDef).newName = "args";
+						memberInfos.Param(paramDef).newName = "args";
 				}
 			}
 		}
diff --git a/de4dot.code/renamer/ResourceKeysRenamer.cs b/de4dot.code/renamer/ResourceKeysRenamer.cs
index 9c00c7d8..a01d2482 100644
--- a/de4dot.code/renamer/ResourceKeysRenamer.cs
+++ b/de4dot.code/renamer/ResourceKeysRenamer.cs
@@ -42,28 +42,28 @@ namespace de4dot.code.renamer {
 			this.nameChecker = nameChecker;
 		}
 
-		public void rename() {
+		public void Rename() {
 			Logger.v("Renaming resource keys ({0})", module);
-			Logger.Instance.indent();
+			Logger.Instance.Indent();
 			foreach (var type in module.GetTypes()) {
-				string resourceName = getResourceName(type);
+				string resourceName = GetResourceName(type);
 				if (resourceName == null)
 					continue;
-				var resource = getResource(resourceName);
+				var resource = GetResource(resourceName);
 				if (resource == null) {
-					Logger.w("Could not find resource {0}", Utils.removeNewlines(resourceName));
+					Logger.w("Could not find resource {0}", Utils.RemoveNewlines(resourceName));
 					continue;
 				}
-				Logger.v("Resource: {0}", Utils.toCsharpString(resource.Name));
-				Logger.Instance.indent();
-				rename(type, resource);
-				Logger.Instance.deIndent();
+				Logger.v("Resource: {0}", Utils.ToCsharpString(resource.Name));
+				Logger.Instance.Indent();
+				Rename(type, resource);
+				Logger.Instance.DeIndent();
 			}
-			Logger.Instance.deIndent();
+			Logger.Instance.DeIndent();
 		}
 
-		EmbeddedResource getResource(string resourceName) {
-			var resource = DotNetUtils.getResource(module, resourceName + ".resources") as EmbeddedResource;
+		EmbeddedResource GetResource(string resourceName) {
+			var resource = DotNetUtils.GetResource(module, resourceName + ".resources") as EmbeddedResource;
 			if (resource != null)
 				return resource;
 
@@ -72,14 +72,14 @@ namespace de4dot.code.renamer {
 			Array.Reverse(pieces);
 			foreach (var piece in pieces) {
 				name = piece + name;
-				resource = DotNetUtils.getResource(module, name + ".resources") as EmbeddedResource;
+				resource = DotNetUtils.GetResource(module, name + ".resources") as EmbeddedResource;
 				if (resource != null)
 					return resource;
 			}
 			return null;
 		}
 
-		static string getResourceName(TypeDef type) {
+		static string GetResourceName(TypeDef type) {
 			foreach (var method in type.Methods) {
 				if (method.Body == null)
 					continue;
@@ -122,27 +122,27 @@ namespace de4dot.code.renamer {
 			}
 		}
 
-		void rename(TypeDef type, EmbeddedResource resource) {
+		void Rename(TypeDef type, EmbeddedResource resource) {
 			newNames.Clear();
 			resource.Data.Position = 0;
-			var resourceSet = ResourceReader.read(module, resource.Data);
+			var resourceSet = ResourceReader.Read(module, resource.Data);
 			var renamed = new List<RenameInfo>();
 			foreach (var elem in resourceSet.ResourceElements) {
-				if (nameChecker.isValidResourceKeyName(elem.Name)) {
+				if (nameChecker.IsValidResourceKeyName(elem.Name)) {
 					newNames.Add(elem.Name, true);
 					continue;
 				}
 
-				renamed.Add(new RenameInfo(elem, getNewName(elem)));
+				renamed.Add(new RenameInfo(elem, GetNewName(elem)));
 			}
 
 			if (renamed.Count == 0)
 				return;
 
-			rename(type, renamed);
+			Rename(type, renamed);
 
 			var outStream = new MemoryStream();
-			ResourceWriter.write(module, outStream, resourceSet);
+			ResourceWriter.Write(module, outStream, resourceSet);
 			var newResource = new EmbeddedResource(resource.Name, outStream.ToArray(), resource.Attributes);
 			int resourceIndex = module.Resources.IndexOf(resource);
 			if (resourceIndex < 0)
@@ -150,7 +150,7 @@ namespace de4dot.code.renamer {
 			module.Resources[resourceIndex] = newResource;
 		}
 
-		void rename(TypeDef 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;
@@ -200,7 +200,7 @@ namespace de4dot.code.renamer {
 						continue;	// should not be renamed
 
 					ldstr.Operand = info.newName;
-					Logger.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;
 				}
@@ -208,19 +208,19 @@ namespace de4dot.code.renamer {
 
 			foreach (var info in renamed) {
 				if (!info.foundInCode)
-					Logger.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));
 			}
 		}
 
-		string getNewName(ResourceElement elem) {
+		string GetNewName(ResourceElement elem) {
 			if (elem.ResourceData.Code != ResourceTypeCode.String)
-				return createDefaultName();
+				return CreateDefaultName();
 			var stringData = (BuiltInResourceData)elem.ResourceData;
-			var name = createPrefixFromStringData((string)stringData.Data);
-			return createName(counter => counter == 0 ? name : string.Format("{0}_{1}", name, counter));
+			var name = CreatePrefixFromStringData((string)stringData.Data);
+			return CreateName(counter => counter == 0 ? name : string.Format("{0}_{1}", name, counter));
 		}
 
-		string createPrefixFromStringData(string data) {
+		string CreatePrefixFromStringData(string data) {
 			var sb = new StringBuilder();
 			data = data.Substring(0, Math.Min(data.Length, 100));
 			data = Regex.Replace(data, "[`'\"]", "");
@@ -237,15 +237,15 @@ namespace de4dot.code.renamer {
 				sb.Append(piece2);
 			}
 			if (sb.Length <= 3)
-				return createDefaultName();
+				return CreateDefaultName();
 			return sb.ToString();
 		}
 
-		string createDefaultName() {
-			return createName(counter => string.Format("{0}{1}", DEFAULT_KEY_NAME, counter));
+		string CreateDefaultName() {
+			return CreateName(counter => string.Format("{0}{1}", DEFAULT_KEY_NAME, counter));
 		}
 
-		string createName(Func<int, string> create) {
+		string CreateName(Func<int, string> create) {
 			for (int counter = 0; ; counter++) {
 				string newName = create(counter);
 				if (!newNames.ContainsKey(newName)) {
diff --git a/de4dot.code/renamer/ResourceRenamer.cs b/de4dot.code/renamer/ResourceRenamer.cs
index e99809b0..e38b6795 100644
--- a/de4dot.code/renamer/ResourceRenamer.cs
+++ b/de4dot.code/renamer/ResourceRenamer.cs
@@ -33,7 +33,7 @@ namespace de4dot.code.renamer {
 			this.module = module;
 		}
 
-		public void rename(List<TypeInfo> renamedTypes) {
+		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) => {
@@ -53,16 +53,16 @@ namespace de4dot.code.renamer {
 					nameToResource[name.Substring(0, index)] = resource;
 			}
 
-			renameResourceNamesInCode(renamedTypes);
-			renameResources(renamedTypes);
+			RenameResourceNamesInCode(renamedTypes);
+			RenameResources(renamedTypes);
 		}
 
-		void renameResourceNamesInCode(List<TypeInfo> renamedTypes) {
+		void RenameResourceNamesInCode(List<TypeInfo> renamedTypes) {
 			var oldNameToTypeInfo = new Dictionary<string, TypeInfo>(StringComparer.Ordinal);
 			foreach (var info in renamedTypes)
 				oldNameToTypeInfo[info.oldFullName] = info;
 
-			foreach (var method in module.getAllMethods()) {
+			foreach (var method in module.GetAllMethods()) {
 				if (!method.HasBody)
 					continue;
 				var instrs = method.Body.Instructions;
@@ -84,18 +84,18 @@ namespace de4dot.code.renamer {
 					var newName = typeInfo.type.TypeDef.FullName;
 
 					bool renameCodeString = module.ObfuscatedFile.RenameResourcesInCode ||
-											isCallingResourceManagerCtor(instrs, i, typeInfo);
+											IsCallingResourceManagerCtor(instrs, i, typeInfo);
 					if (!renameCodeString)
-						Logger.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;
-						Logger.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));
 					}
 				}
 			}
 		}
 
-		static bool isCallingResourceManagerCtor(IList<Instruction> instrs, int ldstrIndex, TypeInfo typeInfo) {
+		static bool IsCallingResourceManagerCtor(IList<Instruction> instrs, int ldstrIndex, TypeInfo typeInfo) {
 			try {
 				int index = ldstrIndex + 1;
 
@@ -105,9 +105,9 @@ namespace de4dot.code.renamer {
 				if (!new SigComparer().Equals(typeInfo.type.TypeDef, ldtoken.Operand as ITypeDefOrRef))
 					return false;
 
-				if (!checkCalledMethod(instrs[index++], "System.Type", "(System.RuntimeTypeHandle)"))
+				if (!CheckCalledMethod(instrs[index++], "System.Type", "(System.RuntimeTypeHandle)"))
 					return false;
-				if (!checkCalledMethod(instrs[index++], "System.Reflection.Assembly", "()"))
+				if (!CheckCalledMethod(instrs[index++], "System.Reflection.Assembly", "()"))
 					return false;
 
 				var newobj = instrs[index++];
@@ -126,10 +126,10 @@ namespace de4dot.code.renamer {
 			}
 		}
 
-		static bool checkCalledMethod(Instruction instr, string returnType, string parameters) {
+		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 IMethod, returnType, parameters);
+			return DotNetUtils.IsMethod(instr.Operand as IMethod, returnType, parameters);
 		}
 
 		class RenameInfo {
@@ -146,7 +146,7 @@ namespace de4dot.code.renamer {
 			}
 		}
 
-		void renameResources(List<TypeInfo> renamedTypes) {
+		void RenameResources(List<TypeInfo> renamedTypes) {
 			var newNames = new Dictionary<Resource, RenameInfo>();
 			foreach (var info in renamedTypes) {
 				var oldFullName = info.oldFullName;
@@ -159,7 +159,7 @@ namespace de4dot.code.renamer {
 				var newName = newTypeName + resource.Name.String.Substring(oldFullName.Length);
 				newNames[resource] = new RenameInfo(resource, info, newName);
 
-				Logger.v("Renamed resource in resources: {0} => {1}", Utils.removeNewlines(resource.Name), newName);
+				Logger.v("Renamed resource in resources: {0} => {1}", Utils.RemoveNewlines(resource.Name), newName);
 				resource.Name = newName;
 			}
 		}
diff --git a/de4dot.code/renamer/TypeInfo.cs b/de4dot.code/renamer/TypeInfo.cs
index b480317a..4f41f0f0 100644
--- a/de4dot.code/renamer/TypeInfo.cs
+++ b/de4dot.code/renamer/TypeInfo.cs
@@ -29,7 +29,7 @@ namespace de4dot.code.renamer {
 	class TypeInfo : MemberInfo {
 		public string oldNamespace;
 		public string newNamespace;
-		public VariableNameState variableNameState = VariableNameState.create();
+		public VariableNameState variableNameState = VariableNameState.Create();
 		public MTypeDef type;
 		MemberInfos memberInfos;
 
@@ -44,154 +44,154 @@ namespace de4dot.code.renamer {
 			oldNamespace = typeDef.TypeDef.Namespace.String;
 		}
 
-		bool isWinFormsClass() {
-			return memberInfos.isWinFormsClass(type);
+		bool IsWinFormsClass() {
+			return memberInfos.IsWinFormsClass(type);
 		}
 
-		public PropertyInfo prop(MPropertyDef prop) {
-			return memberInfos.prop(prop);
+		public PropertyInfo Property(MPropertyDef prop) {
+			return memberInfos.Property(prop);
 		}
 
-		public EventInfo evt(MEventDef evt) {
-			return memberInfos.evt(evt);
+		public EventInfo Event(MEventDef evt) {
+			return memberInfos.Event(evt);
 		}
 
-		public FieldInfo field(MFieldDef field) {
-			return memberInfos.field(field);
+		public FieldInfo Field(MFieldDef field) {
+			return memberInfos.Field(field);
 		}
 
-		public MethodInfo method(MMethodDef method) {
-			return memberInfos.method(method);
+		public MethodInfo Method(MMethodDef method) {
+			return memberInfos.Method(method);
 		}
 
-		public GenericParamInfo gparam(MGenericParamDef gparam) {
-			return memberInfos.gparam(gparam);
+		public GenericParamInfo GenericParam(MGenericParamDef gparam) {
+			return memberInfos.GenericParam(gparam);
 		}
 
-		public ParamInfo param(MParamDef param) {
-			return memberInfos.param(param);
+		public ParamInfo Param(MParamDef param) {
+			return memberInfos.Param(param);
 		}
 
-		TypeInfo getBase() {
+		TypeInfo GetBase() {
 			if (type.baseType == null)
 				return null;
 
 			TypeInfo baseInfo;
-			memberInfos.tryGetType(type.baseType.typeDef, out baseInfo);
+			memberInfos.TryGetType(type.baseType.typeDef, out baseInfo);
 			return baseInfo;
 		}
 
-		bool isModuleType() {
+		bool IsModuleType() {
 			return type.TypeDef.IsGlobalModuleType;
 		}
 
-		public void prepareRenameTypes(TypeRenamerState state) {
+		public void PrepareRenameTypes(TypeRenamerState state) {
 			var checker = NameChecker;
 
 			if (newNamespace == null && oldNamespace != "") {
 				if (type.TypeDef.IsNested)
 					newNamespace = "";
-				else if (!checker.isValidNamespaceName(oldNamespace))
-					newNamespace = state.createNamespace(this.type.TypeDef, oldNamespace);
+				else if (!checker.IsValidNamespaceName(oldNamespace))
+					newNamespace = state.CreateNamespace(this.type.TypeDef, oldNamespace);
 			}
 
 			string origClassName = null;
-			if (isWinFormsClass())
-				origClassName = findWindowsFormsClassName(type);
-			if (isModuleType()) {
+			if (IsWinFormsClass())
+				origClassName = FindWindowsFormsClassName(type);
+			if (IsModuleType()) {
 				if (oldNamespace != "")
 					newNamespace = "";
-				rename("<Module>");
+				Rename("<Module>");
 			}
-			else if (!checker.isValidTypeName(oldName)) {
-				if (origClassName != null && checker.isValidTypeName(origClassName))
-					rename(state.getTypeName(oldName, origClassName));
+			else if (!checker.IsValidTypeName(oldName)) {
+				if (origClassName != null && checker.IsValidTypeName(origClassName))
+					Rename(state.GetTypeName(oldName, origClassName));
 				else {
-					ITypeNameCreator nameCreator = type.isGlobalType() ?
+					ITypeNameCreator nameCreator = type.IsGlobalType() ?
 											state.globalTypeNameCreator :
 											state.internalTypeNameCreator;
 					string newBaseType = null;
-					TypeInfo baseInfo = getBase();
+					TypeInfo baseInfo = GetBase();
 					if (baseInfo != null && baseInfo.renamed)
 						newBaseType = baseInfo.newName;
-					rename(nameCreator.create(type.TypeDef, newBaseType));
+					Rename(nameCreator.Create(type.TypeDef, newBaseType));
 				}
 			}
 
-			prepareRenameGenericParams(type.GenericParams, checker);
+			PrepareRenameGenericParams(type.GenericParams, checker);
 		}
 
-		public void mergeState() {
+		public void MergeState() {
 			foreach (var ifaceInfo in type.interfaces)
-				mergeState(ifaceInfo.typeDef);
+				MergeState(ifaceInfo.typeDef);
 			if (type.baseType != null)
-				mergeState(type.baseType.typeDef);
+				MergeState(type.baseType.typeDef);
 		}
 
-		void mergeState(MTypeDef other) {
+		void MergeState(MTypeDef other) {
 			if (other == null)
 				return;
 			TypeInfo otherInfo;
-			if (!memberInfos.tryGetType(other, out otherInfo))
+			if (!memberInfos.TryGetType(other, out otherInfo))
 				return;
-			variableNameState.merge(otherInfo.variableNameState);
+			variableNameState.Merge(otherInfo.variableNameState);
 		}
 
-		public void prepareRenameMembers() {
-			mergeState();
+		public void PrepareRenameMembers() {
+			MergeState();
 
 			foreach (var fieldDef in type.AllFields)
-				variableNameState.addFieldName(field(fieldDef).oldName);
+				variableNameState.AddFieldName(Field(fieldDef).oldName);
 			foreach (var eventDef in type.AllEvents)
-				variableNameState.addEventName(evt(eventDef).oldName);
+				variableNameState.AddEventName(Event(eventDef).oldName);
 			foreach (var propDef in type.AllProperties)
-				variableNameState.addPropertyName(prop(propDef).oldName);
+				variableNameState.AddPropertyName(Property(propDef).oldName);
 			foreach (var methodDef in type.AllMethods)
-				variableNameState.addMethodName(method(methodDef).oldName);
+				variableNameState.AddMethodName(Method(methodDef).oldName);
 
-			if (isWinFormsClass())
-				initializeWindowsFormsFieldsAndProps();
+			if (IsWinFormsClass())
+				InitializeWindowsFormsFieldsAndProps();
 
-			prepareRenameFields();
+			PrepareRenameFields();
 		}
 
-		public void prepareRenamePropsAndEvents() {
-			mergeState();
-			prepareRenameProperties();
-			prepareRenameEvents();
+		public void PrepareRenamePropsAndEvents() {
+			MergeState();
+			PrepareRenameProperties();
+			PrepareRenameEvents();
 		}
 
-		void prepareRenameFields() {
+		void PrepareRenameFields() {
 			var checker = NameChecker;
 
 			if (type.TypeDef.IsEnum) {
-				var instanceFields = getInstanceFields();
+				var instanceFields = GetInstanceFields();
 				if (instanceFields.Count == 1)
-					field(instanceFields[0]).rename("value__");
+					Field(instanceFields[0]).Rename("value__");
 
 				int i = 0;
-				string nameFormat = hasFlagsAttribute() ? "flag_{0}" : "const_{0}";
+				string nameFormat = HasFlagsAttribute() ? "flag_{0}" : "const_{0}";
 				foreach (var fieldDef in type.AllFieldsSorted) {
-					var fieldInfo = field(fieldDef);
+					var fieldInfo = Field(fieldDef);
 					if (fieldInfo.renamed)
 						continue;
 					if (!fieldDef.FieldDef.IsStatic || !fieldDef.FieldDef.IsLiteral)
 						continue;
-					if (!checker.isValidFieldName(fieldInfo.oldName))
-						fieldInfo.rename(string.Format(nameFormat, i));
+					if (!checker.IsValidFieldName(fieldInfo.oldName))
+						fieldInfo.Rename(string.Format(nameFormat, i));
 					i++;
 				}
 			}
 			foreach (var fieldDef in type.AllFieldsSorted) {
-				var fieldInfo = field(fieldDef);
+				var fieldInfo = Field(fieldDef);
 				if (fieldInfo.renamed)
 					continue;
-				if (!checker.isValidFieldName(fieldInfo.oldName))
-					fieldInfo.rename(fieldInfo.suggestedName ?? variableNameState.getNewFieldName(fieldDef.FieldDef));
+				if (!checker.IsValidFieldName(fieldInfo.oldName))
+					fieldInfo.Rename(fieldInfo.suggestedName ?? variableNameState.GetNewFieldName(fieldDef.FieldDef));
 			}
 		}
 
-		List<MFieldDef> getInstanceFields() {
+		List<MFieldDef> GetInstanceFields() {
 			var fields = new List<MFieldDef>();
 			foreach (var fieldDef in type.AllFields) {
 				if (!fieldDef.FieldDef.IsStatic)
@@ -200,7 +200,7 @@ namespace de4dot.code.renamer {
 			return fields;
 		}
 
-		bool hasFlagsAttribute() {
+		bool HasFlagsAttribute() {
 			foreach (var attr in type.TypeDef.CustomAttributes) {
 				if (attr.AttributeType.FullName == "System.FlagsAttribute")
 					return true;
@@ -208,124 +208,124 @@ namespace de4dot.code.renamer {
 			return false;
 		}
 
-		void prepareRenameProperties() {
+		void PrepareRenameProperties() {
 			foreach (var propDef in type.AllPropertiesSorted) {
-				if (propDef.isVirtual())
+				if (propDef.IsVirtual())
 					continue;
-				prepareRenameProperty(propDef);
+				PrepareRenameProperty(propDef);
 			}
 		}
 
-		void prepareRenameProperty(MPropertyDef propDef) {
-			if (propDef.isVirtual())
+		void PrepareRenameProperty(MPropertyDef propDef) {
+			if (propDef.IsVirtual())
 				throw new ApplicationException("Can't rename virtual props here");
-			var propInfo = prop(propDef);
+			var propInfo = Property(propDef);
 			if (propInfo.renamed)
 				return;
 
 			string propName = propInfo.oldName;
-			if (!NameChecker.isValidPropertyName(propName))
+			if (!NameChecker.IsValidPropertyName(propName))
 				propName = propInfo.suggestedName;
-			if (!NameChecker.isValidPropertyName(propName)) {
-				if (propDef.isItemProperty())
+			if (!NameChecker.IsValidPropertyName(propName)) {
+				if (propDef.IsItemProperty())
 					propName = "Item";
 				else
-					propName = variableNameState.getNewPropertyName(propDef.PropertyDef);
+					propName = variableNameState.GetNewPropertyName(propDef.PropertyDef);
 			}
-			variableNameState.addPropertyName(propName);
-			propInfo.rename(propName);
+			variableNameState.AddPropertyName(propName);
+			propInfo.Rename(propName);
 
-			renameSpecialMethod(propDef.GetMethod, "get_" + propName);
-			renameSpecialMethod(propDef.SetMethod, "set_" + propName);
+			RenameSpecialMethod(propDef.GetMethod, "get_" + propName);
+			RenameSpecialMethod(propDef.SetMethod, "set_" + propName);
 		}
 
-		void prepareRenameEvents() {
+		void PrepareRenameEvents() {
 			foreach (var eventDef in type.AllEventsSorted) {
-				if (eventDef.isVirtual())
+				if (eventDef.IsVirtual())
 					continue;
-				prepareRenameEvent(eventDef);
+				PrepareRenameEvent(eventDef);
 			}
 		}
 
-		void prepareRenameEvent(MEventDef eventDef) {
-			if (eventDef.isVirtual())
+		void PrepareRenameEvent(MEventDef eventDef) {
+			if (eventDef.IsVirtual())
 				throw new ApplicationException("Can't rename virtual events here");
-			var eventInfo = evt(eventDef);
+			var eventInfo = Event(eventDef);
 			if (eventInfo.renamed)
 				return;
 
 			string eventName = eventInfo.oldName;
-			if (!NameChecker.isValidEventName(eventName))
+			if (!NameChecker.IsValidEventName(eventName))
 				eventName = eventInfo.suggestedName;
-			if (!NameChecker.isValidEventName(eventName))
-				eventName = variableNameState.getNewEventName(eventDef.EventDef);
-			variableNameState.addEventName(eventName);
-			eventInfo.rename(eventName);
+			if (!NameChecker.IsValidEventName(eventName))
+				eventName = variableNameState.GetNewEventName(eventDef.EventDef);
+			variableNameState.AddEventName(eventName);
+			eventInfo.Rename(eventName);
 
-			renameSpecialMethod(eventDef.AddMethod, "add_" + eventName);
-			renameSpecialMethod(eventDef.RemoveMethod, "remove_" + eventName);
-			renameSpecialMethod(eventDef.RaiseMethod, "raise_" + eventName);
+			RenameSpecialMethod(eventDef.AddMethod, "add_" + eventName);
+			RenameSpecialMethod(eventDef.RemoveMethod, "remove_" + eventName);
+			RenameSpecialMethod(eventDef.RaiseMethod, "raise_" + eventName);
 		}
 
-		void renameSpecialMethod(MMethodDef methodDef, string newName) {
+		void RenameSpecialMethod(MMethodDef methodDef, string newName) {
 			if (methodDef == null)
 				return;
-			if (methodDef.isVirtual())
+			if (methodDef.IsVirtual())
 				return;
-			renameMethod(methodDef, newName);
+			RenameMethod(methodDef, newName);
 		}
 
-		public void prepareRenameMethods() {
-			mergeState();
+		public void PrepareRenameMethods() {
+			MergeState();
 			foreach (var methodDef in type.AllMethodsSorted) {
-				if (methodDef.isVirtual())
+				if (methodDef.IsVirtual())
 					continue;
-				renameMethod(methodDef);
+				RenameMethod(methodDef);
 			}
 		}
 
-		public void prepareRenameMethods2() {
+		public void PrepareRenameMethods2() {
 			var checker = NameChecker;
 			foreach (var methodDef in type.AllMethodsSorted) {
-				prepareRenameMethodArgs(methodDef);
-				prepareRenameGenericParams(methodDef.GenericParams, checker, methodDef.Owner == null ? null : methodDef.Owner.GenericParams);
+				PrepareRenameMethodArgs(methodDef);
+				PrepareRenameGenericParams(methodDef.GenericParams, checker, methodDef.Owner == null ? null : methodDef.Owner.GenericParams);
 			}
 		}
 
-		void prepareRenameMethodArgs(MMethodDef methodDef) {
+		void PrepareRenameMethodArgs(MMethodDef methodDef) {
 			VariableNameState newVariableNameState = null;
 			ParamInfo info;
 			if (methodDef.VisibleParameterCount > 0) {
-				if (isEventHandler(methodDef)) {
-					info = param(methodDef.ParamDefs[methodDef.VisibleParameterBaseIndex]);
-					if (!info.gotNewName())
+				if (IsEventHandler(methodDef)) {
+					info = Param(methodDef.ParamDefs[methodDef.VisibleParameterBaseIndex]);
+					if (!info.GotNewName())
 						info.newName = "sender";
 
-					info = param(methodDef.ParamDefs[methodDef.VisibleParameterBaseIndex + 1]);
-					if (!info.gotNewName())
+					info = Param(methodDef.ParamDefs[methodDef.VisibleParameterBaseIndex + 1]);
+					if (!info.GotNewName())
 						info.newName = "e";
 				}
 				else {
-					newVariableNameState = variableNameState.cloneParamsOnly();
+					newVariableNameState = variableNameState.CloneParamsOnly();
 					var checker = NameChecker;
 					foreach (var paramDef in methodDef.ParamDefs) {
 						if (paramDef.IsHiddenThisParameter)
 							continue;
-						info = param(paramDef);
-						if (info.gotNewName())
+						info = Param(paramDef);
+						if (info.GotNewName())
 							continue;
-						if (!checker.isValidMethodArgName(info.oldName))
-							info.newName = newVariableNameState.getNewParamName(info.oldName, paramDef.ParameterDef);
+						if (!checker.IsValidMethodArgName(info.oldName))
+							info.newName = newVariableNameState.GetNewParamName(info.oldName, paramDef.ParameterDef);
 					}
 				}
 			}
 
-			info = param(methodDef.ReturnParamDef);
-			if (!info.gotNewName()) {
-				if (!NameChecker.isValidMethodReturnArgName(info.oldName)) {
+			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.ParameterDef);
+						newVariableNameState = variableNameState.CloneParamsOnly();
+					info.newName = newVariableNameState.GetNewParamName(info.oldName, methodDef.ReturnParamDef.ParameterDef);
 				}
 			}
 
@@ -333,19 +333,19 @@ namespace de4dot.code.renamer {
 				(methodDef.Event != null && (methodDef == methodDef.Event.AddMethod || methodDef == methodDef.Event.RemoveMethod))) {
 				if (methodDef.VisibleParameterCount > 0) {
 					var paramDef = methodDef.ParamDefs[methodDef.ParamDefs.Count - 1];
-					param(paramDef).newName = "value";
+					Param(paramDef).newName = "value";
 				}
 			}
 		}
 
-		bool canRenameMethod(MMethodDef methodDef) {
-			var methodInfo = method(methodDef);
-			if (methodDef.isStatic()) {
+		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.TypeDef)) {
+			else if (methodDef.IsVirtual()) {
+				if (DotNetUtils.DerivesFromDelegate(type.TypeDef)) {
 					switch (methodInfo.oldName) {
 					case "BeginInvoke":
 					case "EndInvoke":
@@ -361,53 +361,53 @@ namespace de4dot.code.renamer {
 			return true;
 		}
 
-		public void renameMethod(MMethodDef methodDef, string methodName) {
-			if (!canRenameMethod(methodDef))
+		public void RenameMethod(MMethodDef methodDef, string methodName) {
+			if (!CanRenameMethod(methodDef))
 				return;
-			var methodInfo = method(methodDef);
-			variableNameState.addMethodName(methodName);
-			methodInfo.rename(methodName);
+			var methodInfo = Method(methodDef);
+			variableNameState.AddMethodName(methodName);
+			methodInfo.Rename(methodName);
 		}
 
-		void renameMethod(MMethodDef methodDef) {
-			if (methodDef.isVirtual())
+		void RenameMethod(MMethodDef methodDef) {
+			if (methodDef.IsVirtual())
 				throw new ApplicationException("Can't rename virtual methods here");
-			if (!canRenameMethod(methodDef))
+			if (!CanRenameMethod(methodDef))
 				return;
 
-			var info = method(methodDef);
+			var info = Method(methodDef);
 			if (info.renamed)
 				return;
 			info.renamed = true;
 			var checker = NameChecker;
 
 			// PInvoke methods' EntryPoint is always valid. It has to, so always rename.
-			bool isValidName = NameChecker.isValidMethodName(info.oldName);
+			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;
 				string newName2;
-				if (methodDef.MethodDef.ImplMap != null && !string.IsNullOrEmpty(newName2 = getPinvokeName(methodDef)))
+				if (methodDef.MethodDef.ImplMap != null && !string.IsNullOrEmpty(newName2 = GetPinvokeName(methodDef)))
 					newName = newName2;
-				else if (methodDef.isStatic())
+				else if (methodDef.IsStatic())
 					nameCreator = variableNameState.staticMethodNameCreator;
 				else
 					nameCreator = variableNameState.instanceMethodNameCreator;
 				if (!string.IsNullOrEmpty(newName))
 					nameCreator = new NameCreator2(newName);
-				renameMethod(methodDef, variableNameState.getNewMethodName(info.oldName, nameCreator));
+				RenameMethod(methodDef, variableNameState.GetNewMethodName(info.oldName, nameCreator));
 			}
 		}
 
-		string getPinvokeName(MMethodDef methodDef) {
+		string GetPinvokeName(MMethodDef methodDef) {
 			var entryPoint = methodDef.MethodDef.ImplMap.Name.String;
 			if (Regex.IsMatch(entryPoint, @"^#\d+$"))
-				entryPoint = DotNetUtils.getDllName(methodDef.MethodDef.ImplMap.Module.Name.String) + "_" + entryPoint.Substring(1);
+				entryPoint = DotNetUtils.GetDllName(methodDef.MethodDef.ImplMap.Module.Name.String) + "_" + entryPoint.Substring(1);
 			return entryPoint;
 		}
 
-		static bool isEventHandler(MMethodDef methodDef) {
+		static bool IsEventHandler(MMethodDef methodDef) {
 			var sig = methodDef.MethodDef.MethodSig;
 			if (sig == null || sig.Params.Count != 2)
 				return false;
@@ -420,43 +420,43 @@ namespace de4dot.code.renamer {
 			return true;
 		}
 
-		void prepareRenameGenericParams(IEnumerable<MGenericParamDef> genericParams, INameChecker checker) {
-			prepareRenameGenericParams(genericParams, checker, null);
+		void PrepareRenameGenericParams(IEnumerable<MGenericParamDef> genericParams, INameChecker checker) {
+			PrepareRenameGenericParams(genericParams, checker, null);
 		}
 
-		void prepareRenameGenericParams(IEnumerable<MGenericParamDef> genericParams, INameChecker checker, IEnumerable<MGenericParamDef> otherGenericParams) {
+		void PrepareRenameGenericParams(IEnumerable<MGenericParamDef> genericParams, INameChecker checker, IEnumerable<MGenericParamDef> otherGenericParams) {
 			var usedNames = new Dictionary<string, bool>(StringComparer.Ordinal);
 			var nameCreator = new GenericParamNameCreator();
 
 			if (otherGenericParams != null) {
 				foreach (var param in otherGenericParams) {
-					var gpInfo = memberInfos.gparam(param);
+					var gpInfo = memberInfos.GenericParam(param);
 					usedNames[gpInfo.newName] = true;
 				}
 			}
 
 			foreach (var param in genericParams) {
-				var gpInfo = memberInfos.gparam(param);
-				if (!checker.isValidGenericParamName(gpInfo.oldName) || usedNames.ContainsKey(gpInfo.oldName)) {
+				var gpInfo = memberInfos.GenericParam(param);
+				if (!checker.IsValidGenericParamName(gpInfo.oldName) || usedNames.ContainsKey(gpInfo.oldName)) {
 					string newName;
 					do {
-						newName = nameCreator.create();
+						newName = nameCreator.Create();
 					} while (usedNames.ContainsKey(newName));
 					usedNames[newName] = true;
-					gpInfo.rename(newName);
+					gpInfo.Rename(newName);
 				}
 			}
 		}
 
-		void initializeWindowsFormsFieldsAndProps() {
+		void InitializeWindowsFormsFieldsAndProps() {
 			var checker = NameChecker;
 
 			var ourFields = new FieldDefAndDeclaringTypeDict<MFieldDef>();
 			foreach (var fieldDef in type.AllFields)
-				ourFields.add(fieldDef.FieldDef, fieldDef);
+				ourFields.Add(fieldDef.FieldDef, fieldDef);
 			var ourMethods = new MethodDefAndDeclaringTypeDict<MMethodDef>();
 			foreach (var methodDef in type.AllMethods)
-				ourMethods.add(methodDef.MethodDef, methodDef);
+				ourMethods.Add(methodDef.MethodDef, methodDef);
 
 			foreach (var methodDef in type.AllMethods) {
 				if (methodDef.MethodDef.Body == null)
@@ -468,14 +468,14 @@ namespace de4dot.code.renamer {
 					var call = instructions[i];
 					if (call.OpCode.Code != Code.Call && call.OpCode.Code != Code.Callvirt)
 						continue;
-					if (!isWindowsFormsSetNameMethod(call.Operand as IMethod))
+					if (!IsWindowsFormsSetNameMethod(call.Operand as IMethod))
 						continue;
 
 					var ldstr = instructions[i - 1];
 					if (ldstr.OpCode.Code != Code.Ldstr)
 						continue;
 					var fieldName = ldstr.Operand as string;
-					if (fieldName == null || !checker.isValidFieldName(fieldName))
+					if (fieldName == null || !checker.IsValidFieldName(fieldName))
 						continue;
 
 					var instr = instructions[i - 2];
@@ -484,16 +484,16 @@ namespace de4dot.code.renamer {
 						var calledMethod = instr.Operand as IMethod;
 						if (calledMethod == null)
 							continue;
-						var calledMethodDef = ourMethods.find(calledMethod);
+						var calledMethodDef = ourMethods.Find(calledMethod);
 						if (calledMethodDef == null)
 							continue;
-						fieldRef = getFieldRef(calledMethodDef.MethodDef);
+						fieldRef = GetFieldRef(calledMethodDef.MethodDef);
 
 						var propDef = calledMethodDef.Property;
 						if (propDef == null)
 							continue;
 
-						memberInfos.prop(propDef).suggestedName = fieldName;
+						memberInfos.Property(propDef).suggestedName = fieldName;
 						fieldName = "_" + fieldName;
 					}
 					else if (instr.OpCode.Code == Code.Ldfld) {
@@ -502,63 +502,63 @@ namespace de4dot.code.renamer {
 
 					if (fieldRef == null)
 						continue;
-					var fieldDef = ourFields.find(fieldRef);
+					var fieldDef = ourFields.Find(fieldRef);
 					if (fieldDef == null)
 						continue;
-					var fieldInfo = memberInfos.field(fieldDef);
+					var fieldInfo = memberInfos.Field(fieldDef);
 
 					if (fieldInfo.renamed)
 						continue;
 
-					fieldInfo.suggestedName = variableNameState.getNewFieldName(fieldInfo.oldName, new NameCreator2(fieldName));
+					fieldInfo.suggestedName = variableNameState.GetNewFieldName(fieldInfo.oldName, new NameCreator2(fieldName));
 				}
 			}
 		}
 
-		static IField getFieldRef(MethodDef method) {
+		static IField GetFieldRef(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);
+			var ldarg0 = DotNetUtils.GetInstruction(instructions, ref index);
 			if (ldarg0 == null || ldarg0.GetParameterIndex() != 0)
 				return null;
-			var ldfld = DotNetUtils.getInstruction(instructions, ref index);
+			var ldfld = DotNetUtils.GetInstruction(instructions, ref index);
 			if (ldfld == null || ldfld.OpCode.Code != Code.Ldfld)
 				return null;
-			var ret = DotNetUtils.getInstruction(instructions, ref index);
+			var ret = DotNetUtils.GetInstruction(instructions, ref index);
 			if (ret == null)
 				return null;
 			if (ret.IsStloc()) {
 				var local = ret.GetLocal(method.Body.Variables);
-				ret = DotNetUtils.getInstruction(instructions, ref index);
+				ret = DotNetUtils.GetInstruction(instructions, ref index);
 				if (ret == null || !ret.IsLdloc())
 					return null;
 				if (ret.GetLocal(method.Body.Variables) != local)
 					return null;
-				ret = DotNetUtils.getInstruction(instructions, ref index);
+				ret = DotNetUtils.GetInstruction(instructions, ref index);
 			}
 			if (ret == null || ret.OpCode.Code != Code.Ret)
 				return null;
 			return ldfld.Operand as IField;
 		}
 
-		public void initializeEventHandlerNames() {
+		public void InitializeEventHandlerNames() {
 			var ourFields = new FieldDefAndDeclaringTypeDict<MFieldDef>();
 			foreach (var fieldDef in type.AllFields)
-				ourFields.add(fieldDef.FieldDef, fieldDef);
+				ourFields.Add(fieldDef.FieldDef, fieldDef);
 			var ourMethods = new MethodDefAndDeclaringTypeDict<MMethodDef>();
 			foreach (var methodDef in type.AllMethods)
-				ourMethods.add(methodDef.MethodDef, methodDef);
+				ourMethods.Add(methodDef.MethodDef, methodDef);
 
-			initVbEventHandlers(ourFields, ourMethods);
-			initFieldEventHandlers(ourFields, ourMethods);
-			initTypeEventHandlers(ourFields, ourMethods);
+			InitVbEventHandlers(ourFields, ourMethods);
+			InitFieldEventHandlers(ourFields, ourMethods);
+			InitTypeEventHandlers(ourFields, ourMethods);
 		}
 
 		// 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(FieldDefAndDeclaringTypeDict<MFieldDef> ourFields, MethodDefAndDeclaringTypeDict<MMethodDef> ourMethods) {
+		void InitVbEventHandlers(FieldDefAndDeclaringTypeDict<MFieldDef> ourFields, MethodDefAndDeclaringTypeDict<MMethodDef> ourMethods) {
 			var checker = NameChecker;
 
 			foreach (var propDef in type.AllProperties) {
@@ -567,21 +567,21 @@ namespace de4dot.code.renamer {
 					continue;
 
 				string eventName;
-				var handler = getVbHandler(setterDef.MethodDef, out eventName);
+				var handler = GetVbHandler(setterDef.MethodDef, out eventName);
 				if (handler == null)
 					continue;
-				var handlerDef = ourMethods.find(handler);
+				var handlerDef = ourMethods.Find(handler);
 				if (handlerDef == null)
 					continue;
 
-				if (!checker.isValidEventName(eventName))
+				if (!checker.IsValidEventName(eventName))
 					continue;
 
-				memberInfos.method(handlerDef).suggestedName = string.Format("{0}_{1}", memberInfos.prop(propDef).newName, eventName);
+				memberInfos.Method(handlerDef).suggestedName = string.Format("{0}_{1}", memberInfos.Property(propDef).newName, eventName);
 			}
 		}
 
-		static IMethod getVbHandler(MethodDef method, out string eventName) {
+		static IMethod GetVbHandler(MethodDef method, out string eventName) {
 			eventName = null;
 			if (method.Body == null)
 				return null;
@@ -594,16 +594,16 @@ namespace de4dot.code.renamer {
 				return null;
 			if (method.Body.Variables.Count != 1)
 				return null;
-			if (!isEventHandlerType(method.Body.Variables[0].Type))
+			if (!IsEventHandlerType(method.Body.Variables[0].Type))
 				return null;
 
 			var instructions = method.Body.Instructions;
 			int index = 0;
 
-			int newobjIndex = findInstruction(instructions, index, Code.Newobj);
-			if (newobjIndex == -1 || findInstruction(instructions, newobjIndex + 1, Code.Newobj) != -1)
+			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 IMethod))
+			if (!IsEventHandlerCtor(instructions[newobjIndex].Operand as IMethod))
 				return null;
 			if (newobjIndex < 1)
 				return null;
@@ -619,12 +619,12 @@ namespace de4dot.code.renamer {
 
 			IField addField, removeField;
 			IMethod addMethod, removeMethod;
-			if (!findEventCall(instructions, ref index, out removeField, out removeMethod))
+			if (!FindEventCall(instructions, ref index, out removeField, out removeMethod))
 				return null;
-			if (!findEventCall(instructions, ref index, out addField, out addMethod))
+			if (!FindEventCall(instructions, ref index, out addField, out addMethod))
 				return null;
 
-			if (findInstruction(instructions, index, Code.Callvirt) != -1)
+			if (FindInstruction(instructions, index, Code.Callvirt) != -1)
 				return null;
 			if (!new SigComparer().Equals(addField, removeField))
 				return null;
@@ -645,11 +645,11 @@ namespace de4dot.code.renamer {
 			return handlerMethod;
 		}
 
-		static bool findEventCall(IList<Instruction> instructions, ref int index, out IField field, out IMethod calledMethod) {
+		static bool FindEventCall(IList<Instruction> instructions, ref int index, out IField field, out IMethod calledMethod) {
 			field = null;
 			calledMethod = null;
 
-			int callvirt = findInstruction(instructions, index, Code.Callvirt);
+			int callvirt = FindInstruction(instructions, index, Code.Callvirt);
 			if (callvirt < 2)
 				return false;
 			index = callvirt + 1;
@@ -667,7 +667,7 @@ namespace de4dot.code.renamer {
 			return field != null && calledMethod != null;
 		}
 
-		static int findInstruction(IList<Instruction> instructions, int index, Code code) {
+		static int FindInstruction(IList<Instruction> instructions, int index, Code code) {
 			for (int i = index; i < instructions.Count; i++) {
 				if (instructions[i].OpCode.Code == code)
 					return i;
@@ -675,7 +675,7 @@ namespace de4dot.code.renamer {
 			return -1;
 		}
 
-		void initFieldEventHandlers(FieldDefAndDeclaringTypeDict<MFieldDef> ourFields, MethodDefAndDeclaringTypeDict<MMethodDef> ourMethods) {
+		void InitFieldEventHandlers(FieldDefAndDeclaringTypeDict<MFieldDef> ourFields, MethodDefAndDeclaringTypeDict<MMethodDef> ourMethods) {
 			var checker = NameChecker;
 
 			foreach (var methodDef in type.AllMethods) {
@@ -703,7 +703,7 @@ namespace de4dot.code.renamer {
 					var fieldRef = ldfld.Operand as IField;
 					if (fieldRef == null)
 						continue;
-					var fieldDef = ourFields.find(fieldRef);
+					var fieldDef = ourFields.Find(fieldRef);
 					if (fieldDef == null)
 						continue;
 
@@ -713,7 +713,7 @@ namespace de4dot.code.renamer {
 					IMethod methodRef;
 					var instr = instructions[index + 1];
 					if (instr.OpCode.Code == Code.Ldvirtftn) {
-						if (!isThisOrDup(instructions[index++]))
+						if (!IsThisOrDup(instructions[index++]))
 							continue;
 						var ldvirtftn = instructions[index++];
 						methodRef = ldvirtftn.Operand as IMethod;
@@ -726,14 +726,14 @@ namespace de4dot.code.renamer {
 					}
 					if (methodRef == null)
 						continue;
-					var handlerMethod = ourMethods.find(methodRef);
+					var handlerMethod = ourMethods.Find(methodRef);
 					if (handlerMethod == null)
 						continue;
 
 					var newobj = instructions[index++];
 					if (newobj.OpCode.Code != Code.Newobj)
 						continue;
-					if (!isEventHandlerCtor(newobj.Operand as IMethod))
+					if (!IsEventHandlerCtor(newobj.Operand as IMethod))
 						continue;
 
 					var call = instructions[index++];
@@ -746,15 +746,15 @@ namespace de4dot.code.renamer {
 						continue;
 
 					var eventName = addHandler.Name.String.Substring(4);
-					if (!checker.isValidEventName(eventName))
+					if (!checker.IsValidEventName(eventName))
 						continue;
 
-					memberInfos.method(handlerMethod).suggestedName = string.Format("{0}_{1}", memberInfos.field(fieldDef).newName, eventName);
+					memberInfos.Method(handlerMethod).suggestedName = string.Format("{0}_{1}", memberInfos.Field(fieldDef).newName, eventName);
 				}
 			}
 		}
 
-		void initTypeEventHandlers(FieldDefAndDeclaringTypeDict<MFieldDef> ourFields, MethodDefAndDeclaringTypeDict<MMethodDef> ourMethods) {
+		void InitTypeEventHandlers(FieldDefAndDeclaringTypeDict<MFieldDef> ourFields, MethodDefAndDeclaringTypeDict<MMethodDef> ourMethods) {
 			var checker = NameChecker;
 
 			foreach (var methodDef in type.AllMethods) {
@@ -776,14 +776,14 @@ namespace de4dot.code.renamer {
 						continue;
 					int index = i + 1;
 
-					if (!isThisOrDup(instructions[index++]))
+					if (!IsThisOrDup(instructions[index++]))
 						continue;
 					IMethod handler;
 					if (instructions[index].OpCode.Code == Code.Ldftn) {
 						handler = instructions[index++].Operand as IMethod;
 					}
 					else {
-						if (!isThisOrDup(instructions[index++]))
+						if (!IsThisOrDup(instructions[index++]))
 							continue;
 						var instr = instructions[index++];
 						if (instr.OpCode.Code != Code.Ldvirtftn)
@@ -792,14 +792,14 @@ namespace de4dot.code.renamer {
 					}
 					if (handler == null)
 						continue;
-					var handlerDef = ourMethods.find(handler);
+					var handlerDef = ourMethods.Find(handler);
 					if (handlerDef == null)
 						continue;
 
 					var newobj = instructions[index++];
 					if (newobj.OpCode.Code != Code.Newobj)
 						continue;
-					if (!isEventHandlerCtor(newobj.Operand as IMethod))
+					if (!IsEventHandlerCtor(newobj.Operand as IMethod))
 						continue;
 
 					var call = instructions[index++];
@@ -812,35 +812,35 @@ namespace de4dot.code.renamer {
 						continue;
 
 					var eventName = addMethod.Name.String.Substring(4);
-					if (!checker.isValidEventName(eventName))
+					if (!checker.IsValidEventName(eventName))
 						continue;
 
-					memberInfos.method(handlerDef).suggestedName = string.Format("{0}_{1}", newName, eventName);
+					memberInfos.Method(handlerDef).suggestedName = string.Format("{0}_{1}", newName, eventName);
 				}
 			}
 		}
 
-		static bool isThisOrDup(Instruction instr) {
+		static bool IsThisOrDup(Instruction instr) {
 			return instr.GetParameterIndex() == 0 || instr.OpCode.Code == Code.Dup;
 		}
 
-		static bool isEventHandlerCtor(IMethod method) {
+		static bool IsEventHandlerCtor(IMethod method) {
 			if (method == null)
 				return false;
 			if (method.Name != ".ctor")
 				return false;
-			if (!DotNetUtils.isMethod(method, "System.Void", "(System.Object,System.IntPtr)"))
+			if (!DotNetUtils.IsMethod(method, "System.Void", "(System.Object,System.IntPtr)"))
 				return false;
-			if (!isEventHandlerType(method.DeclaringType))
+			if (!IsEventHandlerType(method.DeclaringType))
 				return false;
 			return true;
 		}
 
-		static bool isEventHandlerType(IType type) {
+		static bool IsEventHandlerType(IType type) {
 			return type.FullName.EndsWith("EventHandler", StringComparison.Ordinal);
 		}
 
-		string findWindowsFormsClassName(MTypeDef type) {
+		string FindWindowsFormsClassName(MTypeDef type) {
 			foreach (var methodDef in type.AllMethods) {
 				if (methodDef.MethodDef.Body == null)
 					continue;
@@ -851,7 +851,7 @@ namespace de4dot.code.renamer {
 					var call = instructions[i];
 					if (call.OpCode.Code != Code.Call && call.OpCode.Code != Code.Callvirt)
 						continue;
-					if (!isWindowsFormsSetNameMethod(call.Operand as IMethod))
+					if (!IsWindowsFormsSetNameMethod(call.Operand as IMethod))
 						continue;
 
 					var ldstr = instructions[i - 1];
@@ -864,14 +864,14 @@ namespace de4dot.code.renamer {
 					if (instructions[i - 2].GetParameterIndex() != 0)
 						continue;
 
-					findInitializeComponentMethod(type, methodDef);
+					FindInitializeComponentMethod(type, methodDef);
 					return className;
 				}
 			}
 			return null;
 		}
 
-		void findInitializeComponentMethod(MTypeDef type, MMethodDef possibleInitMethod) {
+		void FindInitializeComponentMethod(MTypeDef type, MMethodDef possibleInitMethod) {
 			foreach (var methodDef in type.AllMethods) {
 				if (methodDef.MethodDef.Name != ".ctor")
 					continue;
@@ -883,13 +883,13 @@ namespace de4dot.code.renamer {
 					if (!MethodEqualityComparer.CompareDeclaringTypes.Equals(possibleInitMethod.MethodDef, instr.Operand as IMethod))
 						continue;
 
-					memberInfos.method(possibleInitMethod).suggestedName = "InitializeComponent";
+					memberInfos.Method(possibleInitMethod).suggestedName = "InitializeComponent";
 					return;
 				}
 			}
 		}
 
-		static bool isWindowsFormsSetNameMethod(IMethod method) {
+		static bool IsWindowsFormsSetNameMethod(IMethod method) {
 			if (method == null)
 				return false;
 			if (method.Name.String != "set_Name")
diff --git a/de4dot.code/renamer/TypeNames.cs b/de4dot.code/renamer/TypeNames.cs
index ac45a94a..82f84db4 100644
--- a/de4dot.code/renamer/TypeNames.cs
+++ b/de4dot.code/renamer/TypeNames.cs
@@ -30,10 +30,10 @@ namespace de4dot.code.renamer {
 		protected Dictionary<string, string> fullNameToShortName;
 		protected Dictionary<string, string> fullNameToShortNamePrefix;
 
-		public string create(TypeSig typeRef) {
+		public string Create(TypeSig typeRef) {
 			typeRef = typeRef.RemovePinnedAndModifiers();
 			if (typeRef == null)
-				return unknownNameCreator.create();
+				return unknownNameCreator.Create();
 			var gis = typeRef as GenericInstSig;
 			if (gis != null) {
 				if (gis.FullName == "System.Nullable`1" &&
@@ -42,18 +42,18 @@ namespace de4dot.code.renamer {
 				}
 			}
 
-			string prefix = getPrefix(typeRef);
+			string prefix = GetPrefix(typeRef);
 
 			var elementType = typeRef.ScopeType;
-			if (elementType == null && isFnPtrSig(typeRef))
-				return fnPtrNameCreator.create();
-			if (isGenericParam(elementType))
-				return genericParamNameCreator.create();
+			if (elementType == null && IsFnPtrSig(typeRef))
+				return fnPtrNameCreator.Create();
+			if (IsGenericParam(elementType))
+				return genericParamNameCreator.Create();
 
 			NameCreator nc;
 			var typeFullName = typeRef.FullName;
 			if (typeNames.TryGetValue(typeFullName, out nc))
-				return nc.create();
+				return nc.Create();
 
 			var fullName = elementType == null ? typeRef.FullName : elementType.FullName;
 			string shortName;
@@ -68,10 +68,10 @@ namespace de4dot.code.renamer {
 					shortName = shortName.Substring(0, index);
 			}
 
-			return addTypeName(typeFullName, shortName, prefix).create();
+			return AddTypeName(typeFullName, shortName, prefix).Create();
 		}
 
-		bool isFnPtrSig(TypeSig sig) {
+		bool IsFnPtrSig(TypeSig sig) {
 			while (sig != null) {
 				if (sig is FnPtrSig)
 					return true;
@@ -80,7 +80,7 @@ namespace de4dot.code.renamer {
 			return false;
 		}
 
-		bool isGenericParam(ITypeDefOrRef tdr) {
+		bool IsGenericParam(ITypeDefOrRef tdr) {
 			var ts = tdr as TypeSpec;
 			if (ts == null)
 				return false;
@@ -88,7 +88,7 @@ namespace de4dot.code.renamer {
 			return sig is GenericSig;
 		}
 
-		static string getPrefix(TypeSig typeRef) {
+		static string GetPrefix(TypeSig typeRef) {
 			string prefix = "";
 			while (typeRef != null) {
 				if (typeRef.IsPointer)
@@ -98,8 +98,8 @@ namespace de4dot.code.renamer {
 			return prefix;
 		}
 
-		protected INameCreator addTypeName(string fullName, string newName, string prefix) {
-			newName = fixName(prefix, newName);
+		protected INameCreator AddTypeName(string fullName, string newName, string prefix) {
+			newName = FixName(prefix, newName);
 
 			var name2 = " " + newName;
 			NameCreator nc;
@@ -110,23 +110,23 @@ namespace de4dot.code.renamer {
 			return nc;
 		}
 
-		protected abstract string fixName(string prefix, string name);
+		protected abstract string FixName(string prefix, string name);
 
-		public virtual TypeNames merge(TypeNames other) {
+		public virtual TypeNames Merge(TypeNames other) {
 			foreach (var pair in other.typeNames) {
 				NameCreator nc;
 				if (typeNames.TryGetValue(pair.Key, out nc))
-					nc.merge(pair.Value);
+					nc.Merge(pair.Value);
 				else
-					typeNames[pair.Key] = pair.Value.clone();
+					typeNames[pair.Key] = pair.Value.Clone();
 			}
-			genericParamNameCreator.merge(other.genericParamNameCreator);
-			fnPtrNameCreator.merge(other.fnPtrNameCreator);
-			unknownNameCreator.merge(other.unknownNameCreator);
+			genericParamNameCreator.Merge(other.genericParamNameCreator);
+			fnPtrNameCreator.Merge(other.fnPtrNameCreator);
+			unknownNameCreator.Merge(other.unknownNameCreator);
 			return this;
 		}
 
-		protected static string upperFirst(string s) {
+		protected static string UpperFirst(string s) {
 			if (string.IsNullOrEmpty(s))
 				return string.Empty;
 			return s.Substring(0, 1).ToUpperInvariant() + s.Substring(1);
@@ -180,7 +180,7 @@ namespace de4dot.code.renamer {
 			fullNameToShortNamePrefix = ourFullNameToShortNamePrefix;
 		}
 
-		static string lowerLeadingChars(string name) {
+		static string LowerLeadingChars(string name) {
 			var s = "";
 			for (int i = 0; i < name.Length; i++) {
 				char c = char.ToLowerInvariant(name[i]);
@@ -191,11 +191,11 @@ namespace de4dot.code.renamer {
 			return s;
 		}
 
-		protected override string fixName(string prefix, string name) {
-			name = lowerLeadingChars(name);
+		protected override string FixName(string prefix, string name) {
+			name = LowerLeadingChars(name);
 			if (prefix == "")
 				return name;
-			return prefix + upperFirst(name);
+			return prefix + UpperFirst(name);
 		}
 	}
 
@@ -208,8 +208,8 @@ namespace de4dot.code.renamer {
 			fullNameToShortNamePrefix = ourFullNameToShortNamePrefix;
 		}
 
-		protected override string fixName(string prefix, string name) {
-			return prefix.ToUpperInvariant() + upperFirst(name);
+		protected override string FixName(string prefix, string name) {
+			return prefix.ToUpperInvariant() + UpperFirst(name);
 		}
 	}
 }
diff --git a/de4dot.code/renamer/TypeRenamerState.cs b/de4dot.code/renamer/TypeRenamerState.cs
index e04646a7..7eaeea75 100644
--- a/de4dot.code/renamer/TypeRenamerState.cs
+++ b/de4dot.code/renamer/TypeRenamerState.cs
@@ -37,15 +37,15 @@ namespace de4dot.code.renamer {
 			internalTypeNameCreator = new TypeNameCreator(existingNames);
 		}
 
-		public void addTypeName(string name) {
-			existingNames.add(name);
+		public void AddTypeName(string name) {
+			existingNames.Add(name);
 		}
 
-		public string getTypeName(string oldName, string newName) {
-			return existingNames.getName(oldName, new NameCreator2(newName));
+		public string GetTypeName(string oldName, string newName) {
+			return existingNames.GetName(oldName, new NameCreator2(newName));
 		}
 
-		public string createNamespace(TypeDef type, string ns) {
+		public string CreateNamespace(TypeDef type, string ns) {
 			string newName;
 
 			string asmFullName;
@@ -63,7 +63,7 @@ namespace de4dot.code.renamer {
 						ns);
 			if (namespaceToNewName.TryGetValue(key, out newName))
 				return newName;
-			return namespaceToNewName[key] = createNamespaceName.create();
+			return namespaceToNewName[key] = createNamespaceName.Create();
 		}
 	}
 }
diff --git a/de4dot.code/renamer/VariableNameState.cs b/de4dot.code/renamer/VariableNameState.cs
index ce48ad89..4e122028 100644
--- a/de4dot.code/renamer/VariableNameState.cs
+++ b/de4dot.code/renamer/VariableNameState.cs
@@ -32,7 +32,7 @@ namespace de4dot.code.renamer {
 		public NameCreator staticMethodNameCreator;
 		public NameCreator instanceMethodNameCreator;
 
-		public static VariableNameState create() {
+		public static VariableNameState Create() {
 			var vns = new VariableNameState();
 			vns.existingVariableNames = new ExistingNames();
 			vns.existingMethodNames = new ExistingNames();
@@ -51,53 +51,53 @@ namespace de4dot.code.renamer {
 		}
 
 		// Cloning only params will speed up the method param renaming code
-		public VariableNameState cloneParamsOnly() {
+		public VariableNameState CloneParamsOnly() {
 			var vns = new VariableNameState();
 			vns.existingVariableNames = new ExistingNames();
 			vns.variableNameCreator = new VariableNameCreator();
-			vns.existingVariableNames.merge(existingVariableNames);
-			vns.variableNameCreator.merge(variableNameCreator);
+			vns.existingVariableNames.Merge(existingVariableNames);
+			vns.variableNameCreator.Merge(variableNameCreator);
 			return vns;
 		}
 
-		public VariableNameState merge(VariableNameState other) {
-			existingVariableNames.merge(other.existingVariableNames);
-			existingMethodNames.merge(other.existingMethodNames);
-			existingPropertyNames.merge(other.existingPropertyNames);
-			existingEventNames.merge(other.existingEventNames);
-			variableNameCreator.merge(other.variableNameCreator);
-			propertyNameCreator.merge(other.propertyNameCreator);
-			eventNameCreator.merge(other.eventNameCreator);
-			genericPropertyNameCreator.merge(other.genericPropertyNameCreator);
-			staticMethodNameCreator.merge(other.staticMethodNameCreator);
-			instanceMethodNameCreator.merge(other.instanceMethodNameCreator);
+		public VariableNameState Merge(VariableNameState other) {
+			existingVariableNames.Merge(other.existingVariableNames);
+			existingMethodNames.Merge(other.existingMethodNames);
+			existingPropertyNames.Merge(other.existingPropertyNames);
+			existingEventNames.Merge(other.existingEventNames);
+			variableNameCreator.Merge(other.variableNameCreator);
+			propertyNameCreator.Merge(other.propertyNameCreator);
+			eventNameCreator.Merge(other.eventNameCreator);
+			genericPropertyNameCreator.Merge(other.genericPropertyNameCreator);
+			staticMethodNameCreator.Merge(other.staticMethodNameCreator);
+			instanceMethodNameCreator.Merge(other.instanceMethodNameCreator);
 			return this;
 		}
 
-		public void mergeMethods(VariableNameState other) {
-			existingMethodNames.merge(other.existingMethodNames);
+		public void MergeMethods(VariableNameState other) {
+			existingMethodNames.Merge(other.existingMethodNames);
 		}
 
-		public void mergeProperties(VariableNameState other) {
-			existingPropertyNames.merge(other.existingPropertyNames);
+		public void MergeProperties(VariableNameState other) {
+			existingPropertyNames.Merge(other.existingPropertyNames);
 		}
 
-		public void mergeEvents(VariableNameState other) {
-			existingEventNames.merge(other.existingEventNames);
+		public void MergeEvents(VariableNameState other) {
+			existingEventNames.Merge(other.existingEventNames);
 		}
 
-		public string getNewPropertyName(PropertyDef propertyDef) {
+		public string GetNewPropertyName(PropertyDef propertyDef) {
 			var propType = propertyDef.PropertySig.GetRetType();
 			string newName;
-			if (isGeneric(propType))
-				newName = existingPropertyNames.getName(propertyDef.Name, genericPropertyNameCreator);
+			if (IsGeneric(propType))
+				newName = existingPropertyNames.GetName(propertyDef.Name, genericPropertyNameCreator);
 			else
-				newName = existingPropertyNames.getName(propertyDef.Name, () => propertyNameCreator.create(propType));
-			addPropertyName(newName);
+				newName = existingPropertyNames.GetName(propertyDef.Name, () => propertyNameCreator.Create(propType));
+			AddPropertyName(newName);
 			return newName;
 		}
 
-		static bool isGeneric(TypeSig type) {
+		static bool IsGeneric(TypeSig type) {
 			while (type != null) {
 				if (type.IsGenericParameter)
 					return true;
@@ -106,58 +106,58 @@ namespace de4dot.code.renamer {
 			return false;
 		}
 
-		public string getNewEventName(EventDef eventDef) {
-			string newName = eventNameCreator.create();
-			addEventName(newName);
+		public string GetNewEventName(EventDef eventDef) {
+			string newName = eventNameCreator.Create();
+			AddEventName(newName);
 			return newName;
 		}
 
-		public void addFieldName(string fieldName) {
-			existingVariableNames.add(fieldName);
+		public void AddFieldName(string fieldName) {
+			existingVariableNames.Add(fieldName);
 		}
 
-		public void addParamName(string paramName) {
-			existingVariableNames.add(paramName);
+		public void AddParamName(string paramName) {
+			existingVariableNames.Add(paramName);
 		}
 
-		public void addMethodName(string methodName) {
-			existingMethodNames.add(methodName);
+		public void AddMethodName(string methodName) {
+			existingMethodNames.Add(methodName);
 		}
 
-		public void addPropertyName(string propName) {
-			existingPropertyNames.add(propName);
+		public void AddPropertyName(string propName) {
+			existingPropertyNames.Add(propName);
 		}
 
-		public void addEventName(string eventName) {
-			existingEventNames.add(eventName);
+		public void AddEventName(string eventName) {
+			existingEventNames.Add(eventName);
 		}
 
-		public bool isMethodNameUsed(string methodName) {
-			return existingMethodNames.exists(methodName);
+		public bool IsMethodNameUsed(string methodName) {
+			return existingMethodNames.Exists(methodName);
 		}
 
-		public bool isPropertyNameUsed(string propName) {
-			return existingPropertyNames.exists(propName);
+		public bool IsPropertyNameUsed(string propName) {
+			return existingPropertyNames.Exists(propName);
 		}
 
-		public bool isEventNameUsed(string eventName) {
-			return existingEventNames.exists(eventName);
+		public bool IsEventNameUsed(string eventName) {
+			return existingEventNames.Exists(eventName);
 		}
 
-		public string getNewFieldName(FieldDef field) {
-			return existingVariableNames.getName(field.Name, () => variableNameCreator.create(field.FieldSig.GetFieldType()));
+		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 GetNewFieldName(string oldName, INameCreator nameCreator) {
+			return existingVariableNames.GetName(oldName, () => nameCreator.Create());
 		}
 
-		public string getNewParamName(string oldName, Parameter param) {
-			return existingVariableNames.getName(oldName, () => variableNameCreator.create(param.Type));
+		public string GetNewParamName(string oldName, Parameter param) {
+			return existingVariableNames.GetName(oldName, () => variableNameCreator.Create(param.Type));
 		}
 
-		public string getNewMethodName(string oldName, INameCreator nameCreator) {
-			return existingMethodNames.getName(oldName, nameCreator);
+		public string GetNewMethodName(string oldName, INameCreator nameCreator) {
+			return existingMethodNames.GetName(oldName, nameCreator);
 		}
 	}
 }
diff --git a/de4dot.code/renamer/asmmodules/EventDef.cs b/de4dot.code/renamer/asmmodules/EventDef.cs
index b8334e50..7908c197 100644
--- a/de4dot.code/renamer/asmmodules/EventDef.cs
+++ b/de4dot.code/renamer/asmmodules/EventDef.cs
@@ -34,7 +34,7 @@ namespace de4dot.code.renamer.asmmodules {
 			: base(eventDef, owner, index) {
 		}
 
-		public IEnumerable<MethodDef> methodDefs() {
+		public IEnumerable<MethodDef> MethodDefs() {
 			if (EventDef.AddMethod != null)
 				yield return EventDef.AddMethod;
 			if (EventDef.RemoveMethod != null)
@@ -47,8 +47,8 @@ namespace de4dot.code.renamer.asmmodules {
 			}
 		}
 
-		public bool isVirtual() {
-			foreach (var method in methodDefs()) {
+		public bool IsVirtual() {
+			foreach (var method in MethodDefs()) {
 				if (method.IsVirtual)
 					return true;
 			}
diff --git a/de4dot.code/renamer/asmmodules/GenericParamDef.cs b/de4dot.code/renamer/asmmodules/GenericParamDef.cs
index 025c517d..c4498b74 100644
--- a/de4dot.code/renamer/asmmodules/GenericParamDef.cs
+++ b/de4dot.code/renamer/asmmodules/GenericParamDef.cs
@@ -30,7 +30,7 @@ namespace de4dot.code.renamer.asmmodules {
 			: base(genericParameter, null, index) {
 		}
 
-		public static List<MGenericParamDef> createGenericParamDefList(IEnumerable<GenericParam> parameters) {
+		public static List<MGenericParamDef> CreateGenericParamDefList(IEnumerable<GenericParam> parameters) {
 			var list = new List<MGenericParamDef>();
 			if (parameters == null)
 				return list;
diff --git a/de4dot.code/renamer/asmmodules/IResolver.cs b/de4dot.code/renamer/asmmodules/IResolver.cs
index 58f5e266..92ec0827 100644
--- a/de4dot.code/renamer/asmmodules/IResolver.cs
+++ b/de4dot.code/renamer/asmmodules/IResolver.cs
@@ -21,8 +21,8 @@ using dnlib.DotNet;
 
 namespace de4dot.code.renamer.asmmodules {
 	interface IResolver {
-		MTypeDef resolveType(ITypeDefOrRef typeRef);
-		MMethodDef resolveMethod(IMethodDefOrRef methodRef);
-		MFieldDef resolveField(MemberRef fieldRef);
+		MTypeDef ResolveType(ITypeDefOrRef typeRef);
+		MMethodDef ResolveMethod(IMethodDefOrRef methodRef);
+		MFieldDef ResolveField(MemberRef fieldRef);
 	}
 }
diff --git a/de4dot.code/renamer/asmmodules/MemberRefFinder.cs b/de4dot.code/renamer/asmmodules/MemberRefFinder.cs
index 53c3a048..da7b169f 100644
--- a/de4dot.code/renamer/asmmodules/MemberRefFinder.cs
+++ b/de4dot.code/renamer/asmmodules/MemberRefFinder.cs
@@ -58,85 +58,85 @@ namespace de4dot.code.renamer.asmmodules {
 		Stack<object> objectStack;
 		ModuleDef validModule;
 
-		public void removeTypeDef(TypeDef td) {
+		public void RemoveTypeDef(TypeDef td) {
 			if (!typeDefs.Remove(td))
 				throw new ApplicationException(string.Format("Could not remove TypeDef: {0}", td));
 		}
 
-		public void removeEventDef(EventDef ed) {
+		public void RemoveEventDef(EventDef ed) {
 			if (!eventDefs.Remove(ed))
 				throw new ApplicationException(string.Format("Could not remove EventDef: {0}", ed));
 		}
 
-		public void removeFieldDef(FieldDef fd) {
+		public void RemoveFieldDef(FieldDef fd) {
 			if (!fieldDefs.Remove(fd))
 				throw new ApplicationException(string.Format("Could not remove FieldDef: {0}", fd));
 		}
 
-		public void removeMethodDef(MethodDef md) {
+		public void RemoveMethodDef(MethodDef md) {
 			if (!methodDefs.Remove(md))
 				throw new ApplicationException(string.Format("Could not remove MethodDef: {0}", md));
 		}
 
-		public void removePropertyDef(PropertyDef pd) {
+		public void RemovePropertyDef(PropertyDef pd) {
 			if (!propertyDefs.Remove(pd))
 				throw new ApplicationException(string.Format("Could not remove PropertyDef: {0}", pd));
 		}
 
-		public void findAll(ModuleDef module) {
+		public void FindAll(ModuleDef module) {
 			validModule = module;
 
 			// This needs to be big. About 2048 entries should be enough for most though...
 			objectStack = new Stack<object>(0x1000);
 
-			add(module);
-			processAll();
+			Add(module);
+			ProcessAll();
 
 			objectStack = null;
 		}
 
-		void push(object mr) {
+		void Push(object mr) {
 			if (mr == null)
 				return;
 			objectStack.Push(mr);
 		}
 
-		void processAll() {
+		void ProcessAll() {
 			while (objectStack.Count > 0) {
 				var o = objectStack.Pop();
-				switch (getObjectType(o)) {
+				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;
+				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()));
 				}
 			}
 		}
 
 		readonly Dictionary<Type, ObjectType> toObjectType = new Dictionary<Type, ObjectType>();
-		ObjectType getObjectType(object o) {
+		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);
+			mrType = GetObjectType2(o);
 			toObjectType[type] = mrType;
 			return mrType;
 		}
 
-		static ObjectType getObjectType2(object o) {
+		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;
@@ -152,263 +152,263 @@ namespace de4dot.code.renamer.asmmodules {
 			return ObjectType.Unknown;
 		}
 
-		void add(ModuleDef mod) {
-			push(mod.ManagedEntryPoint);
-			add(mod.CustomAttributes);
-			add(mod.Types);
-			add(mod.ExportedTypes);
+		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);
+				Add(mod.Assembly);
+			Add(mod.VTableFixups);
 		}
 
-		void add(VTableFixups fixups) {
+		void Add(VTableFixups fixups) {
 			if (fixups == null)
 				return;
 			foreach (var fixup in fixups) {
 				foreach (var method in fixup)
-					push(method);
+					Push(method);
 			}
 		}
 
-		void add(AssemblyDef asm) {
+		void Add(AssemblyDef asm) {
 			if (asm == null)
 				return;
-			add(asm.DeclSecurities);
-			add(asm.CustomAttributes);
+			Add(asm.DeclSecurities);
+			Add(asm.CustomAttributes);
 		}
 
-		void add(CallingConventionSig sig) {
+		void Add(CallingConventionSig sig) {
 			if (sig == null)
 				return;
 
 			var fs = sig as FieldSig;
 			if (fs != null) {
-				add(fs);
+				Add(fs);
 				return;
 			}
 
 			var mbs = sig as MethodBaseSig;
 			if (mbs != null) {
-				add(mbs);
+				Add(mbs);
 				return;
 			}
 
 			var ls = sig as LocalSig;
 			if (ls != null) {
-				add(ls);
+				Add(ls);
 				return;
 			}
 
 			var gims = sig as GenericInstMethodSig;
 			if (gims != null) {
-				add(gims);
+				Add(gims);
 				return;
 			}
 		}
 
-		void add(FieldSig sig) {
+		void Add(FieldSig sig) {
 			if (sig == null)
 				return;
-			add(sig.Type);
+			Add(sig.Type);
 		}
 
-		void add(MethodBaseSig sig) {
+		void Add(MethodBaseSig sig) {
 			if (sig == null)
 				return;
-			add(sig.RetType);
-			add(sig.Params);
-			add(sig.ParamsAfterSentinel);
+			Add(sig.RetType);
+			Add(sig.Params);
+			Add(sig.ParamsAfterSentinel);
 		}
 
-		void add(LocalSig sig) {
+		void Add(LocalSig sig) {
 			if (sig == null)
 				return;
-			add(sig.Locals);
+			Add(sig.Locals);
 		}
 
-		void add(GenericInstMethodSig sig) {
+		void Add(GenericInstMethodSig sig) {
 			if (sig == null)
 				return;
-			add(sig.GenericArguments);
+			Add(sig.GenericArguments);
 		}
 
-		void add(IEnumerable<CustomAttribute> cas) {
+		void Add(IEnumerable<CustomAttribute> cas) {
 			if (cas == null)
 				return;
 			foreach (var ca in cas)
-				add(ca);
+				Add(ca);
 		}
 
-		void add(CustomAttribute ca) {
+		void Add(CustomAttribute ca) {
 			if (ca == null || customAttributes.ContainsKey(ca))
 				return;
 			customAttributes[ca] = true;
-			push(ca.Constructor);
-			add(ca.ConstructorArguments);
-			add(ca.NamedArguments);
+			Push(ca.Constructor);
+			Add(ca.ConstructorArguments);
+			Add(ca.NamedArguments);
 		}
 
-		void add(IEnumerable<CAArgument> args) {
+		void Add(IEnumerable<CAArgument> args) {
 			if (args == null)
 				return;
 			foreach (var arg in args)
-				add(arg);
+				Add(arg);
 		}
 
-		void add(CAArgument arg) {
+		void Add(CAArgument arg) {
 			// It's a struct so can't be null
-			add(arg.Type);
+			Add(arg.Type);
 		}
 
-		void add(IEnumerable<CANamedArgument> args) {
+		void Add(IEnumerable<CANamedArgument> args) {
 			if (args == null)
 				return;
 			foreach (var arg in args)
-				add(arg);
+				Add(arg);
 		}
 
-		void add(CANamedArgument arg) {
+		void Add(CANamedArgument arg) {
 			if (arg == null)
 				return;
-			add(arg.Type);
-			add(arg.Argument);
+			Add(arg.Type);
+			Add(arg.Argument);
 		}
 
-		void add(IEnumerable<DeclSecurity> decls) {
+		void Add(IEnumerable<DeclSecurity> decls) {
 			if (decls == null)
 				return;
 			foreach (var decl in decls)
-				add(decl);
+				Add(decl);
 		}
 
-		void add(DeclSecurity decl) {
+		void Add(DeclSecurity decl) {
 			if (decl == null)
 				return;
-			add(decl.CustomAttributes);
+			Add(decl.CustomAttributes);
 		}
 
-		void add(IEnumerable<EventDef> eds) {
+		void Add(IEnumerable<EventDef> eds) {
 			if (eds == null)
 				return;
 			foreach (var ed in eds)
-				add(ed);
+				Add(ed);
 		}
 
-		void add(EventDef ed) {
+		void Add(EventDef ed) {
 			if (ed == null || eventDefs.ContainsKey(ed))
 				return;
 			if (ed.DeclaringType != null && ed.DeclaringType.Module != validModule)
 				return;
 			eventDefs[ed] = true;
-			push(ed.EventType);
-			add(ed.CustomAttributes);
-			add(ed.AddMethod);
-			add(ed.InvokeMethod);
-			add(ed.RemoveMethod);
-			add(ed.OtherMethods);
-			add(ed.DeclaringType);
+			Push(ed.EventType);
+			Add(ed.CustomAttributes);
+			Add(ed.AddMethod);
+			Add(ed.InvokeMethod);
+			Add(ed.RemoveMethod);
+			Add(ed.OtherMethods);
+			Add(ed.DeclaringType);
 		}
 
-		void add(IEnumerable<FieldDef> fds) {
+		void Add(IEnumerable<FieldDef> fds) {
 			if (fds == null)
 				return;
 			foreach (var fd in fds)
-				add(fd);
+				Add(fd);
 		}
 
-		void add(FieldDef 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);
+			Add(fd.CustomAttributes);
+			Add(fd.Signature);
+			Add(fd.DeclaringType);
 		}
 
-		void add(IEnumerable<GenericParam> gps) {
+		void Add(IEnumerable<GenericParam> gps) {
 			if (gps == null)
 				return;
 			foreach (var gp in gps)
-				add(gp);
+				Add(gp);
 		}
 
-		void add(GenericParam 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);
+			Push(gp.Owner);
+			Push(gp.Kind);
+			Add(gp.GenericParamConstraints);
+			Add(gp.CustomAttributes);
 		}
 
-		void add(IEnumerable<GenericParamConstraint> gpcs) {
+		void Add(IEnumerable<GenericParamConstraint> gpcs) {
 			if (gpcs == null)
 				return;
 			foreach (var gpc in gpcs)
-				add(gpc);
+				Add(gpc);
 		}
 
-		void add(GenericParamConstraint gpc) {
+		void Add(GenericParamConstraint gpc) {
 			if (gpc == null)
 				return;
-			add(gpc.Owner);
-			push(gpc.Constraint);
-			add(gpc.CustomAttributes);
+			Add(gpc.Owner);
+			Push(gpc.Constraint);
+			Add(gpc.CustomAttributes);
 		}
 
-		void add(MemberRef mr) {
+		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);
+			Push(mr.Class);
+			Add(mr.Signature);
+			Add(mr.CustomAttributes);
 		}
 
-		void add(IEnumerable<MethodDef> methods) {
+		void Add(IEnumerable<MethodDef> methods) {
 			if (methods == null)
 				return;
 			foreach (var m in methods)
-				add(m);
+				Add(m);
 		}
 
-		void add(MethodDef md) {
+		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.ParamDefs);
-			add(md.GenericParameters);
-			add(md.DeclSecurities);
-			add(md.MethodBody);
-			add(md.CustomAttributes);
-			add(md.Overrides);
-			add(md.DeclaringType);
+			Add(md.Signature);
+			Add(md.ParamDefs);
+			Add(md.GenericParameters);
+			Add(md.DeclSecurities);
+			Add(md.MethodBody);
+			Add(md.CustomAttributes);
+			Add(md.Overrides);
+			Add(md.DeclaringType);
 		}
 
-		void add(MethodBody mb) {
+		void Add(MethodBody mb) {
 			var cb = mb as CilBody;
 			if (cb != null)
-				add(cb);
+				Add(cb);
 		}
 
-		void add(CilBody cb) {
+		void Add(CilBody cb) {
 			if (cb == null)
 				return;
-			add(cb.Instructions);
-			add(cb.ExceptionHandlers);
-			add(cb.Variables);
+			Add(cb.Instructions);
+			Add(cb.ExceptionHandlers);
+			Add(cb.Variables);
 		}
 
-		void add(IEnumerable<Instruction> instrs) {
+		void Add(IEnumerable<Instruction> instrs) {
 			if (instrs == null)
 				return;
 			foreach (var instr in instrs) {
@@ -419,23 +419,23 @@ namespace de4dot.code.renamer.asmmodules {
 				case OperandType.InlineType:
 				case OperandType.InlineMethod:
 				case OperandType.InlineField:
-					push(instr.Operand);
+					Push(instr.Operand);
 					break;
 
 				case OperandType.InlineSig:
-					add(instr.Operand as CallingConventionSig);
+					Add(instr.Operand as CallingConventionSig);
 					break;
 
 				case OperandType.InlineVar:
 				case OperandType.ShortInlineVar:
 					var local = instr.Operand as Local;
 					if (local != null) {
-						add(local);
+						Add(local);
 						break;
 					}
 					var arg = instr.Operand as Parameter;
 					if (arg != null) {
-						add(arg);
+						Add(arg);
 						break;
 					}
 					break;
@@ -443,157 +443,157 @@ namespace de4dot.code.renamer.asmmodules {
 			}
 		}
 
-		void add(IEnumerable<ExceptionHandler> ehs) {
+		void Add(IEnumerable<ExceptionHandler> ehs) {
 			if (ehs == null)
 				return;
 			foreach (var eh in ehs)
-				push(eh.CatchType);
+				Push(eh.CatchType);
 		}
 
-		void add(IEnumerable<Local> locals) {
+		void Add(IEnumerable<Local> locals) {
 			if (locals == null)
 				return;
 			foreach (var local in locals)
-				add(local);
+				Add(local);
 		}
 
-		void add(Local local) {
+		void Add(Local local) {
 			if (local == null)
 				return;
-			add(local.Type);
+			Add(local.Type);
 		}
 
-		void add(IEnumerable<Parameter> ps) {
+		void Add(IEnumerable<Parameter> ps) {
 			if (ps == null)
 				return;
 			foreach (var p in ps)
-				add(p);
+				Add(p);
 		}
 
-		void add(Parameter param) {
+		void Add(Parameter param) {
 			if (param == null)
 				return;
-			add(param.Type);
-			add(param.Method);
+			Add(param.Type);
+			Add(param.Method);
 		}
 
-		void add(IEnumerable<ParamDef> pds) {
+		void Add(IEnumerable<ParamDef> pds) {
 			if (pds == null)
 				return;
 			foreach (var pd in pds)
-				add(pd);
+				Add(pd);
 		}
 
-		void add(ParamDef pd) {
+		void Add(ParamDef pd) {
 			if (pd == null)
 				return;
-			add(pd.DeclaringMethod);
-			add(pd.CustomAttributes);
+			Add(pd.DeclaringMethod);
+			Add(pd.CustomAttributes);
 		}
 
-		void add(IEnumerable<MethodOverride> mos) {
+		void Add(IEnumerable<MethodOverride> mos) {
 			if (mos == null)
 				return;
 			foreach (var mo in mos)
-				add(mo);
+				Add(mo);
 		}
 
-		void add(MethodOverride mo) {
+		void Add(MethodOverride mo) {
 			// It's a struct so can't be null
-			push(mo.MethodBody);
-			push(mo.MethodDeclaration);
+			Push(mo.MethodBody);
+			Push(mo.MethodDeclaration);
 		}
 
-		void add(MethodSpec ms) {
+		void Add(MethodSpec ms) {
 			if (ms == null || methodSpecs.ContainsKey(ms))
 				return;
 			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);
+			Push(ms.Method);
+			Add(ms.Instantiation);
+			Add(ms.CustomAttributes);
 		}
 
-		void add(IEnumerable<PropertyDef> pds) {
+		void Add(IEnumerable<PropertyDef> pds) {
 			if (pds == null)
 				return;
 			foreach (var pd in pds)
-				add(pd);
+				Add(pd);
 		}
 
-		void add(PropertyDef pd) {
+		void Add(PropertyDef pd) {
 			if (pd == null || propertyDefs.ContainsKey(pd))
 				return;
 			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);
+			Add(pd.Type);
+			Add(pd.CustomAttributes);
+			Add(pd.GetMethod);
+			Add(pd.SetMethod);
+			Add(pd.OtherMethods);
+			Add(pd.DeclaringType);
 		}
 
-		void add(IEnumerable<TypeDef> tds) {
+		void Add(IEnumerable<TypeDef> tds) {
 			if (tds == null)
 				return;
 			foreach (var td in tds)
-				add(td);
+				Add(td);
 		}
 
-		void add(TypeDef td) {
+		void Add(TypeDef td) {
 			if (td == null || typeDefs.ContainsKey(td))
 				return;
 			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);
+			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 add(IEnumerable<InterfaceImpl> iis) {
+		void Add(IEnumerable<InterfaceImpl> iis) {
 			if (iis == null)
 				return;
 			foreach (var ii in iis)
-				add(ii);
+				Add(ii);
 		}
 
-		void add(InterfaceImpl ii) {
+		void Add(InterfaceImpl ii) {
 			if (ii == null)
 				return;
-			push(ii.Interface);
-			add(ii.CustomAttributes);
+			Push(ii.Interface);
+			Add(ii.CustomAttributes);
 		}
 
-		void add(TypeRef tr) {
+		void Add(TypeRef tr) {
 			if (tr == null || typeRefs.ContainsKey(tr))
 				return;
 			if (tr.Module != validModule)
 				return;
 			typeRefs[tr] = true;
-			push(tr.ResolutionScope);
-			add(tr.CustomAttributes);
+			Push(tr.ResolutionScope);
+			Add(tr.CustomAttributes);
 		}
 
-		void add(IEnumerable<TypeSig> tss) {
+		void Add(IEnumerable<TypeSig> tss) {
 			if (tss == null)
 				return;
 			foreach (var ts in tss)
-				add(ts);
+				Add(ts);
 		}
 
-		void add(TypeSig ts) {
+		void Add(TypeSig ts) {
 			if (ts == null || typeSigs.ContainsKey(ts))
 				return;
 			if (ts.Module != validModule)
@@ -623,24 +623,24 @@ namespace de4dot.code.renamer.asmmodules {
 				case ElementType.U:
 				case ElementType.Object:
 					var tdrs = (TypeDefOrRefSig)ts;
-					push(tdrs.TypeDefOrRef);
+					Push(tdrs.TypeDefOrRef);
 					break;
 
 				case ElementType.FnPtr:
 					var fps = (FnPtrSig)ts;
-					add(fps.Signature);
+					Add(fps.Signature);
 					break;
 
 				case ElementType.GenericInst:
 					var gis = (GenericInstSig)ts;
-					add(gis.GenericType);
-					add(gis.GenericArguments);
+					Add(gis.GenericType);
+					Add(gis.GenericArguments);
 					break;
 
 				case ElementType.CModReqd:
 				case ElementType.CModOpt:
 					var ms = (ModifierSig)ts;
-					push(ms.Modifier);
+					Push(ms.Modifier);
 					break;
 
 				case ElementType.End:
@@ -662,31 +662,31 @@ namespace de4dot.code.renamer.asmmodules {
 			}
 		}
 
-		void add(TypeSpec ts) {
+		void Add(TypeSpec ts) {
 			if (ts == null || typeSpecs.ContainsKey(ts))
 				return;
 			if (ts.Module != validModule)
 				return;
 			typeSpecs[ts] = true;
-			add(ts.TypeSig);
-			add(ts.CustomAttributes);
+			Add(ts.TypeSig);
+			Add(ts.CustomAttributes);
 		}
 
-		void add(IEnumerable<ExportedType> ets) {
+		void Add(IEnumerable<ExportedType> ets) {
 			if (ets == null)
 				return;
 			foreach (var et in ets)
-				add(et);
+				Add(et);
 		}
 
-		void add(ExportedType 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);
+			Add(et.CustomAttributes);
+			Push(et.Implementation);
 		}
 	}
 }
diff --git a/de4dot.code/renamer/asmmodules/MethodDef.cs b/de4dot.code/renamer/asmmodules/MethodDef.cs
index 94a53e36..b021dc63 100644
--- a/de4dot.code/renamer/asmmodules/MethodDef.cs
+++ b/de4dot.code/renamer/asmmodules/MethodDef.cs
@@ -65,7 +65,7 @@ namespace de4dot.code.renamer.asmmodules {
 
 		public MMethodDef(MethodDef methodDef, MTypeDef owner, int index)
 			: base(methodDef, owner, index) {
-			genericParams = MGenericParamDef.createGenericParamDefList(MethodDef.GenericParameters);
+			genericParams = MGenericParamDef.CreateGenericParamDefList(MethodDef.GenericParameters);
 			visibleBaseIndex = methodDef.MethodSig != null && methodDef.MethodSig.HasThis ? 1 : 0;
 			for (int i = 0; i < methodDef.Parameters.Count; i++) {
 				var param = methodDef.Parameters[i];
@@ -76,19 +76,19 @@ namespace de4dot.code.renamer.asmmodules {
 			returnParamDef = new MParamDef(methodDef.Parameters.ReturnParameter, -1);
 		}
 
-		public bool isPublic() {
+		public bool IsPublic() {
 			return MethodDef.IsPublic;
 		}
 
-		public bool isVirtual() {
+		public bool IsVirtual() {
 			return MethodDef.IsVirtual;
 		}
 
-		public bool isNewSlot() {
+		public bool IsNewSlot() {
 			return MethodDef.IsNewSlot;
 		}
 
-		public bool isStatic() {
+		public bool IsStatic() {
 			return MethodDef.IsStatic;
 		}
 	}
diff --git a/de4dot.code/renamer/asmmodules/MethodNameGroups.cs b/de4dot.code/renamer/asmmodules/MethodNameGroups.cs
index dc58a3af..fea4e014 100644
--- a/de4dot.code/renamer/asmmodules/MethodNameGroups.cs
+++ b/de4dot.code/renamer/asmmodules/MethodNameGroups.cs
@@ -32,17 +32,17 @@ namespace de4dot.code.renamer.asmmodules {
 			get { return methods.Count; }
 		}
 
-		public void add(MMethodDef method) {
+		public void Add(MMethodDef method) {
 			methods.Add(method);
 		}
 
-		public void merge(MethodNameGroup other) {
+		public void Merge(MethodNameGroup other) {
 			if (this == other)
 				return;
 			methods.AddRange(other.methods);
 		}
 
-		public bool hasNonRenamableMethod() {
+		public bool HasNonRenamableMethod() {
 			foreach (var method in methods) {
 				if (!method.Owner.HasModule)
 					return true;
@@ -50,7 +50,7 @@ namespace de4dot.code.renamer.asmmodules {
 			return false;
 		}
 
-		public bool hasInterfaceMethod() {
+		public bool HasInterfaceMethod() {
 			foreach (var method in methods) {
 				if (method.Owner.TypeDef.IsInterface)
 					return true;
@@ -58,7 +58,7 @@ namespace de4dot.code.renamer.asmmodules {
 			return false;
 		}
 
-		public bool hasGetterOrSetterPropertyMethod() {
+		public bool HasGetterOrSetterPropertyMethod() {
 			foreach (var method in methods) {
 				if (method.Property == null)
 					continue;
@@ -69,7 +69,7 @@ namespace de4dot.code.renamer.asmmodules {
 			return false;
 		}
 
-		public bool hasAddRemoveOrRaiseEventMethod() {
+		public bool HasAddRemoveOrRaiseEventMethod() {
 			foreach (var method in methods) {
 				if (method.Event == null)
 					continue;
@@ -80,7 +80,7 @@ namespace de4dot.code.renamer.asmmodules {
 			return false;
 		}
 
-		public bool hasProperty() {
+		public bool HasProperty() {
 			foreach (var method in methods) {
 				if (method.Property != null)
 					return true;
@@ -88,7 +88,7 @@ namespace de4dot.code.renamer.asmmodules {
 			return false;
 		}
 
-		public bool hasEvent() {
+		public bool HasEvent() {
 			foreach (var method in methods) {
 				if (method.Event != null)
 					return true;
@@ -104,26 +104,26 @@ namespace de4dot.code.renamer.asmmodules {
 	class MethodNameGroups {
 		Dictionary<MMethodDef, MethodNameGroup> methodGroups = new Dictionary<MMethodDef, MethodNameGroup>();
 
-		public void same(MMethodDef a, MMethodDef b) {
-			merge(get(a), get(b));
+		public void Same(MMethodDef a, MMethodDef b) {
+			Merge(Get(a), Get(b));
 		}
 
-		public void add(MMethodDef methodDef) {
-			get(methodDef);
+		public void Add(MMethodDef methodDef) {
+			Get(methodDef);
 		}
 
-		public MethodNameGroup get(MMethodDef method) {
-			if (!method.isVirtual())
+		public MethodNameGroup Get(MMethodDef method) {
+			if (!method.IsVirtual())
 				throw new ApplicationException("Not a virtual method");
 			MethodNameGroup group;
 			if (!methodGroups.TryGetValue(method, out group)) {
 				methodGroups[method] = group = new MethodNameGroup();
-				group.add(method);
+				group.Add(method);
 			}
 			return group;
 		}
 
-		void merge(MethodNameGroup a, MethodNameGroup b) {
+		void Merge(MethodNameGroup a, MethodNameGroup b) {
 			if (a == b)
 				return;
 
@@ -132,13 +132,13 @@ namespace de4dot.code.renamer.asmmodules {
 				a = b;
 				b = tmp;
 			}
-			a.merge(b);
+			a.Merge(b);
 			foreach (var methodDef in b.Methods)
 				methodGroups[methodDef] = a;
 		}
 
-		public IEnumerable<MethodNameGroup> getAllGroups() {
-			return Utils.unique(methodGroups.Values);
+		public IEnumerable<MethodNameGroup> GetAllGroups() {
+			return Utils.Unique(methodGroups.Values);
 		}
 	}
 }
diff --git a/de4dot.code/renamer/asmmodules/Module.cs b/de4dot.code/renamer/asmmodules/Module.cs
index 462c4e6c..d4d1f255 100644
--- a/de4dot.code/renamer/asmmodules/Module.cs
+++ b/de4dot.code/renamer/asmmodules/Module.cs
@@ -90,25 +90,25 @@ namespace de4dot.code.renamer.asmmodules {
 			this.obfuscatedFile = obfuscatedFile;
 		}
 
-		public IEnumerable<MTypeDef> getAllTypes() {
-			return types.getValues();
+		public IEnumerable<MTypeDef> GetAllTypes() {
+			return types.GetValues();
 		}
 
-		public IEnumerable<MethodDef> getAllMethods() {
+		public IEnumerable<MethodDef> GetAllMethods() {
 			return allMethods;
 		}
 
-		public void findAllMemberRefs(ref int typeIndex) {
+		public void FindAllMemberRefs(ref int typeIndex) {
 			memberRefFinder = new MemberRefFinder();
-			memberRefFinder.findAll(ModuleDefMD);
+			memberRefFinder.FindAll(ModuleDefMD);
 			allMethods = new List<MethodDef>(memberRefFinder.methodDefs.Keys);
 
 			var allTypesList = new List<MTypeDef>();
 			foreach (var type in memberRefFinder.typeDefs.Keys) {
 				var typeDef = new MTypeDef(type, this, typeIndex++);
-				types.add(typeDef);
+				types.Add(typeDef);
 				allTypesList.Add(typeDef);
-				typeDef.addMembers();
+				typeDef.AddMembers();
 			}
 
 			var allTypesCopy = new List<MTypeDef>(allTypesList);
@@ -124,34 +124,34 @@ namespace de4dot.code.renamer.asmmodules {
 					allTypesCopy[index] = null;
 					if (nestedTypeDef == null)	// Impossible
 						throw new ApplicationException("Nested type belongs to two or more types");
-					typeDef.add(nestedTypeDef);
+					typeDef.Add(nestedTypeDef);
 					nestedTypeDef.NestingType = typeDef;
 				}
 			}
 		}
 
-		public void resolveAllRefs(IResolver resolver) {
+		public void ResolveAllRefs(IResolver resolver) {
 			foreach (var typeRef in memberRefFinder.typeRefs.Keys) {
-				var typeDef = resolver.resolveType(typeRef);
+				var typeDef = resolver.ResolveType(typeRef);
 				if (typeDef != null)
 					typeRefsToRename.Add(new RefToDef<TypeRef, TypeDef>(typeRef, typeDef.TypeDef));
 			}
 
 			foreach (var memberRef in memberRefFinder.memberRefs.Keys) {
 				if (memberRef.IsMethodRef) {
-					var methodDef = resolver.resolveMethod(memberRef);
+					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);
+					var fieldDef = resolver.ResolveField(memberRef);
 					if (fieldDef != null)
 						fieldRefsToRename.Add(new RefToDef<MemberRef, FieldDef>(memberRef, fieldDef.FieldDef));
 				}
 			}
 
 			foreach (var cattr in memberRefFinder.customAttributes.Keys) {
-				var typeDef = resolver.resolveType(cattr.AttributeType);
+				var typeDef = resolver.ResolveType(cattr.AttributeType);
 				if (typeDef == null)
 					continue;
 				if (cattr.NamedArguments == null)
@@ -160,11 +160,11 @@ namespace de4dot.code.renamer.asmmodules {
 				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);
+						var fieldDef = FindField(typeDef, namedArg.Name, namedArg.Type);
 						if (fieldDef == null) {
 							Logger.w("Could not find field {0} in attribute {1} ({2:X8})",
-									Utils.toCsharpString(namedArg.Name),
-									Utils.toCsharpString(typeDef.TypeDef.Name),
+									Utils.ToCsharpString(namedArg.Name),
+									Utils.ToCsharpString(typeDef.TypeDef.Name),
 									typeDef.TypeDef.MDToken.ToInt32());
 							continue;
 						}
@@ -172,11 +172,11 @@ namespace de4dot.code.renamer.asmmodules {
 						customAttributeFieldRefs.Add(new CustomAttributeRef(cattr, i, fieldDef.FieldDef));
 					}
 					else {
-						var propDef = findProperty(typeDef, namedArg.Name, namedArg.Type);
+						var propDef = FindProperty(typeDef, namedArg.Name, namedArg.Type);
 						if (propDef == null) {
 							Logger.w("Could not find property {0} in attribute {1} ({2:X8})",
-									Utils.toCsharpString(namedArg.Name),
-									Utils.toCsharpString(typeDef.TypeDef.Name),
+									Utils.ToCsharpString(namedArg.Name),
+									Utils.ToCsharpString(typeDef.TypeDef.Name),
 									typeDef.TypeDef.MDToken.ToInt32());
 							continue;
 						}
@@ -187,7 +187,7 @@ namespace de4dot.code.renamer.asmmodules {
 			}
 		}
 
-		static MFieldDef findField(MTypeDef typeDef, UTF8String name, TypeSig fieldType) {
+		static MFieldDef FindField(MTypeDef typeDef, UTF8String name, TypeSig fieldType) {
 			while (typeDef != null) {
 				foreach (var fieldDef in typeDef.AllFields) {
 					if (fieldDef.FieldDef.Name != name)
@@ -203,7 +203,7 @@ namespace de4dot.code.renamer.asmmodules {
 			return null;
 		}
 
-		static MPropertyDef findProperty(MTypeDef typeDef, UTF8String name, TypeSig propType) {
+		static MPropertyDef FindProperty(MTypeDef typeDef, UTF8String name, TypeSig propType) {
 			while (typeDef != null) {
 				foreach (var propDef in typeDef.AllProperties) {
 					if (propDef.PropertyDef.Name != name)
@@ -219,11 +219,11 @@ namespace de4dot.code.renamer.asmmodules {
 			return null;
 		}
 
-		public void onTypesRenamed() {
+		public void OnTypesRenamed() {
 			var newTypes = new TypeDefDict();
-			foreach (var typeDef in types.getValues()) {
-				typeDef.onTypesRenamed();
-				newTypes.add(typeDef);
+			foreach (var typeDef in types.GetValues()) {
+				typeDef.OnTypesRenamed();
+				newTypes.Add(typeDef);
 			}
 			types = newTypes;
 
@@ -232,7 +232,7 @@ namespace de4dot.code.renamer.asmmodules {
 			ModuleDefMD.EnableTypeDefFindCache = old;
 		}
 
-		static ITypeDefOrRef getNonGenericTypeRef(ITypeDefOrRef typeRef) {
+		static ITypeDefOrRef GetNonGenericTypeRef(ITypeDefOrRef typeRef) {
 			var ts = typeRef as TypeSpec;
 			if (ts == null)
 				return typeRef;
@@ -242,22 +242,22 @@ namespace de4dot.code.renamer.asmmodules {
 			return gis.GenericType.TypeDefOrRef;
 		}
 
-		public MTypeDef resolveType(ITypeDefOrRef typeRef) {
-			return this.types.find(getNonGenericTypeRef(typeRef));
+		public MTypeDef ResolveType(ITypeDefOrRef typeRef) {
+			return this.types.Find(GetNonGenericTypeRef(typeRef));
 		}
 
-		public MMethodDef resolveMethod(IMethodDefOrRef methodRef) {
-			var typeDef = this.types.find(getNonGenericTypeRef(methodRef.DeclaringType));
+		public MMethodDef ResolveMethod(IMethodDefOrRef methodRef) {
+			var typeDef = this.types.Find(GetNonGenericTypeRef(methodRef.DeclaringType));
 			if (typeDef == null)
 				return null;
-			return typeDef.findMethod(methodRef);
+			return typeDef.FindMethod(methodRef);
 		}
 
-		public MFieldDef resolveField(MemberRef fieldRef) {
-			var typeDef = this.types.find(getNonGenericTypeRef(fieldRef.DeclaringType));
+		public MFieldDef ResolveField(MemberRef fieldRef) {
+			var typeDef = this.types.Find(GetNonGenericTypeRef(fieldRef.DeclaringType));
 			if (typeDef == null)
 				return null;
-			return typeDef.findField(fieldRef);
+			return typeDef.FindField(fieldRef);
 		}
 	}
 }
diff --git a/de4dot.code/renamer/asmmodules/Modules.cs b/de4dot.code/renamer/asmmodules/Modules.cs
index 6616abe5..b4477a32 100644
--- a/de4dot.code/renamer/asmmodules/Modules.cs
+++ b/de4dot.code/renamer/asmmodules/Modules.cs
@@ -53,21 +53,21 @@ namespace de4dot.code.renamer.asmmodules {
 		class AssemblyHash {
 			IDictionary<string, ModuleHash> assemblyHash = new Dictionary<string, ModuleHash>(StringComparer.Ordinal);
 
-			public void add(Module module) {
+			public void Add(Module module) {
 				ModuleHash moduleHash;
-				var key = getModuleKey(module);
+				var key = GetModuleKey(module);
 				if (!assemblyHash.TryGetValue(key, out moduleHash))
 					assemblyHash[key] = moduleHash = new ModuleHash();
-				moduleHash.add(module);
+				moduleHash.Add(module);
 			}
 
-			string getModuleKey(Module module) {
+			string GetModuleKey(Module module) {
 				if (module.ModuleDefMD.Assembly != null)
 					return module.ModuleDefMD.Assembly.ToString();
-				return Utils.getBaseName(module.ModuleDefMD.Location);
+				return Utils.GetBaseName(module.ModuleDefMD.Location);
 			}
 
-			public ModuleHash lookup(string assemblyName) {
+			public ModuleHash Lookup(string assemblyName) {
 				ModuleHash moduleHash;
 				if (assemblyHash.TryGetValue(assemblyName, out moduleHash))
 					return moduleHash;
@@ -79,7 +79,7 @@ namespace de4dot.code.renamer.asmmodules {
 			ModulesDict modulesDict = new ModulesDict();
 			Module mainModule = null;
 
-			public void add(Module module) {
+			public void Add(Module module) {
 				var asm = module.ModuleDefMD.Assembly;
 				if (asm != null && ReferenceEquals(asm.ManifestModule, module.ModuleDefMD)) {
 					if (mainModule != null) {
@@ -94,11 +94,11 @@ namespace de4dot.code.renamer.asmmodules {
 					mainModule = module;
 				}
 
-				modulesDict.add(module);
+				modulesDict.Add(module);
 			}
 
-			public Module lookup(string moduleName) {
-				return modulesDict.lookup(moduleName);
+			public Module Lookup(string moduleName) {
+				return modulesDict.Lookup(moduleName);
 			}
 
 			public IEnumerable<Module> Modules {
@@ -109,14 +109,14 @@ namespace de4dot.code.renamer.asmmodules {
 		class ModulesDict {
 			IDictionary<string, Module> modulesDict = new Dictionary<string, Module>(StringComparer.Ordinal);
 
-			public void add(Module module) {
+			public void Add(Module module) {
 				var moduleName = module.ModuleDefMD.Name.String;
-				if (lookup(moduleName) != null)
+				if (Lookup(moduleName) != null)
 					throw new ApplicationException(string.Format("Module \"{0}\" was found twice", moduleName));
 				modulesDict[moduleName] = module;
 			}
 
-			public Module lookup(string moduleName) {
+			public Module Lookup(string moduleName) {
 				Module module;
 				if (modulesDict.TryGetValue(moduleName, out module))
 					return module;
@@ -136,7 +136,7 @@ namespace de4dot.code.renamer.asmmodules {
 			this.deobfuscatorContext = deobfuscatorContext;
 		}
 
-		public void add(Module module) {
+		public void Add(Module module) {
 			if (initializeCalled)
 				throw new ApplicationException("initialize() has been called");
 			Module otherModule;
@@ -144,42 +144,42 @@ namespace de4dot.code.renamer.asmmodules {
 				return;
 			modulesDict[module.ModuleDefMD] = module;
 			modules.Add(module);
-			assemblyHash.add(module);
+			assemblyHash.Add(module);
 		}
 
-		public void initialize() {
+		public void Initialize() {
 			initializeCalled = true;
-			findAllMemberRefs();
-			initAllTypes();
-			resolveAllRefs();
+			FindAllMemberRefs();
+			InitAllTypes();
+			ResolveAllRefs();
 		}
 
-		void findAllMemberRefs() {
+		void FindAllMemberRefs() {
 			Logger.v("Finding all MemberRefs");
 			int index = 0;
 			foreach (var module in modules) {
 				if (modules.Count > 1)
 					Logger.v("Finding all MemberRefs ({0})", module.Filename);
-				Logger.Instance.indent();
-				module.findAllMemberRefs(ref index);
-				Logger.Instance.deIndent();
+				Logger.Instance.Indent();
+				module.FindAllMemberRefs(ref index);
+				Logger.Instance.DeIndent();
 			}
 		}
 
-		void resolveAllRefs() {
+		void ResolveAllRefs() {
 			Logger.v("Resolving references");
 			foreach (var module in modules) {
 				if (modules.Count > 1)
 					Logger.v("Resolving references ({0})", module.Filename);
-				Logger.Instance.indent();
-				module.resolveAllRefs(this);
-				Logger.Instance.deIndent();
+				Logger.Instance.Indent();
+				module.ResolveAllRefs(this);
+				Logger.Instance.DeIndent();
 			}
 		}
 
-		void initAllTypes() {
+		void InitAllTypes() {
 			foreach (var module in modules)
-				allTypes.AddRange(module.getAllTypes());
+				allTypes.AddRange(module.GetAllTypes());
 
 			var typeToTypeDef = new Dictionary<TypeDef, MTypeDef>(allTypes.Count);
 			foreach (var typeDef in allTypes)
@@ -196,9 +196,9 @@ namespace de4dot.code.renamer.asmmodules {
 				var baseType = typeDef.TypeDef.BaseType;
 				if (baseType == null)
 					continue;
-				var baseTypeDef = resolveType(baseType) ?? resolveOther(baseType);
+				var baseTypeDef = ResolveType(baseType) ?? ResolveOther(baseType);
 				if (baseTypeDef != null) {
-					typeDef.addBaseType(baseTypeDef, baseType);
+					typeDef.AddBaseType(baseTypeDef, baseType);
 					baseTypeDef.derivedTypes.Add(typeDef);
 				}
 			}
@@ -206,9 +206,9 @@ namespace de4dot.code.renamer.asmmodules {
 			// Initialize interfaces
 			foreach (var typeDef in allTypes) {
 				foreach (var iface in typeDef.TypeDef.Interfaces) {
-					var ifaceTypeDef = resolveType(iface.Interface) ?? resolveOther(iface.Interface);
+					var ifaceTypeDef = ResolveType(iface.Interface) ?? ResolveOther(iface.Interface);
 					if (ifaceTypeDef != null)
-						typeDef.addInterface(ifaceTypeDef, iface.Interface);
+						typeDef.AddInterface(ifaceTypeDef, iface.Interface);
 				}
 			}
 
@@ -235,7 +235,7 @@ namespace de4dot.code.renamer.asmmodules {
 			public T this[ITypeDefOrRef type] {
 				get {
 					T value;
-					if (tryGetValue(type, out value))
+					if (TryGetValue(type, out value))
 						return value;
 					throw new KeyNotFoundException();
 				}
@@ -251,11 +251,11 @@ namespace de4dot.code.renamer.asmmodules {
 				}
 			}
 
-			public bool tryGetValue(ITypeDefOrRef type, out T value) {
+			public bool TryGetValue(ITypeDefOrRef type, out T value) {
 				return dict.TryGetValue(type, out value);
 			}
 
-			public bool tryGetSimilarValue(ITypeDefOrRef type, out T value) {
+			public bool TryGetSimilarValue(ITypeDefOrRef type, out T value) {
 				List<ITypeDefOrRef> list;
 				if (!refs.TryGetValue(type, out list)) {
 					value = default(T);
@@ -308,7 +308,7 @@ namespace de4dot.code.renamer.asmmodules {
 		}
 
 		AssemblyKeyDictionary<MTypeDef> typeToTypeDefDict = new AssemblyKeyDictionary<MTypeDef>();
-		public MTypeDef resolveOther(ITypeDefOrRef type) {
+		public MTypeDef ResolveOther(ITypeDefOrRef type) {
 			if (type == null)
 				return null;
 			type = type.ScopeType;
@@ -316,17 +316,17 @@ namespace de4dot.code.renamer.asmmodules {
 				return null;
 
 			MTypeDef typeDef;
-			if (typeToTypeDefDict.tryGetValue(type, out typeDef))
+			if (typeToTypeDefDict.TryGetValue(type, out typeDef))
 				return typeDef;
 
-			var typeDef2 = deobfuscatorContext.resolveType(type);
+			var typeDef2 = deobfuscatorContext.ResolveType(type);
 			if (typeDef2 == null) {
-				typeToTypeDefDict.tryGetSimilarValue(type, out typeDef);
+				typeToTypeDefDict.TryGetSimilarValue(type, out typeDef);
 				typeToTypeDefDict[type] = typeDef;
 				return typeDef;
 			}
 
-			if (typeToTypeDefDict.tryGetValue(typeDef2, out typeDef)) {
+			if (typeToTypeDefDict.TryGetValue(typeDef2, out typeDef)) {
 				typeToTypeDefDict[type] = typeDef;
 				return typeDef;
 			}
@@ -335,16 +335,16 @@ namespace de4dot.code.renamer.asmmodules {
 			typeToTypeDefDict[typeDef2] = null;
 
 			typeDef = new MTypeDef(typeDef2, null, 0);
-			typeDef.addMembers();
+			typeDef.AddMembers();
 			foreach (var iface in typeDef.TypeDef.Interfaces) {
-				var ifaceDef = resolveOther(iface.Interface);
+				var ifaceDef = ResolveOther(iface.Interface);
 				if (ifaceDef == null)
 					continue;
-				typeDef.addInterface(ifaceDef, iface.Interface);
+				typeDef.AddInterface(ifaceDef, iface.Interface);
 			}
-			var baseDef = resolveOther(typeDef.TypeDef.BaseType);
+			var baseDef = ResolveOther(typeDef.TypeDef.BaseType);
 			if (baseDef != null)
-				typeDef.addBaseType(baseDef, typeDef.TypeDef.BaseType);
+				typeDef.AddBaseType(baseDef, typeDef.TypeDef.BaseType);
 
 			typeToTypeDefDict[type] = typeDef;
 			if (type != typeDef2)
@@ -352,19 +352,19 @@ namespace de4dot.code.renamer.asmmodules {
 			return typeDef;
 		}
 
-		public MethodNameGroups initializeVirtualMembers() {
+		public MethodNameGroups InitializeVirtualMembers() {
 			var groups = new MethodNameGroups();
 			foreach (var typeDef in allTypes)
-				typeDef.initializeVirtualMembers(groups, this);
+				typeDef.InitializeVirtualMembers(groups, this);
 			return groups;
 		}
 
-		public void onTypesRenamed() {
+		public void OnTypesRenamed() {
 			foreach (var module in modules)
-				module.onTypesRenamed();
+				module.OnTypesRenamed();
 		}
 
-		public void cleanUp() {
+		public void CleanUp() {
 #if PORT
 			foreach (var module in DotNetUtils.typeCaches.invalidateAll())
 				AssemblyResolver.Instance.removeModule(module);
@@ -372,7 +372,7 @@ namespace de4dot.code.renamer.asmmodules {
 		}
 
 		// Returns null if it's a non-loaded module/assembly
-		IEnumerable<Module> findModules(ITypeDefOrRef type) {
+		IEnumerable<Module> FindModules(ITypeDefOrRef type) {
 			if (type == null)
 				return null;
 			var scope = type.Scope;
@@ -381,10 +381,10 @@ namespace de4dot.code.renamer.asmmodules {
 
 			var scopeType = scope.ScopeType;
 			if (scopeType == ScopeType.AssemblyRef)
-				return findModules((AssemblyRef)scope);
+				return FindModules((AssemblyRef)scope);
 
 			if (scopeType == ScopeType.ModuleDef) {
-				var modules = findModules((ModuleDef)scope);
+				var modules = FindModules((ModuleDef)scope);
 				if (modules != null)
 					return modules;
 			}
@@ -392,7 +392,7 @@ namespace de4dot.code.renamer.asmmodules {
 			if (scopeType == ScopeType.ModuleRef) {
 				var moduleRef = (ModuleRef)scope;
 				if (moduleRef.Name == type.Module.Name) {
-					var modules = findModules(type.Module);
+					var modules = FindModules(type.Module);
 					if (modules != null)
 						return modules;
 				}
@@ -402,10 +402,10 @@ namespace de4dot.code.renamer.asmmodules {
 				var asm = type.Module.Assembly;
 				if (asm == null)
 					return null;
-				var moduleHash = assemblyHash.lookup(asm.FullName);
+				var moduleHash = assemblyHash.Lookup(asm.FullName);
 				if (moduleHash == null)
 					return null;
-				var module = moduleHash.lookup(scope.ScopeName);
+				var module = moduleHash.Lookup(scope.ScopeName);
 				if (module == null)
 					return null;
 				return new List<Module> { module };
@@ -414,21 +414,21 @@ namespace de4dot.code.renamer.asmmodules {
 			throw new ApplicationException(string.Format("scope is an unsupported type: {0}", scope.GetType()));
 		}
 
-		IEnumerable<Module> findModules(AssemblyRef assemblyRef) {
-			var moduleHash = assemblyHash.lookup(assemblyRef.FullName);
+		IEnumerable<Module> FindModules(AssemblyRef assemblyRef) {
+			var moduleHash = assemblyHash.Lookup(assemblyRef.FullName);
 			if (moduleHash != null)
 				return moduleHash.Modules;
 			return null;
 		}
 
-		IEnumerable<Module> findModules(ModuleDef moduleDef) {
+		IEnumerable<Module> FindModules(ModuleDef moduleDef) {
 			Module module;
 			if (modulesDict.TryGetValue(moduleDef, out module))
 				return new List<Module> { module };
 			return null;
 		}
 
-		bool isAutoCreatedType(ITypeDefOrRef typeRef) {
+		bool IsAutoCreatedType(ITypeDefOrRef typeRef) {
 			var ts = typeRef as TypeSpec;
 			if (ts == null)
 				return false;
@@ -438,61 +438,61 @@ namespace de4dot.code.renamer.asmmodules {
 			return sig.IsSZArray || sig.IsArray || sig.IsPointer;
 		}
 
-		public MTypeDef resolveType(ITypeDefOrRef typeRef) {
-			var modules = findModules(typeRef);
+		public MTypeDef ResolveType(ITypeDefOrRef typeRef) {
+			var modules = FindModules(typeRef);
 			if (modules == null)
 				return null;
 			foreach (var module in modules) {
-				var rv = module.resolveType(typeRef);
+				var rv = module.ResolveType(typeRef);
 				if (rv != null)
 					return rv;
 			}
-			if (isAutoCreatedType(typeRef))
+			if (IsAutoCreatedType(typeRef))
 				return null;
 			Logger.e("Could not resolve TypeRef {0} ({1:X8}) (from {2} -> {3})",
-						Utils.removeNewlines(typeRef),
+						Utils.RemoveNewlines(typeRef),
 						typeRef.MDToken.ToInt32(),
 						typeRef.Module,
 						typeRef.Scope);
 			return null;
 		}
 
-		public MMethodDef resolveMethod(IMethodDefOrRef methodRef) {
+		public MMethodDef ResolveMethod(IMethodDefOrRef methodRef) {
 			if (methodRef.DeclaringType == null)
 				return null;
-			var modules = findModules(methodRef.DeclaringType);
+			var modules = FindModules(methodRef.DeclaringType);
 			if (modules == null)
 				return null;
 			foreach (var module in modules) {
-				var rv = module.resolveMethod(methodRef);
+				var rv = module.ResolveMethod(methodRef);
 				if (rv != null)
 					return rv;
 			}
-			if (isAutoCreatedType(methodRef.DeclaringType))
+			if (IsAutoCreatedType(methodRef.DeclaringType))
 				return null;
 			Logger.e("Could not resolve MethodRef {0} ({1:X8}) (from {2} -> {3})",
-						Utils.removeNewlines(methodRef),
+						Utils.RemoveNewlines(methodRef),
 						methodRef.MDToken.ToInt32(),
 						methodRef.DeclaringType.Module,
 						methodRef.DeclaringType.Scope);
 			return null;
 		}
 
-		public MFieldDef resolveField(MemberRef fieldRef) {
+		public MFieldDef ResolveField(MemberRef fieldRef) {
 			if (fieldRef.DeclaringType == null)
 				return null;
-			var modules = findModules(fieldRef.DeclaringType);
+			var modules = FindModules(fieldRef.DeclaringType);
 			if (modules == null)
 				return null;
 			foreach (var module in modules) {
-				var rv = module.resolveField(fieldRef);
+				var rv = module.ResolveField(fieldRef);
 				if (rv != null)
 					return rv;
 			}
-			if (isAutoCreatedType(fieldRef.DeclaringType))
+			if (IsAutoCreatedType(fieldRef.DeclaringType))
 				return null;
 			Logger.e("Could not resolve FieldRef {0} ({1:X8}) (from {2} -> {3})",
-						Utils.removeNewlines(fieldRef),
+						Utils.RemoveNewlines(fieldRef),
 						fieldRef.MDToken.ToInt32(),
 						fieldRef.DeclaringType.Module,
 						fieldRef.DeclaringType.Scope);
diff --git a/de4dot.code/renamer/asmmodules/PropertyDef.cs b/de4dot.code/renamer/asmmodules/PropertyDef.cs
index 90a6775e..247af712 100644
--- a/de4dot.code/renamer/asmmodules/PropertyDef.cs
+++ b/de4dot.code/renamer/asmmodules/PropertyDef.cs
@@ -33,7 +33,7 @@ namespace de4dot.code.renamer.asmmodules {
 			: base(propertyDef, owner, index) {
 		}
 
-		public IEnumerable<MethodDef> methodDefs() {
+		public IEnumerable<MethodDef> MethodDefs() {
 			if (PropertyDef.GetMethod != null)
 				yield return PropertyDef.GetMethod;
 			if (PropertyDef.SetMethod != null)
@@ -44,15 +44,15 @@ namespace de4dot.code.renamer.asmmodules {
 			}
 		}
 
-		public bool isVirtual() {
-			foreach (var method in methodDefs()) {
+		public bool IsVirtual() {
+			foreach (var method in MethodDefs()) {
 				if (method.IsVirtual)
 					return true;
 			}
 			return false;
 		}
 
-		public bool isItemProperty() {
+		public bool IsItemProperty() {
 			if (GetMethod != null && GetMethod.VisibleParameterCount >= 1)
 				return true;
 			if (SetMethod != null && SetMethod.VisibleParameterCount >= 2)
diff --git a/de4dot.code/renamer/asmmodules/RefDict.cs b/de4dot.code/renamer/asmmodules/RefDict.cs
index 531abcfc..afd35442 100644
--- a/de4dot.code/renamer/asmmodules/RefDict.cs
+++ b/de4dot.code/renamer/asmmodules/RefDict.cs
@@ -22,7 +22,7 @@ using de4dot.blocks;
 
 namespace de4dot.code.renamer.asmmodules {
 	static class DictHelper {
-		public static IEnumerable<T> getSorted<T>(IEnumerable<T> values) where T : Ref {
+		public static IEnumerable<T> GetSorted<T>(IEnumerable<T> values) where T : Ref {
 			var list = new List<T>(values);
 			list.Sort((a, b) => a.Index.CompareTo(b.Index));
 			return list;
@@ -30,52 +30,52 @@ namespace de4dot.code.renamer.asmmodules {
 	}
 
 	class TypeDefDict : TypeDefDict<MTypeDef> {
-		public IEnumerable<MTypeDef> getSorted() {
-			return DictHelper.getSorted(getValues());
+		public IEnumerable<MTypeDef> GetSorted() {
+			return DictHelper.GetSorted(GetValues());
 		}
 
-		public void add(MTypeDef typeDef) {
-			add(typeDef.TypeDef, typeDef);
+		public void Add(MTypeDef typeDef) {
+			Add(typeDef.TypeDef, typeDef);
 		}
 	}
 
 	class FieldDefDict : FieldDefDict<MFieldDef> {
-		public IEnumerable<MFieldDef> getSorted() {
-			return DictHelper.getSorted(getValues());
+		public IEnumerable<MFieldDef> GetSorted() {
+			return DictHelper.GetSorted(GetValues());
 		}
 
-		public void add(MFieldDef fieldDef) {
-			add(fieldDef.FieldDef, fieldDef);
+		public void Add(MFieldDef fieldDef) {
+			Add(fieldDef.FieldDef, fieldDef);
 		}
 	}
 
 	class MethodDefDict : MethodDefDict<MMethodDef> {
-		public IEnumerable<MMethodDef> getSorted() {
-			return DictHelper.getSorted(getValues());
+		public IEnumerable<MMethodDef> GetSorted() {
+			return DictHelper.GetSorted(GetValues());
 		}
 
-		public void add(MMethodDef methodDef) {
-			add(methodDef.MethodDef, methodDef);
+		public void Add(MMethodDef methodDef) {
+			Add(methodDef.MethodDef, methodDef);
 		}
 	}
 
 	class PropertyDefDict : PropertyDefDict<MPropertyDef> {
-		public IEnumerable<MPropertyDef> getSorted() {
-			return DictHelper.getSorted(getValues());
+		public IEnumerable<MPropertyDef> GetSorted() {
+			return DictHelper.GetSorted(GetValues());
 		}
 
-		public void add(MPropertyDef propDef) {
-			add(propDef.PropertyDef, propDef);
+		public void Add(MPropertyDef propDef) {
+			Add(propDef.PropertyDef, propDef);
 		}
 	}
 
 	class EventDefDict : EventDefDict<MEventDef> {
-		public IEnumerable<MEventDef> getSorted() {
-			return DictHelper.getSorted(getValues());
+		public IEnumerable<MEventDef> GetSorted() {
+			return DictHelper.GetSorted(GetValues());
 		}
 
-		public void add(MEventDef eventDef) {
-			add(eventDef.EventDef, 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 2b523202..7d7990f3 100644
--- a/de4dot.code/renamer/asmmodules/TypeDef.cs
+++ b/de4dot.code/renamer/asmmodules/TypeDef.cs
@@ -32,7 +32,7 @@ namespace de4dot.code.renamer.asmmodules {
 		}
 
 		public TypeInfo(TypeInfo other, GenericInstSig git) {
-			this.typeRef = GenericArgsSubstitutor.create(other.typeRef, git);
+			this.typeRef = GenericArgsSubstitutor.Create(other.typeRef, git);
 			this.typeDef = other.typeDef;
 		}
 
@@ -90,30 +90,30 @@ namespace de4dot.code.renamer.asmmodules {
 	class MethodInstances {
 		Dictionary<IMethodDefOrRef, List<MethodInst>> methodInstances = new Dictionary<IMethodDefOrRef, List<MethodInst>>(MethodEqualityComparer.DontCompareDeclaringTypes);
 
-		public void initializeFrom(MethodInstances other, GenericInstSig git) {
+		public void InitializeFrom(MethodInstances other, GenericInstSig git) {
 			foreach (var list in other.methodInstances.Values) {
 				foreach (var methodInst in list) {
-					var newMethod = GenericArgsSubstitutor.create(methodInst.methodRef, git);
-					add(new MethodInst(methodInst.origMethodDef, newMethod));
+					var newMethod = GenericArgsSubstitutor.Create(methodInst.methodRef, git);
+					Add(new MethodInst(methodInst.origMethodDef, newMethod));
 				}
 			}
 		}
 
-		public void add(MethodInst methodInst) {
+		public void Add(MethodInst methodInst) {
 			List<MethodInst> list;
 			var key = methodInst.methodRef;
-			if (methodInst.origMethodDef.isNewSlot() || !methodInstances.TryGetValue(key, out list))
+			if (methodInst.origMethodDef.IsNewSlot() || !methodInstances.TryGetValue(key, out list))
 				methodInstances[key] = list = new List<MethodInst>();
 			list.Add(methodInst);
 		}
 
-		public List<MethodInst> lookup(IMethodDefOrRef methodRef) {
+		public List<MethodInst> Lookup(IMethodDefOrRef methodRef) {
 			List<MethodInst> list;
 			methodInstances.TryGetValue(methodRef, out list);
 			return list;
 		}
 
-		public IEnumerable<List<MethodInst>> getMethods() {
+		public IEnumerable<List<MethodInst>> GetMethods() {
 			return methodInstances.Values;
 		}
 	}
@@ -143,7 +143,7 @@ namespace de4dot.code.renamer.asmmodules {
 				ifaceMethodToClassMethod[key] = other.ifaceMethodToClassMethod[key];
 		}
 
-		public void merge(InterfaceMethodInfo other) {
+		public void Merge(InterfaceMethodInfo other) {
 			foreach (var key in other.ifaceMethodToClassMethod.Keys) {
 				if (other.ifaceMethodToClassMethod[key] == null)
 					continue;
@@ -154,7 +154,7 @@ namespace de4dot.code.renamer.asmmodules {
 		}
 
 		// Returns the previous method, or null if none
-		public MMethodDef addMethod(MMethodDef ifaceMethod, MMethodDef 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");
@@ -165,9 +165,9 @@ namespace de4dot.code.renamer.asmmodules {
 			return oldMethod;
 		}
 
-		public void addMethodIfEmpty(MMethodDef ifaceMethod, MMethodDef classMethod) {
+		public void AddMethodIfEmpty(MMethodDef ifaceMethod, MMethodDef classMethod) {
 			if (ifaceMethodToClassMethod[new MethodDefKey(ifaceMethod)] == null)
-				addMethod(ifaceMethod, classMethod);
+				AddMethod(ifaceMethod, classMethod);
 		}
 
 		public override string ToString() {
@@ -182,7 +182,7 @@ namespace de4dot.code.renamer.asmmodules {
 			get { return interfaceMethods.Values; }
 		}
 
-		public void initializeFrom(InterfaceMethodInfos other, GenericInstSig 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);
@@ -191,35 +191,35 @@ namespace de4dot.code.renamer.asmmodules {
 
 				InterfaceMethodInfo newMethodsInfo = new InterfaceMethodInfo(newTypeInfo, other.interfaceMethods[oldKey]);
 				if (interfaceMethods.ContainsKey(newKey))
-					newMethodsInfo.merge(interfaceMethods[newKey]);
+					newMethodsInfo.Merge(interfaceMethods[newKey]);
 				interfaceMethods[newKey] = newMethodsInfo;
 			}
 		}
 
-		public void addInterface(TypeInfo iface) {
+		public void AddInterface(TypeInfo iface) {
 			var key = iface.typeRef;
 			if (!interfaceMethods.ContainsKey(key))
 				interfaceMethods[key] = new InterfaceMethodInfo(iface);
 		}
 
 		// Returns the previous classMethod, or null if none
-		public MMethodDef addMethod(TypeInfo iface, MMethodDef ifaceMethod, MMethodDef classMethod) {
-			return addMethod(iface.typeRef, ifaceMethod, classMethod);
+		public MMethodDef AddMethod(TypeInfo iface, MMethodDef ifaceMethod, MMethodDef classMethod) {
+			return AddMethod(iface.typeRef, ifaceMethod, classMethod);
 		}
 
 		// Returns the previous classMethod, or null if none
-		public MMethodDef addMethod(ITypeDefOrRef iface, MMethodDef ifaceMethod, MMethodDef classMethod) {
+		public MMethodDef AddMethod(ITypeDefOrRef iface, MMethodDef ifaceMethod, MMethodDef classMethod) {
 			InterfaceMethodInfo info;
 			if (!interfaceMethods.TryGetValue(iface, out info))
 				throw new ApplicationException("Could not find interface");
-			return info.addMethod(ifaceMethod, classMethod);
+			return info.AddMethod(ifaceMethod, classMethod);
 		}
 
-		public void addMethodIfEmpty(TypeInfo iface, MMethodDef ifaceMethod, MMethodDef classMethod) {
+		public void AddMethodIfEmpty(TypeInfo iface, MMethodDef ifaceMethod, MMethodDef classMethod) {
 			InterfaceMethodInfo info;
 			if (!interfaceMethods.TryGetValue(iface.typeRef, out info))
 				throw new ApplicationException("Could not find interface");
-			info.addMethodIfEmpty(ifaceMethod, classMethod);
+			info.AddMethodIfEmpty(ifaceMethod, classMethod);
 		}
 	}
 
@@ -254,7 +254,7 @@ namespace de4dot.code.renamer.asmmodules {
 		}
 
 		public IEnumerable<MTypeDef> NestedTypes {
-			get { return types.getSorted(); }
+			get { return types.GetSorted(); }
 		}
 
 		public MTypeDef NestingType { get; set; }
@@ -264,150 +264,150 @@ namespace de4dot.code.renamer.asmmodules {
 		}
 
 		public IEnumerable<MEventDef> AllEvents {
-			get { return events.getValues(); }
+			get { return events.GetValues(); }
 		}
 
 		public IEnumerable<MFieldDef> AllFields {
-			get { return fields.getValues(); }
+			get { return fields.GetValues(); }
 		}
 
 		public IEnumerable<MMethodDef> AllMethods {
-			get { return methods.getValues(); }
+			get { return methods.GetValues(); }
 		}
 
 		public IEnumerable<MPropertyDef> AllProperties {
-			get { return properties.getValues(); }
+			get { return properties.GetValues(); }
 		}
 
 		public IEnumerable<MEventDef> AllEventsSorted {
-			get { return events.getSorted(); }
+			get { return events.GetSorted(); }
 		}
 
 		public IEnumerable<MFieldDef> AllFieldsSorted {
-			get { return fields.getSorted(); }
+			get { return fields.GetSorted(); }
 		}
 
 		public IEnumerable<MMethodDef> AllMethodsSorted {
-			get { return methods.getSorted(); }
+			get { return methods.GetSorted(); }
 		}
 
 		public IEnumerable<MPropertyDef> AllPropertiesSorted {
-			get { return properties.getSorted(); }
+			get { return properties.GetSorted(); }
 		}
 
 		public MTypeDef(TypeDef typeDef, Module module, int index)
 			: base(typeDef, null, index) {
 			this.module = module;
-			genericParams = MGenericParamDef.createGenericParamDefList(TypeDef.GenericParameters);
+			genericParams = MGenericParamDef.CreateGenericParamDefList(TypeDef.GenericParameters);
 		}
 
-		public void addInterface(MTypeDef ifaceDef, ITypeDefOrRef iface) {
+		public void AddInterface(MTypeDef ifaceDef, ITypeDefOrRef iface) {
 			if (ifaceDef == null || iface == null)
 				return;
 			interfaces.Add(new TypeInfo(iface, ifaceDef));
 		}
 
-		public void addBaseType(MTypeDef baseDef, ITypeDefOrRef baseRef) {
+		public void AddBaseType(MTypeDef baseDef, ITypeDefOrRef baseRef) {
 			if (baseDef == null || baseRef == null)
 				return;
 			baseType = new TypeInfo(baseRef, baseDef);
 		}
 
-		public void add(MEventDef e) {
-			events.add(e);
+		public void Add(MEventDef e) {
+			events.Add(e);
 		}
 
-		public void add(MFieldDef f) {
-			fields.add(f);
+		public void Add(MFieldDef f) {
+			fields.Add(f);
 		}
 
-		public void add(MMethodDef m) {
-			methods.add(m);
+		public void Add(MMethodDef m) {
+			methods.Add(m);
 		}
 
-		public void add(MPropertyDef p) {
-			properties.add(p);
+		public void Add(MPropertyDef p) {
+			properties.Add(p);
 		}
 
-		public void add(MTypeDef t) {
-			types.add(t);
+		public void Add(MTypeDef t) {
+			types.Add(t);
 		}
 
-		public MMethodDef findMethod(MemberRef mr) {
-			return methods.find(mr);
+		public MMethodDef FindMethod(MemberRef mr) {
+			return methods.Find(mr);
 		}
 
-		public MMethodDef findMethod(IMethodDefOrRef md) {
-			return methods.find(md);
+		public MMethodDef FindMethod(IMethodDefOrRef md) {
+			return methods.Find(md);
 		}
 
-		public MMethodDef findMethod(MethodDef md) {
-			return methods.find(md);
+		public MMethodDef FindMethod(MethodDef md) {
+			return methods.Find(md);
 		}
 
-		public MMethodDef findAnyMethod(MemberRef mr) {
-			return methods.findAny(mr);
+		public MMethodDef FindAnyMethod(MemberRef mr) {
+			return methods.FindAny(mr);
 		}
 
-		public MFieldDef findField(MemberRef fr) {
-			return fields.find(fr);
+		public MFieldDef FindField(MemberRef fr) {
+			return fields.Find(fr);
 		}
 
-		public MFieldDef findAnyField(MemberRef fr) {
-			return fields.findAny(fr);
+		public MFieldDef FindAnyField(MemberRef fr) {
+			return fields.FindAny(fr);
 		}
 
-		public MPropertyDef find(PropertyDef pr) {
-			return properties.find(pr);
+		public MPropertyDef Find(PropertyDef pr) {
+			return properties.Find(pr);
 		}
 
-		public MPropertyDef findAny(PropertyDef pr) {
-			return properties.findAny(pr);
+		public MPropertyDef FindAny(PropertyDef pr) {
+			return properties.FindAny(pr);
 		}
 
-		public MEventDef find(EventDef er) {
-			return events.find(er);
+		public MEventDef Find(EventDef er) {
+			return events.Find(er);
 		}
 
-		public MEventDef findAny(EventDef er) {
-			return events.findAny(er);
+		public MEventDef FindAny(EventDef er) {
+			return events.FindAny(er);
 		}
 
-		public MPropertyDef create(PropertyDef newProp) {
-			if (findAny(newProp) != null)
+		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 MPropertyDef(newProp, this, properties.Count);
-			add(propDef);
+			Add(propDef);
 			TypeDef.Properties.Add(newProp);
 			return propDef;
 		}
 
-		public MEventDef create(EventDef newEvent) {
-			if (findAny(newEvent) != null)
+		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 MEventDef(newEvent, this, events.Count);
-			add(eventDef);
+			Add(eventDef);
 			TypeDef.Events.Add(newEvent);
 			return eventDef;
 		}
 
-		public void addMembers() {
+		public void AddMembers() {
 			var type = TypeDef;
 
 			for (int i = 0; i < type.Events.Count; i++)
-				add(new MEventDef(type.Events[i], this, i));
+				Add(new MEventDef(type.Events[i], this, i));
 			for (int i = 0; i < type.Fields.Count; i++)
-				add(new MFieldDef(type.Fields[i], this, i));
+				Add(new MFieldDef(type.Fields[i], this, i));
 			for (int i = 0; i < type.Methods.Count; i++)
-				add(new MMethodDef(type.Methods[i], this, i));
+				Add(new MMethodDef(type.Methods[i], this, i));
 			for (int i = 0; i < type.Properties.Count; i++)
-				add(new MPropertyDef(type.Properties[i], this, i));
+				Add(new MPropertyDef(type.Properties[i], this, i));
 
-			foreach (var propDef in properties.getValues()) {
-				foreach (var method in propDef.methodDefs()) {
-					var methodDef = findMethod(method);
+			foreach (var propDef in properties.GetValues()) {
+				foreach (var method in propDef.MethodDefs()) {
+					var methodDef = FindMethod(method);
 					if (methodDef == null)
 						throw new ApplicationException("Could not find property method");
 					methodDef.Property = propDef;
@@ -418,9 +418,9 @@ namespace de4dot.code.renamer.asmmodules {
 				}
 			}
 
-			foreach (var eventDef in events.getValues()) {
-				foreach (var method in eventDef.methodDefs()) {
-					var methodDef = findMethod(method);
+			foreach (var eventDef in events.GetValues()) {
+				foreach (var method in eventDef.MethodDefs()) {
+					var methodDef = FindMethod(method);
 					if (methodDef == null)
 						throw new ApplicationException("Could not find event method");
 					methodDef.Event = eventDef;
@@ -434,20 +434,20 @@ namespace de4dot.code.renamer.asmmodules {
 			}
 		}
 
-		public void onTypesRenamed() {
-			events.onTypesRenamed();
-			properties.onTypesRenamed();
-			fields.onTypesRenamed();
-			methods.onTypesRenamed();
-			types.onTypesRenamed();
+		public void OnTypesRenamed() {
+			events.OnTypesRenamed();
+			properties.OnTypesRenamed();
+			fields.OnTypesRenamed();
+			methods.OnTypesRenamed();
+			types.OnTypesRenamed();
 		}
 
-		public bool isNested() {
+		public bool IsNested() {
 			return NestingType != null;
 		}
 
-		public bool isGlobalType() {
-			if (!isNested())
+		public bool IsGlobalType() {
+			if (!IsNested())
 				return TypeDef.IsPublic;
 			switch (TypeDef.Visibility) {
 			case TypeAttributes.NestedPrivate:
@@ -457,53 +457,53 @@ namespace de4dot.code.renamer.asmmodules {
 			case TypeAttributes.NestedPublic:
 			case TypeAttributes.NestedFamily:
 			case TypeAttributes.NestedFamORAssem:
-				return NestingType.isGlobalType();
+				return NestingType.IsGlobalType();
 			default:
 				return false;
 			}
 		}
 
-		public void initializeVirtualMembers(MethodNameGroups groups, IResolver resolver) {
+		public void InitializeVirtualMembers(MethodNameGroups groups, IResolver resolver) {
 			if (initializeVirtualMembersCalled)
 				return;
 			initializeVirtualMembersCalled = true;
 
 			foreach (var iface in interfaces)
-				iface.typeDef.initializeVirtualMembers(groups, resolver);
+				iface.typeDef.InitializeVirtualMembers(groups, resolver);
 			if (baseType != null)
-				baseType.typeDef.initializeVirtualMembers(groups, resolver);
+				baseType.typeDef.InitializeVirtualMembers(groups, resolver);
 
-			foreach (var methodDef in methods.getValues()) {
-				if (methodDef.isVirtual())
-					groups.add(methodDef);
+			foreach (var methodDef in methods.GetValues()) {
+				if (methodDef.IsVirtual())
+					groups.Add(methodDef);
 			}
 
-			instantiateVirtualMembers(groups);
-			initializeInterfaceMethods(groups);
+			InstantiateVirtualMembers(groups);
+			InitializeInterfaceMethods(groups);
 		}
 
-		void initializeAllInterfaces() {
+		void InitializeAllInterfaces() {
 			if (baseType != null)
-				initializeInterfaces(baseType);
+				InitializeInterfaces(baseType);
 
 			foreach (var iface in interfaces) {
 				allImplementedInterfaces[iface] = true;
-				interfaceMethodInfos.addInterface(iface);
-				initializeInterfaces(iface);
+				interfaceMethodInfos.AddInterface(iface);
+				InitializeInterfaces(iface);
 			}
 		}
 
-		void initializeInterfaces(TypeInfo typeInfo) {
+		void InitializeInterfaces(TypeInfo typeInfo) {
 			var git = typeInfo.typeRef.TryGetGenericInstSig();
-			interfaceMethodInfos.initializeFrom(typeInfo.typeDef.interfaceMethodInfos, git);
+			interfaceMethodInfos.InitializeFrom(typeInfo.typeDef.interfaceMethodInfos, git);
 			foreach (var info in typeInfo.typeDef.allImplementedInterfaces.Keys) {
 				var newTypeInfo = new TypeInfo(info, git);
 				allImplementedInterfaces[newTypeInfo] = true;
 			}
 		}
 
-		void initializeInterfaceMethods(MethodNameGroups groups) {
-			initializeAllInterfaces();
+		void InitializeInterfaceMethods(MethodNameGroups groups) {
+			InitializeAllInterfaces();
 
 			if (TypeDef.IsInterface)
 				return;
@@ -526,25 +526,25 @@ namespace de4dot.code.renamer.asmmodules {
 			//---	  methods to implement the corresponding interface method.
 			if (interfaces.Count > 0) {
 				methodsDict.Clear();
-				foreach (var method in methods.getValues()) {
-					if (!method.isPublic() || !method.isVirtual() || !method.isNewSlot())
+				foreach (var method in methods.GetValues()) {
+					if (!method.IsPublic() || !method.IsVirtual() || !method.IsNewSlot())
 						continue;
 					methodsDict[method.MethodDef] = method;
 				}
 
 				foreach (var ifaceInfo in interfaces) {
-					foreach (var methodsList in ifaceInfo.typeDef.virtualMethodInstances.getMethods()) {
+					foreach (var methodsList in ifaceInfo.typeDef.virtualMethodInstances.GetMethods()) {
 						if (methodsList.Count < 1)
 							continue;
 						var methodInst = methodsList[0];
 						var ifaceMethod = methodInst.origMethodDef;
-						if (!ifaceMethod.isVirtual())
+						if (!ifaceMethod.IsVirtual())
 							continue;
-						var ifaceMethodRef = GenericArgsSubstitutor.create(methodInst.methodRef, ifaceInfo.typeRef.TryGetGenericInstSig());
+						var ifaceMethodRef = GenericArgsSubstitutor.Create(methodInst.methodRef, ifaceInfo.typeRef.TryGetGenericInstSig());
 						MMethodDef classMethod;
 						if (!methodsDict.TryGetValue(ifaceMethodRef, out classMethod))
 							continue;
-						interfaceMethodInfos.addMethod(ifaceInfo, ifaceMethod, classMethod);
+						interfaceMethodInfos.AddMethod(ifaceInfo, ifaceMethod, classMethod);
 					}
 				}
 			}
@@ -555,30 +555,30 @@ namespace de4dot.code.renamer.asmmodules {
 			//---	and signature, then use these to implement the corresponding methods on the
 			//---	interface.
 			methodsDict.Clear();
-			foreach (var methodInstList in virtualMethodInstances.getMethods()) {
+			foreach (var methodInstList in virtualMethodInstances.GetMethods()) {
 				// This class' method is at the end
 				for (int i = methodInstList.Count - 1; i >= 0; i--) {
 					var classMethod = methodInstList[i];
 					// These methods are guaranteed to be virtual.
 					// We should allow newslot methods, despite what the official doc says.
-					if (!classMethod.origMethodDef.isPublic())
+					if (!classMethod.origMethodDef.IsPublic())
 						continue;
 					methodsDict[classMethod.methodRef] = classMethod.origMethodDef;
 					break;
 				}
 			}
 			foreach (var ifaceInfo in allImplementedInterfaces.Keys) {
-				foreach (var methodsList in ifaceInfo.typeDef.virtualMethodInstances.getMethods()) {
+				foreach (var methodsList in ifaceInfo.typeDef.virtualMethodInstances.GetMethods()) {
 					if (methodsList.Count < 1)
 						continue;
 					var ifaceMethod = methodsList[0].origMethodDef;
-					if (!ifaceMethod.isVirtual())
+					if (!ifaceMethod.IsVirtual())
 						continue;
-					var ifaceMethodRef = GenericArgsSubstitutor.create(ifaceMethod.MethodDef, ifaceInfo.typeRef.TryGetGenericInstSig());
+					var ifaceMethodRef = GenericArgsSubstitutor.Create(ifaceMethod.MethodDef, ifaceInfo.typeRef.TryGetGenericInstSig());
 					MMethodDef classMethod;
 					if (!methodsDict.TryGetValue(ifaceMethodRef, out classMethod))
 						continue;
-					interfaceMethodInfos.addMethodIfEmpty(ifaceInfo, ifaceMethod, classMethod);
+					interfaceMethodInfos.AddMethodIfEmpty(ifaceInfo, ifaceMethod, classMethod);
 				}
 			}
 
@@ -589,15 +589,15 @@ namespace de4dot.code.renamer.asmmodules {
 			var ifaceMethodsDict = new Dictionary<IMethodDefOrRef, MMethodDef>(MethodEqualityComparer.CompareDeclaringTypes);
 			foreach (var ifaceInfo in allImplementedInterfaces.Keys) {
 				var git = ifaceInfo.typeRef.TryGetGenericInstSig();
-				foreach (var ifaceMethod in ifaceInfo.typeDef.methods.getValues()) {
+				foreach (var ifaceMethod in ifaceInfo.typeDef.methods.GetValues()) {
 					IMethodDefOrRef ifaceMethodRef = ifaceMethod.MethodDef;
 					if (git != null)
-						ifaceMethodRef = simpleClone(ifaceMethod.MethodDef, ifaceInfo.typeRef);
+						ifaceMethodRef = SimpleClone(ifaceMethod.MethodDef, ifaceInfo.typeRef);
 					ifaceMethodsDict[ifaceMethodRef] = ifaceMethod;
 				}
 			}
-			foreach (var classMethod in methods.getValues()) {
-				if (!classMethod.isVirtual())
+			foreach (var classMethod in methods.GetValues()) {
+				if (!classMethod.IsVirtual())
 					continue;
 				foreach (var overrideMethod in classMethod.MethodDef.Overrides) {
 					MMethodDef ifaceMethod;
@@ -607,7 +607,7 @@ namespace de4dot.code.renamer.asmmodules {
 						continue;
 					}
 
-					interfaceMethodInfos.addMethod(overrideMethod.MethodDeclaration.DeclaringType, ifaceMethod, classMethod);
+					interfaceMethodInfos.AddMethod(overrideMethod.MethodDeclaration.DeclaringType, ifaceMethod, classMethod);
 				}
 			}
 
@@ -619,16 +619,16 @@ namespace de4dot.code.renamer.asmmodules {
 				foreach (var pair in info.IfaceMethodToClassMethod) {
 					if (pair.Value != null)
 						continue;
-					if (!resolvedAllInterfaces() || !resolvedBaseClasses())
+					if (!ResolvedAllInterfaces() || !ResolvedBaseClasses())
 						continue;
 					// Ignore if COM class
 					if (!TypeDef.IsImport &&
-						!hasAttribute("System.Runtime.InteropServices.ComImportAttribute") &&
-						!hasAttribute("System.Runtime.InteropServices.TypeLibTypeAttribute")) {
+						!HasAttribute("System.Runtime.InteropServices.ComImportAttribute") &&
+						!HasAttribute("System.Runtime.InteropServices.TypeLibTypeAttribute")) {
 						Logger.w("Could not find interface method {0} ({1:X8}). Type: {2} ({3:X8})",
-								Utils.removeNewlines(pair.Key.methodDef.MethodDef),
+								Utils.RemoveNewlines(pair.Key.methodDef.MethodDef),
 								pair.Key.methodDef.MethodDef.MDToken.ToInt32(),
-								Utils.removeNewlines(TypeDef),
+								Utils.RemoveNewlines(TypeDef),
 								TypeDef.MDToken.ToInt32());
 					}
 				}
@@ -640,12 +640,12 @@ namespace de4dot.code.renamer.asmmodules {
 						continue;
 					if (pair.Key.methodDef.MethodDef.Name != pair.Value.MethodDef.Name)
 						continue;
-					groups.same(pair.Key.methodDef, pair.Value);
+					groups.Same(pair.Key.methodDef, pair.Value);
 				}
 			}
 		}
 
-		bool hasAttribute(string name) {
+		bool HasAttribute(string name) {
 			foreach (var attr in TypeDef.CustomAttributes) {
 				if (attr.TypeFullName == name)
 					return true;
@@ -655,18 +655,18 @@ namespace de4dot.code.renamer.asmmodules {
 
 		// Returns true if all interfaces have been resolved
 		bool? resolvedAllInterfacesResult;
-		bool resolvedAllInterfaces() {
+		bool ResolvedAllInterfaces() {
 			if (!resolvedAllInterfacesResult.HasValue) {
 				resolvedAllInterfacesResult = true;	// If we find a circular reference
-				resolvedAllInterfacesResult = resolvedAllInterfacesInternal();
+				resolvedAllInterfacesResult = ResolvedAllInterfacesInternal();
 			}
 			return resolvedAllInterfacesResult.Value;
 		}
-		bool resolvedAllInterfacesInternal() {
+		bool ResolvedAllInterfacesInternal() {
 			if (TypeDef.Interfaces.Count != interfaces.Count)
 				return false;
 			foreach (var ifaceInfo in interfaces) {
-				if (!ifaceInfo.typeDef.resolvedAllInterfaces())
+				if (!ifaceInfo.typeDef.ResolvedAllInterfaces())
 					return false;
 			}
 			return true;
@@ -674,49 +674,49 @@ namespace de4dot.code.renamer.asmmodules {
 
 		// Returns true if all base classes have been resolved
 		bool? resolvedBaseClassesResult;
-		bool resolvedBaseClasses() {
+		bool ResolvedBaseClasses() {
 			if (!resolvedBaseClassesResult.HasValue) {
 				resolvedBaseClassesResult = true;	// If we find a circular reference
-				resolvedBaseClassesResult = resolvedBaseClassesInternal();
+				resolvedBaseClassesResult = ResolvedBaseClassesInternal();
 			}
 			return resolvedBaseClassesResult.Value;
 		}
-		bool resolvedBaseClassesInternal() {
+		bool ResolvedBaseClassesInternal() {
 			if (TypeDef.BaseType == null)
 				return true;
 			if (baseType == null)
 				return false;
-			return baseType.typeDef.resolvedBaseClasses();
+			return baseType.typeDef.ResolvedBaseClasses();
 		}
 
-		MemberRef simpleClone(MethodDef methodRef, ITypeDefOrRef declaringType) {
+		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) {
+		void InstantiateVirtualMembers(MethodNameGroups groups) {
 			if (!TypeDef.IsInterface) {
 				if (baseType != null)
-					virtualMethodInstances.initializeFrom(baseType.typeDef.virtualMethodInstances, baseType.typeRef.TryGetGenericInstSig());
+					virtualMethodInstances.InitializeFrom(baseType.typeDef.virtualMethodInstances, baseType.typeRef.TryGetGenericInstSig());
 
 				// Figure out which methods we override in the base class
-				foreach (var methodDef in methods.getValues()) {
-					if (!methodDef.isVirtual() || methodDef.isNewSlot())
+				foreach (var methodDef in methods.GetValues()) {
+					if (!methodDef.IsVirtual() || methodDef.IsNewSlot())
 						continue;
-					var methodInstList = virtualMethodInstances.lookup(methodDef.MethodDef);
+					var methodInstList = virtualMethodInstances.Lookup(methodDef.MethodDef);
 					if (methodInstList == null)
 						continue;
 					foreach (var methodInst in methodInstList)
-						groups.same(methodDef, methodInst.origMethodDef);
+						groups.Same(methodDef, methodInst.origMethodDef);
 				}
 			}
 
-			foreach (var methodDef in methods.getValues()) {
-				if (!methodDef.isVirtual())
+			foreach (var methodDef in methods.GetValues()) {
+				if (!methodDef.IsVirtual())
 					continue;
-				virtualMethodInstances.add(new MethodInst(methodDef, methodDef.MethodDef));
+				virtualMethodInstances.Add(new MethodInst(methodDef, methodDef.MethodDef));
 			}
 		}
 	}
diff --git a/de4dot.code/resources/BuiltInResourceData.cs b/de4dot.code/resources/BuiltInResourceData.cs
index cc00dab1..dcd63eba 100644
--- a/de4dot.code/resources/BuiltInResourceData.cs
+++ b/de4dot.code/resources/BuiltInResourceData.cs
@@ -39,7 +39,7 @@ namespace de4dot.code.resources {
 			this.data = data;
 		}
 
-		public void writeData(BinaryWriter writer, IFormatter formatter) {
+		public void WriteData(BinaryWriter writer, IFormatter formatter) {
 			switch (code) {
 			case ResourceTypeCode.Null:
 				return;
diff --git a/de4dot.code/resources/IResourceData.cs b/de4dot.code/resources/IResourceData.cs
index efc0d4f5..be3ab6a1 100644
--- a/de4dot.code/resources/IResourceData.cs
+++ b/de4dot.code/resources/IResourceData.cs
@@ -23,6 +23,6 @@ using System.Runtime.Serialization;
 namespace de4dot.code.resources {
 	interface IResourceData {
 		ResourceTypeCode Code { get; }
-		void writeData(BinaryWriter writer, IFormatter formatter);
+		void WriteData(BinaryWriter writer, IFormatter formatter);
 	}
 }
diff --git a/de4dot.code/resources/ResourceDataCreator.cs b/de4dot.code/resources/ResourceDataCreator.cs
index 95d6528c..0c20f00a 100644
--- a/de4dot.code/resources/ResourceDataCreator.cs
+++ b/de4dot.code/resources/ResourceDataCreator.cs
@@ -38,96 +38,96 @@ namespace de4dot.code.resources {
 			get { return dict.Count; }
 		}
 
-		public BuiltInResourceData createNull() {
+		public BuiltInResourceData CreateNull() {
 			return new BuiltInResourceData(ResourceTypeCode.Null, null);
 		}
 
-		public BuiltInResourceData create(string value) {
+		public BuiltInResourceData Create(string value) {
 			return new BuiltInResourceData(ResourceTypeCode.String, value);
 		}
 
-		public BuiltInResourceData create(bool value) {
+		public BuiltInResourceData Create(bool value) {
 			return new BuiltInResourceData(ResourceTypeCode.Boolean, value);
 		}
 
-		public BuiltInResourceData create(char value) {
+		public BuiltInResourceData Create(char value) {
 			return new BuiltInResourceData(ResourceTypeCode.Char, value);
 		}
 
-		public BuiltInResourceData create(byte value) {
+		public BuiltInResourceData Create(byte value) {
 			return new BuiltInResourceData(ResourceTypeCode.Byte, value);
 		}
 
-		public BuiltInResourceData create(sbyte value) {
+		public BuiltInResourceData Create(sbyte value) {
 			return new BuiltInResourceData(ResourceTypeCode.SByte, value);
 		}
 
-		public BuiltInResourceData create(short value) {
+		public BuiltInResourceData Create(short value) {
 			return new BuiltInResourceData(ResourceTypeCode.Int16, value);
 		}
 
-		public BuiltInResourceData create(ushort value) {
+		public BuiltInResourceData Create(ushort value) {
 			return new BuiltInResourceData(ResourceTypeCode.UInt16, value);
 		}
 
-		public BuiltInResourceData create(int value) {
+		public BuiltInResourceData Create(int value) {
 			return new BuiltInResourceData(ResourceTypeCode.Int32, value);
 		}
 
-		public BuiltInResourceData create(uint value) {
+		public BuiltInResourceData Create(uint value) {
 			return new BuiltInResourceData(ResourceTypeCode.UInt32, value);
 		}
 
-		public BuiltInResourceData create(long value) {
+		public BuiltInResourceData Create(long value) {
 			return new BuiltInResourceData(ResourceTypeCode.Int64, value);
 		}
 
-		public BuiltInResourceData create(ulong value) {
+		public BuiltInResourceData Create(ulong value) {
 			return new BuiltInResourceData(ResourceTypeCode.UInt64, value);
 		}
 
-		public BuiltInResourceData create(float value) {
+		public BuiltInResourceData Create(float value) {
 			return new BuiltInResourceData(ResourceTypeCode.Single, value);
 		}
 
-		public BuiltInResourceData create(double value) {
+		public BuiltInResourceData Create(double value) {
 			return new BuiltInResourceData(ResourceTypeCode.Double, value);
 		}
 
-		public BuiltInResourceData create(decimal value) {
+		public BuiltInResourceData Create(decimal value) {
 			return new BuiltInResourceData(ResourceTypeCode.Decimal, value);
 		}
 
-		public BuiltInResourceData create(DateTime value) {
+		public BuiltInResourceData Create(DateTime value) {
 			return new BuiltInResourceData(ResourceTypeCode.DateTime, value);
 		}
 
-		public BuiltInResourceData create(TimeSpan value) {
+		public BuiltInResourceData Create(TimeSpan value) {
 			return new BuiltInResourceData(ResourceTypeCode.TimeSpan, value);
 		}
 
-		public BuiltInResourceData create(byte[] value) {
+		public BuiltInResourceData Create(byte[] value) {
 			return new BuiltInResourceData(ResourceTypeCode.ByteArray, value);
 		}
 
-		public CharArrayResourceData create(char[] value) {
-			return new CharArrayResourceData(createUserResourceType(CharArrayResourceData.typeName), value);
+		public CharArrayResourceData Create(char[] value) {
+			return new CharArrayResourceData(CreateUserResourceType(CharArrayResourceData.typeName), value);
 		}
 
-		public IconResourceData createIcon(byte[] value) {
-			return new IconResourceData(createUserResourceType(IconResourceData.typeName), value);
+		public IconResourceData CreateIcon(byte[] value) {
+			return new IconResourceData(CreateUserResourceType(IconResourceData.typeName), value);
 		}
 
-		public ImageResourceData createImage(byte[] value) {
-			return new ImageResourceData(createUserResourceType(ImageResourceData.typeName), value);
+		public ImageResourceData CreateImage(byte[] value) {
+			return new ImageResourceData(CreateUserResourceType(ImageResourceData.typeName), value);
 		}
 
-		public BinaryResourceData createSerialized(byte[] value) {
+		public BinaryResourceData CreateSerialized(byte[] value) {
 			string assemblyName, typeName;
-			if (!getSerializedTypeAndAssemblyName(value, out assemblyName, out typeName))
+			if (!GetSerializedTypeAndAssemblyName(value, out assemblyName, out typeName))
 				throw new ApplicationException("Could not get serialized type name");
 			string fullName = string.Format("{0},{1}", typeName, assemblyName);
-			return new BinaryResourceData(createUserResourceType(fullName), value);
+			return new BinaryResourceData(CreateUserResourceType(fullName), value);
 		}
 
 		class MyBinder : SerializationBinder {
@@ -144,7 +144,7 @@ namespace de4dot.code.resources {
 			}
 		}
 
-		bool getSerializedTypeAndAssemblyName(byte[] value, out string assemblyName, out string typeName) {
+		bool GetSerializedTypeAndAssemblyName(byte[] value, out string assemblyName, out string typeName) {
 			try {
 				var formatter = new BinaryFormatter();
 				formatter.Binder = new MyBinder();
@@ -163,19 +163,19 @@ namespace de4dot.code.resources {
 			return false;
 		}
 
-		public UserResourceType createUserResourceType(string fullName) {
+		public UserResourceType CreateUserResourceType(string fullName) {
 			UserResourceType type;
 			if (dict.TryGetValue(fullName, out type))
 				return type;
 
-			var newFullName = getRealTypeFullName(fullName);
+			var newFullName = GetRealTypeFullName(fullName);
 			type = new UserResourceType(newFullName, ResourceTypeCode.UserTypes + dict.Count);
 			dict[fullName] = type;
 			dict[newFullName] = type;
 			return type;
 		}
 
-		static void splitTypeFullName(string fullName, out string typeName, out string assemblyName) {
+		static void SplitTypeFullName(string fullName, out string typeName, out string assemblyName) {
 			int index = fullName.IndexOf(',');
 			if (index < 0) {
 				typeName = fullName;
@@ -187,28 +187,28 @@ namespace de4dot.code.resources {
 			}
 		}
 
-		string getRealTypeFullName(string fullName) {
+		string GetRealTypeFullName(string fullName) {
 			var newFullName = fullName;
 
 			string typeName, assemblyName;
-			splitTypeFullName(fullName, out typeName, out assemblyName);
+			SplitTypeFullName(fullName, out typeName, out assemblyName);
 			if (!string.IsNullOrEmpty(assemblyName))
-				assemblyName = getRealAssemblyName(assemblyName);
+				assemblyName = GetRealAssemblyName(assemblyName);
 			if (!string.IsNullOrEmpty(assemblyName))
 				newFullName = string.Format("{0}, {1}", typeName, assemblyName);
 
 			return newFullName;
 		}
 
-		string getRealAssemblyName(string assemblyName) {
+		string GetRealAssemblyName(string assemblyName) {
 			string newAsmName;
 			if (!asmNameToAsmFullName.TryGetValue(assemblyName, out newAsmName))
-				asmNameToAsmFullName[assemblyName] = newAsmName = tryGetRealAssemblyName(assemblyName);
+				asmNameToAsmFullName[assemblyName] = newAsmName = TryGetRealAssemblyName(assemblyName);
 			return newAsmName;
 		}
 
-		string tryGetRealAssemblyName(string assemblyName) {
-			var simpleName = Utils.getAssemblySimpleName(assemblyName);
+		string TryGetRealAssemblyName(string assemblyName) {
+			var simpleName = Utils.GetAssemblySimpleName(assemblyName);
 
 			var asmRef = module.GetAssemblyRef(simpleName);
 			if (asmRef != null)
@@ -218,7 +218,7 @@ namespace de4dot.code.resources {
 			return asm == null ? null : asm.FullName;
 		}
 
-		public List<UserResourceType> getSortedTypes() {
+		public List<UserResourceType> GetSortedTypes() {
 			var list = new List<UserResourceType>(dict.Values);
 			list.Sort((a, b) => ((int)a.Code).CompareTo((int)b.Code));
 			return list;
diff --git a/de4dot.code/resources/ResourceElementSet.cs b/de4dot.code/resources/ResourceElementSet.cs
index 4190c92b..fe0c8940 100644
--- a/de4dot.code/resources/ResourceElementSet.cs
+++ b/de4dot.code/resources/ResourceElementSet.cs
@@ -32,7 +32,7 @@ namespace de4dot.code.resources {
 			get { return dict.Values; }
 		}
 
-		public void add(ResourceElement elem) {
+		public void Add(ResourceElement elem) {
 			dict[elem.Name] = elem;
 		}
 	}
diff --git a/de4dot.code/resources/ResourceReader.cs b/de4dot.code/resources/ResourceReader.cs
index 98893e96..2982ee35 100644
--- a/de4dot.code/resources/ResourceReader.cs
+++ b/de4dot.code/resources/ResourceReader.cs
@@ -44,17 +44,17 @@ namespace de4dot.code.resources {
 			this.resourceDataCreator = new ResourceDataCreator(module);
 		}
 
-		public static ResourceElementSet read(ModuleDefMD module, IBinaryReader reader) {
-			return new ResourceReader(module, reader).read();
+		public static ResourceElementSet Read(ModuleDefMD module, IBinaryReader reader) {
+			return new ResourceReader(module, reader).Read();
 		}
 
-		ResourceElementSet read() {
+		ResourceElementSet Read() {
 			ResourceElementSet resources = new ResourceElementSet();
 
 			uint sig = reader.ReadUInt32();
 			if (sig != 0xBEEFCACE)
 				throw new ResourceReaderException(string.Format("Invalid resource sig: {0:X8}", sig));
-			if (!checkReaders())
+			if (!CheckReaders())
 				throw new ResourceReaderException("Invalid resource reader");
 			int version = reader.ReadInt32();
 			if (version != 2)
@@ -100,9 +100,9 @@ namespace de4dot.code.resources {
 				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);
+				element.ResourceData = ReadResourceData(userTypes, size);
 
-				resources.add(element);
+				resources.Add(element);
 			}
 
 			return resources;
@@ -120,36 +120,36 @@ namespace de4dot.code.resources {
 			}
 		}
 
-		IResourceData readResourceData(List<UserResourceType> userTypes, int size) {
-			uint code = readUInt32(reader);
+		IResourceData ReadResourceData(List<UserResourceType> userTypes, int size) {
+			uint code = ReadUInt32(reader);
 			switch ((ResourceTypeCode)code) {
-			case ResourceTypeCode.Null: return resourceDataCreator.createNull();
-			case ResourceTypeCode.String: return resourceDataCreator.create(reader.ReadString());
-			case ResourceTypeCode.Boolean: return resourceDataCreator.create(reader.ReadBoolean());
-			case ResourceTypeCode.Char: return resourceDataCreator.create((char)reader.ReadUInt16());
-			case ResourceTypeCode.Byte: return resourceDataCreator.create(reader.ReadByte());
-			case ResourceTypeCode.SByte: return resourceDataCreator.create(reader.ReadSByte());
-			case ResourceTypeCode.Int16: return resourceDataCreator.create(reader.ReadInt16());
-			case ResourceTypeCode.UInt16: return resourceDataCreator.create(reader.ReadUInt16());
-			case ResourceTypeCode.Int32: return resourceDataCreator.create(reader.ReadInt32());
-			case ResourceTypeCode.UInt32: return resourceDataCreator.create(reader.ReadUInt32());
-			case ResourceTypeCode.Int64: return resourceDataCreator.create(reader.ReadInt64());
-			case ResourceTypeCode.UInt64: return resourceDataCreator.create(reader.ReadUInt64());
-			case ResourceTypeCode.Single: return resourceDataCreator.create(reader.ReadSingle());
-			case ResourceTypeCode.Double: return resourceDataCreator.create(reader.ReadDouble());
-			case ResourceTypeCode.Decimal: return resourceDataCreator.create(reader.ReadDecimal());
-			case ResourceTypeCode.DateTime: return resourceDataCreator.create(new DateTime(reader.ReadInt64()));
-			case ResourceTypeCode.TimeSpan: return resourceDataCreator.create(new TimeSpan(reader.ReadInt64()));
-			case ResourceTypeCode.ByteArray: return resourceDataCreator.create(reader.ReadBytes(reader.ReadInt32()));
+			case ResourceTypeCode.Null: return resourceDataCreator.CreateNull();
+			case ResourceTypeCode.String: return resourceDataCreator.Create(reader.ReadString());
+			case ResourceTypeCode.Boolean: return resourceDataCreator.Create(reader.ReadBoolean());
+			case ResourceTypeCode.Char: return resourceDataCreator.Create((char)reader.ReadUInt16());
+			case ResourceTypeCode.Byte: return resourceDataCreator.Create(reader.ReadByte());
+			case ResourceTypeCode.SByte: return resourceDataCreator.Create(reader.ReadSByte());
+			case ResourceTypeCode.Int16: return resourceDataCreator.Create(reader.ReadInt16());
+			case ResourceTypeCode.UInt16: return resourceDataCreator.Create(reader.ReadUInt16());
+			case ResourceTypeCode.Int32: return resourceDataCreator.Create(reader.ReadInt32());
+			case ResourceTypeCode.UInt32: return resourceDataCreator.Create(reader.ReadUInt32());
+			case ResourceTypeCode.Int64: return resourceDataCreator.Create(reader.ReadInt64());
+			case ResourceTypeCode.UInt64: return resourceDataCreator.Create(reader.ReadUInt64());
+			case ResourceTypeCode.Single: return resourceDataCreator.Create(reader.ReadSingle());
+			case ResourceTypeCode.Double: return resourceDataCreator.Create(reader.ReadDouble());
+			case ResourceTypeCode.Decimal: return resourceDataCreator.Create(reader.ReadDecimal());
+			case ResourceTypeCode.DateTime: return resourceDataCreator.Create(new DateTime(reader.ReadInt64()));
+			case ResourceTypeCode.TimeSpan: return resourceDataCreator.Create(new TimeSpan(reader.ReadInt64()));
+			case ResourceTypeCode.ByteArray: return resourceDataCreator.Create(reader.ReadBytes(reader.ReadInt32()));
 			default:
 				int userTypeIndex = (int)(code - (uint)ResourceTypeCode.UserTypes);
 				if (userTypeIndex < 0 || userTypeIndex >= userTypes.Count)
 					throw new ResourceReaderException(string.Format("Invalid resource data code: {0}", code));
-				return resourceDataCreator.createSerialized(reader.ReadBytes(size));
+				return resourceDataCreator.CreateSerialized(reader.ReadBytes(size));
 			}
 		}
 
-		static uint readUInt32(IBinaryReader reader) {
+		static uint ReadUInt32(IBinaryReader reader) {
 			try {
 				return reader.Read7BitEncodedUInt32();
 			}
@@ -158,7 +158,7 @@ namespace de4dot.code.resources {
 			}
 		}
 
-		bool checkReaders() {
+		bool CheckReaders() {
 			bool validReader = false;
 
 			int numReaders = reader.ReadInt32();
diff --git a/de4dot.code/resources/ResourceWriter.cs b/de4dot.code/resources/ResourceWriter.cs
index 71505ea4..c403571f 100644
--- a/de4dot.code/resources/ResourceWriter.cs
+++ b/de4dot.code/resources/ResourceWriter.cs
@@ -40,20 +40,20 @@ namespace de4dot.code.resources {
 			this.resources = resources;
 		}
 
-		public static void write(ModuleDefMD module, Stream stream, ResourceElementSet resources) {
-			new ResourceWriter(module, stream, resources).write();
+		public static void Write(ModuleDefMD module, Stream stream, ResourceElementSet resources) {
+			new ResourceWriter(module, stream, resources).Write();
 		}
 
-		void write() {
-			initializeUserTypes();
+		void Write() {
+			InitializeUserTypes();
 
 			writer.Write(0xBEEFCACE);
 			writer.Write(1);
-			writeReaderType();
+			WriteReaderType();
 			writer.Write(2);
 			writer.Write(resources.Count);
 			writer.Write(typeCreator.Count);
-			foreach (var userType in typeCreator.getSortedTypes())
+			foreach (var userType in typeCreator.GetSortedTypes())
 				writer.Write(userType.Name);
 			int extraBytes = 8 - ((int)writer.BaseStream.Position & 7);
 			if (extraBytes != 8) {
@@ -71,11 +71,11 @@ namespace de4dot.code.resources {
 			int index = 0;
 			foreach (var info in resources.ResourceElements) {
 				offsets[index] = (int)nameOffsetWriter.BaseStream.Position;
-				hashes[index] = (int)hash(info.Name);
+				hashes[index] = (int)Hash(info.Name);
 				index++;
 				nameOffsetWriter.Write(info.Name);
 				nameOffsetWriter.Write((int)dataWriter.BaseStream.Position);
-				writeData(dataWriter, info, formatter);
+				WriteData(dataWriter, info, formatter);
 			}
 
 			Array.Sort(hashes, offsets);
@@ -88,13 +88,13 @@ namespace de4dot.code.resources {
 			writer.Write(dataStream.ToArray());
 		}
 
-		void writeData(BinaryWriter writer, ResourceElement info, IFormatter formatter) {
-			var code = getResourceType(info.ResourceData);
-			writeUInt32(writer, (uint)code);
-			info.ResourceData.writeData(writer, formatter);
+		void WriteData(BinaryWriter writer, ResourceElement info, IFormatter formatter) {
+			var code = GetResourceType(info.ResourceData);
+			WriteUInt32(writer, (uint)code);
+			info.ResourceData.WriteData(writer, formatter);
 		}
 
-		static void writeUInt32(BinaryWriter writer, uint value) {
+		static void WriteUInt32(BinaryWriter writer, uint value) {
 			while (value >= 0x80) {
 				writer.Write((byte)(value | 0x80));
 				value >>= 7;
@@ -102,7 +102,7 @@ namespace de4dot.code.resources {
 			writer.Write((byte)value);
 		}
 
-		ResourceTypeCode getResourceType(IResourceData data) {
+		ResourceTypeCode GetResourceType(IResourceData data) {
 			if (data is BuiltInResourceData)
 				return data.Code;
 
@@ -110,34 +110,34 @@ namespace de4dot.code.resources {
 			return dataToNewType[userData].Code;
 		}
 
-		static uint hash(string key) {
+		static uint Hash(string key) {
 			uint val = 0x1505;
 			foreach (var c in key)
 				val = ((val << 5) + val) ^ (uint)c;
 			return val;
 		}
 
-		void initializeUserTypes() {
+		void InitializeUserTypes() {
 			foreach (var resource in resources.ResourceElements) {
 				var data = resource.ResourceData as UserResourceData;
 				if (data == null)
 					continue;
-				var newType = typeCreator.createUserResourceType(data.TypeName);
+				var newType = typeCreator.CreateUserResourceType(data.TypeName);
 				dataToNewType[data] = newType;
 			}
 		}
 
-		void writeReaderType() {
+		void WriteReaderType() {
 			var memStream = new MemoryStream();
 			var headerWriter = new BinaryWriter(memStream);
-			var mscorlibFullName = getMscorlibFullname();
+			var mscorlibFullName = GetMscorlibFullname();
 			headerWriter.Write("System.Resources.ResourceReader, " + mscorlibFullName);
 			headerWriter.Write("System.Resources.RuntimeResourceSet");
 			writer.Write((int)memStream.Position);
 			writer.Write(memStream.ToArray());
 		}
 
-		string getMscorlibFullname() {
+		string GetMscorlibFullname() {
 			var mscorlibRef = module.GetAssemblyRef("mscorlib");
 			if (mscorlibRef != null)
 				return mscorlibRef.FullName;
diff --git a/de4dot.code/resources/UserResourceData.cs b/de4dot.code/resources/UserResourceData.cs
index 5af6d964..4baadf52 100644
--- a/de4dot.code/resources/UserResourceData.cs
+++ b/de4dot.code/resources/UserResourceData.cs
@@ -37,7 +37,7 @@ namespace de4dot.code.resources {
 			this.type = type;
 		}
 
-		public abstract void writeData(BinaryWriter writer, IFormatter formatter);
+		public abstract void WriteData(BinaryWriter writer, IFormatter formatter);
 	}
 
 	class CharArrayResourceData : UserResourceData {
@@ -49,7 +49,7 @@ namespace de4dot.code.resources {
 			this.data = data;
 		}
 
-		public override void writeData(BinaryWriter writer, IFormatter formatter) {
+		public override void WriteData(BinaryWriter writer, IFormatter formatter) {
 			formatter.Serialize(writer.BaseStream, data);
 		}
 	}
@@ -63,7 +63,7 @@ namespace de4dot.code.resources {
 			icon = new Icon(new MemoryStream(data));
 		}
 
-		public override void writeData(BinaryWriter writer, IFormatter formatter) {
+		public override void WriteData(BinaryWriter writer, IFormatter formatter) {
 			formatter.Serialize(writer.BaseStream, icon);
 		}
 	}
@@ -77,7 +77,7 @@ namespace de4dot.code.resources {
 			bitmap = new Bitmap(Image.FromStream(new MemoryStream(data)));
 		}
 
-		public override void writeData(BinaryWriter writer, IFormatter formatter) {
+		public override void WriteData(BinaryWriter writer, IFormatter formatter) {
 			formatter.Serialize(writer.BaseStream, bitmap);
 		}
 	}
@@ -90,7 +90,7 @@ namespace de4dot.code.resources {
 			this.data = data;
 		}
 
-		public override void writeData(BinaryWriter writer, IFormatter formatter) {
+		public override void WriteData(BinaryWriter writer, IFormatter formatter) {
 			writer.Write(data);
 		}
 	}
diff --git a/de4dot.cui/CommandLineParser.cs b/de4dot.cui/CommandLineParser.cs
index 0b2c9009..695694e1 100644
--- a/de4dot.cui/CommandLineParser.cs
+++ b/de4dot.cui/CommandLineParser.cs
@@ -62,11 +62,11 @@ namespace de4dot.cui {
 				infos.Add(new Info(value, name, desc));
 			}
 
-			public IEnumerable<Info> getInfos() {
+			public IEnumerable<Info> GetInfos() {
 				return infos;
 			}
 
-			public bool getValue(string name, out object value) {
+			public bool GetValue(string name, out object value) {
 				foreach (var info in infos) {
 					if (name.Equals(info.name, StringComparison.OrdinalIgnoreCase)) {
 						value = info.value;
@@ -92,32 +92,32 @@ namespace de4dot.cui {
 			this.filesOptions.DeobfuscatorInfos = deobfuscatorInfos;
 			this.filesOptions.AssemblyClientFactory = new NewAppDomainAssemblyClientFactory();
 
-			addAllOptions();
+			AddAllOptions();
 		}
 
-		void addAllOptions() {
+		void AddAllOptions() {
 			miscOptions.Add(new OneArgOption("r", null, "Scan for .NET files in all subdirs", "dir", (val) => {
-				addSearchDir();
+				AddSearchDir();
 				searchDir = new FilesDeobfuscator.SearchDir();
-				if (!Utils.pathExists(val))
-					exitError(string.Format("Directory {0} does not exist", val));
+				if (!Utils.PathExists(val))
+					ExitError(string.Format("Directory {0} does not exist", val));
 				searchDir.InputDirectory = val;
 			}));
 			miscOptions.Add(new OneArgOption("ro", null, "Output base dir for recursively found files", "dir", (val) => {
 				if (searchDir == null)
-					exitError("Missing -r option");
+					ExitError("Missing -r option");
 				searchDir.OutputDirectory = val;
 			}));
 			miscOptions.Add(new NoArgOption("ru", null, "Skip recursively found files with unsupported obfuscator", () => {
 				if (searchDir == null)
-					exitError("Missing -r option");
+					ExitError("Missing -r option");
 				searchDir.SkipUnknownObfuscators = true;
 			}));
 			miscOptions.Add(new NoArgOption("d", null, "Detect obfuscators and exit", () => {
 				filesOptions.DetectObfuscators = true;
 			}));
 			miscOptions.Add(new OneArgOption(null, "asm-path", "Add an assembly search path", "path", (val) => {
-				TheAssemblyResolver.Instance.addSearchDirectory(val);
+				TheAssemblyResolver.Instance.AddSearchDirectory(val);
 			}));
 			miscOptions.Add(new NoArgOption(null, "dont-rename", "Don't rename classes, methods, etc.", () => {
 				filesOptions.RenameSymbols = false;
@@ -147,8 +147,8 @@ namespace de4dot.cui {
 			}));
 			miscOptions.Add(new OneArgOption(null, "default-strtyp", "Default string decrypter type", "type", (val) => {
 				object decrypterType;
-				if (!stringDecrypterTypes.getValue(val, out decrypterType))
-					exitError(string.Format("Invalid string decrypter type '{0}'", val));
+				if (!stringDecrypterTypes.GetValue(val, out decrypterType))
+					ExitError(string.Format("Invalid string decrypter type '{0}'", val));
 				defaultStringDecrypterType = (DecrypterType)decrypterType;
 			}));
 			miscOptions.Add(new OneArgOption(null, "default-strtok", "Default string decrypter method token or [type::][name][(args,...)]", "method", (val) => {
@@ -224,14 +224,14 @@ namespace de4dot.cui {
 				Logger.Instance.CanIgnoreMessages = false;
 			}));
 			miscOptions.Add(new NoArgOption("h", "help", "Show this help message", () => {
-				usage();
-				exit(0);
+				Usage();
+				Exit(0);
 			}));
 
 			defaultOption = new OneArgOption("f", null, "Name of .NET file", "file", (val) => {
-				addFile();
-				if (!Utils.fileExists(val))
-					exitError(string.Format("File \"{0}\" does not exist.", val));
+				AddFile();
+				if (!Utils.FileExists(val))
+					ExitError(string.Format("File \"{0}\" does not exist.", val));
 				newFileOptions = new ObfuscatedFile.Options {
 					Filename = val,
 					ControlFlowDeobfuscation = filesOptions.ControlFlowDeobfuscation,
@@ -246,46 +246,46 @@ namespace de4dot.cui {
 			fileOptions.Add(defaultOption);
 			fileOptions.Add(new OneArgOption("o", null, "Name of output file", "file", (val) => {
 				if (newFileOptions == null)
-					exitError("Missing input file");
-				if (string.Equals(Utils.getFullPath(newFileOptions.Filename), Utils.getFullPath(val), StringComparison.OrdinalIgnoreCase))
-					exitError(string.Format("Output file can't be same as input file ({0})", val));
+					ExitError("Missing input file");
+				if (string.Equals(Utils.GetFullPath(newFileOptions.Filename), Utils.GetFullPath(val), StringComparison.OrdinalIgnoreCase))
+					ExitError(string.Format("Output file can't be same as input file ({0})", val));
 				newFileOptions.NewFilename = val;
 			}));
 			fileOptions.Add(new OneArgOption("p", null, "Obfuscator type (see below)", "type", (val) => {
 				if (newFileOptions == null)
-					exitError("Missing input file");
-				if (!isValidObfuscatorType(val))
-					exitError(string.Format("Invalid obfuscator type '{0}'", val));
+					ExitError("Missing input file");
+				if (!IsValidObfuscatorType(val))
+					ExitError(string.Format("Invalid obfuscator type '{0}'", val));
 				newFileOptions.ForcedObfuscatorType = val;
 			}));
 			fileOptions.Add(new OneArgOption(null, "strtyp", "String decrypter type", "type", (val) => {
 				if (newFileOptions == null)
-					exitError("Missing input file");
+					ExitError("Missing input file");
 				object decrypterType;
-				if (!stringDecrypterTypes.getValue(val, out decrypterType))
-					exitError(string.Format("Invalid string decrypter type '{0}'", val));
+				if (!stringDecrypterTypes.GetValue(val, out decrypterType))
+					ExitError(string.Format("Invalid string decrypter type '{0}'", val));
 				newFileOptions.StringDecrypterType = (DecrypterType)decrypterType;
 			}));
 			fileOptions.Add(new OneArgOption(null, "strtok", "String decrypter method token or [type::][name][(args,...)]", "method", (val) => {
 				if (newFileOptions == null)
-					exitError("Missing input file");
+					ExitError("Missing input file");
 				newFileOptions.StringDecrypterMethods.Add(val);
 			}));
 
-			addOptions(miscOptions);
-			addOptions(fileOptions);
+			AddOptions(miscOptions);
+			AddOptions(fileOptions);
 			foreach (var info in deobfuscatorInfos)
-				addOptions(info.getOptions());
+				AddOptions(info.GetOptions());
 		}
 
-		void addOptions(IEnumerable<Option> options) {
+		void AddOptions(IEnumerable<Option> options) {
 			foreach (var option in options) {
-				addOption(option, option.ShortName);
-				addOption(option, option.LongName);
+				AddOption(option, option.ShortName);
+				AddOption(option, option.LongName);
 			}
 		}
 
-		void addOption(Option option, string name) {
+		void AddOption(Option option, string name) {
 			if (name == null)
 				return;
 			if (optionsDict.ContainsKey(name))
@@ -293,10 +293,10 @@ namespace de4dot.cui {
 			optionsDict[name] = option;
 		}
 
-		public void parse(string[] args) {
+		public void Parse(string[] args) {
 			if (args.Length == 0) {
-				usage();
-				exit(1);
+				Usage();
+				Exit(1);
 			}
 
 			for (int i = 0; i < args.Length; i++) {
@@ -307,7 +307,7 @@ namespace de4dot.cui {
 				if (optionsDict.TryGetValue(arg, out option)) {
 					if (option.NeedArgument) {
 						if (++i >= args.Length)
-							exitError("Missing options value");
+							ExitError("Missing options value");
 						val = args[i];
 					}
 				}
@@ -317,31 +317,31 @@ namespace de4dot.cui {
 				}
 
 				string errorString;
-				if (!option.set(val, out errorString))
-					exitError(errorString);
+				if (!option.Set(val, out errorString))
+					ExitError(errorString);
 			}
-			addFile();
-			addSearchDir();
+			AddFile();
+			AddSearchDir();
 			filesOptions.Files = files;
 			filesOptions.DefaultStringDecrypterMethods.AddRange(defaultStringDecrypterMethods);
 			filesOptions.DefaultStringDecrypterType = defaultStringDecrypterType;
 		}
 
-		void addFile() {
+		void AddFile() {
 			if (newFileOptions == null)
 				return;
 			files.Add(new ObfuscatedFile(newFileOptions, filesOptions.ModuleContext, filesOptions.AssemblyClientFactory));
 			newFileOptions = null;
 		}
 
-		void addSearchDir() {
+		void AddSearchDir() {
 			if (searchDir == null)
 				return;
 			filesOptions.SearchDirs.Add(searchDir);
 			searchDir = null;
 		}
 
-		bool isValidObfuscatorType(string type) {
+		bool IsValidObfuscatorType(string type) {
 			foreach (var info in deobfuscatorInfos) {
 				if (string.Equals(info.Type, type, StringComparison.OrdinalIgnoreCase))
 					return true;
@@ -349,38 +349,38 @@ namespace de4dot.cui {
 			return false;
 		}
 
-		void exitError(string msg) {
-			usage();
+		void ExitError(string msg) {
+			Usage();
 			Logger.Instance.LogErrorDontIgnore("\n\nERROR: {0}\n", msg);
-			exit(2);
+			Exit(2);
 		}
 
-		void exit(int exitCode) {
+		void Exit(int exitCode) {
 			throw new ExitException(exitCode);
 		}
 
-		void usage() {
-			string progName = getProgramBaseName();
+		void Usage() {
+			string progName = GetProgramBaseName();
 			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);
+				PrintOption(option);
 			Logger.n("");
 			Logger.n("File options:");
 			foreach (var option in fileOptions)
-				printOption(option);
+				PrintOption(option);
 			Logger.n("");
 			Logger.n("Deobfuscator options:");
 			foreach (var info in deobfuscatorInfos) {
 				Logger.n("Type {0} ({1})", info.Type, info.Name);
-				foreach (var option in info.getOptions())
-					printOption(option);
+				foreach (var option in info.GetOptions())
+					PrintOption(option);
 				Logger.n("");
 			}
-			printInfos("String decrypter types", stringDecrypterTypes);
+			PrintInfos("String decrypter types", stringDecrypterTypes);
 			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);
@@ -392,28 +392,28 @@ namespace de4dot.cui {
 			Logger.n("{0} file1 --strtyp delegate --strtok 06000123", progName);
 		}
 
-		string getProgramBaseName() {
-			return Utils.getBaseName(Environment.GetCommandLineArgs()[0]);
+		string GetProgramBaseName() {
+			return Utils.GetBaseName(Environment.GetCommandLineArgs()[0]);
 		}
 
-		void printInfos(string desc, Infos infos) {
+		void PrintInfos(string desc, Infos infos) {
 			Logger.n("{0}", desc);
-			foreach (var info in infos.getInfos())
-				printOptionAndExplanation(info.name, info.desc);
+			foreach (var info in infos.GetInfos())
+				PrintOptionAndExplanation(info.name, info.desc);
 		}
 
-		void printOption(Option option) {
+		void PrintOption(Option option) {
 			string defaultAndDesc;
 			if (option.NeedArgument && option.Default != null)
 				defaultAndDesc = string.Format("{0} ({1})", option.Description, option.Default);
 			else
 				defaultAndDesc = option.Description;
-			printOptionAndExplanation(getOptionAndArgName(option, option.ShortName ?? option.LongName), defaultAndDesc);
+			PrintOptionAndExplanation(GetOptionAndArgName(option, option.ShortName ?? option.LongName), defaultAndDesc);
 			if (option.ShortName != null && option.LongName != null)
-				printOptionAndExplanation(option.LongName, string.Format("Same as {0}", option.ShortName));
+				PrintOptionAndExplanation(option.LongName, string.Format("Same as {0}", option.ShortName));
 		}
 
-		void printOptionAndExplanation(string option, string explanation) {
+		void PrintOptionAndExplanation(string option, string explanation) {
 			const int maxCols = 16;
 			const string prefix = "  ";
 			string left = string.Format(string.Format("{{0,-{0}}}", maxCols), option);
@@ -425,7 +425,7 @@ namespace de4dot.cui {
 				Logger.n("{0}{1} {2}", prefix, left, explanation);
 		}
 
-		string getOptionAndArgName(Option option, string optionName) {
+		string GetOptionAndArgName(Option option, string optionName) {
 			if (option.NeedArgument)
 				return optionName + " " + option.ArgumentValueName.ToUpperInvariant();
 			else
diff --git a/de4dot.cui/FilesDeobfuscator.cs b/de4dot.cui/FilesDeobfuscator.cs
index ba6f9db2..f7106c4d 100644
--- a/de4dot.cui/FilesDeobfuscator.cs
+++ b/de4dot.cui/FilesDeobfuscator.cs
@@ -82,44 +82,44 @@ namespace de4dot.cui {
 			this.options = options;
 		}
 
-		public void doIt() {
+		public void DoIt() {
 			if (options.DetectObfuscators)
-				detectObfuscators();
+				DetectObfuscators();
 			else if (options.OneFileAtATime)
-				deobfuscateOneAtATime();
+				DeobfuscateOneAtATime();
 			else
-				deobfuscateAll();
+				DeobfuscateAll();
 		}
 
-		static void removeModule(ModuleDef module) {
+		static void RemoveModule(ModuleDef module) {
 			TheAssemblyResolver.Instance.Remove(module);
 		}
 
-		void detectObfuscators() {
-			foreach (var file in loadAllFiles(true)) {
-				removeModule(file.ModuleDefMD);
+		void DetectObfuscators() {
+			foreach (var file in LoadAllFiles(true)) {
+				RemoveModule(file.ModuleDefMD);
 				file.Dispose();
-				deobfuscatorContext.clear();
+				deobfuscatorContext.Clear();
 			}
 		}
 
-		void deobfuscateOneAtATime() {
-			foreach (var file in loadAllFiles()) {
+		void DeobfuscateOneAtATime() {
+			foreach (var file in LoadAllFiles()) {
 				int oldIndentLevel = Logger.Instance.IndentLevel;
 				try {
-					file.deobfuscateBegin();
-					file.deobfuscate();
-					file.deobfuscateEnd();
-					rename(new List<IObfuscatedFile> { file });
-					file.save();
+					file.DeobfuscateBegin();
+					file.Deobfuscate();
+					file.DeobfuscateEnd();
+					Rename(new List<IObfuscatedFile> { file });
+					file.Save();
 
-					removeModule(file.ModuleDefMD);
-					TheAssemblyResolver.Instance.clearAll();
-					deobfuscatorContext.clear();
+					RemoveModule(file.ModuleDefMD);
+					TheAssemblyResolver.Instance.ClearAll();
+					deobfuscatorContext.Clear();
 				}
 				catch (Exception ex) {
 					Logger.Instance.Log(false, null, LoggerEvent.Warning, "Could not deobfuscate {0}. Use -v to see stack trace", file.Filename);
-					Program.printStackTrace(ex, LoggerEvent.Verbose);
+					Program.PrintStackTrace(ex, LoggerEvent.Verbose);
 				}
 				finally {
 					file.Dispose();
@@ -128,12 +128,12 @@ namespace de4dot.cui {
 			}
 		}
 
-		void deobfuscateAll() {
-			var allFiles = new List<IObfuscatedFile>(loadAllFiles());
+		void DeobfuscateAll() {
+			var allFiles = new List<IObfuscatedFile>(LoadAllFiles());
 			try {
-				deobfuscateAllFiles(allFiles);
-				rename(allFiles);
-				saveAllFiles(allFiles);
+				DeobfuscateAllFiles(allFiles);
+				Rename(allFiles);
+				SaveAllFiles(allFiles);
 			}
 			finally {
 				foreach (var file in allFiles) {
@@ -143,16 +143,16 @@ namespace de4dot.cui {
 			}
 		}
 
-		IEnumerable<IObfuscatedFile> loadAllFiles() {
-			return loadAllFiles(false);
+		IEnumerable<IObfuscatedFile> LoadAllFiles() {
+			return LoadAllFiles(false);
 		}
 
-		IEnumerable<IObfuscatedFile> loadAllFiles(bool onlyScan) {
+		IEnumerable<IObfuscatedFile> LoadAllFiles(bool onlyScan) {
 			var loader = new DotNetFileLoader(new DotNetFileLoader.Options {
 				ModuleContext = options.ModuleContext,
 				PossibleFiles  = options.Files,
 				SearchDirs = options.SearchDirs,
-				CreateDeobfuscators = () => createDeobfuscators(),
+				CreateDeobfuscators = () => CreateDeobfuscators(),
 				DefaultStringDecrypterType = options.DefaultStringDecrypterType,
 				DefaultStringDecrypterMethods = options.DefaultStringDecrypterMethods,
 				AssemblyClientFactory = options.AssemblyClientFactory,
@@ -164,7 +164,7 @@ namespace de4dot.cui {
 				CreateDestinationDir = !onlyScan,
 			});
 
-			foreach (var file in loader.load())
+			foreach (var file in loader.Load())
 				yield return file;
 		}
 
@@ -193,20 +193,20 @@ namespace de4dot.cui {
 				this.options = options;
 			}
 
-			public IEnumerable<IObfuscatedFile> load() {
+			public IEnumerable<IObfuscatedFile> Load() {
 				foreach (var file in options.PossibleFiles) {
-					if (add(file, false, true))
+					if (Add(file, false, true))
 						yield return file;
 				}
 
 				foreach (var searchDir in options.SearchDirs) {
-					foreach (var file in loadFiles(searchDir))
+					foreach (var file in LoadFiles(searchDir))
 						yield return file;
 				}
 			}
 
-			bool add(IObfuscatedFile file, bool skipUnknownObfuscator, bool isFromPossibleFiles) {
-				var key = Utils.getFullPath(file.Filename);
+			bool Add(IObfuscatedFile file, bool skipUnknownObfuscator, bool isFromPossibleFiles) {
+				var key = Utils.GetFullPath(file.Filename);
 				if (allFiles.ContainsKey(key)) {
 					Logger.Instance.Log(false, null, LoggerEvent.Warning, "Ingoring duplicate file: {0}", file.Filename);
 					return false;
@@ -216,7 +216,7 @@ namespace de4dot.cui {
 				int oldIndentLevel = Logger.Instance.IndentLevel;
 				try {
 					file.DeobfuscatorContext = options.DeobfuscatorContext;
-					file.load(options.CreateDeobfuscators());
+					file.Load(options.CreateDeobfuscators());
 				}
 				catch (NotSupportedException) {
 					return false;	// Eg. unsupported architecture
@@ -240,18 +240,18 @@ namespace de4dot.cui {
 				var deob = file.Deobfuscator;
 				if (skipUnknownObfuscator && deob.Type == "un") {
 					Logger.v("Skipping unknown obfuscator: {0}", file.Filename);
-					removeModule(file.ModuleDefMD);
+					RemoveModule(file.ModuleDefMD);
 					return false;
 				}
 				else {
 					Logger.n("Detected {0} ({1})", deob.Name, file.Filename);
 					if (options.CreateDestinationDir)
-						createDirectories(Path.GetDirectoryName(file.NewFilename));
+						CreateDirectories(Path.GetDirectoryName(file.NewFilename));
 					return true;
 				}
 			}
 
-			IEnumerable<IObfuscatedFile> loadFiles(SearchDir searchDir) {
+			IEnumerable<IObfuscatedFile> LoadFiles(SearchDir searchDir) {
 				DirectoryInfo di = null;
 				bool ok = false;
 				try {
@@ -264,18 +264,18 @@ namespace de4dot.cui {
 				catch (ArgumentException) {
 				}
 				if (ok) {
-					foreach (var filename in doDirectoryInfo(searchDir, di)) {
-						var obfuscatedFile = createObfuscatedFile(searchDir, filename);
+					foreach (var filename in DoDirectoryInfo(searchDir, di)) {
+						var obfuscatedFile = CreateObfuscatedFile(searchDir, filename);
 						if (obfuscatedFile != null)
 							yield return obfuscatedFile;
 					}					
 				}
 			}
 
-			IEnumerable<string> recursiveAdd(SearchDir searchDir, IEnumerable<FileSystemInfo> fileSystemInfos) {
+			IEnumerable<string> RecursiveAdd(SearchDir searchDir, IEnumerable<FileSystemInfo> fileSystemInfos) {
 				foreach (var fsi in fileSystemInfos) {
 					if ((int)(fsi.Attributes & System.IO.FileAttributes.Directory) != 0) {
-						foreach (var filename in doDirectoryInfo(searchDir, (DirectoryInfo)fsi))
+						foreach (var filename in DoDirectoryInfo(searchDir, (DirectoryInfo)fsi))
 							yield return filename;
 					}
 					else {
@@ -286,7 +286,7 @@ namespace de4dot.cui {
 				}
 			}
 
-			IEnumerable<string> doDirectoryInfo(SearchDir searchDir, DirectoryInfo di) {
+			IEnumerable<string> DoDirectoryInfo(SearchDir searchDir, DirectoryInfo di) {
 				if (!di.Exists)
 					return new List<string>();
 
@@ -304,12 +304,12 @@ namespace de4dot.cui {
 				catch (IOException) {
 					return new List<string>();
 				}
-				return recursiveAdd(searchDir, fsinfos);
+				return RecursiveAdd(searchDir, fsinfos);
 			}
 
-			IObfuscatedFile createObfuscatedFile(SearchDir searchDir, string filename) {
+			IObfuscatedFile CreateObfuscatedFile(SearchDir searchDir, string filename) {
 				var fileOptions = new ObfuscatedFile.Options {
-					Filename = Utils.getFullPath(filename),
+					Filename = Utils.GetFullPath(filename),
 					ControlFlowDeobfuscation = options.ControlFlowDeobfuscation,
 					KeepObfuscatorTypes = options.KeepObfuscatorTypes,
 					MetaDataFlags = options.MetaDataFlags,
@@ -320,8 +320,8 @@ namespace de4dot.cui {
 				fileOptions.StringDecrypterMethods.AddRange(options.DefaultStringDecrypterMethods);
 
 				if (!string.IsNullOrEmpty(searchDir.OutputDirectory)) {
-					var inDir = Utils.getFullPath(searchDir.InputDirectory);
-					var outDir = Utils.getFullPath(searchDir.OutputDirectory);
+					var inDir = Utils.GetFullPath(searchDir.InputDirectory);
+					var outDir = Utils.GetFullPath(searchDir.OutputDirectory);
 
 					if (!Utils.StartsWith(fileOptions.Filename, inDir, StringComparison.OrdinalIgnoreCase))
 						throw new UserException(string.Format("Filename {0} does not start with inDir {1}", fileOptions.Filename, inDir));
@@ -329,20 +329,20 @@ namespace de4dot.cui {
 					var subDirs = fileOptions.Filename.Substring(inDir.Length);
 					if (subDirs.Length > 0 && subDirs[0] == Path.DirectorySeparatorChar)
 						subDirs = subDirs.Substring(1);
-					fileOptions.NewFilename = Utils.getFullPath(Path.Combine(outDir, subDirs));
+					fileOptions.NewFilename = Utils.GetFullPath(Path.Combine(outDir, subDirs));
 
 					if (fileOptions.Filename.Equals(fileOptions.NewFilename, StringComparison.OrdinalIgnoreCase))
 						throw new UserException(string.Format("Input and output filename is the same: {0}", fileOptions.Filename));
 				}
 
 				var obfuscatedFile = new ObfuscatedFile(fileOptions, options.ModuleContext, options.AssemblyClientFactory);
-				if (add(obfuscatedFile, searchDir.SkipUnknownObfuscators, false))
+				if (Add(obfuscatedFile, searchDir.SkipUnknownObfuscators, false))
 					return obfuscatedFile;
 				obfuscatedFile.Dispose();
 				return null;
 			}
 
-			void createDirectories(string path) {
+			void CreateDirectories(string path) {
 				if (string.IsNullOrEmpty(path))
 					return;
 				try {
@@ -357,38 +357,38 @@ namespace de4dot.cui {
 			}
 		}
 
-		void deobfuscateAllFiles(IEnumerable<IObfuscatedFile> allFiles) {
+		void DeobfuscateAllFiles(IEnumerable<IObfuscatedFile> allFiles) {
 			try {
 				foreach (var file in allFiles)
-					file.deobfuscateBegin();
+					file.DeobfuscateBegin();
 				foreach (var file in allFiles) {
-					file.deobfuscate();
-					file.deobfuscateEnd();
+					file.Deobfuscate();
+					file.DeobfuscateEnd();
 				}
 			}
 			finally {
 				foreach (var file in allFiles)
-					file.deobfuscateCleanUp();
+					file.DeobfuscateCleanUp();
 			}
 		}
 
-		void saveAllFiles(IEnumerable<IObfuscatedFile> allFiles) {
+		void SaveAllFiles(IEnumerable<IObfuscatedFile> allFiles) {
 			foreach (var file in allFiles)
-				file.save();
+				file.Save();
 		}
 
-		IList<IDeobfuscator> createDeobfuscators() {
+		IList<IDeobfuscator> CreateDeobfuscators() {
 			var list = new List<IDeobfuscator>(options.DeobfuscatorInfos.Count);
 			foreach (var info in options.DeobfuscatorInfos)
-				list.Add(info.createDeobfuscator());
+				list.Add(info.CreateDeobfuscator());
 			return list;
 		}
 
-		void rename(IEnumerable<IObfuscatedFile> theFiles) {
+		void Rename(IEnumerable<IObfuscatedFile> theFiles) {
 			if (!options.RenameSymbols)
 				return;
 			var renamer = new Renamer(deobfuscatorContext, theFiles, options.RenamerFlags);
-			renamer.rename();
+			renamer.Rename();
 		}
 	}
 }
diff --git a/de4dot.cui/Program.cs b/de4dot.cui/Program.cs
index 1be55d0e..d203e2e1 100644
--- a/de4dot.cui/Program.cs
+++ b/de4dot.cui/Program.cs
@@ -33,9 +33,9 @@ namespace de4dot.cui {
 	}
 
 	class Program {
-		static IList<IDeobfuscatorInfo> deobfuscatorInfos = createDeobfuscatorInfos();
+		static IList<IDeobfuscatorInfo> deobfuscatorInfos = CreateDeobfuscatorInfos();
 
-		static IList<IDeobfuscatorInfo> createDeobfuscatorInfos() {
+		static IList<IDeobfuscatorInfo> CreateDeobfuscatorInfos() {
 			return new List<IDeobfuscatorInfo> {
 				new de4dot.code.deobfuscators.Unknown.DeobfuscatorInfo(),
 				new de4dot.code.deobfuscators.Agile_NET.DeobfuscatorInfo(),
@@ -61,7 +61,7 @@ namespace de4dot.cui {
 			};
 		}
 
-		public static int main(string[] args) {
+		public static int Main2(string[] args) {
 			int exitCode = 0;
 
 			const string showAllMessagesEnvName = "SHOWALLMESSAGES";
@@ -69,7 +69,7 @@ namespace de4dot.cui {
 				if (Console.OutputEncoding.IsSingleByte)
 					Console.OutputEncoding = new UTF8Encoding(false);
 
-				Logger.Instance.CanIgnoreMessages = !hasEnv(showAllMessagesEnvName);
+				Logger.Instance.CanIgnoreMessages = !HasEnv(showAllMessagesEnvName);
 
 				Logger.n("");
 				Logger.n("de4dot v{0} Copyright (C) 2011-2013 de4dot@gmail.com", System.Reflection.Assembly.GetExecutingAssembly().GetName().Version);
@@ -77,8 +77,8 @@ namespace de4dot.cui {
 				Logger.n("");
 
 				var options = new FilesDeobfuscator.Options();
-				parseCommandLine(args, options);
-				new FilesDeobfuscator(options).doIt();
+				ParseCommandLine(args, options);
+				new FilesDeobfuscator(options).DoIt();
 			}
 			catch (ExitException ex) {
 				exitCode = ex.code;
@@ -88,8 +88,8 @@ namespace de4dot.cui {
 				exitCode = 1;
 			}
 			catch (Exception ex) {
-				if (printFullStackTrace()) {
-					printStackTrace(ex);
+				if (PrintFullStackTrace()) {
+					PrintStackTrace(ex);
 					Logger.Instance.LogErrorDontIgnore("\nTry the latest version before reporting this problem!");
 				}
 				else {
@@ -109,7 +109,7 @@ namespace de4dot.cui {
 				Logger.n("Use -v/-vv option or set environment variable {0}=1 to see all messages", showAllMessagesEnvName);
 			}
 
-			if (isN00bUser()) {
+			if (IsN00bUser()) {
 				Console.Error.WriteLine("\n\nPress any key to exit...\n");
 				try {
 					Console.ReadKey(true);
@@ -121,16 +121,16 @@ namespace de4dot.cui {
 			return exitCode;
 		}
 
-		static bool printFullStackTrace() {
+		static bool PrintFullStackTrace() {
 			if (!Logger.Instance.IgnoresEvent(LoggerEvent.Verbose))
 				return true;
-			if (hasEnv("STACKTRACE"))
+			if (HasEnv("STACKTRACE"))
 				return true;
 
 			return false;
 		}
 
-		static bool hasEnv(string name) {
+		static bool HasEnv(string name) {
 			foreach (var tmp in Environment.GetEnvironmentVariables().Keys) {
 				var env = tmp as string;
 				if (env == null)
@@ -141,17 +141,17 @@ namespace de4dot.cui {
 			return false;
 		}
 
-		static bool isN00bUser() {
-			if (hasEnv("VisualStudioDir"))
+		static bool IsN00bUser() {
+			if (HasEnv("VisualStudioDir"))
 				return false;
-			return hasEnv("windir") && !hasEnv("PROMPT");
+			return HasEnv("windir") && !HasEnv("PROMPT");
 		}
 
-		public static void printStackTrace(Exception ex) {
-			printStackTrace(ex, LoggerEvent.Error);
+		public static void PrintStackTrace(Exception ex) {
+			PrintStackTrace(ex, LoggerEvent.Error);
 		}
 
-		public static void printStackTrace(Exception ex, LoggerEvent loggerEvent) {
+		public static void PrintStackTrace(Exception ex, LoggerEvent loggerEvent) {
 			var line = new string('-', 78);
 			Logger.Instance.Log(false, null, loggerEvent, "\n\n");
 			Logger.Instance.Log(false, null, loggerEvent, line);
@@ -165,14 +165,14 @@ namespace de4dot.cui {
 			Logger.Instance.Log(false, null, loggerEvent, line);
 		}
 
-		static void parseCommandLine(string[] args, FilesDeobfuscator.Options options) {
-			new CommandLineParser(deobfuscatorInfos, options).parse(args);
+		static void ParseCommandLine(string[] args, FilesDeobfuscator.Options options) {
+			new CommandLineParser(deobfuscatorInfos, options).Parse(args);
 
 			Logger.vv("Args:");
-			Logger.Instance.indent();
+			Logger.Instance.Indent();
 			foreach (var arg in args)
-				Logger.vv("{0}", Utils.toCsharpString(arg));
-			Logger.Instance.deIndent();
+				Logger.vv("{0}", Utils.ToCsharpString(arg));
+			Logger.Instance.DeIndent();
 		}
 	}
 }
diff --git a/de4dot.mdecrypt/DynamicMethodsDecrypter.cs b/de4dot.mdecrypt/DynamicMethodsDecrypter.cs
index 61e58126..3aa2c949 100644
--- a/de4dot.mdecrypt/DynamicMethodsDecrypter.cs
+++ b/de4dot.mdecrypt/DynamicMethodsDecrypter.cs
@@ -36,7 +36,7 @@ namespace de4dot.mdecrypt {
 			public IntPtr ptr;
 			public IntPtr ptrInDll;
 
-			public void prepare(Delegate del) {
+			public void Prepare(Delegate del) {
 				RuntimeHelpers.PrepareDelegate(del);
 				ptr = Marshal.GetFunctionPointerForDelegate(del);
 			}
@@ -149,34 +149,34 @@ namespace de4dot.mdecrypt {
 
 				moduleToDecrypt = value;
 				hInstModule = Marshal.GetHINSTANCE(moduleToDecrypt);
-				moduleToDecryptScope = getScope(moduleToDecrypt);
+				moduleToDecryptScope = GetScope(moduleToDecrypt);
 
 				dnlibModule = ModuleDefMD.Load(hInstModule);
 				methodDefTable = dnlibModule.TablesStream.MethodTable;
 				methodDefTablePtr = new IntPtr((byte*)hInstModule + (uint)dnlibModule.MetaData.PEImage.ToRVA(methodDefTable.StartOffset));
 
-				initializeDNLibMethods();
+				InitializeDNLibMethods();
 			}
 		}
 
-		static IntPtr getScope(Module module) {
-			var obj = getFieldValue(module.ModuleHandle, "m_ptr");
+		static IntPtr GetScope(Module module) {
+			var obj = GetFieldValue(module.ModuleHandle, "m_ptr");
 			if (obj is IntPtr)
 				return (IntPtr)obj;
 			if (obj.GetType().ToString() == "System.Reflection.RuntimeModule")
-				return (IntPtr)getFieldValue(obj, "m_pData");
+				return (IntPtr)GetFieldValue(obj, "m_pData");
 
 			throw new ApplicationException(string.Format("m_ptr is an invalid type: {0}", obj.GetType()));
 		}
 
-		static object getFieldValue(object obj, string fieldName) {
+		static object GetFieldValue(object obj, string fieldName) {
 			var field = obj.GetType().GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
 			if (field == null)
 				throw new ApplicationException(string.Format("Could not get field {0}::{1}", obj.GetType(), fieldName));
 			return field.GetValue(obj);
 		}
 
-		unsafe void initializeDNLibMethods() {
+		unsafe void InitializeDNLibMethods() {
 			moduleCctor = dnlibModule.GlobalType.FindStaticConstructor();
 			if (moduleCctor == null)
 				moduleCctorCodeRva = 0;
@@ -189,9 +189,9 @@ namespace de4dot.mdecrypt {
 			}
 		}
 
-		public unsafe void installCompileMethod() {
-			var hJitterDll = getJitterDllHandle();
-			jitterTextFreeMem = getEndOfText(hJitterDll);
+		public unsafe void InstallCompileMethod() {
+			var hJitterDll = GetJitterDllHandle();
+			jitterTextFreeMem = GetEndOfText(hJitterDll);
 
 			var getJitPtr = GetProcAddress(hJitterDll, "getJit");
 			var getJit = (GetJit)Marshal.GetDelegateForFunctionPointer(getJitPtr, typeof(GetJit));
@@ -199,15 +199,15 @@ namespace de4dot.mdecrypt {
 			jitterVtbl = *(IntPtr*)jitterInstance;
 			origCompileMethod = *(IntPtr*)jitterVtbl;
 
-			prepareMethods();
-			initializeDelegateFunctionPointers();
-			createOurCode();
+			PrepareMethods();
+			InitializeDelegateFunctionPointers();
+			CreateOurCode();
 			callMethodDelegate = (CallMethod)Marshal.GetDelegateForFunctionPointer(callMethod, typeof(CallMethod));
 
-			writeCompileMethod(ourCompileMethodInfo.ptrInDll);
+			WriteCompileMethod(ourCompileMethodInfo.ptrInDll);
 		}
 
-		unsafe void writeCompileMethod(IntPtr newCompileMethod) {
+		unsafe void WriteCompileMethod(IntPtr newCompileMethod) {
 			uint oldProtect;
 			if (!VirtualProtect(jitterVtbl, IntPtr.Size, PAGE_EXECUTE_READWRITE, out oldProtect))
 				throw new ApplicationException("Could not enable write access to jitter vtbl");
@@ -215,22 +215,22 @@ namespace de4dot.mdecrypt {
 			VirtualProtect(jitterVtbl, IntPtr.Size, oldProtect, out oldProtect);
 		}
 
-		void initializeDelegateFunctionPointers() {
-			ourCompileMethodInfo.prepare(ourCompileMethodInfo.del = compileMethod);
-			returnMethodTokenInfo.prepare(returnMethodTokenInfo.del = returnMethodToken);
-			returnNameOfMethodInfo.prepare(returnNameOfMethodInfo.del = returnNameOfMethod);
+		void InitializeDelegateFunctionPointers() {
+			ourCompileMethodInfo.Prepare(ourCompileMethodInfo.del = TheCompileMethod);
+			returnMethodTokenInfo.Prepare(returnMethodTokenInfo.del = ReturnMethodToken2);
+			returnNameOfMethodInfo.Prepare(returnNameOfMethodInfo.del = ReturnNameOfMethod2);
 		}
 
-		public void loadObfuscator() {
+		public void LoadObfuscator() {
 			RuntimeHelpers.RunModuleConstructor(moduleToDecrypt.ModuleHandle);
 		}
 
-		public unsafe bool canDecryptMethods() {
+		public unsafe bool CanDecryptMethods() {
 			return *(IntPtr*)jitterVtbl != ourCompileMethodInfo.ptrInDll &&
 					*(IntPtr*)jitterVtbl != origCompileMethod;
 		}
 
-		unsafe static IntPtr getEndOfText(IntPtr hDll) {
+		unsafe static IntPtr GetEndOfText(IntPtr hDll) {
 			byte* p = (byte*)hDll;
 			p += *(uint*)(p + 0x3C);	// add DOSHDR.e_lfanew
 			p += 4;
@@ -245,7 +245,7 @@ namespace de4dot.mdecrypt {
 			var pSection = (IMAGE_SECTION_HEADER*)p;
 			for (int i = 0; i < numSections; i++, pSection++) {
 				Marshal.Copy(new IntPtr(pSection), name, 0, name.Length);
-				if (!compareName(textName, name, name.Length))
+				if (!CompareName(textName, name, name.Length))
 					continue;
 
 				uint size = pSection->VirtualSize;
@@ -257,7 +257,7 @@ namespace de4dot.mdecrypt {
 			throw new ApplicationException("Could not find .text section");
 		}
 
-		static bool compareName(byte[] b1, byte[] b2, int len) {
+		static bool CompareName(byte[] b1, byte[] b2, int len) {
 			for (int i = 0; i < len; i++) {
 				if (b1[i] != b2[i])
 					return false;
@@ -265,13 +265,13 @@ namespace de4dot.mdecrypt {
 			return true;
 		}
 
-		void prepareMethods() {
+		void PrepareMethods() {
 			Marshal.PrelinkAll(GetType());
 			foreach (var methodInfo in GetType().GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance))
 				RuntimeHelpers.PrepareMethod(methodInfo.MethodHandle);
 		}
 
-		unsafe void createOurCode() {
+		unsafe void CreateOurCode() {
 			var code = new NativeCodeGenerator();
 
 			// our compileMethod() func
@@ -279,44 +279,44 @@ namespace de4dot.mdecrypt {
 
 			int numPushedArgs = compileMethodIsThisCall ? 5 : 6;
 
-			code.writeByte(0x51);			// push ecx
-			code.writeByte(0x50);			// push eax
-			code.writeByte(0x54);			// push esp
+			code.WriteByte(0x51);			// push ecx
+			code.WriteByte(0x50);			// push eax
+			code.WriteByte(0x54);			// push esp
 			for (int i = 0; i < 5; i++)
-				writePushDwordPtrEspDispl(code, (sbyte)(0xC + numPushedArgs * 4));	// push dword ptr [esp+XXh]
+				WritePushDwordPtrEspDispl(code, (sbyte)(0xC + numPushedArgs * 4));	// push dword ptr [esp+XXh]
 			if (!compileMethodIsThisCall)
-				writePushDwordPtrEspDispl(code, (sbyte)(0xC + numPushedArgs * 4));	// push dword ptr [esp+XXh]
+				WritePushDwordPtrEspDispl(code, (sbyte)(0xC + numPushedArgs * 4));	// push dword ptr [esp+XXh]
 			else
-				code.writeByte(0x51);		// push ecx
-			code.writeCall(ourCompileMethodInfo.ptr);
-			code.writeByte(0x5A);			// pop edx
-			code.writeByte(0x59);			// pop ecx
-			code.writeBytes(0x84, 0xD2);	// test dl, dl
-			code.writeBytes(0x74, 0x03);	// jz $+5
-			code.writeBytes(0xC2, (ushort)(numPushedArgs * 4)); // retn 14h/18h
+				code.WriteByte(0x51);		// push ecx
+			code.WriteCall(ourCompileMethodInfo.ptr);
+			code.WriteByte(0x5A);			// pop edx
+			code.WriteByte(0x59);			// pop ecx
+			code.WriteBytes(0x84, 0xD2);	// test dl, dl
+			code.WriteBytes(0x74, 0x03);	// jz $+5
+			code.WriteBytes(0xC2, (ushort)(numPushedArgs * 4)); // retn 14h/18h
 			for (int i = 0; i < numPushedArgs; i++)
-				writePushDwordPtrEspDispl(code, (sbyte)(numPushedArgs * 4));	// push dword ptr [esp+XXh]
-			code.writeCall(origCompileMethod);
-			code.writeBytes(0xC2, (ushort)(numPushedArgs * 4)); // retn 14h/18h
+				WritePushDwordPtrEspDispl(code, (sbyte)(numPushedArgs * 4));	// push dword ptr [esp+XXh]
+			code.WriteCall(origCompileMethod);
+			code.WriteBytes(0xC2, (ushort)(numPushedArgs * 4)); // retn 14h/18h
 
 			// Our callMethod() code. 1st arg is the method to call. stdcall calling convention.
 			int callMethodOffset = code.Size;
-			code.writeByte(0x58);			// pop eax (ret addr)
-			code.writeByte(0x5A);			// pop edx (method to call)
+			code.WriteByte(0x58);			// pop eax (ret addr)
+			code.WriteByte(0x5A);			// pop edx (method to call)
 			if (compileMethodIsThisCall)
-				code.writeByte(0x59);		// pop ecx (this ptr)
-			code.writeByte(0x50);			// push eax (ret addr)
-			code.writeBytes(0xFF, 0xE2);	// jmp edx
+				code.WriteByte(0x59);		// pop ecx (this ptr)
+			code.WriteByte(0x50);			// push eax (ret addr)
+			code.WriteBytes(0xFF, 0xE2);	// jmp edx
 
 			// Returns token of method
 			int getMethodTokenOffset = code.Size;
-			code.writeCall(returnMethodTokenInfo.ptr);
-			code.writeBytes(0xC2, (ushort)(IntPtr.Size * 2));
+			code.WriteCall(returnMethodTokenInfo.ptr);
+			code.WriteBytes(0xC2, (ushort)(IntPtr.Size * 2));
 
 			// Returns name of method
 			int getMethodNameOffset = code.Size;
-			code.writeCall(returnNameOfMethodInfo.ptr);
-			code.writeBytes(0xC2, (ushort)(IntPtr.Size * 3));
+			code.WriteCall(returnNameOfMethodInfo.ptr);
+			code.WriteBytes(0xC2, (ushort)(IntPtr.Size * 3));
 
 			ourCodeAddr = VirtualAlloc(IntPtr.Zero, new UIntPtr((ulong)code.Size), 0x00001000, PAGE_EXECUTE_READWRITE);
 			IntPtr baseAddr = ourCodeAddr;
@@ -324,17 +324,17 @@ namespace de4dot.mdecrypt {
 			callMethod = new IntPtr((byte*)baseAddr + callMethodOffset);
 			returnMethodTokenInfo.ptrInDll = new IntPtr((byte*)baseAddr + getMethodTokenOffset);
 			returnNameOfMethodInfo.ptrInDll = new IntPtr((byte*)baseAddr + getMethodNameOffset);
-			byte[] theCode = code.getCode(baseAddr);
+			byte[] theCode = code.GetCode(baseAddr);
 			Marshal.Copy(theCode, 0, baseAddr, theCode.Length);
 		}
 
 		// Writes push dword ptr [esp+displ]
-		static void writePushDwordPtrEspDispl(NativeCodeGenerator code, sbyte displ) {
-			code.writeBytes(0xFF, 0x74);
-			code.writeBytes(0x24, (byte)displ);
+		static void WritePushDwordPtrEspDispl(NativeCodeGenerator code, sbyte displ) {
+			code.WriteBytes(0xFF, 0x74);
+			code.WriteBytes(0x24, (byte)displ);
 		}
 
-		static IntPtr getJitterDllHandle() {
+		static IntPtr GetJitterDllHandle() {
 			var hJitterDll = GetModuleHandle("mscorjit");
 			if (hJitterDll == IntPtr.Zero)
 				hJitterDll = GetModuleHandle("clrjit");
@@ -343,7 +343,7 @@ namespace de4dot.mdecrypt {
 			return hJitterDll;
 		}
 
-		unsafe int compileMethod(IntPtr jitter, IntPtr comp, IntPtr info, uint flags, IntPtr nativeEntry, IntPtr nativeSizeOfCode, out bool handled) {
+		unsafe int TheCompileMethod(IntPtr jitter, IntPtr comp, IntPtr info, uint flags, IntPtr nativeEntry, IntPtr nativeSizeOfCode, out bool handled) {
 			if (ourCompMem != IntPtr.Zero && comp == ourCompMem) {
 				// We're decrypting methods
 				var info2 = (CORINFO_METHOD_INFO*)info;
@@ -353,9 +353,9 @@ namespace de4dot.mdecrypt {
 				ctx.dm.mhMaxStack = info2->maxStack;
 				ctx.dm.mhCodeSize = info2->ILCodeSize;
 				if ((ctx.dm.mhFlags & 8) != 0)
-					ctx.dm.extraSections = readExtraSections((byte*)info2->ILCode + info2->ILCodeSize);
+					ctx.dm.extraSections = ReadExtraSections((byte*)info2->ILCode + info2->ILCodeSize);
 
-				updateFromMethodDefTableRow();
+				UpdateFromMethodDefTableRow();
 
 				handled = true;
 				return 0;
@@ -372,7 +372,7 @@ namespace de4dot.mdecrypt {
 				uint codeRva = (uint)((byte*)info2->ILCode - (byte*)hInstModule);
 				if (decryptMethodsInfo.moduleCctorBytes != null && moduleCctorCodeRva != 0 && moduleCctorCodeRva == codeRva) {
 					fixed (byte* newIlCodeBytes = &decryptMethodsInfo.moduleCctorBytes[0]) {
-						writeCompileMethod(origCompileMethod);
+						WriteCompileMethod(origCompileMethod);
 						info2->ILCode = new IntPtr(newIlCodeBytes);
 						info2->ILCodeSize = (uint)decryptMethodsInfo.moduleCctorBytes.Length;
 						handled = true;
@@ -385,24 +385,24 @@ namespace de4dot.mdecrypt {
 			return 0;
 		}
 
-		unsafe static byte* align(byte* p, int alignment) {
+		unsafe static byte* Align(byte* p, int alignment) {
 			return (byte*)new IntPtr((long)((ulong)(p + alignment - 1) & ~(ulong)(alignment - 1)));
 		}
 
-		unsafe static byte[] readExtraSections(byte* p) {
-			p = align(p, 4);
+		unsafe static byte[] ReadExtraSections(byte* p) {
+			p = Align(p, 4);
 			byte* startPos = p;
-			p = parseSection(p);
+			p = ParseSection(p);
 			int size = (int)(p - startPos);
 			var sections = new byte[size];
 			Marshal.Copy(new IntPtr(startPos), sections, 0, sections.Length);
 			return sections;
 		}
 
-		unsafe static byte* parseSection(byte* p) {
+		unsafe static byte* ParseSection(byte* p) {
 			byte flags;
 			do {
-				p = align(p, 4);
+				p = Align(p, 4);
 
 				flags = *p++;
 				if ((flags & 1) == 0)
@@ -423,18 +423,18 @@ namespace de4dot.mdecrypt {
 			return p;
 		}
 
-		unsafe void updateFromMethodDefTableRow() {
+		unsafe void UpdateFromMethodDefTableRow() {
 			uint methodIndex = ctx.dm.token - 0x06000001;
 			byte* row = (byte*)methodDefTablePtr + methodIndex * methodDefTable.RowSize;
-			ctx.dm.mdRVA = read(row, methodDefTable.Columns[0]);
-			ctx.dm.mdImplFlags = (ushort)read(row, methodDefTable.Columns[1]);
-			ctx.dm.mdFlags = (ushort)read(row, methodDefTable.Columns[2]);
-			ctx.dm.mdName = read(row, methodDefTable.Columns[3]);
-			ctx.dm.mdSignature = read(row, methodDefTable.Columns[4]);
-			ctx.dm.mdParamList = read(row, methodDefTable.Columns[5]);
+			ctx.dm.mdRVA = Read(row, methodDefTable.Columns[0]);
+			ctx.dm.mdImplFlags = (ushort)Read(row, methodDefTable.Columns[1]);
+			ctx.dm.mdFlags = (ushort)Read(row, methodDefTable.Columns[2]);
+			ctx.dm.mdName = Read(row, methodDefTable.Columns[3]);
+			ctx.dm.mdSignature = Read(row, methodDefTable.Columns[4]);
+			ctx.dm.mdParamList = Read(row, methodDefTable.Columns[5]);
 		}
 
-		static unsafe uint read(byte* row, ColumnInfo colInfo) {
+		static unsafe uint Read(byte* row, ColumnInfo colInfo) {
 			switch (colInfo.Size) {
 			case 1: return *(row + colInfo.Offset);
 			case 2: return *(ushort*)(row + colInfo.Offset);
@@ -443,35 +443,35 @@ namespace de4dot.mdecrypt {
 			}
 		}
 
-		string returnNameOfMethod() {
+		string ReturnNameOfMethod2() {
 			return ctx.method.Name.String;
 		}
 
-		int returnMethodToken() {
+		int ReturnMethodToken2() {
 			return ctx.method.MDToken.ToInt32();
 		}
 
-		public DumpedMethods decryptMethods() {
-			if (!canDecryptMethods())
+		public DumpedMethods DecryptMethods() {
+			if (!CanDecryptMethods())
 				throw new ApplicationException("Can't decrypt methods since compileMethod() isn't hooked yet");
-			installCompileMethod2();
+			InstallCompileMethod2();
 
 			var dumpedMethods = new DumpedMethods();
 
 			if (decryptMethodsInfo.methodsToDecrypt == null) {
 				for (uint rid = 1; rid <= methodDefTable.Rows; rid++)
-					dumpedMethods.add(decryptMethod(0x06000000 + rid));
+					dumpedMethods.Add(DecryptMethod(0x06000000 + rid));
 			}
 			else {
 				foreach (var token in decryptMethodsInfo.methodsToDecrypt)
-					dumpedMethods.add(decryptMethod(token));
+					dumpedMethods.Add(DecryptMethod(token));
 			}
 
 			return dumpedMethods;
 		}
 
-		unsafe DumpedMethod decryptMethod(uint token) {
-			if (!canDecryptMethods())
+		unsafe DumpedMethod DecryptMethod(uint token) {
+			if (!CanDecryptMethods())
 				throw new ApplicationException("Can't decrypt methods since compileMethod() isn't hooked yet");
 
 			ctx = new DecryptContext();
@@ -514,10 +514,10 @@ namespace de4dot.mdecrypt {
 			info.maxStack = ctx.dm.mhMaxStack;
 			info.scope = moduleToDecryptScope;
 
-			initializeOurComp();
+			InitializeOurComp();
 			if (code == null) {
 				ctx.dm.code = new byte[0];
-				updateFromMethodDefTableRow();
+				UpdateFromMethodDefTableRow();
 			}
 			else
 				callMethodDelegate(*(IntPtr*)jitterVtbl, jitterInstance, ourCompMem, new IntPtr(&info), 0, new IntPtr(0x12345678), new IntPtr(0x3ABCDEF0));
@@ -527,7 +527,7 @@ namespace de4dot.mdecrypt {
 			return dm;
 		}
 
-		unsafe void initializeOurComp() {
+		unsafe void InitializeOurComp() {
 			const int numIndexes = 15;
 			if (ourCompMem == IntPtr.Zero)
 				ourCompMem = Marshal.AllocHGlobal(numIndexes * IntPtr.Size);
@@ -549,18 +549,18 @@ namespace de4dot.mdecrypt {
 		}
 
 		bool hasInstalledCompileMethod2 = false;
-		unsafe void installCompileMethod2() {
+		unsafe void InstallCompileMethod2() {
 			if (hasInstalledCompileMethod2)
 				return;
 
-			if (!patchDword(*(IntPtr*)jitterVtbl, 0x30000, origCompileMethod, ourCompileMethodInfo.ptrInDll))
+			if (!PatchDword(*(IntPtr*)jitterVtbl, 0x30000, origCompileMethod, ourCompileMethodInfo.ptrInDll))
 				throw new ApplicationException("Couldn't patch compileMethod");
 
 			hasInstalledCompileMethod2 = true;
 			return;
 		}
 
-		unsafe bool patchDword(IntPtr addr, int size, IntPtr origValue, IntPtr newValue) {
+		unsafe bool PatchDword(IntPtr addr, int size, IntPtr origValue, IntPtr newValue) {
 			addr = new IntPtr(addr.ToInt64() & ~0xFFF);
 			var endAddr = new IntPtr(addr.ToInt64() + size);
 			for (; addr.ToPointer() < endAddr.ToPointer(); addr = new IntPtr(addr.ToInt64() + 0x1000)) {
diff --git a/de4dot.mdecrypt/NativeCodeGenerator.cs b/de4dot.mdecrypt/NativeCodeGenerator.cs
index 71b9ba83..a77028c1 100644
--- a/de4dot.mdecrypt/NativeCodeGenerator.cs
+++ b/de4dot.mdecrypt/NativeCodeGenerator.cs
@@ -36,49 +36,49 @@ namespace de4dot.mdecrypt {
 			writer = new BinaryWriter(memStream);
 		}
 
-		public void writeByte(byte b) {
+		public void WriteByte(byte b) {
 			writer.Write(b);
 		}
 
-		public void writeBytes(byte b1, byte b2) {
-			writeByte(b1);
-			writeByte(b2);
+		public void WriteBytes(byte b1, byte b2) {
+			WriteByte(b1);
+			WriteByte(b2);
 		}
 
-		public void writeBytes(byte b, ushort us) {
-			writeByte(b);
-			writeWord(us);
+		public void WriteBytes(byte b, ushort us) {
+			WriteByte(b);
+			WriteWord(us);
 		}
 
-		public void writeWord(ushort w) {
+		public void WriteWord(ushort w) {
 			writer.Write(w);
 		}
 
-		public void writeDword(uint d) {
+		public void WriteDword(uint d) {
 			writer.Write(d);
 		}
 
-		public void writeBytes(byte[] bytes) {
+		public void WriteBytes(byte[] bytes) {
 			writer.Write(bytes);
 		}
 
-		public void writeCall(IntPtr addr) {
-			writeByte(0xE8);
-			writeBranchAddr(addr);
+		public void WriteCall(IntPtr addr) {
+			WriteByte(0xE8);
+			WriteBranchAddr(addr);
 		}
 
-		public void writeBranchAddr(IntPtr addr) {
+		public void WriteBranchAddr(IntPtr addr) {
 			offsetToBranchAddr.Add((int)memStream.Position, addr);
 			writer.Write(0);
 		}
 
-		public byte[] getCode(IntPtr addr) {
-			fixOffsets(addr);
+		public byte[] GetCode(IntPtr addr) {
+			FixOffsets(addr);
 			memStream.Position = memStream.Length;
 			return memStream.ToArray();
 		}
 
-		unsafe void fixOffsets(IntPtr destAddr) {
+		unsafe void FixOffsets(IntPtr destAddr) {
 			foreach (var kv in offsetToBranchAddr) {
 				memStream.Position = kv.Key;
 				// kv.Value (func/label) = destAddr + kv.Key + 4 + displ
diff --git a/de4dot/Program.cs b/de4dot/Program.cs
index 498ba3dd..dc63c8a0 100644
--- a/de4dot/Program.cs
+++ b/de4dot/Program.cs
@@ -20,7 +20,7 @@
 namespace de4dot_x86 {
 	class Program {
 		static int Main(string[] args) {
-			return de4dot.cui.Program.main(args);
+			return de4dot.cui.Program.Main2(args);
 		}
 	}
 }