Index: /binary-improvements/7dtd-server-fixes/src/TelnetCommands/GetTime.cs
===================================================================
--- /binary-improvements/7dtd-server-fixes/src/TelnetCommands/GetTime.cs	(revision 76)
+++ /binary-improvements/7dtd-server-fixes/src/TelnetCommands/GetTime.cs	(revision 77)
@@ -27,5 +27,5 @@
 		}
 		int sec = (int)(time % 1000) * 60 / 1000;
-		m_Console.md000a (String.Format ("Day {0}, {1}:{2} ", day, hour, sec));
+		m_Console.md000a (String.Format ("Day {0}, {1:00}:{2:00} ", day, hour, sec));
 	}
 }
Index: /binary-improvements/NamePatcher/NameNormalizer.cs
===================================================================
--- /binary-improvements/NamePatcher/NameNormalizer.cs	(revision 77)
+++ /binary-improvements/NamePatcher/NameNormalizer.cs	(revision 77)
@@ -0,0 +1,306 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Mono.Cecil;
+
+namespace NamePatcher
+{
+	class NameNormalizer
+	{
+		public static void CheckType (TypeDefinition tdef)
+		{
+			CheckNames (tdef);
+		}
+
+		public class vmdGroupInfo
+		{
+			public vmdGroupInfo (string newname, TypeDefinition baseclass)
+			{
+				this.newname = newname;
+				this.baseclass = baseclass;
+			}
+
+			public List<MethodDefinition> applyingmdefs = new List<MethodDefinition> ();
+			public string newname;
+			public TypeDefinition baseclass;
+		};
+
+		public static void setName (IMemberDefinition def, string name)
+		{
+			foreach (KeyValuePair<IMemberDefinition, string> entry in clnamestomod) {
+				if (def.Equals (entry.Key)) {
+					clnamestomod.Remove (def);
+					break;
+				}
+			}
+			clnamestomod.Add (def, name);
+		}
+
+		public static string getName (IMemberDefinition def)
+		{
+			foreach (KeyValuePair<IMemberDefinition, string> entry in clnamestomod) {
+				if (def.Equals (entry.Key)) {
+					return entry.Value;
+				}
+			}
+			return def.Name;
+		}
+
+		private static Boolean paramlistEquals (Mono.Collections.Generic.Collection<ParameterDefinition> _pars1,
+                                                Mono.Collections.Generic.Collection<ParameterDefinition> _pars2)
+		{
+			if ((_pars1.Count != _pars2.Count) || _pars1.Count < 0)
+				return false;
+			ParameterDefinition[] pars1 = _pars1.ToArray ();
+			ParameterDefinition[] pars2 = _pars2.ToArray ();
+			for (int i = 0; i < _pars1.Count; i++) {
+				ParameterDefinition par1 = pars1 [i];
+				ParameterDefinition par2 = pars2 [i];
+				if (par1 == null) {
+					if (par2 != null)
+						return false;
+				} else if (par2 == null) {
+					if (par1 != null)
+						return false;
+				} else if (!par1.ParameterType.Resolve ().Equals (par2.ParameterType.Resolve ()))
+					return false;
+			}
+			return true;
+		}
+
+		public static int vmethid = 1;
+		public static int classid = 1;
+		public static List<vmdGroupInfo> vclasses = new List<vmdGroupInfo> ();
+		public static Dictionary<IMemberDefinition, string> clnamestomod = new Dictionary<IMemberDefinition, string> ();
+
+		public static void CheckNames (TypeDefinition tdef)
+		{
+			String newTName = makeValidName (getName (tdef));
+			if (newTName != null) {
+				setName (tdef, "" + (tdef.IsClass ? "cl" : "tp") + String.Format ("{0:x4}", classid)/*newTName*/);//tdef.Name = (tdef.IsClass ? "cl" : "tp") + newTName;
+				classid++;
+			}
+			if (tdef.IsEnum)
+				return;
+
+			int cmid = 0;
+			try {
+				if (tdef.HasInterfaces)
+					cmid += checkTypeReferences (tdef.Interfaces, "if", cmid, tdef);
+				if (tdef.HasNestedTypes)
+					cmid += checkLocalDefinitions<TypeDefinition> (tdef.NestedTypes, "scl", cmid, tdef);
+			} catch (Exception e) {
+				throw new Exception ("occured while patching 1", e);
+			}
+			try {
+				if (tdef.HasMethods)
+					cmid += checkLocalDefinitions<MethodDefinition> (tdef.Methods, "md", cmid, tdef);
+			} catch (Exception e) {
+				throw new Exception ("occured while patching 2", e);
+			}
+			try {
+				if (tdef.HasFields)
+					cmid += checkLocalDefinitions<FieldDefinition> (tdef.Fields, "fd", cmid, tdef);
+			} catch (Exception e) {
+				throw new Exception ("occured while patching 3", e);
+			}
+			try {
+				if (tdef.HasEvents)
+					cmid += checkLocalDefinitions<EventDefinition> (tdef.Events, "event", cmid, tdef);
+			} catch (Exception e) {
+				throw new Exception ("occured while patching 4", e);
+			}
+			try {
+				if (tdef.HasProperties)
+					cmid += checkLocalDefinitions<PropertyDefinition> (tdef.Properties, "prop", cmid, tdef);
+			} catch (Exception e) {
+				throw new Exception ("occured while patching 5", e);
+			}
+
+		}
+
+		static void checkLocalDefinition<T> (T def, string prefix, int cmid, TypeDefinition btdef) where T : IMemberDefinition
+		{
+			String newName = makeValidName (getName (def));
+			if (typeof(T) == typeof(MethodDefinition)) {
+				MethodDefinition mdef = def as MethodDefinition;
+				Mono.Collections.Generic.Collection<ParameterDefinition> pardef = mdef.Parameters;
+				if (pardef == null) {
+					pardef = new Mono.Collections.Generic.Collection<ParameterDefinition> ();
+				}
+
+				int parid = 1;
+				if (mdef.IsVirtual && newName != null) {
+					newName = null;
+					prefix = "mdv";
+					List<MethodDefinition> baseVmdefList = new List<MethodDefinition> ();
+					baseVmdefList.Add (mdef);
+					TypeDefinition baseclass = null;
+					try {
+						TypeReference curBaseType = btdef.BaseType;
+						while (curBaseType != null) {
+							TypeDefinition basetdef = curBaseType.Resolve ();
+							if (basetdef == null)
+								break;
+							if (basetdef.HasMethods && basetdef.Methods != null) {
+								foreach (MethodDefinition basemdef in basetdef.Methods) {
+									if (basemdef == null)
+										continue;
+									Mono.Collections.Generic.Collection<ParameterDefinition> basepardef = basemdef.Parameters;
+									if (basepardef == null) {
+										basepardef = new Mono.Collections.Generic.Collection<ParameterDefinition> ();
+									}
+									try {
+										if (basemdef.Name != null && mdef.Name != null && basemdef.Name.Equals (mdef.Name) && basemdef.IsVirtual && paramlistEquals (basepardef, pardef)) {
+											if (makeValidName (getName (basemdef)) == null)
+												newName = getName (basemdef);
+											baseVmdefList.Add (basemdef);
+											baseclass = basetdef;
+										}
+									} catch (Exception) { /*throw new Exception("2.1");*/
+									}
+								}
+							}
+							curBaseType = basetdef.BaseType;
+						}
+
+					} catch (NotSupportedException) {
+					}
+					if (baseclass != null) {
+						vmdGroupInfo vmGroup = null;
+						foreach (vmdGroupInfo curGroupInfo in vclasses) {
+							if (curGroupInfo.applyingmdefs.Count < 1)
+								continue;
+							if (curGroupInfo.applyingmdefs.ToArray () [0].Name.Equals (mdef.Name)
+								&& curGroupInfo.baseclass.Name.Equals (baseclass.Name)) {
+								vmGroup = curGroupInfo;
+								break;
+							}
+						}
+						if (vmGroup == null) {
+							if (newName != null)
+								vmGroup = new vmdGroupInfo (newName, baseclass);
+							else
+								vmGroup = new vmdGroupInfo (String.Format ("{0}{1:x4}", prefix, vmethid), baseclass);
+							vclasses.Add (vmGroup);
+							++vmethid;
+						}
+						object[] baseVmdefs = baseVmdefList.ToArray ();
+						for (int i = baseVmdefs.Length - 1; i >= 0; i--) {
+							MethodDefinition curBaseDef = baseVmdefs [i] as MethodDefinition;
+							foreach (MethodDefinition curSubDef in vmGroup.applyingmdefs) {
+								if ((curBaseDef.DeclaringType == curSubDef.DeclaringType) && paramlistEquals (curSubDef.Parameters, mdef.Parameters)) {
+									curBaseDef = null;
+									break;
+								}
+							}
+							if (curBaseDef != null)
+								vmGroup.applyingmdefs.Add (curBaseDef);
+						}
+						newName = null;
+					}
+				}
+				if (mdef.HasParameters) {
+					foreach (ParameterDefinition pdef in mdef.Parameters) {
+						String parName = makeValidName (pdef.Name);
+						if (parName != null)
+							pdef.Name = String.Format ("par{0:x4}", parid);
+						++parid;
+					}
+				}
+			}
+			newName = (newName == null ? null : String.Format ("{0}{1:x4}", prefix, cmid));
+			if (newName != null) {
+				setName (def, newName);
+			}
+			if (typeof(T) == typeof(TypeDefinition)) {
+				TypeDefinition tdef = def as TypeDefinition;
+				if (!tdef.IsEnum)
+					CheckNames (tdef);
+			}
+			if (typeof(T) == typeof(PropertyDefinition)) {
+			}
+		}
+
+		static int checkLocalDefinitions<T> (Mono.Collections.Generic.Collection<T> memDef, string prefix, int cmid, TypeDefinition btdef)
+            where T : IMemberDefinition
+		{
+			if (memDef == null)
+				return cmid;
+			foreach (T def in memDef) {
+				checkLocalDefinition<T> (def, prefix, cmid, btdef);
+				++cmid;
+			}
+			return cmid;
+		}
+
+		static int checkTypeReferences<T> (Mono.Collections.Generic.Collection<T> tRefs, string prefix, int cmid, TypeDefinition btdef)
+            where T : MemberReference
+		{
+			if (tRefs == null)
+				return cmid;
+			foreach (MemberReference mref in tRefs) {
+				try {
+					if (typeof(T) == typeof(TypeReference)) {
+						TypeDefinition tDef = (mref as TypeReference).Resolve ();
+						checkLocalDefinition<TypeDefinition> (tDef, prefix, cmid, btdef);
+					} else if (typeof(T) == typeof(MethodReference)) {
+						MethodDefinition mdDef = (mref as MethodReference).Resolve ();
+						checkLocalDefinition<MethodDefinition> (mdDef, prefix, cmid, btdef);
+					}
+				} catch (NotSupportedException) {
+				}
+			}
+			return cmid;
+		}
+		/*
+			 * Made public by Alloc
+			 */
+		public static String makeValidName (String origName)
+		{
+			if (origName == null)
+				return "nullname";
+			StringBuilder namebuilder = new StringBuilder ();
+			bool modname = false;
+			foreach (char ch in origName) {
+				if (
+                        (
+                        ((ch & 0x00FF) > 0x7F) || (((ch & 0xFF00) >> 8) > 0x7F)
+                        ) ||
+					(("" + ch).Normalize ().ToCharArray () [0] > 0x00FF) ||
+					(((("" + ch).Normalize ().ToCharArray () [0] & 0x00FF)) <= 0x20)
+                    ) {
+					namebuilder.Append (String.Format ("u{0:x4}", (ushort)ch));
+					modname = true;
+				} else {
+					namebuilder.Append (ch);
+				}
+			}
+			if (modname)
+				return namebuilder.ToString ();
+			return null;
+		}
+
+		public static void FinalizeNormalizing ()
+		{
+			foreach (KeyValuePair<IMemberDefinition, string> vce in NameNormalizer.clnamestomod) {
+				try {
+					vce.Key.Name = vce.Value;
+				} catch (Exception e) {
+					Console.WriteLine ("An exception occured : ");
+					Console.WriteLine (e.ToString ());
+				}
+			}
+			foreach (NameNormalizer.vmdGroupInfo curGroupEntry in NameNormalizer.vclasses) {
+				try {
+					foreach (MethodDefinition curkey in curGroupEntry.applyingmdefs) {
+						curkey.Name = curGroupEntry.newname;
+					}
+				} catch (Exception e) {
+					Console.WriteLine ("An exception occured : ");
+					Console.WriteLine (e.ToString ());
+				}
+			}
+		}
+	}
+}
Index: /binary-improvements/NamePatcher/NamePatcher.cs
===================================================================
--- /binary-improvements/NamePatcher/NamePatcher.cs	(revision 77)
+++ /binary-improvements/NamePatcher/NamePatcher.cs	(revision 77)
@@ -0,0 +1,234 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using Mono.Cecil;
+using System.Reflection;
+
+namespace NamePatcher
+{
+	class NamePatcher
+	{
+		static void DrawUsage ()
+		{
+			Console.WriteLine ("Usage :");
+			Console.WriteLine ("NamePatcher [input file]    Patches an Assembly and creates a backup of the original file.");
+		}
+
+		static bool TryArgs (string[] args)
+		{
+			return args.Length == 1 && (File.Exists (args [0]));
+		}
+
+		static bool makeBackup (string input)
+		{
+			string backupFile_base = input + ".bck";
+			string backupFile = backupFile_base;
+			int backupIndex = 0;
+			while (File.Exists(backupFile)) {
+				backupFile = backupFile_base + "." + (++backupIndex);
+				if (backupIndex > 10) {
+					return false;
+				}
+			}
+			try {
+				File.Copy (input, backupFile);
+			} catch (Exception e) {
+				Console.WriteLine ("Unable to create backup file : ");
+				Console.WriteLine (e.ToString ());
+				return false;
+			}
+			return true;
+		}
+
+		static DefaultAssemblyResolver getAssemblyResolver (string path)
+		{
+			DefaultAssemblyResolver resolver = null;
+			int lastSlash = path.LastIndexOf ("\\");
+			if (lastSlash == -1)
+				lastSlash = path.LastIndexOf ("/");
+			if (lastSlash != -1) {
+				string inputPath = path.Substring (0, lastSlash);
+				resolver = new DefaultAssemblyResolver ();
+				resolver.AddSearchDirectory (inputPath);
+			}
+			return resolver;
+		}
+
+		static void applyManualPatches (ModuleDefinition mainModule)
+		{
+			foreach (FieldDefinition fd in mainModule.GetType ("World").Fields) {
+				TypeReference fdType = fd.FieldType;
+				if (fdType.FullName.Equals ("System.UInt64")) {
+					Console.WriteLine ("Renaming world field -> gameTime");
+					NameNormalizer.setName (fd, "gameTime");
+				}
+			}
+
+			foreach (FieldDefinition fd in mainModule.GetType ("GameManager").Fields) {
+				TypeReference fdType = fd.FieldType;
+				if (fdType.FullName.Equals ("ConnectionManager")) {
+					Console.WriteLine ("Renaming and making public GameMananger field -> connectionManager");
+					fd.Attributes = fd.Attributes & (~Mono.Cecil.FieldAttributes.Private) | Mono.Cecil.FieldAttributes.Public;
+					NameNormalizer.setName (fd, "connectionManager");
+				}
+			}
+
+			foreach (FieldDefinition fd in mainModule.GetType ("ConnectionManager").Fields) {
+				TypeReference fdType = fd.FieldType;
+				if (fdType.FullName.Contains ("Dictionary") && fdType.FullName.Contains ("ClientInfo")) {
+					Console.WriteLine ("Renaming and making public ConnectionManager field -> connectedClients");
+					fd.Attributes = fd.Attributes & (~Mono.Cecil.FieldAttributes.Private) | Mono.Cecil.FieldAttributes.Public;
+					NameNormalizer.setName (fd, "connectedClients");
+				}
+				if (fdType.FullName.Contains ("Dictionary") && fdType.FullName.Contains ("System.Int32,System.Int32")) {
+					Console.WriteLine ("Renaming and making public ConnectionManager field -> mapClientToEntity");
+					fd.Attributes = fd.Attributes & (~Mono.Cecil.FieldAttributes.Private) | Mono.Cecil.FieldAttributes.Public;
+					NameNormalizer.setName (fd, "mapClientToEntity");
+				}
+			}
+
+			string consoleTypeName = string.Empty;
+			TypeDefinition typeTelnetServer = mainModule.GetType ("NetTelnetServer");
+			foreach (FieldDefinition fd in typeTelnetServer.Fields) {
+				if (NameNormalizer.makeValidName (fd.FieldType.Name) != null) {
+					Console.WriteLine ("Renaming console class -> ConsoleSdtd");
+					consoleTypeName = fd.FieldType.Name;
+					NameNormalizer.setName (fd.FieldType.Resolve (), "ConsoleSdtd");
+					NameNormalizer.setName (fd, "console");
+				}
+			}
+
+			if (consoleTypeName.Length > 0) {
+				TypeDefinition typeConsole = mainModule.GetType (consoleTypeName);
+				string consoleCommandTypeName = string.Empty;
+				foreach (FieldDefinition fd in typeConsole.Fields) {
+					TypeReference fdType = fd.FieldType;
+					if (fdType.FullName.Contains ("Generic.List")) {
+						if (fdType.IsGenericInstance) {
+							GenericInstanceType genType = (GenericInstanceType)fdType;
+							TypeReference genRef = genType.GenericArguments [0];
+							if (genRef.Name.Length < 2) {
+								Console.WriteLine ("Renaming console command class -> ConsoleCommand");
+								NameNormalizer.setName (genRef.Resolve (), "ConsoleCommand");
+								NameNormalizer.setName (fd, "commands");
+								consoleCommandTypeName = genRef.Name;
+							}
+						}
+					}
+					if (fdType.FullName.Equals ("GameManager")) {
+						Console.WriteLine ("Renaming and making public console field -> gameManager");
+						fd.Attributes = fd.Attributes & (~Mono.Cecil.FieldAttributes.Private) | Mono.Cecil.FieldAttributes.Public;
+						NameNormalizer.setName (fd, "gameManager");
+					}
+				}
+
+				if (consoleCommandTypeName.Length > 0) {
+					foreach (MethodDefinition md in typeConsole.Methods) {
+						if (md.Parameters.Count == 1 && md.Parameters [0].ParameterType.Name.Equals (consoleCommandTypeName)) {
+							Console.WriteLine ("Renaming console method -> AddCommand");
+							NameNormalizer.setName (md, "AddCommand");
+						}
+					}
+
+					TypeDefinition typeConsoleCommand = mainModule.GetType (consoleCommandTypeName);
+					foreach (MethodDefinition md in typeConsoleCommand.Methods) {
+						if (!md.IsConstructor) {
+							if (md.Parameters.Count == 1 && md.Parameters [0].ParameterType.Name.Equals (consoleTypeName)) {
+								Console.WriteLine ("Renaming console command method -> Help");
+								NameNormalizer.setName (md, "Help");
+							}
+							if (md.Parameters.Count == 0 && md.ReturnType.Name.Equals ("Int32")) {
+								Console.WriteLine ("Renaming console command method -> Timeout");
+								NameNormalizer.setName (md, "Timeout");
+							}
+							if (md.Parameters.Count == 0 && md.ReturnType.Name.Equals ("String[]")) {
+								Console.WriteLine ("Renaming console command method -> Names");
+								NameNormalizer.setName (md, "Names");
+							}
+							if (md.Parameters.Count == 0 && md.ReturnType.Name.Equals ("String")) {
+								Console.WriteLine ("Renaming console command method -> Description");
+								NameNormalizer.setName (md, "Description");
+							}
+							if (md.Parameters.Count == 1 && md.Parameters [0].ParameterType.IsArray) {
+								Console.WriteLine ("Renaming console command method -> Run");
+								NameNormalizer.setName (md, "Run");
+							}
+						}
+					}
+				}
+			}
+		}
+
+		static void Main (string[] args)
+		{
+			Console.WriteLine ("NamePatcher for 7dtd's Assembly-CSharp.dll [by DerPopo, modified by Alloc] for Dedi build 320404");
+			if (!TryArgs (args)) {
+				DrawUsage ();
+				return;
+			}
+			string dllPath = args [0];
+
+			if (!makeBackup (dllPath)) {
+				Console.WriteLine ("Could not create a backup file (maybe too many old backups?)");
+				return;
+			}
+
+
+			AssemblyDefinition input;
+			try {
+				input = AssemblyDefinition.ReadAssembly (dllPath, new ReaderParameters { AssemblyResolver = getAssemblyResolver(dllPath), });
+			} catch (Exception e) {
+				Console.WriteLine ("Unable to load the input file : ");
+				Console.WriteLine (e.ToString ());
+				return;
+			}
+			Console.WriteLine ();
+			Console.WriteLine ("Patching assembly " + dllPath + " (" + input.Modules.Count + " module[s]) ...");
+
+
+
+			applyManualPatches (input.MainModule);
+
+
+			try {
+				foreach (ModuleDefinition mdef in input.Modules) {
+					Console.WriteLine ("Patching module " + mdef.Name + " (" + mdef.Types.Count + " type[s]) ...");
+					foreach (TypeDefinition tdef in mdef.Types) {
+						NameNormalizer.CheckNames (tdef);
+					}
+				}
+			} catch (Exception e) {
+				Console.WriteLine ();
+				Console.WriteLine ("Unable to patch the assembly : ");
+				Console.WriteLine (e.ToString ());
+				return;
+			}
+			Console.WriteLine ("Finalizing patches...");
+
+			try {
+				NameNormalizer.FinalizeNormalizing ();
+			} catch (Exception e) {
+				Console.WriteLine ();
+				Console.WriteLine ("Unable to finalize patching : ");
+				Console.WriteLine (e.ToString ());
+				return;
+			}
+			NameNormalizer.clnamestomod.Clear ();
+			NameNormalizer.vclasses.Clear ();
+			Console.WriteLine ("Saving the patched assembly ...");
+
+			try {
+				input.Write (dllPath);
+			} catch (Exception e) {
+				Console.WriteLine ();
+				Console.WriteLine ("Unable to save the assembly : ");
+				Console.WriteLine (e.ToString ());
+				return;
+			}
+
+			Console.WriteLine ();
+			Console.WriteLine ("Success.");
+		}
+	}
+}
Index: /binary-improvements/NamePatcher/NamePatcher.csproj
===================================================================
--- /binary-improvements/NamePatcher/NamePatcher.csproj	(revision 77)
+++ /binary-improvements/NamePatcher/NamePatcher.csproj	(revision 77)
@@ -0,0 +1,55 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
+    <ProductVersion>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{E72C28C7-326C-4007-9762-86EE1475B6A6}</ProjectGuid>
+    <OutputType>Exe</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>NamePatcher</RootNamespace>
+    <AssemblyName>NamePatcher</AssemblyName>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <PlatformTarget>x86</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <Commandlineparameters>-p '/home/sdtd/engine/7DaysToDie_Data/Managed/Assembly-CSharp.dll_backup' Assembly-CSharp.dll</Commandlineparameters>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <PlatformTarget>x86</PlatformTarget>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <Commandlineparameters>-p '/home/sdtd/engine/7DaysToDie_Data/Managed/Assembly-CSharp.dll_backup' Assembly-CSharp.dll</Commandlineparameters>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Mono.Cecil">
+      <HintPath>Mono.Cecil.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="NameNormalizer.cs" />
+    <Compile Include="NamePatcher.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
Index: /binary-improvements/NamePatcher/NamePatcher.sln
===================================================================
--- /binary-improvements/NamePatcher/NamePatcher.sln	(revision 77)
+++ /binary-improvements/NamePatcher/NamePatcher.sln	(revision 77)
@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 11.00
+# Visual Studio 2010
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NamePatcher", "NamePatcher.csproj", "{E72C28C7-326C-4007-9762-86EE1475B6A6}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x86 = Debug|x86
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{E72C28C7-326C-4007-9762-86EE1475B6A6}.Debug|x86.ActiveCfg = Debug|x86
+		{E72C28C7-326C-4007-9762-86EE1475B6A6}.Debug|x86.Build.0 = Debug|x86
+		{E72C28C7-326C-4007-9762-86EE1475B6A6}.Release|x86.ActiveCfg = Release|x86
+		{E72C28C7-326C-4007-9762-86EE1475B6A6}.Release|x86.Build.0 = Release|x86
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
Index: /binary-improvements/NamePatcher/NamePatcher.userprefs
===================================================================
--- /binary-improvements/NamePatcher/NamePatcher.userprefs	(revision 77)
+++ /binary-improvements/NamePatcher/NamePatcher.userprefs	(revision 77)
@@ -0,0 +1,39 @@
+<Properties>
+  <MonoDevelop.Ide.Workspace ActiveConfiguration="Release|x86" />
+  <MonoDevelop.Ide.Workbench ActiveDocument="NamePatcher.cs">
+    <Files>
+      <File FileName="NamePatcher.cs" Line="165" Column="120" />
+      <File FileName="NameNormalizer.cs" Line="188" Column="1" />
+    </Files>
+    <Pads>
+      <Pad Id="ProjectPad">
+        <State expanded="True">
+          <Node name="NamePatcher" expanded="True">
+            <Node name="Properties" expanded="True" />
+            <Node name="NamePatcher.cs" selected="True" />
+          </Node>
+        </State>
+      </Pad>
+    </Pads>
+  </MonoDevelop.Ide.Workbench>
+  <MonoDevelop.Ide.DebuggingService.Breakpoints>
+    <BreakpointStore />
+  </MonoDevelop.Ide.DebuggingService.Breakpoints>
+  <MonoDevelop.Ide.DebuggingService.PinnedWatches />
+  <MonoDevelop.Ide.ItemProperties.NamePatcher>
+    <MonoDevelop.Ide.CustomExecutionModes>
+      <Data Name="Standard (Benutzerdefiniert)" Id="c477a1aa-04bd-45a8-a6c4-e8cc7dd18ed8" ModeId="Default">
+        <CommandData>
+          <Item Key="MonoDevelop.Ide.Execution.CustomArgsCustomizer">
+            <Value Arguments="-p '/home/sdtd/engine/7DaysToDie_Data/Managed/Assembly-CSharp.dll_backup' aa.dll" WorkingDirectory="/home/ci/Schreibtisch/7dtd-svn/binary-improvements/NamePatcher/NamePatcher/bin/Release" ctype="CustomArgsExecutionModeData">
+              <EnvironmentVariables />
+            </Value>
+          </Item>
+          <Item Key="MonoDevelop.Ide.Execution.MonoExecutionCustomizer">
+            <Value ctype="MonoExecutionParameters" />
+          </Item>
+        </CommandData>
+      </Data>
+    </MonoDevelop.Ide.CustomExecutionModes>
+  </MonoDevelop.Ide.ItemProperties.NamePatcher>
+</Properties>
Index: /binary-improvements/NamePatcher/Properties/AssemblyInfo.cs
===================================================================
--- /binary-improvements/NamePatcher/Properties/AssemblyInfo.cs	(revision 77)
+++ /binary-improvements/NamePatcher/Properties/AssemblyInfo.cs	(revision 77)
@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// Allgemeine Informationen über eine Assembly werden über die folgenden 
+// Attribute gesteuert. Ändern Sie diese Attributwerte, um die Informationen zu ändern,
+// die mit einer Assembly verknüpft sind.
+[assembly: AssemblyTitle("NamePatcher")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("NamePatcher")]
+[assembly: AssemblyCopyright("Copyright ©  2014")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Durch Festlegen von ComVisible auf "false" werden die Typen in dieser Assembly unsichtbar 
+// für COM-Komponenten. Wenn Sie auf einen Typ in dieser Assembly von 
+// COM zugreifen müssen, legen Sie das ComVisible-Attribut für diesen Typ auf "true" fest.
+[assembly: ComVisible(false)]
+
+// Die folgende GUID bestimmt die ID der Typbibliothek, wenn dieses Projekt für COM verfügbar gemacht wird
+[assembly: Guid("9e3c5a8a-8c02-474a-bc1d-9f6ce106d5f5")]
+
+// Versionsinformationen für eine Assembly bestehen aus den folgenden vier Werten:
+//
+//      Hauptversion
+//      Nebenversion 
+//      Buildnummer
+//      Revision
+//
+// Sie können alle Werte angeben oder die standardmäßigen Build- und Revisionsnummern 
+// übernehmen, indem Sie "*" eingeben:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]