diff --git a/SabreTools.DatFiles/DatFile.cs b/SabreTools.DatFiles/DatFile.cs
index 4e062916..dacc76c6 100644
--- a/SabreTools.DatFiles/DatFile.cs
+++ b/SabreTools.DatFiles/DatFile.cs
@@ -210,7 +210,7 @@ namespace SabreTools.DatFiles
         /// <param name="statsOnly">True to only add item statistics while parsing, false otherwise</param>
         /// <returns>The key for the item</returns>
         protected long ParseAddHelper(DatItem item, long machineIndex, bool statsOnly)
-            => ItemsDB.AddItem(item, machineIndex, statsOnly);
+            => ItemsDB.AddItem(item, machineIndex, statsOnly: statsOnly);
 
         #endregion
 
diff --git a/SabreTools.DatFiles/ItemDictionaryDB.cs b/SabreTools.DatFiles/ItemDictionaryDB.cs
index 21a82c6c..fb0e7204 100644
--- a/SabreTools.DatFiles/ItemDictionaryDB.cs
+++ b/SabreTools.DatFiles/ItemDictionaryDB.cs
@@ -28,7 +28,6 @@ using SabreTools.Matching;
  * - Feature parity with all existing item dictionary operations
  * - A way to transition between the two item dictionaries (a flag?)
  * - Helper methods that target the "database" version instead of assuming the standard dictionary
- * - Should sources be separated out the same as machines are?
  * 
  * Notable changes include:
  * - Separation of Machine from DatItem, leading to a mapping instead
@@ -80,6 +79,22 @@ namespace SabreTools.DatFiles
         [JsonIgnore, XmlIgnore]
         private long _machineIndex = 0;
 
+        /// <summary>
+        /// Internal dictionary for all sources
+        /// </summary>
+        [JsonIgnore, XmlIgnore]
+#if NET40_OR_GREATER || NETCOREAPP
+        private readonly ConcurrentDictionary<long, Source> _sources = new ConcurrentDictionary<long, Source>();
+#else
+        private readonly Dictionary<long, Source> _sources = [];
+#endif
+
+        /// <summary>
+        /// Current highest available source index
+        /// </summary>
+        [JsonIgnore, XmlIgnore]
+        private long _sourceIndex = 0;
+
         /// <summary>
         /// Internal dictionary for item to machine mappings
         /// </summary>
@@ -90,6 +105,16 @@ namespace SabreTools.DatFiles
         private readonly Dictionary<long, long> _itemToMachineMapping = [];
 #endif
 
+        /// <summary>
+        /// Internal dictionary for item to source mappings
+        /// </summary>
+        [JsonIgnore, XmlIgnore]
+#if NET40_OR_GREATER || NETCOREAPP
+        private readonly ConcurrentDictionary<long, long> _itemToSourceMapping = new ConcurrentDictionary<long, long>();
+#else
+        private readonly Dictionary<long, long> _itemToSourceMapping = [];
+#endif
+
         /// <summary>
         /// Internal dictionary representing the current buckets
         /// </summary>
@@ -154,7 +179,7 @@ namespace SabreTools.DatFiles
         /// <param name="machineIndex">Index of the machine related to the item</param>
         /// <param name="statsOnly">True to only add item statistics while parsing, false otherwise (default)</param>
         /// <returns>The index for the added item, -1 on error</returns>
-        public long AddItem(DatItem item, long machineIndex, bool statsOnly)
+        public long AddItem(DatItem item, long machineIndex, long sourceIndex = -1, bool statsOnly = false)
         {
             // If we have a Disk, Media, or Rom, clean the hash data
             if (item is Disk disk)
@@ -235,7 +260,7 @@ namespace SabreTools.DatFiles
             }
             else
             {
-                return AddItem(item, machineIndex);
+                return AddItem(item, machineIndex, sourceIndex);
             }
         }
 
@@ -248,6 +273,15 @@ namespace SabreTools.DatFiles
             return _machineIndex - 1;
         }
 
+        /// <summary>
+        /// Add a source, returning the insert index
+        /// </summary>
+        public long AddSource(Source source)
+        {
+            _sources[_sourceIndex++] = source;
+            return _sourceIndex - 1;
+        }
+
         /// <summary>
         /// Remove any keys that have null or empty values
         /// </summary>
@@ -306,9 +340,14 @@ namespace SabreTools.DatFiles
         }
 
         /// <summary>
-        /// Get all item mappings
+        /// Get all item to machine mappings
         /// </summary>
