diff --git a/SabreTools.Data.Models/XRD/File.cs b/SabreTools.Data.Models/XRD/File.cs
index c233d4a5..41361981 100644
--- a/SabreTools.Data.Models/XRD/File.cs
+++ b/SabreTools.Data.Models/XRD/File.cs
@@ -237,7 +237,7 @@ namespace SabreTools.Data.Models.XRD
         public int DirectoryCount { get; set; }
 
         /// <summary>
-        /// List of XISO descriptors and their sector offsets and sizes 
+        /// List of XISO descriptors and their sector offsets and sizes
         /// The root directory descriptor is not guaranteed to be the first
         /// </summary>
         public DirectoryEntry[] DirectoryInfo { get; set; } = [];
diff --git a/SabreTools.Serialization.Readers/XRD.cs b/SabreTools.Serialization.Readers/XRD.cs
index c8c090d0..d4773066 100644
--- a/SabreTools.Serialization.Readers/XRD.cs
+++ b/SabreTools.Serialization.Readers/XRD.cs
@@ -1,4 +1,3 @@
-using System.Collections.Generic;
 using System.IO;
 using SabreTools.Data.Models.XRD;
 using SabreTools.IO.Extensions;
@@ -105,7 +104,7 @@ namespace SabreTools.Serialization.Readers
                 var vd = XDVDFS.ParseVolumeDescriptor(data);
                 if (vd is null)
                     return null;
-                
+
                 xrd.VolumeDescriptor = vd;
                 xrd.LayoutDescriptor = XDVDFS.ParseLayoutDescriptor(data);
 
diff --git a/SabreTools.Serialization.Writers/Atari7800Cart.cs b/SabreTools.Serialization.Writers/Atari7800Cart.cs
index 32e2c6a2..88117fcf 100644
--- a/SabreTools.Serialization.Writers/Atari7800Cart.cs
+++ b/SabreTools.Serialization.Writers/Atari7800Cart.cs
@@ -151,7 +151,7 @@ namespace SabreTools.Serialization.Writers
             {
                 if (Debug) Console.WriteLine("Attempting to write ROM data");
 
-                stream.Write(obj, 0, obj.Length);
+                stream.Write(obj);
                 stream.Flush();
                 return true;
             }
diff --git a/SabreTools.Serialization.Writers/AtariLynxCart.cs b/SabreTools.Serialization.Writers/AtariLynxCart.cs
index b0a2f0a4..3d7f3876 100644
--- a/SabreTools.Serialization.Writers/AtariLynxCart.cs
+++ b/SabreTools.Serialization.Writers/AtariLynxCart.cs
@@ -109,7 +109,7 @@ namespace SabreTools.Serialization.Writers
             {
                 if (Debug) Console.WriteLine("Attempting to write ROM data");
 
-                stream.Write(obj, 0, obj.Length);
+                stream.Write(obj);
                 stream.Flush();
                 return true;
             }
diff --git a/SabreTools.Serialization.Writers/FDS.cs b/SabreTools.Serialization.Writers/FDS.cs
index 8a61cf88..a866bb32 100644
--- a/SabreTools.Serialization.Writers/FDS.cs
+++ b/SabreTools.Serialization.Writers/FDS.cs
@@ -89,7 +89,7 @@ namespace SabreTools.Serialization.Writers
             {
                 if (Debug) Console.WriteLine("Attempting to write ROM data");
 
-                stream.Write(obj, 0, obj.Length);
+                stream.Write(obj);
                 stream.Flush();
                 return true;
             }
diff --git a/SabreTools.Serialization.Writers/IRD.cs b/SabreTools.Serialization.Writers/IRD.cs
index 46a50f30..ed62d0bf 100644
--- a/SabreTools.Serialization.Writers/IRD.cs
+++ b/SabreTools.Serialization.Writers/IRD.cs
@@ -1,6 +1,7 @@
 using System;
 using System.IO;
 using System.Text;
