diff --git a/SabreTools.Library/DatFiles/DatFile.cs b/SabreTools.Library/DatFiles/DatFile.cs
index 0bf641e0..d294d668 100644
--- a/SabreTools.Library/DatFiles/DatFile.cs
+++ b/SabreTools.Library/DatFiles/DatFile.cs
@@ -4377,7 +4377,7 @@ namespace SabreTools.Library.DatFiles
 				// Seek to the beginning of the stream
 				fileStream.Seek(0, SeekOrigin.Begin);
 
-				Globals.Logger.User("Matches found for '{0}', rebuilding accordingly...", Style.GetFileName(datItem.Name));
+				Globals.Logger.User("Matches found for '{0}', rebuilding accordingly...", Path.GetFileName(datItem.Name));
 				rebuilt = true;
 
 				// Now loop through the list and rebuild accordingly
@@ -4458,8 +4458,8 @@ namespace SabreTools.Library.DatFiles
 
 				// Get the item from the current file
 				Rom item = (Rom)FileTools.GetStreamInfo(fileStream, fileStream.Length, keepReadOpen: true);
-				item.MachineName = Style.GetFileNameWithoutExtension(item.Name);
-				item.MachineDescription = Style.GetFileNameWithoutExtension(item.Name);
+				item.MachineName = Path.GetFileNameWithoutExtension(item.Name);
+				item.MachineDescription = Path.GetFileNameWithoutExtension(item.Name);
 
 				// If we are coming from an archive, set the correct machine name
 				if (machinename != null)
@@ -4468,7 +4468,7 @@ namespace SabreTools.Library.DatFiles
 					item.MachineDescription = machinename;
 				}
 
-				Globals.Logger.User("No matches found for '{0}', rebuilding accordingly from inverse flag...", Style.GetFileName(datItem.Name));
+				Globals.Logger.User("No matches found for '{0}', rebuilding accordingly from inverse flag...", Path.GetFileName(datItem.Name));
 
 				// Get the output archive, if possible
 				BaseArchive outputArchive = FileTools.CreateArchiveFromOutputFormat(outputFormat);
@@ -4574,7 +4574,7 @@ namespace SabreTools.Library.DatFiles
 								return rebuilt;
 							}
 
-							Globals.Logger.User("Headerless matches found for '{0}', rebuilding accordingly...", Style.GetFileName(datItem.Name));
+							Globals.Logger.User("Headerless matches found for '{0}', rebuilding accordingly...", Path.GetFileName(datItem.Name));
 							rebuilt = true;
 
 							// Now loop through the list and rebuild accordingly
@@ -5182,7 +5182,7 @@ namespace SabreTools.Library.DatFiles
 			Parallel.ForEach(keys, Globals.ParallelOptions, key =>
 			{
 				// Here, the key is the name of the game to be used for comparison
-				if (tempDat.Name != null && tempDat.Name != Style.GetDirectoryName(key))
+				if (tempDat.Name != null && tempDat.Name != Path.GetDirectoryName(key))
 				{
 					// Process and output the DAT
 					SplitByLevelHelper(tempDat, outDir, shortname, basedat);
@@ -5196,14 +5196,14 @@ namespace SabreTools.Library.DatFiles
 
 				// Clean the input list and set all games to be pathless
 				List<DatItem> items = this[key];
-				items.ForEach(item => item.MachineName = Style.GetFileName(item.MachineName));
-				items.ForEach(item => item.MachineDescription = Style.GetFileName(item.MachineDescription));
+				items.ForEach(item => item.MachineName = Path.GetFileName(item.MachineName));
+				items.ForEach(item => item.MachineDescription = Path.GetFileName(item.MachineDescription));
 
 				// Now add the game to the output DAT
 				tempDat.AddRange(key, items);
 
 				// Then set the DAT name to be the parent directory name
-				tempDat.Name = Style.GetDirectoryName(key);
+				tempDat.Name = Path.GetDirectoryName(key);
 			});
 
 			// Then we write the last DAT out since it would be skipped otherwise
@@ -5253,7 +5253,7 @@ namespace SabreTools.Library.DatFiles
 			datFile.FileName = HttpUtility.HtmlDecode(String.IsNullOrEmpty(name)
 				? FileName
 				: (shortname
-					? Style.GetFileName(name)
+					? Path.GetFileName(name)
 					: expName
 					)
 				);
diff --git a/SabreTools.Library/Tools/Style.cs b/SabreTools.Library/Tools/Style.cs
index 6868ff22..00f809ea 100644
--- a/SabreTools.Library/Tools/Style.cs
+++ b/SabreTools.Library/Tools/Style.cs
@@ -124,6 +124,135 @@ namespace SabreTools.Library.Tools
 			return hash;
 		}
 
