diff --git a/AutoTOC/AutoTOC.csproj b/AutoTOC/AutoTOC.csproj
index 6a89abb..3b75939 100644
--- a/AutoTOC/AutoTOC.csproj
+++ b/AutoTOC/AutoTOC.csproj
@@ -13,6 +13,21 @@
     <FileAlignment>512</FileAlignment>
     <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
     <TargetFrameworkProfile />
+    <PublishUrl>publish\</PublishUrl>
+    <Install>true</Install>
+    <InstallFrom>Disk</InstallFrom>
+    <UpdateEnabled>false</UpdateEnabled>
+    <UpdateMode>Foreground</UpdateMode>
+    <UpdateInterval>7</UpdateInterval>
+    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
+    <UpdatePeriodically>false</UpdatePeriodically>
+    <UpdateRequired>false</UpdateRequired>
+    <MapFileExtensions>true</MapFileExtensions>
+    <ApplicationRevision>0</ApplicationRevision>
+    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
+    <IsWebBootstrapper>false</IsWebBootstrapper>
+    <UseApplicationTrust>false</UseApplicationTrust>
+    <BootstrapperEnabled>true</BootstrapperEnabled>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <PlatformTarget>AnyCPU</PlatformTarget>
@@ -50,10 +65,25 @@
   <ItemGroup>
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="StreamIO.cs" />
+    <Compile Include="TOCBinFile.cs" />
+    <Compile Include="TOCCreator.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />
   </ItemGroup>