+using SabreTools.Numerics.Extensions;
 
 namespace SabreTools.Serialization.Writers
 {
@@ -9,6 +10,8 @@ namespace SabreTools.Serialization.Writers
         /// <inheritdoc/>
         public override Stream? SerializeStream(Data.Models.IRD.File? obj)
         {
+            #region Validation
+
             // If the data is invalid
             if (obj?.Magic is null)
                 return null;
@@ -50,79 +53,68 @@ namespace SabreTools.Serialization.Writers
             if (obj.Data2Key.Length != 16)
                 return null;
 
+            #endregion
+
             // Create the output stream
             var stream = new MemoryStream();
 
-            stream.Write(obj.Magic, 0, obj.Magic.Length);
-            stream.WriteByte(obj.Version);
+            stream.Write(obj.Magic);
+            stream.Write(obj.Version);
 
             byte[] titleId = Encoding.ASCII.GetBytes(obj.TitleID);
-            stream.Write(titleId, 0, titleId.Length);
+            stream.Write(titleId);
 
-            stream.WriteByte(obj.TitleLength);
+            stream.Write(obj.TitleLength);
             byte[] title = Encoding.ASCII.GetBytes(obj.Title);
-            stream.Write(title, 0, title.Length);
+            stream.Write(title);
 
             byte[] systemVersion = Encoding.ASCII.GetBytes(obj.SystemVersion);
-            stream.Write(systemVersion, 0, systemVersion.Length);
+            stream.Write(systemVersion);
 
             byte[] gameVersion = Encoding.ASCII.GetBytes(obj.GameVersion);
-            stream.Write(gameVersion, 0, gameVersion.Length);
+            stream.Write(gameVersion);
 
             byte[] appVersion = Encoding.ASCII.GetBytes(obj.AppVersion);
-            stream.Write(appVersion, 0, appVersion.Length);
+            stream.Write(appVersion);
 
             if (obj.Version == 7)
-            {
-                byte[] uid = BitConverter.GetBytes(obj.UID);
-                stream.Write(uid, 0, uid.Length);
-            }
+                stream.WriteLittleEndian(obj.UID);
 
-            byte[] headerLength = BitConverter.GetBytes(obj.HeaderLength);
-            stream.Write(headerLength, 0, headerLength.Length);
-            stream.Write(obj.Header, 0, obj.Header.Length);
+            stream.WriteLittleEndian(obj.HeaderLength);
+            stream.Write(obj.Header);
 
-            byte[] footerLength = BitConverter.GetBytes(obj.FooterLength);
-            stream.Write(footerLength, 0, footerLength.Length);
-            stream.Write(obj.Footer, 0, obj.Footer.Length);
+            stream.WriteLittleEndian(obj.FooterLength);
+            stream.Write(obj.Footer);
 
-            stream.WriteByte(obj.RegionCount);
+            stream.Write(obj.RegionCount);
             for (int i = 0; i < obj.RegionCount; i++)
             {
-                stream.Write(obj.RegionHashes[i], 0, obj.RegionHashes[i].Length);
+                stream.Write(obj.RegionHashes[i]);
             }
 
-            byte[] fileCount = BitConverter.GetBytes(obj.FileCount);
-            stream.Write(fileCount, 0, fileCount.Length);
+            stream.WriteLittleEndian(obj.FileCount);
             for (int i = 0; i < obj.FileCount; i++)
             {
-                byte[] fileKey = BitConverter.GetBytes(obj.FileKeys[i]);
-                stream.Write(fileKey, 0, fileKey.Length);
-                stream.Write(obj.FileHashes[i], 0, obj.FileHashes[i].Length);
+                stream.WriteLittleEndian(obj.FileKeys[i]);
+                stream.Write(obj.FileHashes[i]);
             }
 
-            byte[] extraConfig = BitConverter.GetBytes(obj.ExtraConfig);
-            stream.Write(extraConfig, 0, extraConfig.Length);
-            byte[] attachments = BitConverter.GetBytes(obj.Attachments);
-            stream.Write(attachments, 0, attachments.Length);
+            stream.WriteLittleEndian(obj.ExtraConfig);
+            stream.WriteLittleEndian(obj.Attachments);
 
             if (obj.Version >= 9)
-                stream.Write(obj.PIC, 0, obj.PIC.Length);
+                stream.Write(obj.PIC);
 
-            stream.Write(obj.Data1Key, 0, obj.Data1Key.Length);
-            stream.Write(obj.Data2Key, 0, obj.Data2Key.Length);
+            stream.Write(obj.Data1Key);
+            stream.Write(obj.Data2Key);
 
             if (obj.Version < 9)
-                stream.Write(obj.PIC, 0, obj.PIC.Length);
+                stream.Write(obj.PIC);
 
             if (obj.Version > 7)
-            {
-                byte[] uid = BitConverter.GetBytes(obj.UID);
-                stream.Write(uid, 0, uid.Length);
-            }
+                stream.WriteLittleEndian(obj.UID);
 
-            byte[] crc = BitConverter.GetBytes(obj.CRC);
-            stream.Write(crc, 0, crc.Length);
+            stream.WriteLittleEndian(obj.CRC);
 
             return stream;
         }
diff --git a/SabreTools.Serialization.Writers/NESCart.cs b/SabreTools.Serialization.Writers/NESCart.cs
index 095c2062..65aec9f0 100644
--- a/SabreTools.Serialization.Writers/NESCart.cs
+++ b/SabreTools.Serialization.Writers/NESCart.cs
@@ -63,7 +63,7 @@ namespace SabreTools.Serialization.Writers
             {
                 if (Debug) Console.WriteLine("Attempting to write CHR-ROM data");
 
-                stream.Write(obj, 0, obj.Length);
+                stream.Write(obj);
                 stream.Flush();
                 return true;
             }
@@ -250,7 +250,7 @@ namespace SabreTools.Serialization.Writers
             {
                 if (Debug) Console.WriteLine("Attempting to write INST-ROM data");
 
-                stream.Write(obj, 0, obj.Length);
+                stream.Write(obj);
                 stream.Flush();
                 return true;
             }
@@ -279,7 +279,7 @@ namespace SabreTools.Serialization.Writers
             {
                 if (Debug) Console.WriteLine("Attempting to write PRG-ROM data");
 
-                stream.Write(obj, 0, obj.Length);
+                stream.Write(obj);
                 stream.Flush();
                 return true;
             }
@@ -308,7 +308,7 @@ namespace SabreTools.Serialization.Writers
             {
                 if (Debug) Console.WriteLine("Attempting to write trainer data");
 
-                stream.Write(obj, 0, obj.Length);
+                stream.Write(obj);
                 stream.Flush();
                 return true;
             }
diff --git a/SabreTools.Serialization.Writers/QD.cs b/SabreTools.Serialization.Writers/QD.cs
index e94287de..bd80048b 100644
--- a/SabreTools.Serialization.Writers/QD.cs
+++ b/SabreTools.Serialization.Writers/QD.cs
@@ -1,6 +1,7 @@
 using System;
 using System.IO;
 using SabreTools.IO.Extensions;
+using SabreTools.Numerics.Extensions;
 
 namespace SabreTools.Serialization.Writers
 {
@@ -43,7 +44,7 @@ namespace SabreTools.Serialization.Writers
             {
                 if (Debug) Console.WriteLine("Attempting to write ROM data");
 
-                stream.Write(obj, 0, obj.Length);
+                stream.Write(obj);
                 stream.Flush();
                 return true;
             }
diff --git a/SabreTools.Serialization.Writers/XDVDFS.cs b/SabreTools.Serialization.Writers/XDVDFS.cs
index 14129e09..fcb526f9 100644
--- a/SabreTools.Serialization.Writers/XDVDFS.cs
+++ b/SabreTools.Serialization.Writers/XDVDFS.cs
@@ -23,7 +23,7 @@ namespace SabreTools.Serialization.Writers
             // Create the file stream
             using var fs = File.Open(path, FileMode.Create, FileAccess.Write, FileShare.None);
 
-            fs.Write(obj.ReservedArea, 0, obj.ReservedArea.Length);
+            fs.Write(obj.ReservedArea);
             SerializeVolumeDescriptor(fs, obj.VolumeDescriptor);
             if (obj.LayoutDescriptor is not null)
                 SerializeLayoutDescriptor(fs, obj.LayoutDescriptor);
@@ -79,26 +79,26 @@ namespace SabreTools.Serialization.Writers
 
         public static void SerializeVolumeDescriptor(Stream stream, VolumeDescriptor obj)
         {
-            stream.Write(obj.StartSignature, 0, obj.StartSignature.Length);
+            stream.Write(obj.StartSignature);
             stream.WriteLittleEndian(obj.RootOffset);
             stream.WriteLittleEndian(obj.RootSize);
             stream.WriteLittleEndian(obj.MasteringTimestamp);
-            stream.WriteByte(obj.UnknownByte);
-            stream.Write(obj.Reserved, 0, obj.Reserved.Length);
-            stream.Write(obj.EndSignature, 0, obj.EndSignature.Length);
+            stream.Write(obj.UnknownByte);
+            stream.Write(obj.Reserved);
+            stream.Write(obj.EndSignature);
         }
 
         public static void SerializeLayoutDescriptor(Stream stream, LayoutDescriptor obj)
         {
-            stream.Write(obj.Signature, 0, obj.Signature.Length);
-            stream.Write(obj.Unused8Bytes, 0, obj.Unused8Bytes.Length);
+            stream.Write(obj.Signature);
+            stream.Write(obj.Unused8Bytes);
             SerializeFourPartVersionType(stream, obj.XBLayoutVersion);
             SerializeFourPartVersionType(stream, obj.XBPremasterVersion);
             SerializeFourPartVersionType(stream, obj.XBGameDiscVersion);
             SerializeFourPartVersionType(stream, obj.XBOther1Version);
             SerializeFourPartVersionType(stream, obj.XBOther2Version);
             SerializeFourPartVersionType(stream, obj.XBOther3Version);
-            stream.Write(obj.Reserved, 0, obj.Reserved.Length);
+            stream.Write(obj.Reserved);
         }
 
         public static void SerializeFourPartVersionType(Stream stream, FourPartVersionType obj)
@@ -114,7 +114,7 @@ namespace SabreTools.Serialization.Writers
             foreach (var dr in obj.DirectoryRecords)
                 SerializeDirectoryRecord(stream, dr);
             if (obj.Padding is not null && obj.Padding.Length > 0)
-                stream.Write(obj.Padding, 0, obj.Padding.Length);
+                stream.Write(obj.Padding);
         }
 
         public static void SerializeDirectoryRecord(Stream stream, DirectoryRecord obj)
@@ -123,11 +123,11 @@ namespace SabreTools.Serialization.Writers
             stream.WriteLittleEndian(obj.RightChildOffset);
             stream.WriteLittleEndian(obj.ExtentOffset);
             stream.WriteLittleEndian(obj.ExtentSize);
-            stream.WriteByte((byte)obj.FileFlags);
-            stream.WriteByte(obj.FilenameLength);
-            stream.Write(obj.Filename, 0, obj.Filename.Length);
+            stream.Write((byte)obj.FileFlags);
+            stream.Write(obj.FilenameLength);
+            stream.Write(obj.Filename);
             if (obj.Padding is not null && obj.Padding.Length > 0)
-                stream.Write(obj.Padding, 0, obj.Padding.Length);
+                stream.Write(obj.Padding);
         }
     }
 }