+		/// <summary>
+		/// Replace accented characters
+		/// </summary>
+		/// <param name="input">String to be parsed</param>
+		/// <returns>String with characters replaced</returns>
+		public static string NormalizeChars(string input)
+		{
+			string[,] charmap = {
+				{ "Á", "A" },   { "á", "a" },
+				{ "À", "A" },   { "à", "a" },
+				{ "Â", "A" },   { "â", "a" },
+				{ "Ä", "Ae" },  { "ä", "ae" },
+				{ "Ã", "A" },   { "ã", "a" },
+				{ "Å", "A" },   { "å", "a" },
+				{ "Æ", "Ae" },  { "æ", "ae" },
+				{ "Ç", "C" },   { "ç", "c" },
+				{ "Ð", "D" },   { "ð", "d" },
+				{ "É", "E" },   { "é", "e" },
+				{ "È", "E" },   { "è", "e" },
+				{ "Ê", "E" },   { "ê", "e" },
+				{ "Ë", "E" },   { "ë", "e" },
+				{ "ƒ", "f" },
+				{ "Í", "I" },   { "í", "i" },
+				{ "Ì", "I" },   { "ì", "i" },
+				{ "Î", "I" },   { "î", "i" },
+				{ "Ï", "I" },   { "ï", "i" },
+				{ "Ñ", "N" },   { "ñ", "n" },
+				{ "Ó", "O" },   { "ó", "o" },
+				{ "Ò", "O" },   { "ò", "o" },
+				{ "Ô", "O" },   { "ô", "o" },
+				{ "Ö", "Oe" },  { "ö", "oe" },
+				{ "Õ", "O" },   { "õ", "o" },
+				{ "Ø", "O" },   { "ø", "o" },
+				{ "Š", "S" },   { "š", "s" },
+				{ "ß", "ss" },
+				{ "Þ", "B" },   { "þ", "b" },
+				{ "Ú", "U" },   { "ú", "u" },
+				{ "Ù", "U" },   { "ù", "u" },
+				{ "Û", "U" },   { "û", "u" },
+				{ "Ü", "Ue" },  { "ü", "ue" },
+				{ "ÿ", "y" },
+				{ "Ý", "Y" },   { "ý", "y" },
+				{ "Ž", "Z" },   { "ž", "z" },
+			};
+
+			for (int i = 0; i < charmap.GetLength(0); i++)
+			{
+				input = input.Replace(charmap[i, 0], charmap[i, 1]);
+			}
+
+			return input;
+		}
+
+		/// <summary>
+		/// Convert Cyrillic lettering to Latin lettering
+		/// </summary>
+		/// <param name="input">String to be parsed</param>
+		/// <returns>String with characters replaced</returns>
+		public static string RussianToLatin(string input)
+		{
+			string[,] charmap = {
+					{ "А", "A" }, { "Б", "B" }, { "В", "V" }, { "Г", "G" }, { "Д", "D" },
+					{ "Е", "E" }, { "Ё", "Yo" }, { "Ж", "Zh" }, { "З", "Z" }, { "И", "I" },
+					{ "Й", "J" }, { "К", "K" }, { "Л", "L" }, { "М", "M" }, { "Н", "N" },
+					{ "О", "O" }, { "П", "P" }, { "Р", "R" }, { "С", "S" }, { "Т", "T" },
+					{ "У", "U" }, { "Ф", "f" }, { "Х", "Kh" }, { "Ц", "Ts" }, { "Ч", "Ch" },
+					{ "Ш", "Sh" }, { "Щ", "Sch" }, { "Ъ", "" }, { "Ы", "y" }, { "Ь", "" },
+					{ "Э", "e" }, { "Ю", "yu" }, { "Я", "ya" }, { "а", "a" }, { "б", "b" },
+					{ "в", "v" }, { "г", "g" }, { "д", "d" }, { "е", "e" }, { "ё", "yo" },
+					{ "ж", "zh" }, { "з", "z" }, { "и", "i" }, { "й", "j" }, { "к", "k" },
+					{ "л", "l" }, { "м", "m" }, { "н", "n" }, { "о", "o" }, { "п", "p" },
+					{ "р", "r" }, { "с", "s" }, { "т", "t" }, { "у", "u" }, { "ф", "f" },
+					{ "х", "kh" }, { "ц", "ts" }, { "ч", "ch" }, { "ш", "sh" }, { "щ", "sch" },
+					{ "ъ", "" }, { "ы", "y" }, { "ь", "" }, { "э", "e" }, { "ю", "yu" },
+					{ "я", "ya" },
+			};
+
+			for (int i = 0; i < charmap.GetLength(0); i++)
+			{
+				input = input.Replace(charmap[i, 0], charmap[i, 1]);
+			}
+
+			return input;
+		}
+
+		/// <summary>
+		/// Replace special characters and patterns
+		/// </summary>
+		/// <param name="input">String to be parsed</param>
+		/// <returns>String with characters replaced</returns>
+		public static string SearchPattern(string input)
+		{
+			string[,] charmap = {
+				{ @"~", " - " },
+				{ @"_", " " },
+				{ @":", " " },
+				{ @">", ")" },
+				{ @"<", "(" },
+				{ @"\|", "-" },
+				{ "\"", "'" },
+				{ @"\*", "." },
+				{ @"\\", "-" },
+				{ @"/", "-" },
+				{ @"\?", " " },
+				{ @"\(([^)(]*)\(([^)]*)\)([^)(]*)\)", " " },
+				{ @"\(([^)]+)\)", " " },
+				{ @"\[([^]]+)\]", " " },
+				{ @"\{([^}]+)\}", " " },
+				{ @"(ZZZJUNK|ZZZ-UNK-|ZZZ-UNK |zzz unknow |zzz unk |Copy of |[.][a-z]{3}[.][a-z]{3}[.]|[.][a-z]{3}[.])", " " },
+				{ @" (r|rev|v|ver)\s*[\d\.]+[^\s]*", " " },
+				{ @"(( )|(\A))(\d{6}|\d{8})(( )|(\Z))", " " },
+				{ @"(( )|(\A))(\d{1,2})-(\d{1,2})-(\d{4}|\d{2})", " " },
+				{ @"(( )|(\A))(\d{4}|\d{2})-(\d{1,2})-(\d{1,2})", " " },
+				{ @"[-]+", "-" },
+				{ @"\A\s*\)", " " },
+				{ @"\A\s*(,|-)", " " },
+				{ @"\s+", " " },
+				{ @"\s+,", "," },
+				{ @"\s*(,|-)\s*\Z", " " },
+			};
+
+			for (int i = 0; i < charmap.GetLength(0); i++)
+			{
+				input = Regex.Replace(input, charmap[i, 0], charmap[i, 1]);
+			}
+
+			return input;
+		}
+
 		#endregion
 
 		#region String Manipulation