+  <ItemGroup>
+    <BootstrapperPackage Include=".NETFramework,Version=v4.8">
+      <Visible>False</Visible>
+      <ProductName>Microsoft .NET Framework 4.8 %28x86 and x64%29</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1</ProductName>
+      <Install>false</Install>
+    </BootstrapperPackage>
+  </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.
diff --git a/AutoTOC/Program.cs b/AutoTOC/Program.cs
index df953c0..98366f0 100644
--- a/AutoTOC/Program.cs
+++ b/AutoTOC/Program.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
@@ -12,36 +13,24 @@ namespace AutoTOC
 {
     class Program
     {
-        enum MEGame
-        {
-            ME3,
-            LE1,
-            LE2,
-            LE3
-        }
-
         static void Main(string[] args)
         {
             string gameDir;
+            MEGame game = MEGame.ME3;
 
             if (args.Length == 1)
             {
-                // Path is passed in, hopefully is game root directory or .exe
+                // Path is passed in, hopefully is game .exe
                 gameDir = args[0];
-                if (gameDir.EndsWith("\""))
+                if (gameDir.EndsWith(".exe"))
                 {
-                    gameDir = gameDir.Remove(gameDir.Length - 1);
-                }
-                else if (gameDir.EndsWith(".exe"))
-                {
-                    gameDir = GetGamepathFromExe(gameDir);
+                    (gameDir, game) = GetGamepathFromExe(gameDir);
                 }
             }
             else if (args.Length == 2 && args[0] == "-r")
             {
                 try {
-                    MEGame game = (MEGame)Enum.Parse(typeof(MEGame), args[1], true);
-
+                    game = (MEGame)Enum.Parse(typeof(MEGame), args[1], true);
                     gameDir = GetGamepathFromRegistry(game);
                     if(game != MEGame.ME3)
                     {
@@ -72,18 +61,18 @@ static void Main(string[] args)
             }
             else
             {
-                Console.WriteLine("Requires one argument: the install dir or .exe of the game you're trying to TOC.");
-                Console.WriteLine("(eg. \"D:\\Origin Games\\Mass Effect Legendary Edition\\ME3\")");
+                Console.WriteLine("Requires one argument: .exe of the game you're trying to TOC.");
+                Console.WriteLine("(eg. \"D:\\Origin Games\\Mass Effect Legendary Edition\\ME3\\Binaries\\Win64\\MassEffect3.exe)");
                 Console.WriteLine("Detect game from registry with -r {game}. Options: ME3, LE1, LE2, LE3");
                 return;
             }
 
             Console.WriteLine($"Generating TOCs for {gameDir}");
-            GenerateTocFromGamedir(gameDir);
+            GenerateTocFromGamedir(gameDir, game);
             Console.WriteLine("Done!");
         }
 
-        static void GenerateTocFromGamedir(string gameDir)
+        static void GenerateTocFromGamedir(string gameDir, MEGame game)
         {
             string baseDir = Path.Combine(gameDir, @"BIOGame\");
             string dlcDir = Path.Combine(baseDir, @"DLC\");
@@ -97,151 +86,54 @@ static void GenerateTocFromGamedir(string gameDir)
             {
                 Console.WriteLine("DLC folder not detected, TOCing basegame only...");
             }
-            Task.WhenAll(folders.Select(loc => TOCAsync(loc))).Wait();
+            Task.WhenAll(folders.Select(loc => TOCAsync(loc, game))).Wait();
         }
 
-        static Task TOCAsync(string tocLoc)
+        static Task TOCAsync(string tocLoc, MEGame game)
         {
-            return Task.Run(() => PrepareToCreateTOC(tocLoc));
+            return Task.Run(() => CreateTOC(tocLoc, game));
         }
 
-        static void PrepareToCreateTOC(string consoletocFile)
+        static void CreateTOC(string tocLoc, MEGame game)
         {
-            if (!consoletocFile.EndsWith("\\")) consoletocFile += "\\";
-            List<string> files = GetFiles(consoletocFile);
-
-            if (files.Count > 0)
-            {
-                string t = files[0];
-                int n = t.LastIndexOf("DLC_");
-                if (n > 0)
-                {
-                    for (int i = 0; i < files.Count; i++)
-                        files[i] = files[i].Substring(n);
-                    string t2 = files[0];
-                    n = t2.IndexOf("\\");
-                    for (int i = 0; i < files.Count; i++)
-                        files[i] = files[i].Substring(n + 1);
-                }
-                else
-                {
-                    n = t.LastIndexOf("BIOGame");
-                    if (n > 0)
-                    {
-                        for (int i = 0; i < files.Count; i++)
-                            files[i] = files[i].Substring(n);
-                    }
-                }
-                string pathbase;
-                string t3 = files[0];
-                int n2 = t3.LastIndexOf("BIOGame");
-                if (n2 >= 0)
-                {
-                    pathbase = Path.GetDirectoryName(Path.GetDirectoryName(consoletocFile)) + "\\";
-                }
-                else
-                {
-                    pathbase = consoletocFile;
-                }
-                CreateTOC(pathbase, consoletocFile + "PCConsoleTOC.bin", files.ToArray());
-            }
-        }
-
-        static void CreateTOC(string basepath, string tocFile, string[] files)
-        {
-            FileStream fs = new FileStream(tocFile, FileMode.Create, FileAccess.Write);
-            long selfSizePosition = -1;
-            fs.Write(BitConverter.GetBytes((int)0x3AB70C13), 0, 4);
-            fs.Write(BitConverter.GetBytes((int)0x0), 0, 4);
-            fs.Write(BitConverter.GetBytes((int)0x1), 0, 4);
-            fs.Write(BitConverter.GetBytes((int)0x8), 0, 4);
-            fs.Write(BitConverter.GetBytes((int)files.Length), 0, 4);
-            for (int i = 0; i < files.Length; i++)
-            {
-                string file = files[i];
-                if (i == files.Length - 1)//Entry Size
-                    fs.Write(new byte[2], 0, 2);
-                else
-                    fs.Write(BitConverter.GetBytes((ushort)(0x1D + file.Length)), 0, 2);
-                fs.Write(BitConverter.GetBytes((ushort)0), 0, 2);//Flags
-                if (Path.GetFileName(file).ToLower() != "pcconsoletoc.bin")
-                {
-                    fs.Write(BitConverter.GetBytes((int) (new FileInfo(basepath + file).Length)), 0, 4);//Filesize
-                }
-                else
-                {
-                    selfSizePosition = fs.Position;
-                    fs.Write(BitConverter.GetBytes((int)0), 0, 4);//Filesize
-                }
-                fs.Write(BitConverter.GetBytes((int)0x0), 0, 4);//SHA1
-                fs.Write(BitConverter.GetBytes((int)0x0), 0, 4);
-                fs.Write(BitConverter.GetBytes((int)0x0), 0, 4);
-                fs.Write(BitConverter.GetBytes((int)0x0), 0, 4);
-                fs.Write(BitConverter.GetBytes((int)0x0), 0, 4);
-                foreach (char c in file)
-                    fs.WriteByte((byte)c);
-                fs.WriteByte(0);
-            }
-            if (selfSizePosition >= 0)
-            {
-                // Write the size of our own TOC. This ensures TOC appears up to date when we try to update it later
-                // (important for DLC TOCs)
-                fs.Seek(selfSizePosition, SeekOrigin.Begin);
-                fs.Write(BitConverter.GetBytes((int)fs.Length), 0, 4);
-            }
-            fs.Close();
-        }
-
-        static List<string> GetFiles(string basefolder)
-        {
-            List<string> res = new List<string>();
-            string test = Path.GetFileName(Path.GetDirectoryName(basefolder));
-            string[] files = GetTocableFiles(basefolder);
-            res.AddRange(files);
-            DirectoryInfo folder = new DirectoryInfo(basefolder);
-            DirectoryInfo[] folders = folder.GetDirectories();
-            if (folders.Length != 0)
-                if (test != "BIOGame")
-                    foreach (DirectoryInfo f in folders)
-                        res.AddRange(GetFiles(basefolder + f.Name + "\\"));
-                else
-                    foreach (DirectoryInfo f in folders)
-                        if (f.Name == "CookedPCConsole" || f.Name == "Movies" || f.Name == "Splash")
-                            res.AddRange(GetFiles(Path.Combine(basefolder, f.Name)));
-                        else if (f.Name == "Content")
-                            res.AddRange(GetFiles(Path.Combine(basefolder, f.Name, "Packages\\ISACT")));
-            
-            return res;
-        }
-
-        static string[] Pattern = { "*.pcc", "*.afc", "*.bik", "*.bin", "*.tlk", "*.txt", "*.cnd", "*.upk", "*.tfc", "*.isb" };
-
-        static string[] GetTocableFiles(string path)
-        {
-            List<string> res = new List<string>();
-            foreach (string s in Pattern)
-                res.AddRange(Directory.GetFiles(path, s));
-            return res.ToArray();
+            var TOC = TOCCreator.CreateTOCForDirectory(tocLoc, game);
+            TOC.WriteToFile(Path.Combine(tocLoc, "PCConsoleTOC.bin"));
         }
 
         static string[] ValidExecutables = { "MassEffect1.exe", "MassEffect2.exe", "MassEffect3.exe" };
 
-        static string GetGamepathFromExe(string path)
+        static (string, MEGame) GetGamepathFromExe(string path)
         {
-            if(path != null && ValidExecutables.Any((exe) => path.EndsWith(exe)))
+            if(File.Exists(path) && ValidExecutables.Any((exe) => path.EndsWith(exe)))
             {
-                return path.Substring(0, path.LastIndexOf("Binaries", StringComparison.OrdinalIgnoreCase));
+                var dir = path.Substring(0, path.LastIndexOf("Binaries", StringComparison.OrdinalIgnoreCase));
+                if (path.EndsWith(ValidExecutables[0])) return (dir, MEGame.LE1);
+                if (path.EndsWith(ValidExecutables[1])) return (dir, MEGame.LE2);
+                if (path.EndsWith(ValidExecutables[2]))
+                {
+                    var versionInfo = FileVersionInfo.GetVersionInfo(path);
+                    if (versionInfo.FileVersion.StartsWith("1")) return (dir, MEGame.ME3);
+                    else return (dir, MEGame.LE3);
+                }
+                // Should never get here
+                throw new ArgumentException("Executable file is not a supported Mass Effect game.");
             }
-            else throw new ArgumentException("Executable file is not a supported Mass Effect game.");
+            throw new ArgumentException("Executable file is not a supported Mass Effect game.");
         }
 
         static string GetGamepathFromRegistry(MEGame game)
         {
             if(game != MEGame.ME3)
             {
-                // Get LE path from registry
-                string hkey64 = @"HKEY_LOCAL_MACHINE\SOFTWARE\BioWare\Mass Effect Legendary Edition";
-                return (string)Registry.GetValue(hkey64, "Install Dir", null);
+                string hkey64 = @"HKEY_LOCAL_MACHINE\SOFTWARE\BioWare\Mass Effectâ„¢ Legendary Edition"; // Yes all that weird garbage in this name is required... but not for everyone
+                string test = (string)Registry.GetValue(hkey64, "Install Dir", null);
+                if (test != null)
+                {
+                    return test;
+                }
+                hkey64 = @"HKEY_LOCAL_MACHINE\SOFTWARE\BioWare\Mass Effect Legendary Edition"; //For those without weird garbage
+                test = (string)Registry.GetValue(hkey64, "Install Dir", null);
+                return test;
             }
             else
             {
diff --git a/AutoTOC/Properties/AssemblyInfo.cs b/AutoTOC/Properties/AssemblyInfo.cs
index c7bff01..d8bd842 100644
--- a/AutoTOC/Properties/AssemblyInfo.cs
+++ b/AutoTOC/Properties/AssemblyInfo.cs
@@ -32,5 +32,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("2.0.*")]
-[assembly: AssemblyFileVersion("2.0.1.0")]
+[assembly: AssemblyVersion("2.1.*")]
+[assembly: AssemblyFileVersion("2.1.0.0")]
diff --git a/AutoTOC/StreamIO.cs b/AutoTOC/StreamIO.cs
new file mode 100644
index 0000000..cc394c9
--- /dev/null
+++ b/AutoTOC/StreamIO.cs
@@ -0,0 +1,245 @@
+/*
+ * C# Stream Helpers
+ *
+ * Copyright (C) 2015-2018 Pawel Kolodziejski
+ * Copyright (C) 2019 ME3Explorer
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+/*
+ *  This is modified code from the LegendaryExplorerCore codebase
+ *  Taken from LEC on 2021/6/10, at https://github.com/ME3Tweaks/ME3Explorer/commit/0e01b9cfb85668a775afa22ba268e94b525ddc2e
+ */
+
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Text;
+
+namespace AutoTOC
+{
+    public static class StreamHelpers
+    {
+
+        public static byte[] ReadToBuffer(this Stream stream, int count)
+        {
+            var buffer = new byte[count];
+            if (stream.Read(buffer, 0, count) != count)
+                throw new Exception("Stream read error!");
+            return buffer;
+        }
+
+        public static byte[] ReadToBuffer(this Stream stream, uint count)
+        {
+            return stream.ReadToBuffer((int)count);
+        }
+
+        public static byte[] ReadToBuffer(this Stream stream, long count)
+        {
+            return stream.ReadToBuffer((int)count);
+        }
+
+        public static void WriteFromBuffer(this Stream stream, byte[] buffer)
+        {
+            stream.Write(buffer, 0, buffer.Length);
+        }
+
+        public static void WriteGuid(this Stream stream, Guid value)
+        {
+            var data = value.ToByteArray();
+
+            Debug.Assert(data.Length == 16);
+
+            stream.WriteInt32(BitConverter.ToInt32(data, 0));
+            stream.WriteInt16(BitConverter.ToInt16(data, 4));
+            stream.WriteInt16(BitConverter.ToInt16(data, 6));
+            stream.Write(data, 8, 8);
+        }
+
+
+        public static void WriteToFile(this MemoryStream stream, string outfile)
+        {
+            long oldPos = stream.Position;
+            stream.Position = 0;
+            using (FileStream file = new FileStream(outfile, FileMode.Create, System.IO.FileAccess.Write))
+                stream.CopyTo(file);
+            stream.Position = oldPos;
+        }
+
+        public static void WriteFromStream(this Stream stream, Stream inputStream, int count)
+        {
+            var buffer = new byte[0x10000];
+            do
+            {
+                int readed = inputStream.Read(buffer, 0, Math.Min(buffer.Length, count));
+                if (readed > 0)
+                    stream.Write(buffer, 0, readed);
+                else
+                    break;
+                count -= readed;
+            } while (count != 0);
+        }
+
+        public static void WriteFromStream(this Stream stream, Stream inputStream, uint count)
+        {
+            WriteFromStream(stream, inputStream, (int)count);
+        }
+
+        public static void WriteFromStream(this Stream stream, Stream inputStream, long count)
+        {
+            WriteFromStream(stream, inputStream, (int)count);
+        }
+
+        public static string ReadStringLatin1Null(this Stream stream)
+        {
+            string str = "";
+            for (; ; )
+            {
+                char c = (char)stream.ReadByte();
+                if (c == 0)
+                    break;
+                str += c;
+            }
+            return str;
+        }
+
+        public static string ReadStringUnicode(this Stream stream, int count)
+        {
+            var buffer = stream.ReadToBuffer(count);
+            return Encoding.Unicode.GetString(buffer);
+        }
+
+        public static string ReadStringUnicodeNull(this Stream stream, int count)
+        {
+            return stream.ReadStringUnicode(count).Trim('\0');
+        }
+
+        // DO NOT REMOVE ASCII CODE
+        #region ASCII SUPPORT
+        public static string ReadStringASCII(this Stream stream, int count)
+        {
+            byte[] buffer = stream.ReadToBuffer(count);
+            return Encoding.ASCII.GetString(buffer);
+        }
+
+        public static string ReadStringASCIINull(this Stream stream)
+        {
+            string str = "";
+            for (; ; )
+            {
+                char c = (char)stream.ReadByte();
+                if (c == 0)
+                    break;
+                str += c;
+            }
+            return str;
+        }
+
+        public static string ReadStringASCIINull(this Stream stream, int count)
+        {
+            return stream.ReadStringASCII(count).Trim('\0');
+        }
+
+        public static void WriteStringASCII(this Stream stream, string str)
+        {
+            stream.Write(Encoding.ASCII.GetBytes(str), 0, Encoding.ASCII.GetByteCount(str));
+        }
+
+        public static void WriteStringASCIINull(this Stream stream, string str)
+        {
+            stream.WriteStringASCII(str + "\0");
+        }
+
+        #endregion
+
+        public static void WriteStringUnicode(this Stream stream, string str)
+        {
+            stream.Write(Encoding.Unicode.GetBytes(str), 0, Encoding.Unicode.GetByteCount(str));
+        }
+
+        public static void WriteStringUnicodeNull(this Stream stream, string str)
+        {
+            stream.WriteStringUnicode(str);
+            stream.WriteByte(0);
+            stream.WriteByte(0);
+        }
+
+        public static void WriteUInt64(this Stream stream, ulong data)
+        {
+            stream.Write(BitConverter.GetBytes(data), 0, sizeof(ulong));
+        }
+
+        public static void WriteInt64(this Stream stream, long data)
+        {
+            stream.Write(BitConverter.GetBytes(data), 0, sizeof(long));
+        }
+
+        public static void WriteUInt32(this Stream stream, uint data)
+        {
+            stream.Write(BitConverter.GetBytes(data), 0, sizeof(uint));
+        }
+
+        public static void WriteInt32(this Stream stream, int data)
+        {
+            stream.Write(BitConverter.GetBytes(data), 0, sizeof(int));
+        }
+
+        /// <summary>
+        /// Writes the stream to file from the beginning. This should only be used on streams that support seeking. The position is restored after the file has been written.
+        /// </summary>
+        /// <param name="stream">Stream to write from</param>
+        /// <param name="outfile">File to write to</param>
+        public static void WriteToFile(this Stream stream, string outfile)
+        {
+            long oldPos = stream.Position;
+            stream.Position = 0;
+            using (var file = new FileStream(outfile, FileMode.Create, System.IO.FileAccess.Write))
+                stream.CopyTo(file);
+            stream.Position = oldPos;
+        }
+
+        public static void WriteUInt16(this Stream stream, ushort data)
+        {
+            stream.Write(BitConverter.GetBytes(data), 0, sizeof(ushort));
+        }
+
+        public static void WriteInt16(this Stream stream, short data)
+        {
+            stream.Write(BitConverter.GetBytes(data), 0, sizeof(short));
+        }
+
+        public static void WriteDouble(this Stream stream, double data)
+        {
+            stream.Write(BitConverter.GetBytes(data), 0, sizeof(double));
+        }
+
+        private const int DefaultBufferSize = 8 * 1024;
+
+        public static void WriteZeros(this Stream stream, uint count)
+        {
+            for (int i = 0; i < count; i++)
+                stream.WriteByte(0);
+        }
+
+        public static void WriteZeros(this Stream stream, int count)
+        {
+            WriteZeros(stream, (uint)count);
+        }
+
+        private static void ThrowEndOfStreamException() => throw new EndOfStreamException();
+    }
+}
diff --git a/AutoTOC/TOCBinFile.cs b/AutoTOC/TOCBinFile.cs
new file mode 100644
index 0000000..eaa140c
--- /dev/null
+++ b/AutoTOC/TOCBinFile.cs
@@ -0,0 +1,244 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+
+/*
+ *  This is modified code from the LegendaryExplorerCore codebase
+ *  Taken from LEC on 2021/6/10, at https://github.com/ME3Tweaks/ME3Explorer/commit/0e01b9cfb85668a775afa22ba268e94b525ddc2e
+ */
+
+namespace AutoTOC
+{
+    // Todo: Convert to EndianReader
+    public class TOCBinFile
+    {
+        public const int TOCMagicNumber = 0x3AB70C13;
+
+        /// <summary>
+        /// Single entry in TOC file, contained in a hash bucket
+        /// </summary>
+        [DebuggerDisplay("TOCEntry 0x{offset.ToString(\"8\")}, {name}, file size {size}")]
+        public class Entry
+        {
+            /// <summary>
+            /// Offset of the entry. Not used for writing to disk, only for reading in
+            /// </summary>
+            public int offset;
+
+            /// <summary>
+            /// Size of this entry on disk. Not used for writing to disk, only for reading in
+            /// </summary>
+            public int entrydisksize;
+
+            /// <summary>
+            /// Flags for the file. It's a bitmask
+            /// </summary>
+            public short flags;
+
+            /// <summary>
+            /// Size of the file in bytes
+            /// </summary>
+            public int size;
+
+            /// <summary>
+            /// The SHA1 of the file. Not used if the flag for SHA1 is not set
+            /// </summary>
+            public byte[] sha1;
+
+            /// <summary>
+            /// The relative path of the file
+            /// </summary>
+            public string name;
+
+            /// <summary>
+            /// Size this entry consumes on disk with byte alignment
+            /// </summary>
+            public short ToCSize
+            {
+                get
+                {
+                    short memSize = MemorySize;
+                    return (short)
+                        (memSize // Base size of the object
+                         + ((memSize % 4 == 0) ? 0 : (4 - (memSize % 4))));    // Padding to 4 byte alignment.
+                }
+            }
+
+            /// <summary>
+            /// Size this entry alone consumes in memory.
+            /// </summary>
+            public short MemorySize
+            {
+                get
+                {
+                    return (short)
+                        (2 * sizeof(short) // ToCSize, Flags
+                         + 1 * sizeof(int)    // Filesize
+                         + 20 // SHA1
+                              // DVD information (not used on PC)
+                              //+ Sectors.Length * sizeof(int) // integer for each sector
+                         + (name.Length + 1));    // String + Null Terminator
+                }
+            }
+
+            /// <summary>
+            /// Writes this entry out to the stream
+            /// </summary>
+            /// <param name="fs">Stream to write to</param>
+            /// <param name="dontWriteEntrySize">If ToCSize should be written out. The final entry in the TOC file will not write this out</param>
+            /// <param name="byteAligned">If entries should byte align the next entry. ME3 does not use byte alignment, LE games do</param>
+            public void WriteOut(MemoryStream fs, bool dontWriteEntrySize)
+            {
+                var expectedEndPos = (int)fs.Position + ToCSize;
+                fs.WriteInt16(dontWriteEntrySize ? (short)0 : ToCSize);
+                fs.WriteInt16(flags);
+                fs.WriteInt32(size);
+                if (sha1 != null)
+                    fs.Write(sha1,0,sha1.Length);
+                else
+                    fs.WriteZeros(20); // must not have flag for CRC
+
+                fs.WriteStringASCIINull(name);
+                var padding = expectedEndPos - fs.Position;
+                fs.WriteZeros((int)padding); // Byte align
+            }
+        }
+
+        public List<TOCHashTableEntry> HashBuckets = new List<TOCHashTableEntry>();
+
+        public TOCBinFile()
+        {
+        }
+
+        public class TOCHashTableEntry
+        {
+            internal int offset { get; set; }
+            internal int entrycount { get; set; }
+            internal List<Entry> TOCEntries { get; } = new List<Entry>();
+        }
+
+        /*
+        public void ReadFile(MemoryStream ms)
+        {
+            var reader = new EndianReader(ms);
+            uint magic = (uint)reader.ReadInt32();
+            if (magic != TOCMagicNumber)
+            {
+                throw new Exception("Not a TOC file, bad magic header");
+            }
+
+            var mediaTableCount = reader.ReadInt32(); // Should be 0
+            var hashTableCount = reader.ReadInt32();
+
+            long maxReadValue = 0;
+            for (int i = 0; i < hashTableCount; i++)
+            {
+                var pos = reader.Position;
+                var newEntry = new TOCHashTableEntry()
+                {
+                    offset = reader.ReadInt32(),
+                    entrycount = reader.ReadInt32(),
+                };
+                HashBuckets.Add(newEntry);
+
+                var resumePosition = reader.Position;
+                // Read Entries
+
+                reader.Position = newEntry.offset + pos;
+                for (int j = 0; j < newEntry.entrycount; j++)
+                {
+
+                    Entry e = new()
+                    {
+                        offset = (int)reader.Position,
+                        entrydisksize = reader.ReadInt16(),
+                        flags = reader.ReadInt16(),
+                        size = reader.ReadInt32(),
+                        sha1 = reader.ReadToBuffer(0x14), // 20
+                        name = reader.ReadStringASCIINull()
+                    };
+
+                    reader.Seek(e.offset + e.entrydisksize, SeekOrigin.Begin);
+
+                    maxReadValue = Math.Max(maxReadValue, reader.Position);
+
+                    newEntry.TOCEntries.Add(e);
+                }
+
+                reader.Position = resumePosition;
+            }
+        } */
+
+
+        public void UpdateEntry(int Index, int size)
+        {
+            // Uhhhhhhhhhhhh
+            // Not sure how useful this is
+            throw new NotImplementedException("Not implemented in LEC right now");
+            //if (Entries == null || Index < 0 || Index >= Entries.Count)
+            //    return;
+            //Entry e = Entries[Index];
+            //e.size = size;
+            //Entries[Index] = e;
+        }
+
+        public MemoryStream Save()
+        {
+            var lastBucketWithEntries = HashBuckets.LastOrDefault(x => x.TOCEntries.Any());
+
+            MemoryStream fs = new MemoryStream();
+
+            fs.WriteInt32(TOCBinFile.TOCMagicNumber); // Endian check
+            fs.WriteInt32(0x0); // Media Data Count
+            fs.WriteInt32(HashBuckets.Count); // Hash Table Count
+
+            var hashTableStartPos = fs.Position;
+
+            // Skip the hash table for now, we will come back and rewrite it
+            fs.Seek((int)HashBuckets.Count * 8, SeekOrigin.Current);
+
+            for (int i = 0; i < HashBuckets.Count; i++)
+            {
+                var hb = HashBuckets[i];
+
+                var hbEntryStartPos = fs.Position;
+                for (int j = 0; j < hb.TOCEntries.Count; j++)
+                {
+                    var entry = hb.TOCEntries[j];
+                    var dontWriteEntrySize = hb == lastBucketWithEntries && j == (hb.TOCEntries.Count - 1);
+                    entry.WriteOut(fs, dontWriteEntrySize); // byte aligns automatically
+                }
+
+
+
+                var nextEntryPos = fs.Position;
+
+                // Update hash table info
+                fs.Seek(hashTableStartPos + (i * 8), SeekOrigin.Begin);
+                if (hb.TOCEntries.Any())
+                {
+                    var firstEntryOffset = (int)(hbEntryStartPos - fs.Position);
+                    fs.WriteInt32(firstEntryOffset); // Offset from hash entry to first TOC file entry
+                    fs.WriteInt32(hb.TOCEntries.Count); // How many files have this hash
+                }
+                else
+                {
+                    fs.WriteInt32(0); // No Offset
+                    fs.WriteInt32(0); // 0 Entries
+                }
+
+                fs.Seek(nextEntryPos, SeekOrigin.Begin);
+            }
+            return fs;
+        }
+
+        /// <summary>
+        /// Gets a list of all entries, without hash table information
+        /// </summary>
+        /// <returns></returns>
+        public List<Entry> GetAllEntries() => HashBuckets.Where(x => x.TOCEntries.Any()).SelectMany(x => x.TOCEntries).ToList();
+    }
+}
diff --git a/AutoTOC/TOCCreator.cs b/AutoTOC/TOCCreator.cs
new file mode 100644
index 0000000..a6b9c37
--- /dev/null
+++ b/AutoTOC/TOCCreator.cs
@@ -0,0 +1,221 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+/*
+ *  This is modified code from the LegendaryExplorerCore codebase
+ *  Taken from LEC on 2021/6/10, at https://github.com/ME3Tweaks/ME3Explorer/commit/0e01b9cfb85668a775afa22ba268e94b525ddc2e
+ */
+
+namespace AutoTOC
+{
+    public enum MEGame
+    {
+        ME3,
+        LE1,
+        LE2,
+        LE3
+    }
+
+    /// <summary>
+    /// Class for generating TOC files
+    /// </summary>
+    public class TOCCreator
+    {
+        /// <summary>
+        /// Returns the files in a given directory that match the pattern of a TOCable file
+        /// </summary>
+        /// <param name="path"></param>
+        /// <returns></returns>
+        public static IEnumerable<string> GetTocableFiles(string path)
+        {
+            string[] Pattern = { "*.pcc", "*.afc", "*.bik", "*.bin", "*.tlk", "*.cnd", "*.upk", "*.tfc", "*.isb", "*.usf" };
+            var res = new List<string>();
+            foreach (string s in Pattern)
+                res.AddRange(Directory.GetFiles(path, s));
+            return res;
+        }
+
+        /// <summary>
+        /// Recursively finds all TOCable files in a directory and it's subfolders
+        /// </summary>
+        /// <param name="basefolder"></param>
+        /// <returns></returns>
+        private static List<string> GetFiles(string basefolder, bool isLE2LE3)
+        {
+            var res = new List<string>();
+            string directoryName = Path.GetFileName(Path.GetDirectoryName(basefolder));
+            // Do not include the directory's existing PCConsoleTOC.bin
+            res.AddRange(GetTocableFiles(basefolder).Except(new[] { Path.Combine(basefolder, "PCConsoleTOC.bin") }, StringComparer.InvariantCultureIgnoreCase));
+            DirectoryInfo folder = new DirectoryInfo(basefolder);
+            var folders = folder.GetDirectories();
+            if (folders.Length != 0)
+            {
+                if (!directoryName.Equals("BioGame", StringComparison.InvariantCultureIgnoreCase))
+                {
+                    //treat as dlc and include all folders.
+                    foreach (DirectoryInfo f in folders)
+                        res.AddRange(GetFiles(Path.Combine(basefolder, f.Name), isLE2LE3));
+                }
+                else
+                {
+                    //biogame, only do cookedpcconsole and movies.
+                    foreach (DirectoryInfo f in folders)
+                    {
+                        if (f.Name == "CookedPCConsole" || f.Name == "Movies")
+                            res.AddRange(GetFiles(Path.Combine(basefolder, f.Name), isLE2LE3));
+                        else if (isLE2LE3 && f.Name == "DLC")
+                            res.AddRange(GetFiles(Path.Combine(basefolder, f.Name), isLE2LE3));  // may need updated when we get LE1 DLC system up
+                        else if (f.Name == "Content")
+                            res.AddRange(GetFiles(Path.Combine(basefolder, f.Name, "Packages", "ISACT"), isLE2LE3));
+
+                    }
+                }
+            }
+
+            return res;
+        }
+
+
+        /// <summary>
+        /// Creates the binary for a TOC file for a specified directory root
+        /// </summary>
+        /// <param name="directory">DLC_ directory, like DLC_CON_JAM, or the BIOGame directory of the game.</param>
+        /// <param name="game"></param>
+        /// <returns>Memorystream of TOC created, null if there are no entries or input was invalid</returns>
+        public static MemoryStream CreateTOCForDirectory(string directory, MEGame game)
+        {
+            bool isLe2Le3 = game == MEGame.LE2 || game == MEGame.LE3;
+            var files = GetFiles(directory, isLe2Le3);
+            var originalFilesList = files;
+            if (files.Count > 0)
+            {
+                //Strip the non-relative path information
+                string file0fullpath = files[0];
+                int dlcFolderStartSubStrPos = file0fullpath.IndexOf("DLC_", StringComparison.InvariantCultureIgnoreCase);
+                if (dlcFolderStartSubStrPos > 0)
+                {
+                    // DLC TOC
+                    files = files.Select(x => x.Substring(dlcFolderStartSubStrPos)).ToList();
+                    files = files.Select(x => x.Substring(x.IndexOf(Path.DirectorySeparatorChar) + 1)).ToList(); //remove first slash
+                }
+                else
+                {
+                    // Basegame TOC
+                    int biogameStrPos = file0fullpath.IndexOf("BIOGame", StringComparison.InvariantCultureIgnoreCase);
+                    if (game != MEGame.ME3)
+                    {
+                        files.AddRange(GetFiles(Path.Combine(directory.Substring(0, biogameStrPos), "Engine", "Shaders"), isLe2Le3));
+                        //TODO: is this required? It seems to include some DLC files in the TOC, but not all?
+                        //if (game is MEGame.LE3)
+                        //{
+
+                        //    var dlcFolders = new DirectoryInfo(Path.Combine(directory, "DLC")).GetDirectories();
+                        //    files.AddRange(dlcFolders.Where(f => f.Name.StartsWith("DLC_", StringComparison.OrdinalIgnoreCase)).Select(f => f.ToString())
+                        //                             .SelectMany(dlcDir => GetFiles(dlcDir, isLe2Le3)));
+                        //}
+                    }
+                    if (biogameStrPos > 0)
+                    {
+                        files = files.Select(x => x.Substring(biogameStrPos)).ToList();
+                    }
+                }
+
+                var entries = originalFilesList.Select((t, i) => (files[i], (int)new FileInfo(t).Length)).ToList();
+
+                return CreateTOCForEntries(entries);
+            }
+            throw new Exception("There are no TOCable files in the specified directory.");
+        }
+
+        /// <summary>
+        /// Creates the binary for a TOC file for a specified list of filenames and sizes. The filenames should already be in the format that will be used in the TOC itself.
+        /// </summary>
+        /// <param name="filesystemInfo">list of filenames and sizes for the TOC</param>
+        /// <returns>memorystream of TOC, null if list is empty</returns>
+        public static MemoryStream CreateTOCForEntries(List<(string filename, int size)> filesystemInfo)
+        {
+            if (filesystemInfo.Count != 0)
+            {
+                var tbf = new TOCBinFile();
+
+                // Todo: Update this someday so it lines up with the actual correct implementation
+                var hashBucket = new TOCBinFile.TOCHashTableEntry();
+                tbf.HashBuckets.Add(hashBucket);
+                hashBucket.TOCEntries.AddRange(filesystemInfo.Select(x => new TOCBinFile.Entry
+                {
+                    flags = 0,
+                    name = x.filename,
+                    size = x.size
+                }));
+
+                return tbf.Save();
+            }
+
+            return null;
+            /*
+            MemoryStream fs = MemoryManager.GetMemoryStream();
+
+                fs.WriteInt32(TOCBinFile.TOCMagicNumber); // Endian check
+                fs.WriteInt32(0x0); // Media Data Count
+                fs.WriteInt32(0x1); // Hash Table Count
+
+                // TOCHashTableEntry (Only have 1 entry)
+                fs.WriteInt32(0x8); // Offset of first entry from 
+                fs.WriteInt32(filesystemInfo.Count); // Number of files in this table
+
+                for (int i = 0; i < filesystemInfo.Count; i++)
+                {
+
+                    // TOCFileEntry - 4 Byte Aligned
+                    (string file, int size) entry = filesystemInfo[i];
+
+                    // Next Entry Offset
+                    if (i == filesystemInfo.Count - 1) // Last entry has no next offset
+                        fs.WriteAligned(BitConverter.GetBytes((ushort)0), 0, 2, 4);
+                    else
+                        fs.WriteAligned(BitConverter.GetBytes((ushort)entry.file.Length), 0, 2, 4);
+
+                    //nextEntryOffsetPos = fs.Position;
+                    fs.WriteUInt16((ushort)(0x1D + entry.file.Length)); // Next entry start offset
+
+                    // Flags
+                    fs.WriteUInt16(0);
+
+                    // FileSize
+                    if (!Path.GetFileName(entry.file).Equals("PCConsoleTOC.bin", StringComparison.InvariantCultureIgnoreCase))
+                    {
+                        fs.WriteInt32(entry.size);
+                    }
+                    else
+                    {
+                        selfSizePosition = fs.Position; // Save self-position so we can rewrite our own file size at the end
+                        fs.WriteInt32(0);
+                    }
+
+                    // SHA1 - Not used by games...
+                    fs.WriteZeros(20);
+                    fs.WriteStringLatin1(entry.file); // Not present in hash table?
+
+                    // Old method
+                    //foreach (char c in file)
+                    //    fs.WriteByte((byte)c);
+                    fs.WriteByte(0);
+                }
+
+                if (selfSizePosition >= 0)
+                {
+                    // Write the size of our own TOC. This ensures TOC appears up to date when we try to update it later
+                    // (important for DLC TOCs)
+                    fs.Seek(selfSizePosition, SeekOrigin.Begin);
+                    fs.WriteInt32((int)fs.Length);
+                }
+
+                return fs;
+            }
+
+            return null;*/
+        }
+    }
+}
\ No newline at end of file
diff --git a/README.md b/README.md
index 80b1055..c56ca1e 100644
--- a/README.md
+++ b/README.md
@@ -1,12 +1,12 @@
 # AutoTOC
 Standalone program to create the PCConsoleTOC.bin files for ME3 and Mass Effect Legendary Edition.
 
-Run from the command line, just pass it the root ME3 folder or .exe, and it will generate a TOC for the base game and all DLCs.
+Run from the command line, pass it the game executable, and it will generate a TOC for the base game and all DLCs.
 
-eg. ```.\AutoTOC.exe "C:\Program Files (x86)\Origin Games\Mass Effect 3"```
+eg. ```.\AutoTOC.exe "C:\Program Files (x86)\Origin Games\Mass Effect 3\Binaries\Win32\MassEffect3.exe"```
 
 You can also drag a game executable file directly onto AutoTOC in Windows Explorer to TOC.
 
-You can use the registry detection feature with the -r flag and the game you're trying to TOC.
+You can use the registry detection feature with the -r flag and the game you're trying to TOC. Game options are ME3, LE1, LE2, and LE3.
 
 eg: ```.\AutoTOC.exe -r LE2```