-        public (long, long)[] GetItemMappings() => _itemToMachineMapping.Select(kvp => (kvp.Key, kvp.Value)).ToArray();
+        public (long, long)[] GetItemMachineMappings() => _itemToMachineMapping.Select(kvp => (kvp.Key, kvp.Value)).ToArray();
+
+        /// <summary>
+        /// Get all item to source mappings
+        /// </summary>
+        public (long, long)[] GetItemSourceMappings() => _itemToSourceMapping.Select(kvp => (kvp.Key, kvp.Value)).ToArray();
 
         /// <summary>
         /// Get all items and their indicies
@@ -354,6 +393,25 @@ namespace SabreTools.DatFiles
             return [.. datItems];
         }
 
+        /// <summary>
+        /// Get the indices and items associated with a source index
+        /// </summary>
+        public (long, DatItem)[]? GetItemsForSource(long sourceIndex, bool filter = false)
+        {
+            var itemIds = _itemToSourceMapping
+                .Where(mapping => mapping.Value == sourceIndex)
+                .Select(mapping => mapping.Key);
+
+            var datItems = new List<(long, DatItem)>();
+            foreach (long itemId in itemIds)
+            {
+                if (_items.ContainsKey(itemId) && (!filter || _items[itemId].GetBoolFieldValue(DatItem.RemoveKey) != true))
+                    datItems.Add((itemId, _items[itemId]));
+            }
+
+            return [.. datItems];
+        }
+
         /// <summary>
         /// Get a machine based on the index
         /// </summary>
@@ -398,6 +456,37 @@ namespace SabreTools.DatFiles
         /// </summary>
         public (long, Machine)[] GetMachines() => _machines.Select(kvp => (kvp.Key, kvp.Value)).ToArray();
 
+        /// <summary>
+        /// Get a source based on the index
+        /// </summary>
+        public Source? GetSource(long index)
+        {
+            if (!_sources.ContainsKey(index))
+                return null;
+
+            return _sources[index];
+        }
+
+        /// <summary>
+        /// Get the index and source associated with an item index
+        /// </summary>
+        public (long, Source?) GetSourceForItem(long itemIndex)
+        {
+            if (!_itemToSourceMapping.ContainsKey(itemIndex))
+                return (-1, null);
+
+            long sourceIndex = _itemToSourceMapping[itemIndex];
+            if (!_sources.ContainsKey(sourceIndex))
+                return (-1, null);
+
+            return (sourceIndex, _sources[sourceIndex]);
+        }
+
+        /// <summary>
+        /// Get all sources and their indicies
+        /// </summary>
+        public (long, Source)[] GetSources() => _sources.Select(kvp => (kvp.Key, kvp.Value)).ToArray();
+
         /// <summary>
         /// Remove an item, returning if it could be removed
         /// </summary>
@@ -467,7 +556,7 @@ namespace SabreTools.DatFiles
         /// <summary>
         /// Add an item, returning the insert index
         /// </summary>
-        private long AddItem(DatItem item, long machineIndex)
+        private long AddItem(DatItem item, long machineIndex, long sourceIndex)
         {
             // Add the item with a new index
             _items[_itemIndex++] = item;
@@ -475,6 +564,9 @@ namespace SabreTools.DatFiles
             // Add the machine mapping
             _itemToMachineMapping[_itemIndex - 1] = machineIndex;
 
+            // Add the source mapping
+            _itemToSourceMapping[_itemIndex - 1] = sourceIndex;
+
             // Add the item statistics
             DatStatistics.AddItemStatistics(item);
 
diff --git a/SabreTools.DatTools/DatFileTool.cs b/SabreTools.DatTools/DatFileTool.cs
index c050fe85..242e48b2 100644
--- a/SabreTools.DatTools/DatFileTool.cs
+++ b/SabreTools.DatTools/DatFileTool.cs
@@ -641,7 +641,7 @@ namespace SabreTools.DatTools
             // Get all current items, machines, and mappings
             var datItems = datFile.ItemsDB.GetItems().ToDictionary(m => m.Item1, m => m.Item2);
             var machines = datFile.ItemsDB.GetMachines().ToDictionary(m => m.Item1, m => m.Item2);
-            var mappings = datFile.ItemsDB.GetItemMappings().ToDictionary(m => m.Item1, m => m.Item2);
+            var mappings = datFile.ItemsDB.GetItemMachineMappings().ToDictionary(m => m.Item1, m => m.Item2);
 
             // Create a mapping from old machine index to new machine index
             var machineRemapping = new Dictionary<long, long>();
@@ -683,7 +683,7 @@ namespace SabreTools.DatTools
                         continue;
 #endif
 
-                    dupeData.ItemsDB.AddItem(newrom, machineRemapping[machineIndex], false);
+                    dupeData.ItemsDB.AddItem(newrom, machineRemapping[machineIndex], statsOnly: false);
                 }
 #if NET40_OR_GREATER || NETCOREAPP
             });