diff --git a/SabreTools.Serialization.Writers/XRD.cs b/SabreTools.Serialization.Writers/XRD.cs
index dfa410c3..4ce758ad 100644
--- a/SabreTools.Serialization.Writers/XRD.cs
+++ b/SabreTools.Serialization.Writers/XRD.cs
@@ -1,6 +1,5 @@
-using System;
 using System.IO;
-using System.Text;
+using SabreTools.Numerics.Extensions;
 
 namespace SabreTools.Serialization.Writers
 {
@@ -9,6 +8,8 @@ namespace SabreTools.Serialization.Writers
         /// <inheritdoc/>
         public override Stream? SerializeStream(Data.Models.XRD.File? obj)
         {
+            #region Validation
+
             // If the data is invalid
             if (obj?.Magic is null)
                 return null;
@@ -38,11 +39,11 @@ namespace SabreTools.Serialization.Writers
             // If the XGD Type specific fields are not set/unset
             if ((obj.XGDType == 1 || obj.XGDType == 2 || obj.XGDType == 3) && obj.SecuritySectors is null)
                 return null;
-            if ((obj.XGDType != 1 && obj.XGDType != 2 && obj.XGDType != 3) && obj.SecuritySectors is not null)
+            if (obj.XGDType != 1 && obj.XGDType != 2 && obj.XGDType != 3 && obj.SecuritySectors is not null)
                 return null;
             if ((obj.XGDType == 2 || obj.XGDType == 3) && obj.Xbox360Certificate is null)
                 return null;
-            if ((obj.XGDType != 2 && obj.XGDType != 3) && obj.Xbox360Certificate is not null)
+            if (obj.XGDType != 2 && obj.XGDType != 3 && obj.Xbox360Certificate is not null)
                 return null;
 
             // If any static-length fields aren't the correct length
@@ -109,12 +110,14 @@ namespace SabreTools.Serialization.Writers
                     if (obj.XboxCertificate.AlternateSignatureKeys[i].Length != 16)
                         return null;
                 }
+
                 if (obj.XboxCertificate.CodeEncKey.Length != 16)
                     return null;
             }
+
             if (obj.Xbox360Certificate is not null)
             {
-                var certificateLength = 388 + 24 * obj.Xbox360Certificate.Table.Length;
+                var certificateLength = 388 + (24 * obj.Xbox360Certificate.Table.Length);
                 if (obj.Xbox360Certificate.Length != certificateLength)
                     return null;
                 if (obj.Xbox360Certificate.Signature.Length != 256)
@@ -135,6 +138,7 @@ namespace SabreTools.Serialization.Writers
                         return null;
                 }
             }