@@ -398,214 +527,6 @@ namespace SabreTools.Library.Tools
 
 		#endregion
 
-		#region System.IO.Path Replacements
-
-		/// <summary>
-		/// Replacement for System.IO.Path.GetDirectoryName
-		/// </summary>
-		/// <param name="s">Path to get directory name out of</param>
-		/// <returns>Directory name from path</returns>
-		/// <see cref="System.IO.Path.GetDirectoryName(string)"/>
-		public static string GetDirectoryName(string s)
-		{
-			if (s == null)
-			{
-				return "";
-			}
-
-			if (s.Contains("/"))
-			{
-				string[] tempkey = s.Split('/');
-				return String.Join("/", tempkey.Take(tempkey.Length - 1));
-			}
-			else if (s.Contains("\\"))
-			{
-				string[] tempkey = s.Split('\\');
-				return String.Join("\\", tempkey.Take(tempkey.Length - 1));
-			}
-
-			return "";
-		}
-
-		/// <summary>
-		/// Replacement for System.IO.Path.GetFileName
-		/// </summary>
-		/// <param name="s">Path to get file name out of</param>
-		/// <returns>File name from path</returns>
-		/// <see cref="System.IO.Path.GetFileName(string)"/>
-		public static string GetFileName(string s)
-		{
-			if (s == null)
-			{
-				return "";
-			}
-
-			if (s.Contains("/"))
-			{
-				string[] tempkey = s.Split('/');
-				return tempkey.Last();
-			}
-			else if (s.Contains("\\"))
-			{
-				string[] tempkey = s.Split('\\');
-				return tempkey.Last();
-			}
-
-			return s;
-		}
-
-		/// <summary>
-		/// Replacement for System.IO.Path.GetFileNameWithoutExtension
-		/// </summary>
-		/// <param name="s">Path to get file name out of</param>
-		/// <returns>File name without extension from path</returns>
-		/// <see cref="System.IO.Path.GetFileNameWithoutExtension(string)"/>
-		public static string GetFileNameWithoutExtension(string s)
-		{
-			s = GetFileName(s);
-			string[] tempkey = s.Split('.');
-			if (tempkey.Count() == 1)
-			{
-				return s;
-			}
-			return String.Join(".", tempkey.Take(tempkey.Length - 1));
-		}
-
-		#endregion
-
-		#region WoD-based String Cleaning
-
-		/// <summary>
-		/// Replace accented characters
-		/// </summary>
-		/// <param name="input">String to be parsed</param>
-		/// <returns>String with characters replaced</returns>
-		public static string NormalizeChars(string input)
-		{
-			string[,] charmap = {
-				{ "Á", "A" },   { "á", "a" },
-				{ "À", "A" },   { "à", "a" },
-				{ "Â", "A" },   { "â", "a" },
-				{ "Ä", "Ae" },  { "ä", "ae" },
-				{ "Ã", "A" },   { "ã", "a" },
-				{ "Å", "A" },   { "å", "a" },
-				{ "Æ", "Ae" },  { "æ", "ae" },
-				{ "Ç", "C" },   { "ç", "c" },
-				{ "Ð", "D" },   { "ð", "d" },
-				{ "É", "E" },   { "é", "e" },
-				{ "È", "E" },   { "è", "e" },
-				{ "Ê", "E" },   { "ê", "e" },
-				{ "Ë", "E" },   { "ë", "e" },
-				{ "ƒ", "f" },
-				{ "Í", "I" },   { "í", "i" },
-				{ "Ì", "I" },   { "ì", "i" },
-				{ "Î", "I" },   { "î", "i" },
-				{ "Ï", "I" },   { "ï", "i" },
-				{ "Ñ", "N" },   { "ñ", "n" },
-				{ "Ó", "O" },   { "ó", "o" },
-				{ "Ò", "O" },   { "ò", "o" },
-				{ "Ô", "O" },   { "ô", "o" },
-				{ "Ö", "Oe" },  { "ö", "oe" },
-				{ "Õ", "O" },   { "õ", "o" },
-				{ "Ø", "O" },   { "ø", "o" },
-				{ "Š", "S" },   { "š", "s" },
-				{ "ß", "ss" },
-				{ "Þ", "B" },   { "þ", "b" },
-				{ "Ú", "U" },   { "ú", "u" },
-				{ "Ù", "U" },   { "ù", "u" },
-				{ "Û", "U" },   { "û", "u" },
-				{ "Ü", "Ue" },  { "ü", "ue" },
-				{ "ÿ", "y" },
-				{ "Ý", "Y" },   { "ý", "y" },
-				{ "Ž", "Z" },   { "ž", "z" },
-			};
-
-			for (int i = 0; i < charmap.GetLength(0); i++)
-			{
-				input = input.Replace(charmap[i, 0], charmap[i, 1]);
-			}
-
-			return input;
-		}
-
-		/// <summary>
-		/// Convert Cyrillic lettering to Latin lettering
-		/// </summary>
-		/// <param name="input">String to be parsed</param>
-		/// <returns>String with characters replaced</returns>
-		public static string RussianToLatin(string input)
-		{
-			string[,] charmap = {
-					{ "А", "A" }, { "Б", "B" }, { "В", "V" }, { "Г", "G" }, { "Д", "D" },
-					{ "Е", "E" }, { "Ё", "Yo" }, { "Ж", "Zh" }, { "З", "Z" }, { "И", "I" },
-					{ "Й", "J" }, { "К", "K" }, { "Л", "L" }, { "М", "M" }, { "Н", "N" },
-					{ "О", "O" }, { "П", "P" }, { "Р", "R" }, { "С", "S" }, { "Т", "T" },
-					{ "У", "U" }, { "Ф", "f" }, { "Х", "Kh" }, { "Ц", "Ts" }, { "Ч", "Ch" },
-					{ "Ш", "Sh" }, { "Щ", "Sch" }, { "Ъ", "" }, { "Ы", "y" }, { "Ь", "" },
-					{ "Э", "e" }, { "Ю", "yu" }, { "Я", "ya" }, { "а", "a" }, { "б", "b" },
-					{ "в", "v" }, { "г", "g" }, { "д", "d" }, { "е", "e" }, { "ё", "yo" },
-					{ "ж", "zh" }, { "з", "z" }, { "и", "i" }, { "й", "j" }, { "к", "k" },
-					{ "л", "l" }, { "м", "m" }, { "н", "n" }, { "о", "o" }, { "п", "p" },
-					{ "р", "r" }, { "с", "s" }, { "т", "t" }, { "у", "u" }, { "ф", "f" },
-					{ "х", "kh" }, { "ц", "ts" }, { "ч", "ch" }, { "ш", "sh" }, { "щ", "sch" },
-					{ "ъ", "" }, { "ы", "y" }, { "ь", "" }, { "э", "e" }, { "ю", "yu" },
-					{ "я", "ya" },
-			};
-
-			for (int i = 0; i < charmap.GetLength(0); i++)
-			{
-				input = input.Replace(charmap[i, 0], charmap[i, 1]);
-			}
-
-			return input;
-		}
-
-		/// <summary>
-		/// Replace special characters and patterns
-		/// </summary>
-		/// <param name="input">String to be parsed</param>
-		/// <returns>String with characters replaced</returns>
-		public static string SearchPattern(string input)
-		{
-			string[,] charmap = {
-				{ @"~", " - " },
-				{ @"_", " " },
-				{ @":", " " },
-				{ @">", ")" },
-				{ @"<", "(" },
-				{ @"\|", "-" },
-				{ "\"", "'" },
-				{ @"\*", "." },
-				{ @"\\", "-" },
-				{ @"/", "-" },
-				{ @"\?", " " },
-				{ @"\(([^)(]*)\(([^)]*)\)([^)(]*)\)", " " },
-				{ @"\(([^)]+)\)", " " },
-				{ @"\[([^]]+)\]", " " },
-				{ @"\{([^}]+)\}", " " },
-				{ @"(ZZZJUNK|ZZZ-UNK-|ZZZ-UNK |zzz unknow |zzz unk |Copy of |[.][a-z]{3}[.][a-z]{3}[.]|[.][a-z]{3}[.])", " " },
-				{ @" (r|rev|v|ver)\s*[\d\.]+[^\s]*", " " },
-				{ @"(( )|(\A))(\d{6}|\d{8})(( )|(\Z))", " " },
-				{ @"(( )|(\A))(\d{1,2})-(\d{1,2})-(\d{4}|\d{2})", " " },
-				{ @"(( )|(\A))(\d{4}|\d{2})-(\d{1,2})-(\d{1,2})", " " },
-				{ @"[-]+", "-" },
-				{ @"\A\s*\)", " " },
-				{ @"\A\s*(,|-)", " " },
-				{ @"\s+", " " },
-				{ @"\s+,", "," },
-				{ @"\s*(,|-)\s*\Z", " " },
-			};
-
-			for (int i = 0; i < charmap.GetLength(0); i++)
-			{
-				input = Regex.Replace(input, charmap[i, 0], charmap[i, 1]);
-			}
-
-			return input;
-		}
-
-		#endregion
-
 		#region Externally sourced methods
 
 		/// <summary>