Add other known blank values

Better comments
Handle empty secure area, better
2026-02-08 13:49:50 +00:00 · 2019-04-11 15:28:10 -07:00 · 2019-04-11 15:02:01 -07:00 · 2019-04-11 14:59:05 -07:00 · 2019-04-11 14:43:39 -07:00 · 2019-04-11 14:15:11 -07:00
30 changed files with 1406 additions and 172 deletions
--- a/3DSDecrypt/Data/Constants.cs
+++ b/3DSDecrypt/Data/Constants.cs
@@ -1,69 +0,0 @@
-using System.Numerics;
-
-namespace ThreeDS.Data
-{
-    public static class Constants
-    {
-        // Setup Keys and IVs
-        public static byte[] PlainCounter = new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
-        public static byte[] ExefsCounter = new byte[] { 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
-        public static byte[] RomfsCounter = new byte[] { 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
-
-        // Note: BigInteger requires the 0x00 at the end of each string in order to preserve the sign value
-        // Note: BigInteger requires that the values be in little endian format, the values in 
-
-        // Big Endian - 0x1F, 0xF9, 0xE9, 0xAA, 0xC5, 0xFE, 0x04, 0x08, 0x02, 0x45, 0x91, 0xDC, 0x5D, 0x52, 0x76, 0x8A
-        // Little Endian - 0x8A, 0x76, 0x52, 0x5D, 0xDC, 0x91, 0x45, 0x02, 0x08, 0x04, 0xFE, 0xC5, 0xAA, 0xE9, 0xF9, 0x1F
-        public static BigInteger AESHardwareConstant = new BigInteger(new byte[] { 0x8A, 0x76, 0x52, 0x5D, 0xDC, 0x91, 0x45, 0x02, 0x08, 0x04, 0xFE, 0xC5, 0xAA, 0xE9, 0xF9, 0x1F });
-
-        #region Retail keys
-
-        // KeyX 0x18 (New 3DS 9.3)
-        // Big Endian - 0x82, 0xE9, 0xC9, 0xBE, 0xBF, 0xB8, 0xBD, 0xB8, 0x75, 0xEC, 0xC0, 0xA0, 0x7D, 0x47, 0x43, 0x74
-        // Little Endian - 0x74, 0x43, 0x47, 0x7D, 0xA0, 0xC0, 0xEC, 0x75, 0xB8, 0xBD, 0xB8, 0xBF, 0xBE, 0xC9, 0xE9, 0x82
-        public static BigInteger KeyX0x18 = new BigInteger(new byte[] { 0x74, 0x43, 0x47, 0x7D, 0xA0, 0xC0, 0xEC, 0x75, 0xB8, 0xBD, 0xB8, 0xBF, 0xBE, 0xC9, 0xE9, 0x82, 0x00 });
-
-        // KeyX 0x1B (New 3DS 9.6)
-        // Big Endian - 0x45, 0xAD, 0x04, 0x95, 0x39, 0x92, 0xC7, 0xC8, 0x93, 0x72, 0x4A, 0x9A, 0x7B, 0xCE, 0x61, 0x82
-        // Little Endian - 0x82, 0x61, 0xCE, 0x7B, 0x9A, 0x4A, 0x72, 0x93, 0xC8, 0xC7, 0x92, 0x39, 0x95, 0x04, 0xAD, 0x45
-        public static BigInteger KeyX0x1B = new BigInteger(new byte[] { 0x82, 0x61, 0xCE, 0x7B, 0x9A, 0x4A, 0x72, 0x93, 0xC8, 0xC7, 0x92, 0x39, 0x95, 0x04, 0xAD, 0x45, 0x00 });
-
-        // KeyX 0x25 (> 7.x)
-        // Big Endian - 0xCE, 0xE7, 0xD8, 0xAB, 0x30, 0xC0, 0x0D, 0xAE, 0x85, 0x0E, 0xF5, 0xE3, 0x82, 0xAC, 0x5A, 0xF3
-        // Little Endian - 0xF3, 0x5A, 0xAC, 0x82, 0xE3, 0xF5, 0x0E, 0x85, 0xAE, 0x0D, 0xC0, 0x30, 0xAB, 0xD8, 0xE7, 0xCE
-        public static BigInteger KeyX0x25 = new BigInteger(new byte[] { 0xF3, 0x5A, 0xAC, 0x82, 0xE3, 0xF5, 0x0E, 0x85, 0xAE, 0x0D, 0xC0, 0x30, 0xAB, 0xD8, 0xE7, 0xCE, 0x00 });
-
-        // Dev KeyX 0x2C (< 6.x)
-        // Big Endian - 0xB9, 0x8E, 0x95, 0xCE, 0xCA, 0x3E, 0x4D, 0x17, 0x1F, 0x76, 0xA9, 0x4D, 0xE9, 0x34, 0xC0, 0x53
-        // Little Endian - 0x53, 0xC0, 0x34, 0xE9, 0x4D, 0xA9, 0x76, 0x1F, 0x17, 0x4D, 0x3E, 0xCA, 0xCE, 0x95, 0x8E, 0xB9
-        public static BigInteger KeyX0x2C = new BigInteger(new byte[] { 0x53, 0xC0, 0x34, 0xE9, 0x4D, 0xA9, 0x76, 0x1F, 0x17, 0x4D, 0x3E, 0xCA, 0xCE, 0x95, 0x8E, 0xB9, 0x00 });
-
-        #endregion
-
-        #region Dev Keys
-
-        // Dev KeyX 0x18 (New 3DS 9.3)
-        // Big Endian - 0x30, 0x4B, 0xF1, 0x46, 0x83, 0x72, 0xEE, 0x64, 0x11, 0x5E, 0xBD, 0x40, 0x93, 0xD8, 0x42, 0x76
-        // Little Endian - 0x76, 0x42, 0xD8, 0x93, 0x40, 0xBD, 0x5E, 0x11, 0x64, 0xEE, 0x72, 0x83, 0x46, 0xF1, 0x4B, 0x30
-        public static BigInteger DevKeyX0x18 = new BigInteger(new byte[] { 0x76, 0x42, 0xD8, 0x93, 0x40, 0xBD, 0x5E, 0x11, 0x64, 0xEE, 0x72, 0x83, 0x46, 0xF1, 0x4B, 0x30, 0x00 });
-
-        // Dev KeyX 0x1B New 3DS 9.6)
-        // Big Endian - 0x6C, 0x8B, 0x29, 0x44, 0xA0, 0x72, 0x60, 0x35, 0xF9, 0x41, 0xDF, 0xC0, 0x18, 0x52, 0x4F, 0xB6
-        // Little Endian - 0xB6, 0x4F, 0x52, 0x18, 0xC0, 0xDF, 0x41, 0xF9, 0x35, 0x60, 0x72, 0xA0, 0x44, 0x29, 0x8B, 0x6C
-        public static BigInteger DevKeyX0x1B = new BigInteger(new byte[] { 0xB6, 0x4F, 0x52, 0x18, 0xC0, 0xDF, 0x41, 0xF9, 0x35, 0x60, 0x72, 0xA0, 0x44, 0x29, 0x8B, 0x6C, 0x00 });
-
-        // Dev KeyX 0x25 (> 7.x)
-        // Big Endian - 0x81, 0x90, 0x7A, 0x4B, 0x6F, 0x1B, 0x47, 0x32, 0x3A, 0x67, 0x79, 0x74, 0xCE, 0x4A, 0xD7, 0x1B
-        // Little Endian - 0x1B, 0xD7, 0x4A, 0xCE, 0x74, 0x79, 0x67, 0x3A, 0x32, 0x47, 0x1B, 0x6F, 0x4B, 0x7A, 0x90, 0x81
-        public static BigInteger DevKeyX0x25 = new BigInteger(new byte[] { 0x1B, 0xD7, 0x4A, 0xCE, 0x74, 0x79, 0x67, 0x3A, 0x32, 0x47, 0x1B, 0x6F, 0x4B, 0x7A, 0x90, 0x81, 0x00 });
-
-        // Dev KeyX 0x2C (< 6.x)
-        // Big Endian - 0x51, 0x02, 0x07, 0x51, 0x55, 0x07, 0xCB, 0xB1, 0x8E, 0x24, 0x3D, 0xCB, 0x85, 0xE2, 0x3A, 0x1D
-        // Little Endian - 0x1D, 0x3A, 0xE2, 0x85, 0xCB, 0x3D, 0x24, 0x8E, 0xB1, 0xCB, 0x07, 0x55, 0x51, 0x07, 0x02, 0x51
-        public static BigInteger DevKeyX0x2C = new BigInteger(new byte[] { 0x1D, 0x3A, 0xE2, 0x85, 0xCB, 0x3D, 0x24, 0x8E, 0xB1, 0xCB, 0x07, 0x55, 0x51, 0x07, 0x02, 0x51, 0x00 });
-
-        #endregion
-
-        public const int CXTExtendedDataHeaderLength = 0x800;
-    }
-}
--- a/3DSDecrypt/Program.cs
+++ b/3DSDecrypt/Program.cs
@@ -1,70 +0,0 @@
-using System;
-using System.IO;
-
-namespace ThreeDS
-{
-    class Program
-    {
-        public static void Main(string[] args)
-        {
-            if (args.Length < 2)
-            {
-                DisplayHelp("Not enough arguments");
-                return;
-            }
-
-            bool? encrypt = null;
-            if (args[0] == "decrypt")
-            {
-                encrypt = false;
-            }
-            else if (args[0] == "encrypt")
-            {
-                encrypt = true;
-            }
-            else
-            {
-                DisplayHelp($"Invalid operation: {args[0]}");
-                return;
-            }
-
-            bool development = false;
-            int start = 1;
-            if (args[1] == "-dev")
-            {
-                development = true;
-                start = 2;
-            }
-
-            for (int i = start; i < args.Length; i++)
-            {
-                if (File.Exists(args[i]))
-                {
-                    ThreeDSTool tool = new ThreeDSTool(args[i], development, encrypt.Value);
-                    if (!tool.ProcessFile())
-                        Console.WriteLine("Processing failed!");
-                }
-                else if (Directory.Exists(args[i]))
-                {
-                    foreach (string file in Directory.EnumerateFiles(args[i], "*", SearchOption.AllDirectories))
-                    {
-                        ThreeDSTool tool = new ThreeDSTool(file, development, encrypt.Value);
-                        if (!tool.ProcessFile())
-                            Console.WriteLine("Processing failed!");
-                    }
-                }
-            }
-
-            Console.WriteLine("Press Enter to Exit...");
-            Console.Read();
-        }
-
-        private static void DisplayHelp(string err = null)
-        {
-            if (!string.IsNullOrWhiteSpace(err))
-                Console.WriteLine($"Error: {err}");
-
-            Console.WriteLine("Usage: 3dsdecrypt.exe (decrypt|encrypt) [-dev] <file|dir> ...");
-        }
-    }
-}
--- a/3DSDecrypt.sln
+++ b/3DSDecrypt.sln
@@ -1,9 +1,9 @@

 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.27004.2006
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.28803.156
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "3DSDecrypt", "3DSDecrypt\3DSDecrypt.csproj", "{2E30006A-3C60-4576-A262-937B21C83C06}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NDecrypt", "NDecrypt\NDecrypt.csproj", "{2E30006A-3C60-4576-A262-937B21C83C06}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
--- a/NDecrypt/DSTool.cs
+++ b/NDecrypt/DSTool.cs
@@ -0,0 +1,53 @@
+using System;
+using System.IO;
+using NDecrypt.Headers;
+
+namespace NDecrypt
+{
+    public class DSTool : ITool
+    {
+        /// <summary>
+        /// Name of the input DS/DSi file
+        /// </summary>
+        private readonly string filename;
+
+        /// <summary>
+        /// Flag to determine if encrypting or decrypting
+        /// </summary>
+        private readonly bool encrypt;
+
+        public DSTool(string filename, bool encrypt)
+        {
+            this.filename = filename;
+            this.encrypt = encrypt;
+        }
+
+        /// <summary>
+        /// Process an input file given the input values
+        /// </summary>
+        public bool ProcessFile()
+        {
+            // Make sure we have a file to process first
+            Console.WriteLine(filename);
+            if (!File.Exists(filename))
+                return false;
+
+            // Open the read and write on the same file for inplace processing
+            using (BinaryReader reader = new BinaryReader(File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)))
+            using (BinaryWriter writer = new BinaryWriter(File.Open(filename, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite)))
+            {
+                NDSHeader header = NDSHeader.Read(reader);
+                if (header == null)
+                {
+                    Console.WriteLine("Error: Not a DS or DSi Rom!");
+                    return false;
+                }
+
+                // Process the secure area
+                header.ProcessSecureArea(reader, writer, encrypt);
+            }
+
+            return true;
+        }
+    }
+}
--- a/NDecrypt/Data/Constants.cs
+++ b/NDecrypt/Data/Constants.cs
@@ -0,0 +1,334 @@
+using System.Numerics;
+
+namespace NDecrypt.Data
+{
+    public static class Constants
+    {
+        public static byte[] NDSEncryptionData = new byte[]
+        {
+            0x99,0xD5,0x20,0x5F,0x57,0x44,0xF5,0xB9,0x6E,0x19,0xA4,0xD9,0x9E,0x6A,0x5A,0x94,
+            0xD8,0xAE,0xF1,0xEB,0x41,0x75,0xE2,0x3A,0x93,0x82,0xD0,0x32,0x33,0xEE,0x31,0xD5,
+            0xCC,0x57,0x61,0x9A,0x37,0x06,0xA2,0x1B,0x79,0x39,0x72,0xF5,0x55,0xAE,0xF6,0xBE,
+            0x5F,0x1B,0x69,0xFB,0xE5,0x9D,0xF1,0xE9,0xCE,0x2C,0xD9,0xA1,0x5E,0x32,0x05,0xE6,
+            0xFE,0xD3,0xFE,0xCF,0xD4,0x62,0x04,0x0D,0x8B,0xF5,0xEC,0xB7,0x2B,0x60,0x79,0xBB,
+            0x12,0x95,0x31,0x0D,0x6E,0x3F,0xDA,0x2B,0x88,0x84,0xF0,0xF1,0x3D,0x12,0x7E,0x25,
+            0x45,0x22,0xF1,0xBB,0x24,0x06,0x1A,0x06,0x11,0xAD,0xDF,0x28,0x8B,0x64,0x81,0x34,
+            0x2B,0xEB,0x33,0x29,0x99,0xAA,0xF2,0xBD,0x9C,0x14,0x95,0x9D,0x9F,0xF7,0xF5,0x8C,
+            0x72,0x97,0xA1,0x29,0x9D,0xD1,0x5F,0xCF,0x66,0x4D,0x07,0x1A,0xDE,0xD3,0x4A,0x4B,
+            0x85,0xC9,0xA7,0xA3,0x17,0x95,0x05,0x3A,0x3D,0x49,0x0A,0xBF,0x0A,0x89,0x8B,0xA2,
+            0x4A,0x82,0x49,0xDD,0x27,0x90,0xF1,0x0B,0xE9,0xEB,0x1C,0x6A,0x83,0x76,0x45,0x05,
+            0xBA,0x81,0x70,0x61,0x17,0x3F,0x4B,0xDE,0xAE,0xCF,0xAB,0x39,0x57,0xF2,0x3A,0x56,
+            0x48,0x11,0xAD,0x8A,0x40,0xE1,0x45,0x3F,0xFA,0x9B,0x02,0x54,0xCA,0xA6,0x93,0xFB,
+            0xEF,0x4D,0xFE,0x6F,0xA3,0xD8,0x87,0x9C,0x08,0xBA,0xD5,0x48,0x6A,0x8D,0x2D,0xFD,
+            0x6E,0x15,0xF8,0x74,0xBD,0xBE,0x52,0x8B,0x18,0x22,0x8A,0x9E,0xFB,0x74,0x37,0x07,
+            0x1B,0x36,0x6C,0x4A,0x19,0xBA,0x42,0x62,0xB9,0x79,0x91,0x10,0x7B,0x67,0x65,0x96,
+            0xFE,0x02,0x23,0xE8,0xEE,0x99,0x8C,0x77,0x3E,0x5C,0x86,0x64,0x4D,0x6D,0x78,0x86,
+            0xA5,0x4F,0x65,0xE2,0x1E,0xB2,0xDF,0x5A,0x0A,0xD0,0x7E,0x08,0x14,0xB0,0x71,0xAC,
+            0xBD,0xDB,0x83,0x1C,0xB9,0xD7,0xA1,0x62,0xCD,0xC6,0x63,0x7C,0x52,0x69,0xC3,0xE6,
+            0xBF,0x75,0xCE,0x12,0x44,0x5D,0x21,0x04,0xFA,0xFB,0xD3,0x3C,0x38,0x11,0x63,0xD4,
+            0x95,0x85,0x41,0x49,0x46,0x09,0xF2,0x08,0x43,0x11,0xDC,0x1F,0x76,0xC0,0x15,0x6D,
+            0x1F,0x3C,0x63,0x70,0xEA,0x87,0x80,0x6C,0xC3,0xBD,0x63,0x8B,0xC2,0x37,0x21,0x37,
+            0xDC,0xEE,0x09,0x23,0x2E,0x37,0x6A,0x4D,0x73,0x90,0xF7,0x50,0x30,0xAC,0x1C,0x92,
+            0x04,0x10,0x23,0x91,0x4F,0xD2,0x07,0xAA,0x68,0x3E,0x4F,0x9A,0xC9,0x64,0x60,0x6A,
+            0xC8,0x14,0x21,0xF3,0xD6,0x22,0x41,0x12,0x44,0x24,0xCF,0xE6,0x8A,0x56,0xDD,0x0D,
+            0x53,0x4D,0xE1,0x85,0x1E,0x8C,0x52,0x5A,0x9C,0x19,0x84,0xC2,0x03,0x57,0xF1,0x6F,
+            0xE3,0x00,0xBE,0x58,0xF6,0x4C,0xED,0xD5,0x21,0x64,0x9C,0x1F,0xBE,0x55,0x03,0x3C,
+            0x4A,0xDC,0xFF,0xAA,0xC9,0xDA,0xE0,0x5D,0x5E,0xBF,0xE6,0xDE,0xF5,0xD8,0xB1,0xF8,
+            0xFF,0x36,0xB3,0xB9,0x62,0x67,0x95,0xDB,0x31,0x5F,0x37,0xED,0x4C,0x70,0x67,0x99,
+            0x90,0xB5,0x18,0x31,0x6C,0x3D,0x99,0x99,0xE4,0x42,0xDA,0xD3,0x25,0x42,0x13,0xA0,
+            0xAE,0xD7,0x70,0x6C,0xB1,0x55,0xCF,0xC7,0xD7,0x46,0xD5,0x43,0x61,0x17,0x3D,0x44,
+            0x28,0xE9,0x33,0x85,0xD5,0xD0,0xA2,0x93,0xAA,0x25,0x12,0x1F,0xFB,0xC5,0x0B,0x46,
+            0xF5,0x97,0x76,0x56,0x45,0xA6,0xBE,0x87,0xB1,0x94,0x6B,0xE8,0xB1,0xFE,0x33,0x99,
+            0xAE,0x1F,0x3E,0x6C,0x39,0x71,0x1D,0x09,0x00,0x90,0x37,0xE4,0x10,0x3E,0x75,0x74,
+            0xFF,0x8C,0x83,0x3B,0xB0,0xF1,0xB0,0xF9,0x01,0x05,0x47,0x42,0x95,0xF1,0xD6,0xAC,
+            0x7E,0x38,0xE6,0x9E,0x95,0x74,0x26,0x3F,0xB4,0x68,0x50,0x18,0xD0,0x43,0x30,0xB4,
+            0x4C,0x4B,0xE3,0x68,0xBF,0xE5,0x4D,0xB6,0x95,0x8B,0x0A,0xA0,0x74,0x25,0x32,0x77,
+            0xCF,0xA1,0xF7,0x2C,0xD8,0x71,0x13,0x5A,0xAB,0xEA,0xC9,0x51,0xE8,0x0D,0xEE,0xEF,
+            0xE9,0x93,0x7E,0x19,0xA7,0x1E,0x43,0x38,0x81,0x16,0x2C,0xA1,0x48,0xE3,0x73,0xCC,
+            0x29,0x21,0x6C,0xD3,0x5D,0xCE,0xA0,0xD9,0x61,0x71,0x43,0xA0,0x15,0x13,0xB5,0x64,
+            0x92,0xCF,0x2A,0x19,0xDC,0xAD,0xB7,0xA5,0x9F,0x86,0x65,0xF8,0x1A,0x9F,0xE7,0xFB,
+            0xF7,0xFD,0xB8,0x13,0x6C,0x27,0xDB,0x6F,0xDF,0x35,0x1C,0xF7,0x8D,0x2C,0x5B,0x9B,
+            0x12,0xAB,0x38,0x64,0x06,0xCC,0xDE,0x31,0xE8,0x4E,0x75,0x11,0x64,0xE3,0xFA,0xEA,
+            0xEB,0x34,0x54,0xC2,0xAD,0x3F,0x34,0xEB,0x93,0x2C,0x7D,0x26,0x36,0x9D,0x56,0xF3,
+            0x5A,0xE1,0xF6,0xB3,0x98,0x63,0x4A,0x9E,0x32,0x83,0xE4,0x9A,0x84,0x60,0x7D,0x90,
+            0x2E,0x13,0x0E,0xEE,0x93,0x4B,0x36,0xA2,0x85,0xEC,0x16,0x38,0xE8,0x88,0x06,0x02,
+            0xBF,0xF0,0xA0,0x3A,0xED,0xD7,0x6A,0x9A,0x73,0xE1,0x57,0xCF,0xF8,0x44,0xB8,0xDC,
+            0x2E,0x23,0x59,0xD1,0xDF,0x95,0x52,0x71,0x99,0x61,0xA0,0x4B,0xD5,0x7F,0x6E,0x78,
+            0xBA,0xA9,0xC5,0x30,0xD3,0x40,0x86,0x32,0x9D,0x32,0x0C,0x9C,0x37,0xB7,0x02,0x2F,
+            0xBA,0x54,0x98,0xA9,0xC4,0x13,0x04,0xC9,0x8D,0xBE,0xC8,0xE7,0x5D,0x97,0x50,0x2E,
+            0x93,0xD6,0x22,0x59,0x0C,0x27,0xBC,0x22,0x92,0xE0,0xA7,0x20,0x0F,0x93,0x6F,0x7F,
+            0x4C,0x9F,0xD3,0xB5,0xA6,0x2A,0x0B,0x74,0x67,0x49,0x7D,0x10,0x26,0xCB,0xD1,0xC5,
+            0x86,0x71,0xE7,0x8C,0xA0,0x9C,0xE9,0x5B,0xB2,0x1A,0xF6,0x01,0xEE,0x8C,0x9E,0x5E,
+            0x83,0xF2,0x1A,0xDB,0xE6,0xE5,0xEA,0x84,0x59,0x76,0xD2,0x7C,0xF6,0x8D,0xA5,0x49,
+            0x36,0x48,0xC2,0x16,0x52,0xBB,0x83,0xA3,0x74,0xB9,0x07,0x0C,0x3B,0xFF,0x61,0x28,
+            0xE1,0x61,0xE9,0xE4,0xEF,0x6E,0x15,0xAA,0x4E,0xBA,0xE8,0x5D,0x05,0x96,0xBB,0x32,
+            0x56,0xB0,0xFB,0x72,0x52,0x0F,0x0E,0xC8,0x42,0x25,0x65,0x76,0x89,0xAF,0xF2,0xDE,
+            0x10,0x27,0xF0,0x01,0x4B,0x74,0xA7,0x97,0x07,0xD5,0x26,0x54,0x54,0x09,0x1F,0x82,
+            0x0A,0x86,0x7D,0x30,0x39,0x0E,0xB3,0x26,0x9B,0x0B,0x57,0xBB,0x36,0x06,0x31,0xAF,
+            0xFD,0x79,0xFC,0xD9,0x30,0x10,0x2B,0x0C,0xB3,0xE1,0x9B,0xD7,0x7B,0xDC,0x5F,0xEF,
+            0xD2,0xF8,0x13,0x45,0x4D,0x47,0x75,0xBD,0x46,0x96,0x3C,0x7E,0x75,0xF3,0x3E,0xB5,
+            0x67,0xC5,0x9A,0x3B,0xB0,0x5B,0x29,0x6B,0xDE,0x80,0x5B,0xC8,0x15,0x05,0xB1,0x31,
+            0xB6,0xCE,0x49,0xDD,0xAD,0x84,0xB5,0xAE,0x60,0xDC,0x67,0x31,0x34,0x30,0xFE,0x4E,
+            0xBD,0x80,0x2F,0xA6,0xBF,0x63,0x39,0x21,0x86,0xD9,0x35,0x7F,0x16,0x68,0x22,0x05,
+            0x54,0xE9,0x90,0x26,0x8C,0x07,0x6C,0x51,0xA4,0x31,0x55,0xD7,0x09,0x07,0xA8,0x3E,
+            0x2E,0x53,0x66,0xC1,0xF8,0xF2,0x7B,0xC4,0xF2,0x58,0xCF,0xF1,0x87,0xC5,0xA2,0xE7,
+            0x27,0x8F,0x30,0x87,0x58,0xA0,0x64,0x62,0x23,0x18,0xB9,0x88,0x7C,0xFA,0xCE,0xC4,
+            0x98,0xAE,0xAD,0x17,0xCC,0x4A,0x5B,0xF3,0xE9,0x48,0xD5,0x56,0xD3,0x0D,0xF2,0xC8,
+            0x92,0x73,0x8C,0xDB,0xD7,0x2F,0x56,0xAC,0x81,0xF9,0x92,0x69,0x4D,0xC6,0x32,0xF6,
+            0xE6,0xC0,0x8D,0x21,0xE2,0x76,0x80,0x61,0x11,0xBC,0xDC,0x6C,0x93,0xAF,0x19,0x69,
+            0x9B,0xD0,0xBF,0xB9,0x31,0x9F,0x02,0x67,0xA3,0x51,0xEE,0x83,0x06,0x22,0x7B,0x0C,
+            0xAB,0x49,0x42,0x40,0xB8,0xD5,0x01,0x7D,0xCE,0x5E,0xF7,0x55,0x53,0x39,0xC5,0x99,
+            0x46,0xD8,0x87,0x9F,0xBA,0xF7,0x64,0xB4,0xE3,0x9A,0xFA,0xA1,0x6D,0x90,0x68,0x10,
+            0x30,0xCA,0x8A,0x54,0xA7,0x9F,0x60,0xC3,0x19,0xF5,0x6B,0x0D,0x7A,0x51,0x98,0xE6,
+            0x98,0x43,0x51,0xB4,0xD6,0x35,0xE9,0x4F,0xC3,0xDF,0x0F,0x7B,0xD6,0x2F,0x5C,0xBD,
+            0x3A,0x15,0x61,0x19,0xF1,0x4B,0xCB,0xAA,0xDC,0x6D,0x64,0xC9,0xD3,0xC6,0x1E,0x56,
+            0xEF,0x38,0x4C,0x50,0x71,0x86,0x75,0xCC,0x0D,0x0D,0x4E,0xE9,0x28,0xF6,0x06,0x5D,
+            0x70,0x1B,0xAA,0xD3,0x45,0xCF,0xA8,0x39,0xAC,0x95,0xA6,0x2E,0xB4,0xE4,0x22,0xD4,
+            0x74,0xA8,0x37,0x5F,0x48,0x7A,0x04,0xCC,0xA5,0x4C,0x40,0xD8,0x28,0xB4,0x28,0x08,
+            0x0D,0x1C,0x72,0x52,0x41,0xF0,0x7D,0x47,0x19,0x3A,0x53,0x4E,0x58,0x84,0x62,0x6B,
+            0x93,0xB5,0x8A,0x81,0x21,0x4E,0x0D,0xDC,0xB4,0x3F,0xA2,0xC6,0xFC,0xC9,0x2B,0x40,
+            0xDA,0x38,0x04,0xE9,0x5E,0x5A,0x86,0x6B,0x0C,0x22,0x25,0x85,0x68,0x11,0x8D,0x7C,
+            0x92,0x1D,0x95,0x55,0x4D,0xAB,0x8E,0xBB,0xDA,0xA6,0xE6,0xB7,0x51,0xB6,0x32,0x5A,
+            0x05,0x41,0xDD,0x05,0x2A,0x0A,0x56,0x50,0x91,0x17,0x47,0xCC,0xC9,0xE6,0x7E,0xB5,
+            0x61,0x4A,0xDB,0x73,0x67,0x51,0xC8,0x33,0xF5,0xDA,0x6E,0x74,0x2E,0x54,0xC3,0x37,
+            0x0D,0x6D,0xAF,0x08,0xE8,0x15,0x8A,0x5F,0xE2,0x59,0x21,0xCD,0xA8,0xDE,0x0C,0x06,
+            0x5A,0x77,0x6B,0x5F,0xDB,0x18,0x65,0x3E,0xC8,0x50,0xDE,0x78,0xE0,0xB8,0x82,0xB3,
+            0x5D,0x4E,0x72,0x32,0x07,0x4F,0xC1,0x34,0x23,0xBA,0x96,0xB7,0x67,0x4E,0xA4,0x28,
+            0x1E,0x34,0x62,0xEB,0x2D,0x6A,0x70,0xE9,0x2F,0x42,0xC4,0x70,0x4E,0x5A,0x31,0x9C,
+            0xF9,0x5B,0x47,0x28,0xAA,0xDA,0x71,0x6F,0x38,0x1F,0xB3,0x78,0xC4,0x92,0x6B,0x1C,
+            0x9E,0xF6,0x35,0x9A,0xB7,0x4D,0x0E,0xBF,0xCC,0x18,0x29,0x41,0x03,0x48,0x35,0x5D,
+            0x55,0xD0,0x2B,0xC6,0x29,0xAF,0x5C,0x60,0x74,0x69,0x8E,0x5E,0x9B,0x7C,0xD4,0xBD,
+            0x7B,0x44,0x64,0x7D,0x3F,0x92,0x5D,0x69,0xB6,0x1F,0x00,0x4B,0xD4,0x83,0x35,0xCF,
+            0x7E,0x64,0x4E,0x17,0xAE,0x8D,0xD5,0x2E,0x9A,0x28,0x12,0x4E,0x2E,0x2B,0x49,0x08,
+            0x5C,0xAE,0xC6,0x46,0x85,0xAE,0x41,0x61,0x1E,0x6F,0x82,0xD2,0x51,0x37,0x16,0x1F,
+            0x0B,0xF6,0x59,0xA4,0x9A,0xCA,0x5A,0xAF,0x0D,0xD4,0x33,0x8B,0x20,0x63,0xF1,0x84,
+            0x80,0x5C,0xCB,0xCF,0x08,0xB4,0xB9,0xD3,0x16,0x05,0xBD,0x62,0x83,0x31,0x9B,0x56,
+            0x51,0x98,0x9F,0xBA,0xB2,0x5B,0xAA,0xB2,0x22,0x6B,0x2C,0xB5,0xD4,0x48,0xFA,0x63,
+            0x2B,0x5F,0x58,0xFA,0x61,0xFA,0x64,0x09,0xBB,0x38,0xE0,0xB8,0x9D,0x92,0x60,0xA8,
+            0x0D,0x67,0x6F,0x0E,0x37,0xF5,0x0D,0x01,0x9F,0xC2,0x77,0xD4,0xFE,0xEC,0xF1,0x73,
+            0x30,0x39,0xE0,0x7D,0xF5,0x61,0x98,0xE4,0x2C,0x28,0x55,0x04,0x56,0x55,0xDB,0x2F,
+            0x6B,0xEC,0xE5,0x58,0x06,0xB6,0x64,0x80,0x6A,0x2A,0x1A,0x4E,0x5B,0x0F,0xD8,0xC4,
+            0x0A,0x2E,0x52,0x19,0xD9,0x62,0xF5,0x30,0x48,0xBE,0x8C,0x7B,0x4F,0x38,0x9B,0xA2,
+            0xC3,0xAF,0xC9,0xD3,0xC7,0xC1,0x62,0x41,0x86,0xB9,0x61,0x21,0x57,0x6F,0x99,0x4F,
+            0xC1,0xBA,0xCE,0x7B,0xB5,0x3B,0x4D,0x5E,0x8A,0x8B,0x44,0x57,0x5F,0x13,0x5F,0x70,
+            0x6D,0x5B,0x29,0x47,0xDC,0x38,0xE2,0xEC,0x04,0x55,0x65,0x12,0x2A,0xE8,0x17,0x43,
+            0xE1,0x8E,0xDD,0x2A,0xB3,0xE2,0x94,0xF7,0x09,0x6E,0x5C,0xE6,0xEB,0x8A,0xF8,0x6D,
+            0x89,0x49,0x54,0x48,0xF5,0x2F,0xAD,0xBF,0xEA,0x94,0x4B,0xCA,0xFC,0x39,0x87,0x82,
+            0x5F,0x8A,0x01,0xF2,0x75,0xF2,0xE6,0x71,0xD6,0xD8,0x42,0xDE,0xF1,0x2D,0x1D,0x28,
+            0xA6,0x88,0x7E,0xA3,0xA0,0x47,0x1D,0x30,0xD9,0xA3,0x71,0xDF,0x49,0x1C,0xCB,0x01,
+            0xF8,0x36,0xB1,0xF2,0xF0,0x22,0x58,0x5D,0x45,0x6B,0xBD,0xA0,0xBB,0xB2,0x88,0x42,
+            0xC7,0x8C,0x28,0xCE,0x93,0xE8,0x90,0x63,0x08,0x90,0x7C,0x89,0x3C,0xF5,0x7D,0xB7,
+            0x04,0x2D,0x4F,0x55,0x51,0x16,0xFD,0x7E,0x79,0xE8,0xBE,0xC1,0xF2,0x12,0xD4,0xF8,
+            0xB4,0x84,0x05,0x23,0xA0,0xCC,0xD2,0x2B,0xFD,0xE1,0xAB,0xAD,0x0D,0xD1,0x55,0x6C,
+            0x23,0x41,0x94,0x4D,0x77,0x37,0x4F,0x05,0x28,0x0C,0xBF,0x17,0xB3,0x12,0x67,0x6C,
+            0x8C,0xC3,0x5A,0xF7,0x41,0x84,0x2A,0x6D,0xD0,0x94,0x12,0x27,0x2C,0xB4,0xED,0x9C,
+            0x4D,0xEC,0x47,0x82,0x97,0xD5,0x67,0xB9,0x1B,0x9D,0xC0,0x55,0x07,0x7E,0xE5,0x8E,
+            0xE2,0xA8,0xE7,0x3E,0x12,0xE4,0x0E,0x3A,0x2A,0x45,0x55,0x34,0xA2,0xF9,0x2D,0x5A,
+            0x1B,0xAB,0x52,0x7C,0x83,0x10,0x5F,0x55,0xD2,0xF1,0x5A,0x43,0x2B,0xC6,0xA7,0xA4,
+            0x89,0x15,0x95,0xE8,0xB4,0x4B,0x9D,0xF8,0x75,0xE3,0x9F,0x60,0x78,0x5B,0xD6,0xE6,
+            0x0D,0x44,0xE6,0x21,0x06,0xBD,0x47,0x22,0x53,0xA4,0x00,0xAD,0x8D,0x43,0x13,0x85,
+            0x39,0xF7,0xAA,0xFC,0x38,0xAF,0x7B,0xED,0xFC,0xE4,0x2B,0x54,0x50,0x98,0x4C,0xFC,
+            0x85,0x80,0xF7,0xDF,0x3C,0x80,0x22,0xE1,0x94,0xDA,0xDE,0x24,0xC6,0xB0,0x7A,0x39,
+            0x38,0xDC,0x0F,0xA1,0xA7,0xF4,0xF9,0x6F,0x63,0x18,0x57,0x8B,0x84,0x41,0x2A,0x2E,
+            0xD4,0x53,0xF2,0xD9,0x00,0x0F,0xD0,0xDD,0x99,0x6E,0x19,0xA6,0x0A,0xD0,0xEC,0x5B,
+            0x58,0x24,0xAB,0xC0,0xCB,0x06,0x65,0xEC,0x1A,0x13,0x38,0x94,0x0A,0x67,0x03,0x2F,
+            0x3F,0xF7,0xE3,0x77,0x44,0x77,0x33,0xC6,0x14,0x39,0xD0,0xE3,0xC0,0xA2,0x08,0x79,
+            0xBB,0x40,0x99,0x57,0x41,0x0B,0x01,0x90,0xCD,0xE1,0xCC,0x48,0x67,0xDB,0xB3,0xAF,
+            0x88,0x74,0xF3,0x4C,0x82,0x8F,0x72,0xB1,0xB5,0x23,0x29,0xC4,0x12,0x6C,0x19,0xFC,
+            0x8E,0x46,0xA4,0x9C,0xC4,0x25,0x65,0x87,0xD3,0x6D,0xBE,0x8A,0x93,0x11,0x03,0x38,
+            0xED,0x83,0x2B,0xF3,0x46,0xA4,0x93,0xEA,0x3B,0x53,0x85,0x1D,0xCE,0xD4,0xF1,0x08,
+            0x83,0x27,0xED,0xFC,0x9B,0x1A,0x18,0xBC,0xF9,0x8B,0xAE,0xDC,0x24,0xAB,0x50,0x38,
+            0xE9,0x72,0x4B,0x10,0x22,0x17,0x7B,0x46,0x5D,0xAB,0x59,0x64,0xF3,0x40,0xAE,0xF8,
+            0xBB,0xE5,0xC8,0xF9,0x26,0x03,0x4E,0x55,0x7D,0xEB,0xEB,0xFE,0xF7,0x39,0xE6,0xE0,
+            0x0A,0x11,0xBE,0x2E,0x28,0xFF,0x98,0xED,0xC0,0xC9,0x42,0x56,0x42,0xC3,0xFD,0x00,
+            0xF6,0xAF,0x87,0xA2,0x5B,0x01,0x3F,0x32,0x92,0x47,0x95,0x9A,0x72,0xA5,0x32,0x3D,
+            0xAE,0x6B,0xD0,0x9B,0x07,0xD2,0x49,0x92,0xE3,0x78,0x4A,0xFA,0xA1,0x06,0x7D,0xF2,
+            0x41,0xCF,0x77,0x74,0x04,0x14,0xB2,0x0C,0x86,0x84,0x64,0x16,0xD5,0xBB,0x51,0xA1,
+            0xE5,0x6F,0xF1,0xD1,0xF2,0xE2,0xF7,0x5F,0x58,0x20,0x4D,0xB8,0x57,0xC7,0xCF,0xDD,
+            0xC5,0xD8,0xBE,0x76,0x3D,0xF6,0x5F,0x7E,0xE7,0x2A,0x8B,0x88,0x24,0x1B,0x38,0x3F,
+            0x0E,0x41,0x23,0x77,0xF5,0xF0,0x4B,0xD4,0x0C,0x1F,0xFA,0xA4,0x0B,0x80,0x5F,0xCF,
+            0x45,0xF6,0xE0,0xDA,0x2F,0x34,0x59,0x53,0xFB,0x20,0x3C,0x52,0x62,0x5E,0x35,0xB5,
+            0x62,0xFE,0x8B,0x60,0x63,0xE3,0x86,0x5A,0x15,0x1A,0x6E,0xD1,0x47,0x45,0xBC,0x32,
+            0xB4,0xEB,0x67,0x38,0xAB,0xE4,0x6E,0x33,0x3A,0xB5,0xED,0xA3,0xAD,0x67,0xE0,0x4E,
+            0x41,0x95,0xEE,0x62,0x62,0x71,0x26,0x1D,0x31,0xEF,0x62,0x30,0xAF,0xD7,0x82,0xAC,
+            0xC2,0xDC,0x05,0x04,0xF5,0x97,0x07,0xBF,0x11,0x59,0x23,0x07,0xC0,0x64,0x02,0xE8,
+            0x97,0xE5,0x3E,0xAF,0x18,0xAC,0x59,0xA6,0x8B,0x4A,0x33,0x90,0x1C,0x6E,0x7C,0x9C,
+            0x20,0x7E,0x4C,0x3C,0x3E,0x61,0x64,0xBB,0xC5,0x6B,0x7C,0x7E,0x3E,0x9F,0xC5,0x4C,
+            0x9F,0xEA,0x73,0xF5,0xD7,0x89,0xC0,0x4C,0xF4,0xFB,0xF4,0x2D,0xEC,0x14,0x1B,0x51,
+            0xD5,0xC1,0x12,0xC8,0x10,0xDF,0x0B,0x4A,0x8B,0x9C,0xBC,0x93,0x45,0x6A,0x3E,0x3E,
+            0x7D,0xC1,0xA9,0xBA,0xCD,0xC1,0xB4,0x07,0xE4,0xE1,0x68,0x86,0x43,0xB2,0x6D,0x38,
+            0xF3,0xFB,0x0C,0x5C,0x66,0x37,0x71,0xDE,0x56,0xEF,0x6E,0xA0,0x10,0x40,0x65,0xA7,
+            0x98,0xF7,0xD0,0xBE,0x0E,0xC8,0x37,0x36,0xEC,0x10,0xCA,0x7C,0x9C,0xAB,0x84,0x1E,
+            0x05,0x17,0x76,0x02,0x1C,0x4F,0x52,0xAA,0x5F,0xC1,0xC6,0xA0,0x56,0xB9,0xD8,0x04,
+            0x84,0x44,0x4D,0xA7,0x59,0xD8,0xDE,0x60,0xE6,0x38,0x0E,0x05,0x8F,0x03,0xE1,0x3B,
+            0x6D,0x81,0x04,0x33,0x6F,0x30,0x0B,0xCE,0x69,0x05,0x21,0x33,0xFB,0x26,0xBB,0x89,
+            0x7D,0xB6,0xAE,0x87,0x7E,0x51,0x07,0xE0,0xAC,0xF7,0x96,0x0A,0x6B,0xF9,0xC4,0x5C,
+            0x1D,0xE4,0x44,0x47,0xB8,0x5E,0xFA,0xE3,0x78,0x84,0x55,0x42,0x4B,0x48,0x5E,0xF7,
+            0x7D,0x47,0x35,0x86,0x1D,0x2B,0x43,0x05,0x03,0xEC,0x8A,0xB8,0x1E,0x06,0x3C,0x76,
+            0x0C,0x48,0x1A,0x43,0xA7,0xB7,0x8A,0xED,0x1E,0x13,0xC6,0x43,0xEE,0x10,0xEF,0xDB,
+            0xEC,0xFB,0x3C,0x83,0xB2,0x95,0x44,0xEF,0xD8,0x54,0x51,0x4E,0x2D,0x11,0x44,0x1D,
+            0xFB,0x36,0x59,0x1E,0x7A,0x34,0xC1,0xC3,0xCA,0x57,0x00,0x61,0xEA,0x67,0xA5,0x16,
+            0x9B,0x55,0xD0,0x55,0xE1,0x7F,0xD9,0x36,0xD2,0x40,0x76,0xAE,0xDC,0x01,0xCE,0xB0,
+            0x7A,0x83,0xD5,0xCB,0x20,0x98,0xEC,0x6B,0xC1,0x72,0x92,0x34,0xF3,0x82,0x57,0x37,
+            0x62,0x8A,0x32,0x36,0x0C,0x90,0x43,0xAE,0xAE,0x5C,0x9B,0x78,0x8E,0x13,0x65,0x02,
+            0xFD,0x68,0x71,0xC1,0xFE,0xB0,0x31,0xA0,0x24,0x82,0xB0,0xC3,0xB1,0x79,0x69,0xA7,
+            0xF5,0xD2,0xEB,0xD0,0x82,0xC0,0x32,0xDC,0x9E,0xC7,0x26,0x3C,0x6D,0x8D,0x98,0xC1,
+            0xBB,0x22,0xD4,0xD0,0x0F,0x33,0xEC,0x3E,0xB9,0xCC,0xE1,0xDC,0x6A,0x4C,0x77,0x36,
+            0x14,0x1C,0xF9,0xBF,0x81,0x9F,0x28,0x5F,0x71,0x85,0x32,0x29,0x90,0x75,0x48,0xC4,
+            0xB3,0x4A,0xCE,0xD8,0x44,0x8F,0x14,0x2F,0xFD,0x40,0x57,0xEF,0xAA,0x08,0x75,0xD9,
+            0x46,0xD1,0xD6,0x6E,0x32,0x55,0x1F,0xC3,0x18,0xFE,0x84,0x1F,0xFC,0x84,0xD5,0xFF,
+            0x71,0x5E,0x1B,0x48,0xC3,0x86,0x95,0x0E,0x28,0x08,0x27,0xD3,0x38,0x83,0x71,0x7B,
+            0x4C,0x80,0x63,0x54,0x9A,0x56,0xB0,0xAC,0xCF,0x80,0xCA,0x31,0x09,0xEF,0xFE,0xF3,
+            0xBE,0xAF,0x24,0x7E,0xA6,0xFE,0x53,0x3F,0xC2,0x8D,0x4A,0x33,0x68,0xD1,0x22,0xA6,
+            0x66,0xAD,0x7B,0xEA,0xDE,0xB6,0x43,0xB0,0xA1,0x25,0x95,0x00,0xA3,0x3F,0x75,0x46,
+            0x14,0x11,0x44,0xEC,0xD7,0x95,0xBC,0x92,0xF0,0x4F,0xA9,0x16,0x53,0x62,0x97,0x60,
+            0x2A,0x0F,0x41,0xF1,0x71,0x24,0xBE,0xEE,0x94,0x7F,0x08,0xCD,0x60,0x93,0xB3,0x85,
+            0x5B,0x07,0x00,0x3F,0xD8,0x0F,0x28,0x83,0x9A,0xD1,0x69,0x9F,0xD1,0xDA,0x2E,0xC3,
+            0x90,0x01,0xA2,0xB9,0x6B,0x4E,0x2A,0x66,0x9D,0xDA,0xAE,0xA6,0xEA,0x2A,0xD3,0x68,
+            0x2F,0x0C,0x0C,0x9C,0xD2,0x8C,0x4A,0xED,0xE2,0x9E,0x57,0x65,0x9D,0x09,0x87,0xA3,
+            0xB4,0xC4,0x32,0x5D,0xC9,0xD4,0x32,0x2B,0xB1,0xE0,0x71,0x1E,0x64,0x4D,0xE6,0x90,
+            0x71,0xE3,0x1E,0x40,0xED,0x7D,0xF3,0x84,0x0E,0xED,0xC8,0x78,0x76,0xAE,0xC0,0x71,
+            0x27,0x72,0xBB,0x05,0xEA,0x02,0x64,0xFB,0xF3,0x48,0x6B,0xB5,0x42,0x93,0x3F,0xED,
+            0x9F,0x13,0x53,0xD2,0xF7,0xFE,0x2A,0xEC,0x1D,0x47,0x25,0xDB,0x3C,0x91,0x86,0xC6,
+            0x8E,0xF0,0x11,0xFD,0x23,0x74,0x36,0xF7,0xA4,0xF5,0x9E,0x7A,0x7E,0x53,0x50,0x44,
+            0xD4,0x47,0xCA,0xD3,0xEB,0x38,0x6D,0xE6,0xD9,0x71,0x94,0x7F,0x4A,0xC6,0x69,0x4B,
+            0x11,0xF4,0x52,0xEA,0x22,0xFE,0x8A,0xB0,0x36,0x67,0x8B,0x59,0xE8,0xE6,0x80,0x2A,
+            0xEB,0x65,0x04,0x13,0xEE,0xEC,0xDC,0x9E,0x5F,0xB1,0xEC,0x05,0x6A,0x59,0xE6,0x9F,
+            0x5E,0x59,0x6B,0x89,0xBF,0xF7,0x1A,0xCA,0x44,0xF9,0x5B,0x6A,0x71,0x85,0x03,0xE4,
+            0x29,0x62,0xE0,0x70,0x6F,0x41,0xC4,0xCF,0xB2,0xB1,0xCC,0xE3,0x7E,0xA6,0x07,0xA8,
+            0x87,0xE7,0x7F,0x84,0x93,0xDB,0x52,0x4B,0x6C,0xEC,0x7E,0xDD,0xD4,0x24,0x48,0x10,
+            0x69,0x9F,0x04,0x60,0x74,0xE6,0x48,0x18,0xF3,0xE4,0x2C,0xB9,0x4F,0x2E,0x50,0x7A,
+            0xDF,0xD4,0x54,0x69,0x2B,0x8B,0xA7,0xF3,0xCE,0xFF,0x1F,0xF3,0x3E,0x26,0x01,0x39,
+            0x17,0x95,0x84,0x89,0xB0,0xF0,0x4C,0x4B,0x82,0x91,0x9F,0xC4,0x4B,0xAC,0x9D,0xA5,
+            0x74,0xAF,0x17,0x25,0xC9,0xCA,0x32,0xD3,0xBC,0x89,0x8A,0x84,0x89,0xCC,0x0D,0xAE,
+            0x7C,0xA2,0xDB,0x9C,0x6A,0x78,0x91,0xEE,0xEA,0x76,0x5D,0x4E,0x87,0x60,0xF5,0x69,
+            0x15,0x67,0xD4,0x02,0xCF,0xAF,0x48,0x36,0x07,0xEA,0xBF,0x6F,0x66,0x2D,0x06,0x8F,
+            0xC4,0x9A,0xFE,0xF9,0xF6,0x90,0x87,0x75,0xB8,0xF7,0xAD,0x0F,0x76,0x10,0x5A,0x3D,
+            0x59,0xB0,0x2E,0xB3,0xC7,0x35,0x2C,0xCC,0x70,0x56,0x2B,0xCB,0xE3,0x37,0x96,0xC5,
+            0x2F,0x46,0x1B,0x8A,0x22,0x46,0xC7,0x88,0xA7,0x26,0x32,0x98,0x61,0xDF,0x86,0x22,
+            0x8A,0xF4,0x1C,0x2F,0x87,0xA1,0x09,0xAA,0xCC,0xA9,0xAE,0xD3,0xBD,0x00,0x45,0x1C,
+            0x9A,0x54,0x87,0x86,0x52,0x87,0xEF,0xFF,0x1E,0x8F,0xA1,0x8F,0xC1,0x89,0x5C,0x35,
+            0x1B,0xDA,0x2D,0x3A,0x2C,0x16,0xB2,0xC2,0xF1,0x56,0xE2,0x78,0xC1,0x6B,0x63,0x97,
+            0xC5,0x56,0x8F,0xC9,0x32,0x7F,0x2C,0xAA,0xAF,0xA6,0xA8,0xAC,0x20,0x91,0x22,0x88,
+            0xDE,0xE4,0x60,0x8B,0xF9,0x4B,0x42,0x25,0x1A,0xE3,0x7F,0x9C,0x2C,0x19,0x89,0x3A,
+            0x7E,0x05,0xD4,0x36,0xCC,0x69,0x58,0xC2,0xC1,0x32,0x8B,0x2F,0x90,0x85,0xEB,0x7A,
+            0x39,0x50,0xA5,0xA1,0x27,0x92,0xC5,0x66,0xB0,0x20,0x4F,0x58,0x7E,0x55,0x83,0x43,
+            0x2B,0x45,0xE2,0x9C,0xE4,0xD8,0x12,0x90,0x2C,0x16,0x83,0x56,0x16,0x79,0x03,0xB3,
+            0xAD,0x2D,0x61,0x18,0x1A,0x13,0x1F,0x37,0xE2,0xE1,0x9C,0x73,0x7B,0x80,0xD5,0xFD,
+            0x2D,0x51,0x87,0xFC,0x7B,0xAA,0xD7,0x1F,0x2C,0x7A,0x8E,0xAF,0xF4,0x8D,0xBB,0xCD,
+            0x95,0x11,0x7C,0x72,0x0B,0xEE,0x6F,0xE2,0xB9,0xAF,0xDE,0x37,0x83,0xDE,0x8C,0x8D,
+            0x62,0x05,0x67,0xB7,0x96,0xC6,0x8D,0x56,0xB6,0x0D,0xD7,0x62,0xBA,0xD6,0x46,0x36,
+            0xBD,0x8E,0xC8,0xE6,0xEA,0x2A,0x6C,0x10,0x14,0xFF,0x6B,0x5B,0xFA,0x82,0x3C,0x46,
+            0xB1,0x30,0x43,0x46,0x51,0x8A,0x7D,0x9B,0x92,0x3E,0x83,0x79,0x5B,0x55,0x5D,0xB2,
+            0x6C,0x5E,0xCE,0x90,0x62,0x8E,0x53,0x98,0xC9,0x0D,0x6D,0xE5,0x2D,0x57,0xCD,0xC5,
+            0x81,0x57,0xBA,0xE1,0xE8,0xB8,0x8F,0x72,0xE5,0x4F,0x13,0xDC,0xEA,0x9D,0x71,0x15,
+            0x10,0xB2,0x11,0x88,0xD5,0x09,0xD4,0x7F,0x5B,0x65,0x7F,0x2C,0x3B,0x38,0x4C,0x11,
+            0x68,0x50,0x8D,0xFB,0x9E,0xB0,0x59,0xBF,0x94,0x80,0x89,0x4A,0xC5,0x1A,0x18,0x12,
+            0x89,0x53,0xD1,0x4A,0x10,0x29,0xE8,0x8C,0x1C,0xEC,0xB6,0xEA,0x46,0xC7,0x17,0x8B,
+            0x25,0x15,0x31,0xA8,0xA2,0x6B,0x43,0xB1,0x9D,0xE2,0xDB,0x0B,0x87,0x9B,0xB0,0x11,
+            0x04,0x0E,0x71,0xD2,0x29,0x77,0x89,0x82,0x0A,0x66,0x41,0x7F,0x1D,0x0B,0x48,0xFF,
+            0x72,0xBB,0x24,0xFD,0xC2,0x48,0xA1,0x9B,0xFE,0x7B,0x7F,0xCE,0x88,0xDB,0x86,0xD9,
+            0x85,0x3B,0x1C,0xB0,0xDC,0xA8,0x33,0x07,0xBF,0x51,0x2E,0xE3,0x0E,0x9A,0x00,0x97,
+            0x1E,0x06,0xC0,0x97,0x43,0x9D,0xD8,0xB6,0x45,0xC4,0x86,0x67,0x5F,0x00,0xF8,0x88,
+            0x9A,0xA4,0x52,0x9E,0xC7,0xAA,0x8A,0x83,0x75,0xEC,0xC5,0x18,0xAE,0xCE,0xC3,0x2F,
+            0x1A,0x2B,0xF9,0x18,0xFF,0xAE,0x1A,0xF5,0x53,0x0B,0xB5,0x33,0x51,0xA7,0xFD,0xE8,
+            0xA8,0xE1,0xA2,0x64,0xB6,0x22,0x17,0x43,0x80,0xCC,0x0A,0xD8,0xAE,0x3B,0xBA,0x40,
+            0xD7,0xD9,0x92,0x4A,0x89,0xDF,0x04,0x10,0xEE,0x9B,0x18,0x2B,0x6A,0x77,0x69,0x8A,
+            0x68,0xF4,0xF9,0xB9,0xA2,0x21,0x15,0x6E,0xE6,0x1E,0x3B,0x03,0x62,0x30,0x9B,0x60,
+            0x41,0x7E,0x25,0x9B,0x9E,0x8F,0xC5,0x52,0x10,0x08,0xF8,0xC2,0x69,0xA1,0x21,0x11,
+            0x88,0x37,0x5E,0x79,0x35,0x66,0xFF,0x10,0x42,0x18,0x6E,0xED,0x97,0xB6,0x6B,0x1C,
+            0x4E,0x36,0xE5,0x6D,0x7D,0xB4,0xE4,0xBF,0x20,0xB9,0xE0,0x05,0x3A,0x69,0xD5,0xB8,
+            0xE3,0xD5,0xDC,0xE0,0xB9,0xAC,0x53,0x3E,0x07,0xA4,0x57,0xAD,0x77,0xFF,0x48,0x18,
+            0x76,0x2A,0xAC,0x49,0x2A,0x8E,0x47,0x75,0x6D,0x9F,0x67,0x63,0x30,0x35,0x8C,0x39,
+            0x05,0x39,0xD5,0x6F,0x64,0x3A,0x5B,0xAD,0xCA,0x0B,0xBB,0x82,0x52,0x99,0x45,0xB1,
+            0x93,0x36,0x36,0x99,0xAF,0x13,0x20,0x44,0x36,0xD8,0x02,0x44,0x09,0x39,0x92,0x85,
+            0xFF,0x4A,0x4A,0x97,0x87,0xA6,0x63,0xD7,0xC7,0xB5,0xB5,0x24,0xED,0x0F,0xB4,0x6F,
+            0x0C,0x58,0x52,0x14,0xD9,0xA6,0x7B,0xD3,0x79,0xBC,0x38,0x58,0xA1,0xBD,0x3B,0x84,
+            0x06,0xD8,0x1A,0x06,0xFD,0x6B,0xA8,0xEA,0x4B,0x69,0x28,0x04,0x37,0xAD,0x82,0x99,
+            0xFB,0x0E,0x1B,0x85,0xBD,0xA8,0x5D,0x73,0xCD,0xDC,0x58,0x75,0x0A,0xBE,0x63,0x6C,
+            0x48,0xE7,0x4C,0xE4,0x30,0x2B,0x04,0x60,0xB9,0x15,0xD8,0xDA,0x86,0x81,0x75,0x8F,
+            0x96,0xD4,0x8D,0x1C,0x5D,0x70,0x85,0x7C,0x1C,0x67,0x7B,0xD5,0x08,0x67,0xA6,0xCE,
+            0x4B,0x0A,0x66,0x70,0xB7,0xE5,0x63,0xD4,0x5B,0x8A,0x82,0xEA,0x10,0x67,0xCA,0xE2,
+            0xF4,0xEF,0x17,0x85,0x2F,0x2A,0x5F,0x8A,0x97,0x82,0xF8,0x6A,0xD6,0x34,0x10,0xEA,
+            0xEB,0xC9,0x5C,0x3C,0xE1,0x49,0xF8,0x46,0xEB,0xDE,0xBD,0xF6,0xA9,0x92,0xF1,0xAA,
+            0xA6,0xA0,0x18,0xB0,0x3A,0xD3,0x0F,0x1F,0xF3,0x6F,0xFF,0x31,0x45,0x43,0x44,0xD3,
+            0x50,0x9A,0xF7,0x88,0x09,0x96,0xC1,0xCE,0x76,0xCC,0xF2,0x2C,0x2C,0xBA,0xAD,0x82,
+            0x77,0x8F,0x18,0x84,0xC0,0xD2,0x07,0x9C,0x36,0x90,0x83,0x4E,0x0B,0xA5,0x4F,0x43,
+            0x3E,0x04,0xAB,0x78,0x4F,0xD6,0xFB,0x09,0x01,0x24,0x90,0xDA,0x6F,0x3C,0x3A,0x61,
+            0x0D,0x7F,0x69,0x4A,0xEB,0x2B,0x30,0x02,0xB4,0xDB,0xE0,0x84,0xA9,0xEC,0xD7,0x35,
+            0xBF,0x37,0x7D,0x85,0x58,0xCE,0xA9,0x4E,0xE4,0x80,0xC7,0xA8,0xD3,0x30,0x67,0x48,
+            0xEB,0x29,0xAF,0x2F,0x74,0x6A,0xB4,0xA7,0x3F,0x0F,0x3F,0x92,0xAF,0xF3,0xCA,0xAC,
+            0xAF,0x4B,0xD9,0x94,0xC0,0x43,0xCA,0x81,0x0D,0x2F,0x48,0xA1,0xB0,0x27,0xD5,0xD2,
+            0xEF,0x4B,0x05,0x85,0xA3,0xDE,0x4D,0x93,0x30,0x3C,0xF0,0xBB,0x4A,0x8F,0x30,0x27,
+            0x4C,0xEB,0xE3,0x3E,0x64,0xED,0x9A,0x2F,0x3B,0xF1,0x82,0xF0,0xBA,0xF4,0xCF,0x7F,
+            0x40,0xCB,0xB0,0xE1,0x7F,0xBC,0xAA,0x57,0xD3,0xC9,0x74,0xF2,0xFA,0x43,0x0D,0x22,
+            0xD0,0xF4,0x77,0x4E,0x93,0xD7,0x85,0x70,0x1F,0x99,0xBF,0xB6,0xDE,0x35,0xF1,0x30,
+            0xA7,0x5E,0x71,0xF0,0x6B,0x01,0x2D,0x7B,0x64,0xF0,0x33,0x53,0x0A,0x39,0x88,0xF3,
+            0x6B,0x3A,0xA6,0x6B,0x35,0xD2,0x2F,0x43,0xCD,0x02,0xFD,0xB5,0xE9,0xBC,0x5B,0xAA,
+            0xD8,0xA4,0x19,0x7E,0x0E,0x5D,0x94,0x81,0x9E,0x6F,0x77,0xAD,0xD6,0x0E,0x74,0x93,
+            0x96,0xE7,0xC4,0x18,0x5F,0xAD,0xF5,0x19,
+        };
+
+        // Setup Keys and IVs
+        public static byte[] PlainCounter = new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+        public static byte[] ExefsCounter = new byte[] { 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+        public static byte[] RomfsCounter = new byte[] { 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+        // Note: BigInteger requires the 0x00 at the end of each string in order to preserve the sign value
+        // Note: BigInteger requires that the values be in little endian format, the values in 
+
+        // Big Endian - 0x1F, 0xF9, 0xE9, 0xAA, 0xC5, 0xFE, 0x04, 0x08, 0x02, 0x45, 0x91, 0xDC, 0x5D, 0x52, 0x76, 0x8A
+        // Little Endian - 0x8A, 0x76, 0x52, 0x5D, 0xDC, 0x91, 0x45, 0x02, 0x08, 0x04, 0xFE, 0xC5, 0xAA, 0xE9, 0xF9, 0x1F
+        public static BigInteger AESHardwareConstant = new BigInteger(new byte[] { 0x8A, 0x76, 0x52, 0x5D, 0xDC, 0x91, 0x45, 0x02, 0x08, 0x04, 0xFE, 0xC5, 0xAA, 0xE9, 0xF9, 0x1F });
+
+        #region Retail 3DS keys
+
+        // KeyX 0x18 (New 3DS 9.3)
+        // Big Endian - 0x82, 0xE9, 0xC9, 0xBE, 0xBF, 0xB8, 0xBD, 0xB8, 0x75, 0xEC, 0xC0, 0xA0, 0x7D, 0x47, 0x43, 0x74
+        // Little Endian - 0x74, 0x43, 0x47, 0x7D, 0xA0, 0xC0, 0xEC, 0x75, 0xB8, 0xBD, 0xB8, 0xBF, 0xBE, 0xC9, 0xE9, 0x82
+        public static BigInteger KeyX0x18 = new BigInteger(new byte[] { 0x74, 0x43, 0x47, 0x7D, 0xA0, 0xC0, 0xEC, 0x75, 0xB8, 0xBD, 0xB8, 0xBF, 0xBE, 0xC9, 0xE9, 0x82, 0x00 });
+
+        // KeyX 0x1B (New 3DS 9.6)
+        // Big Endian - 0x45, 0xAD, 0x04, 0x95, 0x39, 0x92, 0xC7, 0xC8, 0x93, 0x72, 0x4A, 0x9A, 0x7B, 0xCE, 0x61, 0x82
+        // Little Endian - 0x82, 0x61, 0xCE, 0x7B, 0x9A, 0x4A, 0x72, 0x93, 0xC8, 0xC7, 0x92, 0x39, 0x95, 0x04, 0xAD, 0x45
+        public static BigInteger KeyX0x1B = new BigInteger(new byte[] { 0x82, 0x61, 0xCE, 0x7B, 0x9A, 0x4A, 0x72, 0x93, 0xC8, 0xC7, 0x92, 0x39, 0x95, 0x04, 0xAD, 0x45, 0x00 });
+
+        // KeyX 0x25 (> 7.x)
+        // Big Endian - 0xCE, 0xE7, 0xD8, 0xAB, 0x30, 0xC0, 0x0D, 0xAE, 0x85, 0x0E, 0xF5, 0xE3, 0x82, 0xAC, 0x5A, 0xF3
+        // Little Endian - 0xF3, 0x5A, 0xAC, 0x82, 0xE3, 0xF5, 0x0E, 0x85, 0xAE, 0x0D, 0xC0, 0x30, 0xAB, 0xD8, 0xE7, 0xCE
+        public static BigInteger KeyX0x25 = new BigInteger(new byte[] { 0xF3, 0x5A, 0xAC, 0x82, 0xE3, 0xF5, 0x0E, 0x85, 0xAE, 0x0D, 0xC0, 0x30, 0xAB, 0xD8, 0xE7, 0xCE, 0x00 });
+
+        // Dev KeyX 0x2C (< 6.x)
+        // Big Endian - 0xB9, 0x8E, 0x95, 0xCE, 0xCA, 0x3E, 0x4D, 0x17, 0x1F, 0x76, 0xA9, 0x4D, 0xE9, 0x34, 0xC0, 0x53
+        // Little Endian - 0x53, 0xC0, 0x34, 0xE9, 0x4D, 0xA9, 0x76, 0x1F, 0x17, 0x4D, 0x3E, 0xCA, 0xCE, 0x95, 0x8E, 0xB9
+        public static BigInteger KeyX0x2C = new BigInteger(new byte[] { 0x53, 0xC0, 0x34, 0xE9, 0x4D, 0xA9, 0x76, 0x1F, 0x17, 0x4D, 0x3E, 0xCA, 0xCE, 0x95, 0x8E, 0xB9, 0x00 });
+
+        #endregion
+
+        #region Dev 3DS Keys
+
+        // Dev KeyX 0x18 (New 3DS 9.3)
+        // Big Endian - 0x30, 0x4B, 0xF1, 0x46, 0x83, 0x72, 0xEE, 0x64, 0x11, 0x5E, 0xBD, 0x40, 0x93, 0xD8, 0x42, 0x76
+        // Little Endian - 0x76, 0x42, 0xD8, 0x93, 0x40, 0xBD, 0x5E, 0x11, 0x64, 0xEE, 0x72, 0x83, 0x46, 0xF1, 0x4B, 0x30
+        public static BigInteger DevKeyX0x18 = new BigInteger(new byte[] { 0x76, 0x42, 0xD8, 0x93, 0x40, 0xBD, 0x5E, 0x11, 0x64, 0xEE, 0x72, 0x83, 0x46, 0xF1, 0x4B, 0x30, 0x00 });
+
+        // Dev KeyX 0x1B New 3DS 9.6)
+        // Big Endian - 0x6C, 0x8B, 0x29, 0x44, 0xA0, 0x72, 0x60, 0x35, 0xF9, 0x41, 0xDF, 0xC0, 0x18, 0x52, 0x4F, 0xB6
+        // Little Endian - 0xB6, 0x4F, 0x52, 0x18, 0xC0, 0xDF, 0x41, 0xF9, 0x35, 0x60, 0x72, 0xA0, 0x44, 0x29, 0x8B, 0x6C
+        public static BigInteger DevKeyX0x1B = new BigInteger(new byte[] { 0xB6, 0x4F, 0x52, 0x18, 0xC0, 0xDF, 0x41, 0xF9, 0x35, 0x60, 0x72, 0xA0, 0x44, 0x29, 0x8B, 0x6C, 0x00 });
+
+        // Dev KeyX 0x25 (> 7.x)
+        // Big Endian - 0x81, 0x90, 0x7A, 0x4B, 0x6F, 0x1B, 0x47, 0x32, 0x3A, 0x67, 0x79, 0x74, 0xCE, 0x4A, 0xD7, 0x1B
+        // Little Endian - 0x1B, 0xD7, 0x4A, 0xCE, 0x74, 0x79, 0x67, 0x3A, 0x32, 0x47, 0x1B, 0x6F, 0x4B, 0x7A, 0x90, 0x81
+        public static BigInteger DevKeyX0x25 = new BigInteger(new byte[] { 0x1B, 0xD7, 0x4A, 0xCE, 0x74, 0x79, 0x67, 0x3A, 0x32, 0x47, 0x1B, 0x6F, 0x4B, 0x7A, 0x90, 0x81, 0x00 });
+
+        // Dev KeyX 0x2C (< 6.x)
+        // Big Endian - 0x51, 0x02, 0x07, 0x51, 0x55, 0x07, 0xCB, 0xB1, 0x8E, 0x24, 0x3D, 0xCB, 0x85, 0xE2, 0x3A, 0x1D
+        // Little Endian - 0x1D, 0x3A, 0xE2, 0x85, 0xCB, 0x3D, 0x24, 0x8E, 0xB1, 0xCB, 0x07, 0x55, 0x51, 0x07, 0x02, 0x51
+        public static BigInteger DevKeyX0x2C = new BigInteger(new byte[] { 0x1D, 0x3A, 0xE2, 0x85, 0xCB, 0x3D, 0x24, 0x8E, 0xB1, 0xCB, 0x07, 0x55, 0x51, 0x07, 0x02, 0x51, 0x00 });
+
+        #endregion
+
+        public const int CXTExtendedDataHeaderLength = 0x800;
+    }
+}
--- a/3DSDecrypt/Data/Enums.cs
+++ b/3DSDecrypt/Data/Enums.cs
@@ -1,6 +1,6 @@
 using System;

-namespace ThreeDS.Data
+namespace NDecrypt.Data
 {
    [Flags]
    public enum ARM9AccessControlDescriptors : byte
@@ -165,6 +165,13 @@ namespace ThreeDS.Data
        MediaCardDevice2X = 0x07,
    }

+    public enum NDSUnitcode : byte
+    {
+        NDS = 0x00,
+        NDSPlusDSi = 0x02,
+        DSi = 0x03,
+    }
+
    public enum ResourceLimitCategory
    {
        APPLICATION = 0,
--- a/3DSDecrypt/Headers/ARM11KernelCapabilities.cs
+++ b/3DSDecrypt/Headers/ARM11KernelCapabilities.cs
@@ -1,6 +1,6 @@
 using System.IO;

-namespace ThreeDS.Headers
+namespace NDecrypt.Headers
 {
    public class ARM11KernelCapabilities
    {
--- a/3DSDecrypt/Headers/ARM11LocalSystemCapabilities.cs
+++ b/3DSDecrypt/Headers/ARM11LocalSystemCapabilities.cs
@@ -1,7 +1,7 @@
 using System.IO;
-using ThreeDS.Data;
+using NDecrypt.Data;

-namespace ThreeDS.Headers
+namespace NDecrypt.Headers
 {
    public class ARM11LocalSystemCapabilities
    {
--- a/3DSDecrypt/Headers/ARM9AccessControl.cs
+++ b/3DSDecrypt/Headers/ARM9AccessControl.cs
@@ -1,7 +1,7 @@
 using System.IO;
-using ThreeDS.Data;
+using NDecrypt.Data;

-namespace ThreeDS.Headers
+namespace NDecrypt.Headers
 {
    public class ARM9AccessControl
    {
--- a/3DSDecrypt/Headers/AccessControlInfo.cs
+++ b/3DSDecrypt/Headers/AccessControlInfo.cs
@@ -1,6 +1,6 @@
 using System.IO;

-namespace ThreeDS.Headers
+namespace NDecrypt.Headers
 {
    public class AccessControlInfo
    {
--- a/3DSDecrypt/Headers/CXIExtendedHeader.cs
+++ b/3DSDecrypt/Headers/CXIExtendedHeader.cs
@@ -1,6 +1,6 @@
 using System.IO;

-namespace ThreeDS.Headers
+namespace NDecrypt.Headers
 {
    public class CXIExtendedHeader
    {
--- a/3DSDecrypt/Headers/CodeSetInfo.cs
+++ b/3DSDecrypt/Headers/CodeSetInfo.cs
@@ -1,6 +1,6 @@
 using System.IO;

-namespace ThreeDS.Headers
+namespace NDecrypt.Headers
 {
    public class CodeSetInfo
    {
--- a/3DSDecrypt/Headers/ExeFSFileHeader.cs
+++ b/3DSDecrypt/Headers/ExeFSFileHeader.cs
@@ -2,7 +2,7 @@
 using System.Linq;
 using System.Text;

-namespace ThreeDS.Headers
+namespace NDecrypt.Headers
 {
    public class ExeFSFileHeader
    {
--- a/3DSDecrypt/Headers/ExeFSHeader.cs
+++ b/3DSDecrypt/Headers/ExeFSHeader.cs
@@ -1,6 +1,6 @@
 using System.IO;

-namespace ThreeDS.Headers
+namespace NDecrypt.Headers
 {
    public class ExeFSHeader
    {
--- a/3DSDecrypt/Headers/NCCHHeader.cs
+++ b/3DSDecrypt/Headers/NCCHHeader.cs
@@ -2,9 +2,9 @@
 using System.IO;
 using System.Linq;
 using System.Numerics;
-using ThreeDS.Data;
+using NDecrypt.Data;

-namespace ThreeDS.Headers
+namespace NDecrypt.Headers
 {
    public class NCCHHeader
    {
--- a/3DSDecrypt/Headers/NCCHHeaderFlags.cs
+++ b/3DSDecrypt/Headers/NCCHHeaderFlags.cs
@@ -1,8 +1,8 @@
 using System;
 using System.IO;
-using ThreeDS.Data;
+using NDecrypt.Data;

-namespace ThreeDS.Headers
+namespace NDecrypt.Headers
 {
    public class NCCHHeaderFlags
    {
--- a/3DSDecrypt/Headers/NCSDHeader.cs
+++ b/3DSDecrypt/Headers/NCSDHeader.cs
@@ -1,8 +1,8 @@
 using System;
 using System.IO;
-using ThreeDS.Data;
+using NDecrypt.Data;

-namespace ThreeDS.Headers
+namespace NDecrypt.Headers
 {
    public class NCSDHeader
    {
--- a/NDecrypt/Headers/NDSHeader.cs
+++ b/NDecrypt/Headers/NDSHeader.cs
@@ -0,0 +1,854 @@
+using System;
+using System.IO;
+using System.Linq;
+using NDecrypt.Data;
+
+namespace NDecrypt.Headers
+{
+    public class NDSHeader
+    {
+        #region Encryption process variables
+
+        private uint[] cardHash = new uint[0x412];
+        private uint[] arg2 = new uint[3];
+
+        // ARM9 decryption check values
+        private const uint MAGIC30 = 0x72636E65;
+        private const uint MAGIC34 = 0x6A624F79;
+
+        #endregion
+
+        #region Common to all NDS files
+
+        /// <summary>
+        /// Game Title
+        /// </summary>
+        public char[] GameTitle { get; private set; }
+
+        /// <summary>
+        /// Gamecode
+        /// </summary>
+        public uint Gamecode { get; private set; }
+
+        /// <summary>
+        /// Makercode
+        /// </summary>
+        public char[] Makercode { get; private set; }
+
+        /// <summary>
+        /// Unitcode
+        /// </summary>
+        public NDSUnitcode Unitcode { get; private set; }
+
+        /// <summary>
+        /// Encryption seed select (device code. 0 = normal)
+        /// </summary>
+        public byte EncryptionSeedSelect { get; private set; }
+
+        /// <summary>
+        /// Devicecapacity
+        /// </summary>
+        public byte Devicecapacity { get; private set; }
+        public int DeviceCapacityInBytes { get { return (1 << Devicecapacity) * (1024 * 1024); } }
+
+        /// <summary>
+        /// Reserved
+        /// </summary>
+        public byte[] Reserved1 { get; private set; }
+
+        /// <summary>
+        /// Game Revision (used by DSi titles)
+        /// </summary>
+        public ushort GameRevision { get; private set; }
+
+        /// <summary>
+        /// ROM Version
+        /// </summary>
+        public byte RomVersion { get; private set; }
+
+        /// <summary>
+        /// Internal flags, (Bit2: Autostart)
+        /// </summary>
+        public byte InternalFlags { get; private set; }
+
+        /// <summary>
+        /// ARM9 rom offset
+        /// </summary>
+        public uint ARM9RomOffset { get; private set; }
+
+        /// <summary>
+        /// ARM9 entry address
+        /// </summary>
+        public uint ARM9EntryAddress { get; private set; }
+
+        /// <summary>
+        /// ARM9 load address
+        /// </summary>
+        public uint ARM9LoadAddress { get; private set; }
+
+        /// <summary>
+        /// ARM9 size
+        /// </summary>
+        public uint ARM9Size { get; private set; }
+
+        /// <summary>
+        /// ARM7 rom offset
+        /// </summary>
+        public uint ARM7RomOffset { get; private set; }
+
+        /// <summary>
+        /// ARM7 entry address
+        /// </summary>
+        public uint ARM7EntryAddress { get; private set; }
+
+        /// <summary>
+        /// ARM7 load address
+        /// </summary>
+        public uint ARM7LoadAddress { get; private set; }
+
+        /// <summary>
+        /// ARM7 size
+        /// </summary>
+        public uint ARM7Size { get; private set; }
+
+        /// <summary>
+        /// File Name Table (FNT) offset
+        /// </summary>
+        public uint FileNameTableOffset { get; private set; }
+
+        /// <summary>
+        /// File Name Table (FNT) length
+        /// </summary>
+        public uint FileNameTableLength { get; private set; }
+
+        /// <summary>
+        /// File Allocation Table (FNT) offset
+        /// </summary>
+        public uint FileAllocationTableOffset { get; private set; }
+
+        /// <summary>
+        /// File Allocation Table (FNT) length
+        /// </summary>
+        public uint FileAllocationTableLength { get; private set; }
+
+        /// <summary>
+        /// File Name Table (FNT) offset
+        /// </summary>
+        public uint ARM9OverlayOffset { get; private set; }
+
+        /// <summary>
+        /// File Name Table (FNT) length
+        /// </summary>
+        public uint ARM9OverlayLength { get; private set; }
+
+        /// <summary>
+        /// File Name Table (FNT) offset
+        /// </summary>
+        public uint ARM7OverlayOffset { get; private set; }
+
+        /// <summary>
+        /// File Name Table (FNT) length
+        /// </summary>
+        public uint ARM7OverlayLength { get; private set; }
+
+        /// <summary>
+        /// Normal card control register settings (0x00416657 for OneTimePROM)
+        /// </summary>
+        public byte[] NormalCardControlRegisterSettings { get; private set; }
+
+        /// <summary>
+        /// Secure card control register settings (0x081808F8 for OneTimePROM)
+        /// </summary>
+        public byte[] SecureCardControlRegisterSettings { get; private set; }
+
+        /// <summary>
+        /// Icon Banner offset (NDSi same as NDS, but with new extra entries)
+        /// </summary>
+        public uint IconBannerOffset { get; private set; }
+
+        /// <summary>
+        /// Secure area (2K) CRC
+        /// </summary>
+        public ushort SecureAreaCRC { get; private set; }
+
+        /// <summary>
+        /// Secure transfer timeout (0x0D7E for OneTimePROM)
+        /// </summary>
+        public ushort SecureTransferTimeout { get; private set; }
+
+        /// <summary>
+        /// ARM9 autoload
+        /// </summary>
+        public byte[] ARM9Autoload { get; private set; }
+
+        /// <summary>
+        /// ARM7 autoload
+        /// </summary>
+        public byte[] ARM7Autoload { get; private set; }
+
+        /// <summary>
+        /// Secure disable
+        /// </summary>
+        public byte[] SecureDisable { get; private set; }
+
+        /// <summary>
+        /// NTR region ROM size (excluding DSi area)
+        /// </summary>
+        public uint NTRRegionRomSize { get; private set; }
+
+        /// <summary>
+        /// Header size
+        /// </summary>
+        public uint HeaderSize { get; private set; }
+
+        /// <summary>
+        ///Reserved (0x88, 0x8C, 0x90 = Unknown, used by DSi)
+        /// </summary>
+        public byte[] Reserved2 { get; private set; }
+
+        /// <summary>
+        /// Nintendo Logo
+        /// </summary>
+        public byte[] NintendoLogo { get; private set; }
+
+        /// <summary>
+        /// Nintendo Logo CRC
+        /// </summary>
+        public ushort NintendoLogoCRC { get; private set; }
+
+        /// <summary>
+        /// Header CRC
+        /// </summary>
+        public ushort HeaderCRC { get; private set; }
+
+        /// <summary>
+        /// Debugger reserved
+        /// </summary>
+        public byte[] DebuggerReserved { get; private set; }
+
+        #endregion
+
+        #region Extended DSi
+
+        /// <summary>
+        /// Global MBK1..MBK5 Settings
+        /// </summary>
+        public byte[] GlobalMBK15Settings { get; private set; }
+
+        /// <summary>
+        ///	Local MBK6..MBK8 Settings for ARM9
+        /// </summary>
+        public byte[] LocalMBK68SettingsARM9 { get; private set; }
+
+        /// <summary>
+        /// Local MBK6..MBK8 Settings for ARM7
+        /// </summary>
+        public byte[] LocalMBK68SettingsARM7 { get; private set; }
+
+        /// <summary>
+        /// Global MBK9 Setting
+        /// </summary>
+        public byte[] GlobalMBK9Setting { get; private set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public byte[] RegionFlags { get; private set; }
+
+        /// <summary>
+        /// Access control
+        /// </summary>
+        public byte[] AccessControl { get; private set; }
+
+        /// <summary>
+        /// ARM7 SCFG EXT mask (controls which devices to enable)
+        /// </summary>
+        public byte[] ARM7SCFGEXTMask { get; private set; }
+
+        /// <summary>
+        /// Reserved/flags? When bit2 of byte 0x1bf is set, usage of banner.sav from the title data dir is enabled.(additional banner data)
+        /// </summary>
+        public byte[] ReservedFlags { get; private set; }
+
+        /// <summary>
+        /// ARM9i rom offset
+        /// </summary>
+        public uint ARM9iRomOffset { get; private set; }
+
+        /// <summary>
+        /// Reserved
+        /// </summary>
+        public byte[] Reserved3 { get; private set; }
+
+        /// <summary>
+        /// ARM9i load address
+        /// </summary>
+        public uint ARM9iLoadAddress { get; private set; }
+
+        /// <summary>
+        /// ARM9i size;
+        /// </summary>
+        public uint ARM9iSize { get; private set; }
+
+        /// <summary>
+        /// ARM7i rom offset
+        /// </summary>
+        public uint ARM7iRomOffset { get; private set; }
+
+        /// <summary>
+        /// Pointer to base address where various structures and parameters are passed to the title - what is that???
+        /// </summary>
+        public byte[] Reserved4 { get; private set; }
+
+        /// <summary>
+        /// ARM7i load address
+        /// </summary>
+        public uint ARM7iLoadAddress { get; private set; }
+
+        /// <summary>
+        /// ARM7i size;
+        /// </summary>
+        public uint ARM7iSize { get; private set; }
+
+        /// <summary>
+        /// Digest NTR region offset
+        /// </summary>
+        public uint DigestNTRRegionOffset { get; private set; }
+
+        /// <summary>
+        /// Digest NTR region length
+        /// </summary>
+        public uint DigestNTRRegionLength { get; private set; }
+
+        // <summary>
+        /// Digest TWL region offset
+        /// </summary>
+        public uint DigestTWLRegionOffset { get; private set; }
+
+        /// <summary>
+        /// Digest TWL region length
+        /// </summary>
+        public uint DigestTWLRegionLength { get; private set; }
+
+        // <summary>
+        /// Digest Sector Hashtable region offset
+        /// </summary>
+        public uint DigestSectorHashtableRegionOffset { get; private set; }
+
+        /// <summary>
+        /// Digest Sector Hashtable region length
+        /// </summary>
+        public uint DigestSectorHashtableRegionLength { get; private set; }
+
+        // <summary>
+        /// Digest Block Hashtable region offset
+        /// </summary>
+        public uint DigestBlockHashtableRegionOffset { get; private set; }
+
+        /// <summary>
+        /// Digest Block Hashtable region length
+        /// </summary>
+        public uint DigestBlockHashtableRegionLength { get; private set; }
+
+        /// <summary>
+        /// Digest Sector size
+        /// </summary>
+        public uint DigestSectorSize { get; private set; }
+
+        /// <summary>
+        /// Digeset Block Sectorount
+        /// </summary>
+        public uint DigestBlockSectorCount { get; private set; }
+
+        /// <summary>
+        /// Icon Banner Size (usually 0x23C0)
+        /// </summary>
+        public uint IconBannerSize { get; private set; }
+
+        /// <summary>
+        /// Unknown (used by DSi)
+        /// </summary>
+        public byte[] Unknown1 { get; private set; }
+
+        /// <summary>
+        /// NTR+TWL region ROM size (total size including DSi area)
+        /// </summary>
+        public uint NTRTWLRegionRomSize { get; private set; }
+
+        /// <summary>
+        /// Unknown (used by DSi)
+        /// </summary>
+        public byte[] Unknown2 { get; private set; }
+
+        /// <summary>
+        /// Modcrypt area 1 offset
+        /// </summary>
+        public uint ModcryptArea1Offset { get; private set; }
+
+        /// <summary>
+        /// Modcrypt area 1 size
+        /// </summary>
+        public uint ModcryptArea1Size { get; private set; }
+
+        /// <summary>
+        /// Modcrypt area 2 offset
+        /// </summary>
+        public uint ModcryptArea2Offset { get; private set; }
+
+        /// <summary>
+        /// Modcrypt area 2 size
+        /// </summary>
+        public uint ModcryptArea2Size { get; private set; }
+
+        /// <summary>
+        /// Title ID
+        /// </summary>
+        public byte[] TitleID { get; private set; }
+
+        /// <summary>
+        /// DSiWare: "public.sav" size
+        /// </summary>
+        public uint DSiWarePublicSavSize { get; private set; }
+
+        /// <summary>
+        /// DSiWare: "private.sav" size
+        /// </summary>
+        public uint DSiWarePrivateSavSize { get; private set; }
+
+        /// <summary>
+        /// Reserved (zero)
+        /// </summary>
+        public byte[] ReservedZero { get; private set; }
+
+        /// <summary>
+        /// Unknown (used by DSi)
+        /// </summary>
+        public byte[] Unknown3 { get; private set; }
+
+        /// <summary>
+        /// ARM9 (with encrypted secure area) SHA1 HMAC hash
+        /// </summary>
+        public byte[] ARM9WithSecureAreaSHA1HMACHash { get; private set; }
+
+        /// <summary>
+        /// ARM7 SHA1 HMAC hash
+        /// </summary>
+        public byte[] ARM7SHA1HMACHash { get; private set; }
+
+        /// <summary>
+        /// Digest master SHA1 HMAC hash
+        /// </summary>
+        public byte[] DigestMasterSHA1HMACHash { get; private set; }
+
+        /// <summary>
+        /// Banner SHA1 HMAC hash
+        /// </summary>
+        public byte[] BannerSHA1HMACHash { get; private set; }
+
+        /// <summary>
+        /// ARM9i (decrypted) SHA1 HMAC hash
+        /// </summary>
+        public byte[] ARM9iDecryptedSHA1HMACHash { get; private set; }
+
+        /// <summary>
+        /// ARM7i (decrypted) SHA1 HMAC hash
+        /// </summary>
+        public byte[] ARM7iDecryptedSHA1HMACHash { get; private set; }
+
+        /// <summary>
+        /// Reserved
+        /// </summary>
+        public byte[] Reserved5 { get; private set; }
+
+        /// <summary>
+        /// ARM9 (without secure area) SHA1 HMAC hash
+        /// </summary>
+        public byte[] ARM9NoSecureAreaSHA1HMACHash { get; private set; }
+
+        /// <summary>
+        /// Reserved
+        /// </summary>
+        public byte[] Reserved6 { get; private set; }
+
+        /// <summary>
+        /// Reserved and unchecked region, always zero. Used for passing arguments in debug environment.
+        /// </summary>
+        public byte[] ReservedAndUnchecked { get; private set; }
+
+        /// <summary>
+        /// RSA signature (the first 0xE00 bytes of the header are signed with an 1024-bit RSA signature).
+        /// </summary>
+        public byte[] RSASignature { get; private set; }
+
+        #endregion
+
+        /// <summary>
+        /// Read from a stream and get an NDS/NDSi header, if possible
+        /// </summary>
+        /// <param name="reader">BinaryReader representing the input stream</param>
+        /// <returns>NDS/NDSi header object, null on error</returns>
+        public static NDSHeader Read(BinaryReader reader)
+        {
+            NDSHeader header = new NDSHeader();
+
+            try
+            {
+                header.GameTitle = reader.ReadChars(0xC);
+                header.Gamecode = reader.ReadUInt32();
+                header.Makercode = reader.ReadChars(2);
+                header.Unitcode = (NDSUnitcode)reader.ReadByte();
+                header.EncryptionSeedSelect = reader.ReadByte();
+                header.Devicecapacity = reader.ReadByte();
+                header.Reserved1 = reader.ReadBytes(7);
+                header.GameRevision = reader.ReadUInt16();
+                header.RomVersion = reader.ReadByte();
+                header.InternalFlags = reader.ReadByte();
+                header.ARM9RomOffset = reader.ReadUInt32();
+                header.ARM9EntryAddress = reader.ReadUInt32();
+                header.ARM9LoadAddress = reader.ReadUInt32();
+                header.ARM9Size = reader.ReadUInt32();
+                header.ARM7RomOffset = reader.ReadUInt32();
+                header.ARM7EntryAddress = reader.ReadUInt32();
+                header.ARM7LoadAddress = reader.ReadUInt32();
+                header.ARM7Size = reader.ReadUInt32();
+                header.FileNameTableOffset = reader.ReadUInt32();
+                header.FileNameTableLength = reader.ReadUInt32();
+                header.FileAllocationTableOffset = reader.ReadUInt32();
+                header.FileAllocationTableLength = reader.ReadUInt32();
+                header.ARM9OverlayOffset = reader.ReadUInt32();
+                header.ARM9OverlayLength = reader.ReadUInt32();
+                header.ARM7OverlayOffset = reader.ReadUInt32();
+                header.ARM7OverlayLength = reader.ReadUInt32();
+                header.SecureDisable = reader.ReadBytes(8);
+                header.NTRRegionRomSize = reader.ReadUInt32();
+                header.HeaderSize = reader.ReadUInt32();
+                header.Reserved2 = reader.ReadBytes(56);
+                header.NintendoLogo = reader.ReadBytes(156);
+                header.NintendoLogoCRC = reader.ReadUInt16();
+                header.DebuggerReserved = reader.ReadBytes(0x20);
+
+                // If we have a DSi compatible title
+                if (header.Unitcode == NDSUnitcode.NDSPlusDSi
+                    || header.Unitcode == NDSUnitcode.DSi)
+                {
+                    header.GlobalMBK15Settings = reader.ReadBytes(20);
+                    header.LocalMBK68SettingsARM9 = reader.ReadBytes(12);
+                    header.LocalMBK68SettingsARM7 = reader.ReadBytes(12);
+                    header.GlobalMBK9Setting = reader.ReadBytes(4);
+                    header.RegionFlags = reader.ReadBytes(4);
+                    header.AccessControl = reader.ReadBytes(4);
+                    header.ARM7SCFGEXTMask = reader.ReadBytes(4);
+                    header.ReservedFlags = reader.ReadBytes(4);
+                    header.ARM9iRomOffset = reader.ReadUInt32();
+                    header.Reserved3 = reader.ReadBytes(4);
+                    header.ARM9iLoadAddress = reader.ReadUInt32();
+                    header.ARM9iSize = reader.ReadUInt32();
+                    header.ARM7iRomOffset = reader.ReadUInt32();
+                    header.Reserved4 = reader.ReadBytes(4);
+                    header.ARM7iLoadAddress = reader.ReadUInt32();
+                    header.ARM7iSize = reader.ReadUInt32();
+                    header.DigestNTRRegionOffset = reader.ReadUInt32();
+                    header.DigestNTRRegionLength = reader.ReadUInt32();
+                    header.DigestTWLRegionOffset = reader.ReadUInt32();
+                    header.DigestTWLRegionLength = reader.ReadUInt32();
+                    header.DigestSectorHashtableRegionOffset = reader.ReadUInt32();
+                    header.DigestSectorHashtableRegionLength = reader.ReadUInt32();
+                    header.DigestBlockHashtableRegionOffset = reader.ReadUInt32();
+                    header.DigestBlockHashtableRegionLength = reader.ReadUInt32();
+                    header.DigestSectorSize = reader.ReadUInt32();
+                    header.DigestBlockSectorCount = reader.ReadUInt32();
+                    header.IconBannerSize = reader.ReadUInt32();
+                    header.Unknown1 = reader.ReadBytes(4);
+                    header.ModcryptArea1Offset = reader.ReadUInt32();
+                    header.ModcryptArea1Size = reader.ReadUInt32();
+                    header.ModcryptArea2Offset = reader.ReadUInt32();
+                    header.ModcryptArea2Size = reader.ReadUInt32();
+                    header.TitleID = reader.ReadBytes(8);
+                    header.DSiWarePublicSavSize = reader.ReadUInt32();
+                    header.DSiWarePrivateSavSize = reader.ReadUInt32();
+                    header.ReservedZero = reader.ReadBytes(176);
+                    header.Unknown2 = reader.ReadBytes(0x10);
+                    header.ARM9WithSecureAreaSHA1HMACHash = reader.ReadBytes(20);
+                    header.ARM7SHA1HMACHash = reader.ReadBytes(20);
+                    header.DigestMasterSHA1HMACHash = reader.ReadBytes(20);
+                    header.BannerSHA1HMACHash = reader.ReadBytes(20);
+                    header.ARM9iDecryptedSHA1HMACHash = reader.ReadBytes(20);
+                    header.ARM7iDecryptedSHA1HMACHash = reader.ReadBytes(20);
+                    header.Reserved5 = reader.ReadBytes(40);
+                    header.ARM9NoSecureAreaSHA1HMACHash = reader.ReadBytes(20);
+                    header.Reserved6 = reader.ReadBytes(2636);
+                    header.ReservedAndUnchecked = reader.ReadBytes(0x180);
+                    header.RSASignature = reader.ReadBytes(0x80);
+                }
+
+                return header;
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Process secure area in the DS/DSi file
+        /// </summary>
+        /// <param name="reader">BinaryReader representing the input stream</param>
+        /// <param name="writer">BinaryWriter representing the output stream</param>
+        /// <param name="encrypt">True if we want to encrypt the partitions, false otherwise</param>
+        public void ProcessSecureArea(BinaryReader reader, BinaryWriter writer, bool encrypt)
+        {
+            bool? isDecrypted = CheckIfDecrypted(reader);
+            if (isDecrypted == null)
+            {
+                Console.WriteLine("File has an empty secure area, cannot proceed");
+                return;
+            }
+            else if (encrypt ^ isDecrypted.Value)
+            {
+                Console.WriteLine("File is already " + (encrypt ? "encrypted" : "decrypted"));
+                return;
+            }
+
+            ProcessARM9(reader, writer, encrypt);
+
+            Console.WriteLine("File has been " + (encrypt ? "encrypted" : "decrypted"));
+        }
+
+        /// <summary>
+        /// Determine if the current file is already decrypted or not (or has an empty secure area)
+        /// </summary>
+        /// <param name="reader">BinaryReader representing the input stream</param>
+        /// <returns>True if the file has known values for a decrypted file, null if it's empty, false otherwise</returns>
+        private bool? CheckIfDecrypted(BinaryReader reader)
+        {
+            reader.BaseStream.Seek(0x4000, SeekOrigin.Begin);
+            uint firstValue = reader.ReadUInt32();
+            uint secondValue = reader.ReadUInt32();
+
+            // Empty secure area standard
+            if (firstValue == 0x00000000 && secondValue == 0x00000000)
+                return null;
+
+            // Improperly decrypted empty secure area (decrypt empty with woodsec)
+            else if ((firstValue == 0xE386C397 && secondValue == 0x82775B7E)
+                  || (firstValue == 0xF98415B8 && secondValue == 0x698068FC))
+                return true;
+
+            // Improperly encrypted empty secure area (encrypt empty with woodsec)
+            else if ((firstValue == 0x4BCE88BE && secondValue == 0xD3662DD1)
+                  || (firstValue == 0x2543C534 && secondValue == 0xCC4BE38E))
+                return false;
+
+            // Properly decrypted nonstandard value (mastering issue)
+            else if (firstValue == 0xD0D48B67 && secondValue == 0x39392F23)
+                return true;
+
+            // Standard decryption values
+            return (firstValue == 0xE7FFDEFF && secondValue == 0xE7FFDEFF);
+        }
+
+        /// <summary>
+        /// Process the secure ARM9 region of the file, if possible
+        /// </summary>
+        /// <param name="reader">BinaryReader representing the input stream</param>
+        /// <param name="writer">BinaryWriter representing the output stream</param>
+        /// <param name="encrypt">True if we want to encrypt the partitions, false otherwise</param>
+        private void ProcessARM9(BinaryReader reader, BinaryWriter writer, bool encrypt)
+        {
+            // Seek to the beginning of the secure area
+            reader.BaseStream.Seek(0x4000, SeekOrigin.Begin);
+            writer.BaseStream.Seek(0x4000, SeekOrigin.Begin);
+
+            // Grab the first two blocks
+            uint p0 = reader.ReadUInt32();
+            uint p1 = reader.ReadUInt32();
+
+            // Perform the initialization steps
+            Init1();
+            if (!encrypt) Decrypt(ref p1, ref p0);
+            arg2[1] <<= 1;
+            arg2[2] >>= 1;
+            Init2();
+
+            // If we're decrypting, set the proper flags
+            if (!encrypt)
+            {
+                Decrypt(ref p1, ref p0);
+                if (p0 == MAGIC30 && p1 == MAGIC34)
+                {
+                    p0 = 0xE7FFDEFF;
+                    p1 = 0xE7FFDEFF;
+                }
+
+                writer.Write(p0);
+                writer.Write(p1);
+            }
+
+            // Ensure alignment
+            reader.BaseStream.Seek(0x4008, SeekOrigin.Begin);
+            writer.BaseStream.Seek(0x4008, SeekOrigin.Begin);
+
+            // Loop throgh the main encryption step
+            uint size = 0x800 - 8;
+            while (size > 0)
+            {
+                p0 = reader.ReadUInt32();
+                p1 = reader.ReadUInt32();
+
+                if (encrypt)
+                    Encrypt(ref p1, ref p0);
+                else
+                    Decrypt(ref p1, ref p0);
+
+                writer.Write(p0);
+                writer.Write(p1);
+
+                size -= 8;
+            }
+
+            // Replace the header explicitly if we're encrypting
+            if (encrypt)
+            {
+                reader.BaseStream.Seek(0x4000, SeekOrigin.Begin);
+                writer.BaseStream.Seek(0x4000, SeekOrigin.Begin);
+
+                p0 = reader.ReadUInt32();
+                p1 = reader.ReadUInt32();
+
+                if (p0 == 0xE7FFDEFF && p1 == 0xE7FFDEFF)
+                {
+                    p0 = MAGIC30;
+                    p1 = MAGIC34;
+                }
+
+                Encrypt(ref p1, ref p0);
+                Init1();
+                Encrypt(ref p1, ref p0);
+
+                writer.Write(p0);
+                writer.Write(p1);
+            }
+        }
+
+        /// <summary>
+        /// First common initialization step
+        /// </summary>
+        private void Init1()
+        {
+            Buffer.BlockCopy(Constants.NDSEncryptionData, 0, cardHash, 0, 4 * (1024 + 18));
+            arg2 = new uint[] { Gamecode, Gamecode >> 1, Gamecode << 1 };
+            Init2();
+            Init2();
+        }
+
+        /// <summary>
+        /// Second common initialization step
+        /// </summary>
+        private void Init2()
+        {
+            Encrypt(ref arg2[2], ref arg2[1]);
+            Encrypt(ref arg2[1], ref arg2[0]);
+
+            byte[] allBytes = BitConverter.GetBytes(arg2[0])
+                .Concat(BitConverter.GetBytes(arg2[1]))
+                .Concat(BitConverter.GetBytes(arg2[2]))
+                .ToArray();
+
+            UpdateHashtable(allBytes);
+        }
+
+        /// <summary>
+        /// Perform a decryption step
+        /// </summary>
+        /// <param name="arg1">First unsigned value to use in decryption</param>
+        /// <param name="arg2">Second unsigned value to use in decryption</param>
+        private void Decrypt(ref uint arg1, ref uint arg2)
+        {
+            uint a = arg1;
+            uint b = arg2;
+            for (int i = 17; i > 1; i--)
+            {
+                uint c = cardHash[i] ^ a;
+                a = b ^ Lookup(c);
+                b = c;
+            }
+
+            arg1 = b ^ cardHash[0];
+            arg2 = a ^ cardHash[1];
+        }
+
+        /// <summary>
+        /// Perform an encryption step
+        /// </summary>
+        /// <param name="arg1">First unsigned value to use in encryption</param>
+        /// <param name="arg2">Second unsigned value to use in encryption</param>
+        private void Encrypt(ref uint arg1, ref uint arg2)
+        {
+            uint a = arg1;
+            uint b = arg2;
+            for (int i = 0; i < 16; i++)
+            {
+                uint c = cardHash[i] ^ a;
+                a = b ^ Lookup(c);
+                b = c;
+            }
+
+            arg2 = a ^ cardHash[16];
+            arg1 = b ^ cardHash[17];
+        }
+
+        /// <summary>
+        /// Lookup the value from the hashtable
+        /// </summary>
+        /// <param name="v">Value to lookup in the hashtable</param>
+        /// <returns>Processed value through the hashtable</returns>
+        private uint Lookup(uint v)
+        {
+            uint a = (v >> 24) & 0xFF;
+            uint b = (v >> 16) & 0xFF;
+            uint c = (v >> 8) & 0xFF;
+            uint d = (v >> 0) & 0xFF;
+
+            a = cardHash[a + 18 + 0];
+            b = cardHash[b + 18 + 256];
+            c = cardHash[c + 18 + 512];
+            d = cardHash[d + 18 + 768];
+
+            return d + (c ^ (b + a));
+        }
+
+        /// <summary>
+        /// Update the hashtable
+        /// </summary>
+        /// <param name="arg1">Value to update the hashtable with</param>
+        private void UpdateHashtable(byte[] arg1)
+        {
+            for (int j = 0; j < 18; j++)
+            {
+                uint r3 = 0;
+                for (int i = 0; i < 4; i++)
+                {
+                    r3 <<= 8;
+                    r3 |= arg1[(j * 4 + i) & 7];
+                }
+
+                cardHash[j] ^= r3;
+            }
+
+            uint tmp1 = 0;
+            uint tmp2 = 0;
+            for (int i = 0; i < 18; i += 2)
+            {
+                Encrypt(ref tmp1, ref tmp2);
+                cardHash[i + 0] = tmp1;
+                cardHash[i + 1] = tmp2;
+            }
+            for (int i = 0; i < 0x400; i += 2)
+            {
+                Encrypt(ref tmp1, ref tmp2);
+                cardHash[i + 18 + 0] = tmp1;
+                cardHash[i + 18 + 1] = tmp2;
+            }
+        }
+    }
+}
--- a/3DSDecrypt/Headers/PartitionTableEntry.cs
+++ b/3DSDecrypt/Headers/PartitionTableEntry.cs
@@ -1,6 +1,6 @@
 using System.IO;

-namespace ThreeDS.Headers
+namespace NDecrypt.Headers
 {
    public class PartitionTableEntry
    {
--- a/3DSDecrypt/Headers/RomFSHeader.cs
+++ b/3DSDecrypt/Headers/RomFSHeader.cs
@@ -1,6 +1,6 @@
 using System.IO;

-namespace ThreeDS.Headers
+namespace NDecrypt.Headers
 {
    // https://www.3dbrew.org/wiki/RomFS
    public class RomFSHeader
--- a/3DSDecrypt/Headers/StorageInfo.cs
+++ b/3DSDecrypt/Headers/StorageInfo.cs
@@ -1,7 +1,7 @@
 using System.IO;
-using ThreeDS.Data;
+using NDecrypt.Data;

-namespace ThreeDS.Headers
+namespace NDecrypt.Headers
 {
    public class StorageInfo
    {
--- a/3DSDecrypt/Headers/SystemControlInfo.cs
+++ b/3DSDecrypt/Headers/SystemControlInfo.cs
@@ -1,6 +1,6 @@
 using System.IO;

-namespace ThreeDS.Headers
+namespace NDecrypt.Headers
 {
    public class SystemControlInfo
    {
--- a/3DSDecrypt/Headers/SystemInfo.cs
+++ b/3DSDecrypt/Headers/SystemInfo.cs
@@ -1,6 +1,6 @@
 using System.IO;

-namespace ThreeDS.Headers
+namespace NDecrypt.Headers
 {
    public class SystemInfo
    {
--- a/3DSDecrypt/Helper.cs
+++ b/3DSDecrypt/Helper.cs
@@ -5,7 +5,7 @@ using Org.BouncyCastle.Crypto;
 using Org.BouncyCastle.Crypto.Parameters;
 using Org.BouncyCastle.Security;

-namespace ThreeDS
+namespace NDecrypt
 {
    public static class Helper
    {
--- a/NDecrypt/ITool.cs
+++ b/NDecrypt/ITool.cs
@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NDecrypt
+{
+    public interface ITool
+    {
+        bool ProcessFile();
+    }
+}
--- a/3DSDecrypt/3DSDecrypt.csproj
+++ b/3DSDecrypt/3DSDecrypt.csproj
@@ -7,8 +7,8 @@
    <ProjectGuid>{2E30006A-3C60-4576-A262-937B21C83C06}</ProjectGuid>
    <OutputType>Exe</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>_3DSDecrypt</RootNamespace>
-    <AssemblyName>3DSDecrypt</AssemblyName>
+    <RootNamespace>NDecrypt</RootNamespace>
+    <AssemblyName>NDecrypt</AssemblyName>
    <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
    <FileAlignment>512</FileAlignment>
  </PropertyGroup>
@@ -48,9 +48,12 @@
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Data\Constants.cs" />
+    <Compile Include="DSTool.cs" />
    <Compile Include="Headers\NCCHHeaderFlags.cs" />
+    <Compile Include="Headers\NDSHeader.cs" />
    <Compile Include="Headers\RomFSHeader.cs" />
    <Compile Include="Helper.cs" />
+    <Compile Include="ITool.cs" />
    <Compile Include="ThreeDSTool.cs" />
    <Compile Include="Data\Enums.cs" />
    <Compile Include="Headers\AccessControlInfo.cs" />
--- a/NDecrypt/Program.cs
+++ b/NDecrypt/Program.cs
@@ -0,0 +1,110 @@
+using System;
+using System.IO;
+
+namespace NDecrypt
+{
+    class Program
+    {
+        public static void Main(string[] args)
+        {
+            if (args.Length < 2)
+            {
+                DisplayHelp("Not enough arguments");
+                return;
+            }
+
+            bool? encrypt = null;
+            if (args[0] == "decrypt")
+            {
+                encrypt = false;
+            }
+            else if (args[0] == "encrypt")
+            {
+                encrypt = true;
+            }
+            else
+            {
+                DisplayHelp($"Invalid operation: {args[0]}");
+                return;
+            }
+
+            bool development = false;
+            int start = 1;
+            if (args[1] == "-dev")
+            {
+                development = true;
+                start = 2;
+            }
+
+            for (int i = start; i < args.Length; i++)
+            {
+                if (File.Exists(args[i]))
+                {
+                    ITool tool = DeriveTool(args[i], encrypt.Value, development);
+                    if (tool?.ProcessFile() != true)
+                        Console.WriteLine("Processing failed!");
+                }
+                else if (Directory.Exists(args[i]))
+                {
+                    foreach (string file in Directory.EnumerateFiles(args[i], "*", SearchOption.AllDirectories))
+                    {
+                        ITool tool = DeriveTool(file, encrypt.Value, development);
+                        if (tool?.ProcessFile() != true)
+                            Console.WriteLine("Processing failed!");
+                    }
+                }
+            }
+
+            Console.WriteLine("Press Enter to Exit...");
+            Console.Read();
+        }
+
+        private static void DisplayHelp(string err = null)
+        {
+            if (!string.IsNullOrWhiteSpace(err))
+                Console.WriteLine($"Error: {err}");
+
+            Console.WriteLine("Usage: NDecrypt.exe (decrypt|encrypt) [-dev] <file|dir> ...");
+        }
+
+        private enum RomType
+        {
+            NULL,
+            NDS,
+            NDSi,
+            N3DS,
+        }
+
+        private static RomType DetermineRomType(string filename)
+        {
+            if (filename.EndsWith(".nds", StringComparison.OrdinalIgnoreCase)
+                || filename.EndsWith(".srl", StringComparison.OrdinalIgnoreCase))
+                return RomType.NDS;
+
+            else if (filename.EndsWith(".dsi", StringComparison.OrdinalIgnoreCase))
+                return RomType.NDSi;
+
+            else if (filename.EndsWith(".3ds", StringComparison.OrdinalIgnoreCase))
+                return RomType.N3DS;
+
+            return RomType.NULL;
+        }
+
+        private static ITool DeriveTool(string filename, bool encrypt, bool development)
+        {
+            RomType type = DetermineRomType(filename);
+            switch(type)
+            {
+                case RomType.NDS:
+                case RomType.NDSi:
+                    return new DSTool(filename, encrypt);
+                case RomType.N3DS:
+                    return new ThreeDSTool(filename, development, encrypt);
+                case RomType.NULL:
+                default:
+                    Console.WriteLine($"Unrecognized file format for {filename}. Expected *.nds, *.dsi, *.3ds");
+                    return null;
+            }
+        }
+    }
+}
--- a/3DSDecrypt/Properties/AssemblyInfo.cs
+++ b/3DSDecrypt/Properties/AssemblyInfo.cs
--- a/3DSDecrypt/ThreeDSTool.cs
+++ b/3DSDecrypt/ThreeDSTool.cs
@@ -1,10 +1,10 @@
 using System;
 using System.IO;
-using ThreeDS.Headers;
+using NDecrypt.Headers;

-namespace ThreeDS
+namespace NDecrypt
 {
-    public class ThreeDSTool
+    public class ThreeDSTool : ITool
    {
        /// <summary>
        /// Name of the input 3DS file
@@ -26,7 +26,6 @@ namespace ThreeDS
            this.filename = filename;
            this.development = development;
            this.encrypt = encrypt;
-
        }

        /// <summary>
--- a/3DSDecrypt/packages.config
+++ b/3DSDecrypt/packages.config
Author	SHA1	Message	Date
Matt Nadareski	52a928638b	Add other known blank values	2019-04-11 15:28:10 -07:00
Matt Nadareski	5962fc6072	Better comments	2019-04-11 15:02:01 -07:00
Matt Nadareski	5807d4ddc2	Handle empty secure area, better	2019-04-11 14:59:05 -07:00
Matt Nadareski	6fa8867f93	Empty secure area	2019-04-11 14:43:39 -07:00
Matt Nadareski	ed45d2d14e	Add edge case decrypt values	2019-04-11 14:15:11 -07:00
Matt Nadareski	69ecb0d379	Fix name	2019-04-11 12:55:41 -07:00
Matt Nadareski	5974e2371e	Rename stuff, add SRL extension	2019-04-11 11:17:21 -07:00
Matt Nadareski	1e5e3badbc	Start of cleanup	2019-04-11 10:02:38 -07:00
Matt Nadareski	ef02b1c33a	Rename to NDecrypt, Add NDS encrypt/decrypt	2019-04-11 03:01:13 -07:00