+
             if (obj.FileCount != obj.FileInfo.Length)
                 return null;
             for (int i = 0; i < obj.FileInfo.Length; i++)
@@ -142,6 +146,7 @@ namespace SabreTools.Serialization.Writers
                 if (obj.FileInfo[i].SHA1.Length != 20)
                     return null;
             }
+
             if (obj.DirectoryCount != obj.DirectoryInfo.Length)
                 return null;
             if (obj.VideoISOFileCount is not null && obj.VideoISOFileInfo is not null && obj.VideoISOFileCount != obj.VideoISOFileInfo.Length)
@@ -149,63 +154,56 @@ namespace SabreTools.Serialization.Writers
             if (obj.XRDSHA1.Length != 20)
                 return null;
 
+            #endregion
+
             // Create the output stream
             var stream = new MemoryStream();
 
-            stream.Write(obj.Magic, 0, obj.Magic.Length);
-            stream.WriteByte(obj.Version);
-            stream.WriteByte(obj.XGDType);
-            stream.WriteByte(obj.XGDSubtype);
-            stream.Write(obj.Ringcode, 0, obj.Ringcode.Length);
+            stream.Write(obj.Magic);
+            stream.Write(obj.Version);
+            stream.Write(obj.XGDType);
+            stream.Write(obj.XGDSubtype);
+            stream.Write(obj.Ringcode);
 
-            byte[] redumpSize = BitConverter.GetBytes(obj.RedumpSize);
-            stream.Write(redumpSize, 0, redumpSize.Length);
-            stream.Write(obj.RedumpCRC, 0, obj.RedumpCRC.Length);
-            stream.Write(obj.RedumpMD5, 0, obj.RedumpMD5.Length);
-            stream.Write(obj.RedumpSHA1, 0, obj.RedumpSHA1.Length);
+            stream.WriteLittleEndian(obj.RedumpSize);
+            stream.Write(obj.RedumpCRC);
+            stream.Write(obj.RedumpMD5);
+            stream.Write(obj.RedumpSHA1);
 
-            byte[] rawXISOSize = BitConverter.GetBytes(obj.RawXISOSize);
-            stream.Write(rawXISOSize, 0, rawXISOSize.Length);
-            stream.Write(obj.RawXISOCRC, 0, obj.RawXISOCRC.Length);
-            stream.Write(obj.RawXISOMD5, 0, obj.RawXISOMD5.Length);
-            stream.Write(obj.RawXISOSHA1, 0, obj.RawXISOSHA1.Length);
+            stream.WriteLittleEndian(obj.RawXISOSize);
+            stream.Write(obj.RawXISOCRC);
+            stream.Write(obj.RawXISOMD5);
+            stream.Write(obj.RawXISOSHA1);
 
-            byte[] cookedXISOSize = BitConverter.GetBytes(obj.CookedXISOSize);
-            stream.Write(cookedXISOSize, 0, cookedXISOSize.Length);
-            stream.Write(obj.CookedXISOCRC, 0, obj.CookedXISOCRC.Length);
-            stream.Write(obj.CookedXISOMD5, 0, obj.CookedXISOMD5.Length);
-            stream.Write(obj.CookedXISOSHA1, 0, obj.CookedXISOSHA1.Length);
+            stream.WriteLittleEndian(obj.CookedXISOSize);
+            stream.Write(obj.CookedXISOCRC);
+            stream.Write(obj.CookedXISOMD5);
+            stream.Write(obj.CookedXISOSHA1);
 
-            byte[] videoISOSize = BitConverter.GetBytes(obj.VideoISOSize);
-            stream.Write(videoISOSize, 0, videoISOSize.Length);
-            stream.Write(obj.VideoISOCRC, 0, obj.VideoISOCRC.Length);
-            stream.Write(obj.VideoISOMD5, 0, obj.VideoISOMD5.Length);
-            stream.Write(obj.VideoISOSHA1, 0, obj.VideoISOSHA1.Length);
+            stream.WriteLittleEndian(obj.VideoISOSize);
+            stream.Write(obj.VideoISOCRC);
+            stream.Write(obj.VideoISOMD5);
+            stream.Write(obj.VideoISOSHA1);
 
             if (obj.WipedVideoISOSize is not null)
-            {
-                byte[] wipedVideoISOSize = BitConverter.GetBytes(obj.WipedVideoISOSize ?? 0);
-                stream.Write(videoISOSize, 0, videoISOSize.Length);
-            }
+                stream.WriteLittleEndian(obj.WipedVideoISOSize.Value);
             if (obj.WipedVideoISOCRC is not null)
-                stream.Write(obj.WipedVideoISOCRC, 0, obj.WipedVideoISOCRC.Length);
+                stream.Write(obj.WipedVideoISOCRC);
             if (obj.WipedVideoISOMD5 is not null)
-                stream.Write(obj.WipedVideoISOMD5, 0, obj.WipedVideoISOMD5.Length);
+                stream.Write(obj.WipedVideoISOMD5);
             if (obj.WipedVideoISOSHA1 is not null)
-                stream.Write(obj.WipedVideoISOSHA1, 0, obj.WipedVideoISOSHA1.Length);
+                stream.Write(obj.WipedVideoISOSHA1);
 
-            byte[] fillerSize = BitConverter.GetBytes(obj.FillerSize);
-            stream.Write(fillerSize, 0, fillerSize.Length);
-            stream.Write(obj.FillerCRC, 0, obj.FillerCRC.Length);
-            stream.Write(obj.FillerMD5, 0, obj.FillerMD5.Length);
-            stream.Write(obj.FillerSHA1, 0, obj.FillerSHA1.Length);
+            stream.WriteLittleEndian(obj.FillerSize);
+            stream.Write(obj.FillerCRC);
+            stream.Write(obj.FillerMD5);
+            stream.Write(obj.FillerSHA1);
 
             if (obj.SecuritySectors is not null)
             {
                 for (int i = 0; i < obj.SecuritySectors.Length; i++)
                 {
-                    byte[] securitySector = BitConverter.GetBytes(obj.SecuritySectors[i]);
-                    stream.Write(securitySector, 0, securitySector.Length);
+                    stream.Write(obj.SecuritySectors[i]);
                 }
             }
 