@@ -855,7 +855,7 @@ namespace SabreTools.DatTools
             // Get all current items, machines, and mappings
             var datItems = datFile.ItemsDB.GetItems().ToDictionary(m => m.Item1, m => m.Item2);
             var machines = datFile.ItemsDB.GetMachines().ToDictionary(m => m.Item1, m => m.Item2);
-            var mappings = datFile.ItemsDB.GetItemMappings().ToDictionary(m => m.Item1, m => m.Item2);
+            var mappings = datFile.ItemsDB.GetItemMachineMappings().ToDictionary(m => m.Item1, m => m.Item2);
 
             // Create a mapping from old machine index to new machine index
             var machineRemapping = new Dictionary<long, long>();
@@ -896,7 +896,7 @@ namespace SabreTools.DatTools
 #else
                 if (item.Value.GetFieldValue<DupeType>(DatItem.DupeTypeKey).HasFlag(DupeType.Internal) || item.Value.GetFieldValue<DupeType>(DatItem.DupeTypeKey) == 0x00)
 #endif
-                    outDats[item.Value.GetFieldValue<Source?>(DatItem.SourceKey)!.Index].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                    outDats[item.Value.GetFieldValue<Source?>(DatItem.SourceKey)!.Index].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
 #if NET40_OR_GREATER || NETCOREAPP
             });
 #else
@@ -1030,7 +1030,7 @@ namespace SabreTools.DatTools
             // Get all current items, machines, and mappings
             var datItems = datFile.ItemsDB.GetItems().ToDictionary(m => m.Item1, m => m.Item2);
             var machines = datFile.ItemsDB.GetMachines().ToDictionary(m => m.Item1, m => m.Item2);
-            var mappings = datFile.ItemsDB.GetItemMappings().ToDictionary(m => m.Item1, m => m.Item2);
+            var mappings = datFile.ItemsDB.GetItemMachineMappings().ToDictionary(m => m.Item1, m => m.Item2);
 
             // Create a mapping from old machine index to new machine index
             var machineRemapping = new Dictionary<long, long>();
@@ -1073,7 +1073,7 @@ namespace SabreTools.DatTools
 #endif
 
                     newrom.GetFieldValue<Machine>(DatItem.MachineKey)!.SetFieldValue<string?>(Models.Metadata.Machine.NameKey, newrom.GetFieldValue<Machine>(DatItem.MachineKey)!.GetStringFieldValue(Models.Metadata.Machine.NameKey) + $" ({Path.GetFileNameWithoutExtension(inputs[newrom.GetFieldValue<Source?>(DatItem.SourceKey)!.Index].CurrentPath)})");
-                    outerDiffData.ItemsDB.AddItem(newrom, machineRemapping[machineIndex], false);
+                    outerDiffData.ItemsDB.AddItem(newrom, machineRemapping[machineIndex], statsOnly: false);
                 }
 #if NET40_OR_GREATER || NETCOREAPP
             });
@@ -1178,7 +1178,7 @@ namespace SabreTools.DatTools
             // Get all current items, machines, and mappings
             var datItems = addFrom.ItemsDB.GetItems().ToDictionary(m => m.Item1, m => m.Item2);
             var machines = addFrom.ItemsDB.GetMachines().ToDictionary(m => m.Item1, m => m.Item2);
-            var mappings = addFrom.ItemsDB.GetItemMappings().ToDictionary(m => m.Item1, m => m.Item2);
+            var mappings = addFrom.ItemsDB.GetItemMachineMappings().ToDictionary(m => m.Item1, m => m.Item2);
 
             // Create a mapping from old machine index to new machine index
             var machineRemapping = new Dictionary<long, long>();
@@ -1201,7 +1201,7 @@ namespace SabreTools.DatTools
             {
                 // Get the machine index for this item
                 long machineIndex = mappings[item.Key];
-                addTo.ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                addTo.ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
                 
                 // Now remove the key from the source DAT
                 if (delete)
@@ -1270,7 +1270,7 @@ namespace SabreTools.DatTools
             // Get all current items, machines, and mappings
             var datItems = datFile.ItemsDB.GetItems().ToDictionary(m => m.Item1, m => m.Item2);
             var machines = datFile.ItemsDB.GetMachines().ToDictionary(m => m.Item1, m => m.Item2);
-            var mappings = datFile.ItemsDB.GetItemMappings().ToDictionary(m => m.Item1, m => m.Item2);
+            var mappings = datFile.ItemsDB.GetItemMachineMappings().ToDictionary(m => m.Item1, m => m.Item2);
 
             // Create a mapping from old machine index to new machine index
             var machineRemapping = new Dictionary<long, long>();
@@ -1295,7 +1295,7 @@ namespace SabreTools.DatTools
                 long machineIndex = mappings[item.Key];
 
                 if (item.Value.GetFieldValue<Source?>(DatItem.SourceKey) != null && item.Value.GetFieldValue<Source?>(DatItem.SourceKey)!.Index == index)
-                    indexDat.ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                    indexDat.ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
 #if NET40_OR_GREATER || NETCOREAPP
             });
 #else