@@ -214,29 +212,23 @@ namespace SabreTools.Serialization.Writers
             if (obj.Xbox360Certificate is not null)
                 SerializeXbox360Certificate(stream, obj.Xbox360Certificate);
 
-            byte[] fileCount = BitConverter.GetBytes(obj.FileCount);
-            stream.Write(fileCount, 0, fileCount.Length);
+            stream.WriteLittleEndian(obj.FileCount);
             for (int i = 0; i < obj.FileInfo.Length; i++)
             {
-                byte[] offset = BitConverter.GetBytes(obj.FileInfo[i].Offset);
-                stream.Write(offset, 0, offset.Length);
-                byte[] size = BitConverter.GetBytes(obj.FileInfo[i].Size);
-                stream.Write(size, 0, size.Length);
-                stream.Write(obj.FileInfo[i].SHA1, 0, obj.FileInfo[i].SHA1.Length);
+                stream.WriteLittleEndian(obj.FileInfo[i].Offset);
+                stream.WriteLittleEndian(obj.FileInfo[i].Size);
+                stream.Write(obj.FileInfo[i].SHA1);
             }
 
             XDVDFS.SerializeVolumeDescriptor(stream, obj.VolumeDescriptor);
             if (obj.LayoutDescriptor is not null)
                 XDVDFS.SerializeLayoutDescriptor(stream, obj.LayoutDescriptor);
 
-            byte[] directoryCount = BitConverter.GetBytes(obj.DirectoryCount);
-            stream.Write(directoryCount, 0, directoryCount.Length);
+            stream.WriteLittleEndian(obj.DirectoryCount);
             for (int i = 0; i < obj.DirectoryInfo.Length; i++)
             {
-                byte[] offset = BitConverter.GetBytes(obj.DirectoryInfo[i].Offset);
-                stream.Write(offset, 0, offset.Length);
-                byte[] size = BitConverter.GetBytes(obj.DirectoryInfo[i].Size);
-                stream.Write(size, 0, size.Length);
+                stream.Write(obj.DirectoryInfo[i].Offset);
+                stream.Write(obj.DirectoryInfo[i].Size);
                 XDVDFS.SerializeDirectoryDescriptor(stream, obj.DirectoryInfo[i].DirectoryDescriptor);
             }
 
@@ -245,77 +237,56 @@ namespace SabreTools.Serialization.Writers
 
         public static void SerializeXboxCertificate(Stream stream, Data.Models.XboxExecutable.Certificate obj)
         {
-            byte[] sizeOfCertificate = BitConverter.GetBytes(obj.SizeOfCertificate);
-            stream.Write(sizeOfCertificate, 0, sizeOfCertificate.Length);
-            byte[] timeDate = BitConverter.GetBytes(obj.TimeDate);
-            stream.Write(timeDate, 0, timeDate.Length);
-            byte[] titleID = BitConverter.GetBytes(obj.TitleID);
-            stream.Write(titleID, 0, titleID.Length);
-            stream.Write(obj.TitleName, 0, obj.TitleName.Length);
+            stream.WriteLittleEndian(obj.SizeOfCertificate);
+            stream.WriteLittleEndian(obj.TimeDate);
+            stream.WriteLittleEndian(obj.TitleID);
+            stream.Write(obj.TitleName);
             for (int i = 0; i < obj.AlternativeTitleIDs.Length; i++)
             {
-                byte[] alternativeTitleID = BitConverter.GetBytes(obj.AlternativeTitleIDs[i]);
-                stream.Write(alternativeTitleID, 0, alternativeTitleID.Length);
+                stream.WriteLittleEndian(obj.AlternativeTitleIDs[i]);
             }
-            byte[] allowedMediaTypes = BitConverter.GetBytes((uint)obj.AllowedMediaTypes);
-            stream.Write(allowedMediaTypes, 0, allowedMediaTypes.Length);
-            byte[] gameRegion = BitConverter.GetBytes((uint)obj.GameRegion);
-            stream.Write(gameRegion, 0, gameRegion.Length);
-            byte[] gameRatings = BitConverter.GetBytes(obj.GameRatings);
-            stream.Write(gameRatings, 0, gameRatings.Length);
-            byte[] diskNumber = BitConverter.GetBytes(obj.DiskNumber);
-            stream.Write(diskNumber, 0, diskNumber.Length);
-            byte[] version = BitConverter.GetBytes(obj.Version);
-            stream.Write(version, 0, version.Length);
-            stream.Write(obj.LANKey, 0, obj.LANKey.Length);
-            stream.Write(obj.SignatureKey, 0, obj.SignatureKey.Length);
+
+            stream.WriteLittleEndian((uint)obj.AllowedMediaTypes);
+            stream.WriteLittleEndian((uint)obj.GameRegion);
+            stream.WriteLittleEndian(obj.GameRatings);
+            stream.WriteLittleEndian(obj.DiskNumber);
+            stream.WriteLittleEndian(obj.Version);
+            stream.Write(obj.LANKey);
+            stream.Write(obj.SignatureKey);
             for (int i = 0; i < obj.AlternateSignatureKeys.Length; i++)
             {
-                stream.Write(obj.AlternateSignatureKeys[i], 0, obj.AlternateSignatureKeys[i].Length);
+                stream.Write(obj.AlternateSignatureKeys[i]);
             }
-            byte[] originalCertificateSize = BitConverter.GetBytes(obj.OriginalCertificateSize);
-            stream.Write(originalCertificateSize, 0, originalCertificateSize.Length);
-            byte[] onlineService = BitConverter.GetBytes(obj.OnlineService);
-            stream.Write(onlineService, 0, onlineService.Length);
-            byte[] securityFlags = BitConverter.GetBytes(obj.SecurityFlags);
-            stream.Write(securityFlags, 0, securityFlags.Length);
-            stream.Write(obj.CodeEncKey, 0, obj.CodeEncKey.Length);
+
+            stream.WriteLittleEndian(obj.OriginalCertificateSize);
+            stream.WriteLittleEndian(obj.OnlineService);
+            stream.WriteLittleEndian(obj.SecurityFlags);
+            stream.Write(obj.CodeEncKey);
         }
 
         public static void SerializeXbox360Certificate(Stream stream, Data.Models.XenonExecutable.Certificate obj)
         {
-            byte[] length = BitConverter.GetBytes(obj.Length);
-            stream.Write(length, 0, length.Length);
-            byte[] imageSize = BitConverter.GetBytes(obj.ImageSize);
-            stream.Write(imageSize, 0, imageSize.Length);
-            stream.Write(obj.Signature, 0, obj.Signature.Length);
-            byte[] baseFileLoadAddress = BitConverter.GetBytes(obj.BaseFileLoadAddress);
-            stream.Write(baseFileLoadAddress, 0, baseFileLoadAddress.Length);
-            byte[] imageFlags = BitConverter.GetBytes(obj.ImageFlags);
-            stream.Write(imageFlags, 0, imageFlags.Length);
-            byte[] imageBaseAddress = BitConverter.GetBytes(obj.ImageBaseAddress);
-            stream.Write(imageBaseAddress, 0, imageBaseAddress.Length);
-            stream.Write(obj.UnknownHash1, 0, obj.UnknownHash1.Length);
-            byte[] unknown0128 = BitConverter.GetBytes(obj.Unknown0128);
-            stream.Write(unknown0128, 0, unknown0128.Length);
-            stream.Write(obj.UnknownHash2, 0, obj.UnknownHash2.Length);
-            stream.Write(obj.MediaID, 0, obj.MediaID.Length);
-            stream.Write(obj.XEXFileKey, 0, obj.XEXFileKey.Length);
-            byte[] unknown0160 = BitConverter.GetBytes(obj.Unknown0160);
-            stream.Write(unknown0160, 0, unknown0160.Length);
-            stream.Write(obj.UnknownHash3, 0, obj.UnknownHash3.Length);
-            byte[] regionFlags = BitConverter.GetBytes(obj.RegionFlags);
-            stream.Write(regionFlags, 0, regionFlags.Length);
-            byte[] allowedMediaTypeFlags = BitConverter.GetBytes(obj.AllowedMediaTypeFlags);
-            stream.Write(allowedMediaTypeFlags, 0, allowedMediaTypeFlags.Length);
-            byte[] tableCount = BitConverter.GetBytes(obj.TableCount);
-            stream.Write(tableCount, 0, tableCount.Length);
+            stream.WriteLittleEndian(obj.Length);
+            stream.WriteLittleEndian(obj.ImageSize);
+            stream.Write(obj.Signature);
+            stream.WriteLittleEndian(obj.BaseFileLoadAddress);
+            stream.WriteLittleEndian(obj.ImageFlags);
+            stream.WriteLittleEndian(obj.ImageBaseAddress);
+            stream.Write(obj.UnknownHash1);
+            stream.WriteLittleEndian(obj.Unknown0128);
+            stream.Write(obj.UnknownHash2);
+            stream.Write(obj.MediaID);
+            stream.Write(obj.XEXFileKey);
+            stream.WriteLittleEndian(obj.Unknown0160);
+            stream.Write(obj.UnknownHash3);
+            stream.WriteLittleEndian(obj.RegionFlags);
+            stream.WriteLittleEndian(obj.AllowedMediaTypeFlags);
+            stream.WriteLittleEndian(obj.TableCount);
 
             for (int i = 0; i < obj.Table.Length; i++)
             {
-                byte[] id = BitConverter.GetBytes(obj.Table[i].ID);
-                stream.Write(id, 0, id.Length);
-                stream.Write(obj.Table[i].Data, 0, obj.Table[i].Data.Length);
+                stream.WriteLittleEndian(obj.Table[i].ID);
+                stream.Write(obj.Table[i].Data);
             }
         }
     }
diff --git a/SabreTools.Wrappers/BSP.Extraction.cs b/SabreTools.Wrappers/BSP.Extraction.cs
index 696cbd5d..f3d657a1 100644
--- a/SabreTools.Wrappers/BSP.Extraction.cs
+++ b/SabreTools.Wrappers/BSP.Extraction.cs
@@ -1,6 +1,7 @@
 using System;
 using System.IO;
 using SabreTools.Data.Models.BSP;
+using SabreTools.Numerics.Extensions;
 
 namespace SabreTools.Wrappers
 {
@@ -81,7 +82,7 @@ namespace SabreTools.Wrappers
             {
                 // Open the output file for writing
                 using var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.None);
-                fs.Write(data, 0, data.Length);
+                fs.Write(data);
                 fs.Flush();
             }
             catch (Exception ex)
diff --git a/SabreTools.Wrappers/GCF.Extraction.cs b/SabreTools.Wrappers/GCF.Extraction.cs
index 897cc776..0f2ebae2 100644
--- a/SabreTools.Wrappers/GCF.Extraction.cs
+++ b/SabreTools.Wrappers/GCF.Extraction.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using SabreTools.Numerics.Extensions;
 
 namespace SabreTools.Wrappers
 {
@@ -97,7 +98,7 @@ namespace SabreTools.Wrappers
                     if (data.Length == 0)
                         return false;
 
-                    fs.Write(data, 0, data.Length);
+                    fs.Write(data);
                     fs.Flush();
                 }
             }
diff --git a/SabreTools.Wrappers/InstallShieldArchiveV3.Extraction.cs b/SabreTools.Wrappers/InstallShieldArchiveV3.Extraction.cs
index 08813003..ce3c7354 100644
--- a/SabreTools.Wrappers/InstallShieldArchiveV3.Extraction.cs
+++ b/SabreTools.Wrappers/InstallShieldArchiveV3.Extraction.cs
@@ -1,6 +1,7 @@
 using System;
 using System.IO;
 using SabreTools.IO.Compression.Blast;