diff --git a/SabreTools.DatTools/Splitter.cs b/SabreTools.DatTools/Splitter.cs
index e7f874e6..0ca54acf 100644
--- a/SabreTools.DatTools/Splitter.cs
+++ b/SabreTools.DatTools/Splitter.cs
@@ -145,7 +145,7 @@ namespace SabreTools.DatTools
             // Get all current items, machines, and mappings
             var datItems = datFile.ItemsDB.GetItems().ToDictionary(m => m.Item1, m => m.Item2);
             var machines = datFile.ItemsDB.GetMachines().ToDictionary(m => m.Item1, m => m.Item2);
-            var mappings = datFile.ItemsDB.GetItemMappings().ToDictionary(m => m.Item1, m => m.Item2);
+            var mappings = datFile.ItemsDB.GetItemMachineMappings().ToDictionary(m => m.Item1, m => m.Item2);
 
             // Create a mapping from old machine index to new machine index
             var machineRemapping = new Dictionary<long, long>();
@@ -172,16 +172,16 @@ namespace SabreTools.DatTools
 
                 if (newExtA.Contains((item.Value.GetName() ?? string.Empty).GetNormalizedExtension()))
                 {
-                    extADat.ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                    extADat.ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
                 }
                 else if (newExtB.Contains((item.Value.GetName() ?? string.Empty).GetNormalizedExtension()))
                 {
-                    extBDat.ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                    extBDat.ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
                 }
                 else
                 {
-                    extADat.ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
-                    extBDat.ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                    extADat.ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
+                    extBDat.ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
                 }
 #if NET40_OR_GREATER || NETCOREAPP
             });
@@ -383,7 +383,7 @@ namespace SabreTools.DatTools
             // Get all current items, machines, and mappings
             var datItems = datFile.ItemsDB.GetItems().ToDictionary(m => m.Item1, m => m.Item2);
             var machines = datFile.ItemsDB.GetMachines().ToDictionary(m => m.Item1, m => m.Item2);
-            var mappings = datFile.ItemsDB.GetItemMappings().ToDictionary(m => m.Item1, m => m.Item2);
+            var mappings = datFile.ItemsDB.GetItemMachineMappings().ToDictionary(m => m.Item1, m => m.Item2);
 
             // Create a mapping from old machine index to new machine index
             var machineRemapping = new Dictionary<long, long>();
@@ -419,45 +419,45 @@ namespace SabreTools.DatTools
                 {
                     case Disk disk:
                         if (disk.GetStringFieldValue(Models.Metadata.Disk.StatusKey).AsEnumValue<ItemStatus>() == ItemStatus.Nodump)
-                            fieldDats[Models.Metadata.Disk.StatusKey].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                            fieldDats[Models.Metadata.Disk.StatusKey].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
                         else if (!string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.SHA1Key)))
-                            fieldDats[Models.Metadata.Disk.SHA1Key].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                            fieldDats[Models.Metadata.Disk.SHA1Key].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
                         else if (!string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.MD5Key)))
-                            fieldDats[Models.Metadata.Disk.MD5Key].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                            fieldDats[Models.Metadata.Disk.MD5Key].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
                         else if (!string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.MD5Key)))
-                            fieldDats[Models.Metadata.Disk.MD5Key].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                            fieldDats[Models.Metadata.Disk.MD5Key].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
                         else
-                            fieldDats["null"].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                            fieldDats["null"].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
                         break;
 
                     case Media media:
                         if (!string.IsNullOrEmpty(media.GetStringFieldValue(Models.Metadata.Media.SHA256Key)))
-                            fieldDats[Models.Metadata.Media.SHA256Key].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                            fieldDats[Models.Metadata.Media.SHA256Key].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
                         else if (!string.IsNullOrEmpty(media.GetStringFieldValue(Models.Metadata.Media.SHA1Key)))
-                            fieldDats[Models.Metadata.Media.SHA1Key].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                            fieldDats[Models.Metadata.Media.SHA1Key].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
                         else if (!string.IsNullOrEmpty(media.GetStringFieldValue(Models.Metadata.Media.MD5Key)))