+using SabreTools.Numerics.Extensions;
 
 namespace SabreTools.Wrappers
 {
@@ -110,7 +111,7 @@ namespace SabreTools.Wrappers
             {
                 // Open the output file for writing
                 using var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.None);
-                fs.Write(data, 0, data.Length);
+                fs.Write(data);
                 fs.Flush();
             }
             catch (Exception ex)
diff --git a/SabreTools.Wrappers/MicrosoftCabinet.cs b/SabreTools.Wrappers/MicrosoftCabinet.cs
index 0728b416..4a3a9635 100644
--- a/SabreTools.Wrappers/MicrosoftCabinet.cs
+++ b/SabreTools.Wrappers/MicrosoftCabinet.cs
@@ -3,6 +3,7 @@ using System.IO;
 using SabreTools.Data.Models.MicrosoftCabinet;
 using SabreTools.IO.Compression.MSZIP;
 using SabreTools.IO.Extensions;
+using SabreTools.Numerics.Extensions;
 
 namespace SabreTools.Wrappers
 {
@@ -200,7 +201,7 @@ namespace SabreTools.Wrappers
                         Console.Error.WriteLine($"Data block {blockIndex} in folder {folderIndex} had mismatching sizes. Expected: {block.UncompressedSize}, Got: {stream.Length}");
 
                     byte[] padding = new byte[block.UncompressedSize - stream.Length];
-                    stream.Write(padding, 0, padding.Length);
+                    stream.Write(padding);
                 }
 
                 // Return the byte array data
diff --git a/SabreTools.Wrappers/NewExecutable.Extraction.cs b/SabreTools.Wrappers/NewExecutable.Extraction.cs
index 40776d7f..47dc0638 100644
--- a/SabreTools.Wrappers/NewExecutable.Extraction.cs
+++ b/SabreTools.Wrappers/NewExecutable.Extraction.cs
@@ -176,7 +176,7 @@ namespace SabreTools.Wrappers
                         if (buffer.Length == 0)
                             break;
 
-                        tempStream.Write(buffer, 0, buffer.Length);
+                        tempStream.Write(buffer);
                         tempStream.Flush();
 
                         currentOffset += bytesToRead;
diff --git a/SabreTools.Wrappers/PAK.Extraction.cs b/SabreTools.Wrappers/PAK.Extraction.cs
index 276babaf..6094053d 100644
--- a/SabreTools.Wrappers/PAK.Extraction.cs
+++ b/SabreTools.Wrappers/PAK.Extraction.cs
@@ -1,5 +1,6 @@
 using System;
 using System.IO;
+using SabreTools.Numerics.Extensions;
 
 namespace SabreTools.Wrappers
 {
@@ -67,7 +68,7 @@ namespace SabreTools.Wrappers
             {
                 // Open the output file for writing
                 using var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.None);
-                fs.Write(data, 0, data.Length);
+                fs.Write(data);
                 fs.Flush();
             }
             catch (Exception ex)
diff --git a/SabreTools.Wrappers/PortableExecutable.Extraction.cs b/SabreTools.Wrappers/PortableExecutable.Extraction.cs
index ecf08cb6..7f44b6d1 100644
--- a/SabreTools.Wrappers/PortableExecutable.Extraction.cs
+++ b/SabreTools.Wrappers/PortableExecutable.Extraction.cs
@@ -96,7 +96,7 @@ namespace SabreTools.Wrappers
 
                     // Write the output file
                     var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
-                    fs.Write(data, 0, data.Length);
+                    fs.Write(data);
                     fs.Flush();
                 }
 
@@ -151,7 +151,7 @@ namespace SabreTools.Wrappers
 
                 // Write the file data to a temp file
                 var tempStream = File.Open(tempFile, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
-                tempStream.Write(data, 0, data.Length);
+                tempStream.Write(data);
                 tempStream.Flush();
 
                 return true;
@@ -317,7 +317,7 @@ namespace SabreTools.Wrappers
                         if (buffer.Length == 0)
                             break;
 
-                        tempStream.Write(buffer, 0, buffer.Length);
+                        tempStream.Write(buffer);
                         tempStream.Flush();
 
                         currentOffset += bytesToRead;
@@ -614,7 +614,7 @@ namespace SabreTools.Wrappers
 
                     // Write the output file
                     var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
-                    fs.Write(data, 0, data.Length);
+                    fs.Write(data);
                     fs.Flush();
                 }
 
diff --git a/SabreTools.Wrappers/Quantum.Extraction.cs b/SabreTools.Wrappers/Quantum.Extraction.cs
index 61147867..e75eac3c 100644
--- a/SabreTools.Wrappers/Quantum.Extraction.cs
+++ b/SabreTools.Wrappers/Quantum.Extraction.cs
@@ -102,7 +102,7 @@ namespace SabreTools.Wrappers
             // {
             //     // Open the output file for writing
             //     using var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.None);
-            //     fs.Write(data, 0, data.Length);
+            //     fs.Write(data);
             //     fs.Flush();
             // }
             // catch
diff --git a/SabreTools.Wrappers/SGA.Extraction.cs b/SabreTools.Wrappers/SGA.Extraction.cs
index 552b6d52..9efe14a6 100644
--- a/SabreTools.Wrappers/SGA.Extraction.cs
+++ b/SabreTools.Wrappers/SGA.Extraction.cs
@@ -2,6 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using SabreTools.IO.Compression.zlib;
+using SabreTools.Numerics.Extensions;
 
 namespace SabreTools.Wrappers
 {
@@ -135,7 +136,7 @@ namespace SabreTools.Wrappers
             {
                 // Open the output file for writing
                 using var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.None);
-                fs.Write(data, 0, data.Length);
+                fs.Write(data);
                 fs.Flush();
             }
             catch (Exception ex)
diff --git a/SabreTools.Wrappers/SecuROMMatroschkaPackage.Extraction.cs b/SabreTools.Wrappers/SecuROMMatroschkaPackage.Extraction.cs
index 227e4632..157beb2a 100644
--- a/SabreTools.Wrappers/SecuROMMatroschkaPackage.Extraction.cs
+++ b/SabreTools.Wrappers/SecuROMMatroschkaPackage.Extraction.cs
@@ -2,6 +2,7 @@ using System;
 using System.IO;
 using SabreTools.Data.Models.SecuROM;
 using SabreTools.Hashing;
+using SabreTools.Numerics.Extensions;
 
 namespace SabreTools.Wrappers
 {
@@ -71,7 +72,7 @@ namespace SabreTools.Wrappers
             {
                 // Open the output file for writing
                 using var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.None);
-                fs.Write(data, 0, data.Length);
+                fs.Write(data);
                 fs.Flush();
             }
             catch (Exception ex)
diff --git a/SabreTools.Wrappers/TapeArchive.Extraction.cs b/SabreTools.Wrappers/TapeArchive.Extraction.cs
index 27b0d9e7..4f22920e 100644
--- a/SabreTools.Wrappers/TapeArchive.Extraction.cs
+++ b/SabreTools.Wrappers/TapeArchive.Extraction.cs
@@ -1,6 +1,7 @@
 using System;
 using System.IO;
 using SabreTools.Data.Models.TAR;
+using SabreTools.Numerics.Extensions;
 
 namespace SabreTools.Wrappers
 {
@@ -148,7 +149,7 @@ namespace SabreTools.Wrappers
 
                     // Write the file
                     using var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.None);
-                    fs.Write(dataBytes, 0, dataBytes.Length);
+                    fs.Write(dataBytes);
                     fs.Flush();
                 }
 
diff --git a/SabreTools.Wrappers/VBSP.Extraction.cs b/SabreTools.Wrappers/VBSP.Extraction.cs
index 3710ee0f..ac9df864 100644
--- a/SabreTools.Wrappers/VBSP.Extraction.cs
+++ b/SabreTools.Wrappers/VBSP.Extraction.cs
@@ -1,6 +1,7 @@
 using System;
 using System.IO;
 using SabreTools.Data.Models.BSP;
+using SabreTools.Numerics.Extensions;
 
 namespace SabreTools.Wrappers
 {
@@ -81,7 +82,7 @@ namespace SabreTools.Wrappers
             {
                 // Open the output file for writing
                 using var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.None);
-                fs.Write(data, 0, data.Length);
+                fs.Write(data);
                 fs.Flush();
             }
             catch (Exception ex)
diff --git a/SabreTools.Wrappers/VPK.Extraction.cs b/SabreTools.Wrappers/VPK.Extraction.cs
index 76d5d452..9e3be57d 100644
--- a/SabreTools.Wrappers/VPK.Extraction.cs
+++ b/SabreTools.Wrappers/VPK.Extraction.cs
@@ -129,7 +129,7 @@ namespace SabreTools.Wrappers
             {
                 // Open the output file for writing
                 using var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.None);
-                fs.Write(data, 0, data.Length);
+                fs.Write(data);
                 fs.Flush();
             }
             catch (Exception ex)
diff --git a/SabreTools.Wrappers/WAD3.Extraction.cs b/SabreTools.Wrappers/WAD3.Extraction.cs
index 5c8c55fb..148ad5e8 100644
--- a/SabreTools.Wrappers/WAD3.Extraction.cs
+++ b/SabreTools.Wrappers/WAD3.Extraction.cs
@@ -1,5 +1,6 @@
 using System;
 using System.IO;
+using SabreTools.Numerics.Extensions;
 
 namespace SabreTools.Wrappers
 {
@@ -67,7 +68,7 @@ namespace SabreTools.Wrappers
             {
                 // Open the output file for writing
                 using var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.None);
-                fs.Write(data, 0, data.Length);
+                fs.Write(data);
                 fs.Flush();
             }
             catch (Exception ex)
diff --git a/SabreTools.Wrappers/WiseSectionHeader.Extraction.cs b/SabreTools.Wrappers/WiseSectionHeader.Extraction.cs
index d43d93e1..18db9e08 100644
--- a/SabreTools.Wrappers/WiseSectionHeader.Extraction.cs
+++ b/SabreTools.Wrappers/WiseSectionHeader.Extraction.cs
@@ -157,7 +157,7 @@ namespace SabreTools.Wrappers
                     }
                 }
 
-                destination.Write(actual, 0, actual.Length);
+                destination.Write(actual);
                 return ExtractionStatus.GOOD;
             }
             catch
@@ -199,7 +199,7 @@ namespace SabreTools.Wrappers
                 // Debug output
                 if (includeDebug) Console.WriteLine("No CRC-32!");
 
-                destination.Write(actual, 0, actual.Length);
+                destination.Write(actual);
                 return ExtractionStatus.GOOD;
             }
             catch
diff --git a/SabreTools.Wrappers/XRD.Printing.cs b/SabreTools.Wrappers/XRD.Printing.cs
index b0fb3f29..d7d5b22f 100644
--- a/SabreTools.Wrappers/XRD.Printing.cs
+++ b/SabreTools.Wrappers/XRD.Printing.cs
@@ -61,10 +61,10 @@ namespace SabreTools.Wrappers
                     builder.AppendLine(Model.SecuritySectors[i], $"Security Sector {i}");
                 }
             }
-            
+
             if (Model.XboxCertificate is not null)
                 XboxExecutable.Print(builder, Model.XboxCertificate);
-            
+
             if (Model.Xbox360Certificate is not null)
                 XenonExecutable.Print(builder, Model.Xbox360Certificate);
 
diff --git a/SabreTools.Wrappers/XZP.Extraction.cs b/SabreTools.Wrappers/XZP.Extraction.cs
index b3e60b1c..ac722e33 100644
--- a/SabreTools.Wrappers/XZP.Extraction.cs
+++ b/SabreTools.Wrappers/XZP.Extraction.cs
@@ -1,5 +1,6 @@
 using System;
 using System.IO;
+using SabreTools.Numerics.Extensions;
 
 namespace SabreTools.Wrappers
 {
@@ -76,7 +77,7 @@ namespace SabreTools.Wrappers
             {
                 // Open the output file for writing
                 using var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.None);
-                fs.Write(data, 0, data.Length);
+                fs.Write(data);
                 fs.Flush();
             }
             catch (Exception ex)