-                            fieldDats[Models.Metadata.Media.MD5Key].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                            fieldDats[Models.Metadata.Media.MD5Key].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
                         else
-                            fieldDats["null"].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                            fieldDats["null"].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
                         break;
 
                     case Rom rom:
                         if (rom.GetStringFieldValue(Models.Metadata.Rom.StatusKey).AsEnumValue<ItemStatus>() == ItemStatus.Nodump)
-                            fieldDats[Models.Metadata.Rom.StatusKey].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                            fieldDats[Models.Metadata.Rom.StatusKey].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
                         else if (!string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA512Key)))
-                            fieldDats[Models.Metadata.Rom.SHA512Key].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                            fieldDats[Models.Metadata.Rom.SHA512Key].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
                         else if (!string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA384Key)))
-                            fieldDats[Models.Metadata.Rom.SHA384Key].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                            fieldDats[Models.Metadata.Rom.SHA384Key].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
                         else if (!string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA256Key)))
-                            fieldDats[Models.Metadata.Rom.SHA256Key].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                            fieldDats[Models.Metadata.Rom.SHA256Key].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
                         else if (!string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA1Key)))
-                            fieldDats[Models.Metadata.Rom.SHA1Key].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                            fieldDats[Models.Metadata.Rom.SHA1Key].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
                         else if (!string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.MD5Key)))
-                            fieldDats[Models.Metadata.Rom.MD5Key].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                            fieldDats[Models.Metadata.Rom.MD5Key].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
                         else if (!string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.CRCKey)))
-                            fieldDats[Models.Metadata.Rom.CRCKey].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                            fieldDats[Models.Metadata.Rom.CRCKey].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
                         else
-                            fieldDats["null"].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                            fieldDats["null"].ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
                         break;
 
                     default:
@@ -695,7 +695,7 @@ namespace SabreTools.DatTools
             // Get all current items, machines, and mappings
             var datItems = datFile.ItemsDB.GetItems().ToDictionary(m => m.Item1, m => m.Item2);
             var machines = datFile.ItemsDB.GetMachines().ToDictionary(m => m.Item1, m => m.Item2);
-            var mappings = datFile.ItemsDB.GetItemMappings().ToDictionary(m => m.Item1, m => m.Item2);
+            var mappings = datFile.ItemsDB.GetItemMachineMappings().ToDictionary(m => m.Item1, m => m.Item2);
 
             // Create a mapping from old machine index to new machine index
             var machineRemapping = new Dictionary<long, long>();
@@ -722,19 +722,19 @@ namespace SabreTools.DatTools
 
                 // If the file is not a Rom, it automatically goes in the "lesser" dat
                 if (item.Value is not Rom rom)
-                    lessThan.ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                    lessThan.ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
 
                 // If the file is a Rom and has no size, put it in the "lesser" dat
                 else if (rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) == null)
-                    lessThan.ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                    lessThan.ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
 
                 // If the file is a Rom and less than the radix, put it in the "lesser" dat
                 else if (rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) < radix)
-                    lessThan.ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                    lessThan.ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
 
                 // If the file is a Rom and greater than or equal to the radix, put it in the "greater" dat
                 else if (rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) >= radix)
-                    greaterThan.ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                    greaterThan.ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
 #if NET40_OR_GREATER || NETCOREAPP
             });
 #else
@@ -939,7 +939,7 @@ namespace SabreTools.DatTools
             // Get all current items, machines, and mappings
             var datItems = datFile.ItemsDB.GetItems().ToDictionary(m => m.Item1, m => m.Item2);
             var machines = datFile.ItemsDB.GetMachines().ToDictionary(m => m.Item1, m => m.Item2);
-            var mappings = datFile.ItemsDB.GetItemMappings().ToDictionary(m => m.Item1, m => m.Item2);
+            var mappings = datFile.ItemsDB.GetItemMachineMappings().ToDictionary(m => m.Item1, m => m.Item2);
 
             // Create a mapping from old machine index to new machine index
             var machineRemapping = new Dictionary<long, long>();
@@ -964,7 +964,7 @@ namespace SabreTools.DatTools
                 long machineIndex = mappings[item.Key];
 
                 if (item.Value.GetStringFieldValue(Models.Metadata.DatItem.TypeKey).AsEnumValue<ItemType>() == itemType)
-                    indexDat.ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], false);
+                    indexDat.ItemsDB.AddItem(item.Value, machineRemapping[machineIndex], statsOnly: false);
 #if NET40_OR_GREATER || NETCOREAPP
             });
 #else