diff --git a/SabreTools.DatItems/DatItem.cs b/SabreTools.DatItems/DatItem.cs
index b8bdb42c..2e29852b 100644
--- a/SabreTools.DatItems/DatItem.cs
+++ b/SabreTools.DatItems/DatItem.cs
@@ -152,11 +152,6 @@ namespace SabreTools.DatItems
             Dictionary<DatItemField, string> datItemMappings,
             Dictionary<MachineField, string> machineMappings)
         {
-            // Set machine fields
-            if (Machine == null)
-                Machine = new Machine();
-
-            Machine.SetFields(machineMappings);
         }
 
         #endregion
@@ -470,8 +465,6 @@ namespace SabreTools.DatItems
             List<DatItemField> datItemFields,
             List<MachineField> machineFields)
         {
-            // Remove machine fields
-            Machine.RemoveFields(machineFields);
         }
 
         /// <summary>
diff --git a/SabreTools.DatItems/Machine.cs b/SabreTools.DatItems/Machine.cs
index 2f8d580c..efd4a4e1 100644
--- a/SabreTools.DatItems/Machine.cs
+++ b/SabreTools.DatItems/Machine.cs
@@ -1,10 +1,7 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Xml.Serialization;
 
 using SabreTools.Core;
-using SabreTools.Core.Tools;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 
@@ -311,153 +308,6 @@ namespace SabreTools.DatItems
 
         #endregion // Fields
 
-        #region Accessors
-
-        /// <summary>
-        /// Set fields with given values
-        /// </summary>
-        /// <param name="mappings">Mappings dictionary</param>
-        public void SetFields(Dictionary<MachineField, string> mappings)
-        {
-            if (mappings == null)
-                return;
-
-            #region Common
-
-            if (mappings.Keys.Contains(MachineField.Name))
-                Name = mappings[MachineField.Name];
-
-            if (mappings.Keys.Contains(MachineField.Comment))
-                Comment = mappings[MachineField.Comment];
-
-            if (mappings.Keys.Contains(MachineField.Description))
-                Description = mappings[MachineField.Description];
-
-            if (mappings.Keys.Contains(MachineField.Year))
-                Year = mappings[MachineField.Year];
-
-            if (mappings.Keys.Contains(MachineField.Manufacturer))
-                Manufacturer = mappings[MachineField.Manufacturer];
-
-            if (mappings.Keys.Contains(MachineField.Publisher))
-                Publisher = mappings[MachineField.Publisher];
-
-            if (mappings.Keys.Contains(MachineField.Category))
-                Category = mappings[MachineField.Category];
-
-            if (mappings.Keys.Contains(MachineField.RomOf))
-                RomOf = mappings[MachineField.RomOf];
-
-            if (mappings.Keys.Contains(MachineField.CloneOf))
-                CloneOf = mappings[MachineField.CloneOf];
-
-            if (mappings.Keys.Contains(MachineField.SampleOf))
-                SampleOf = mappings[MachineField.SampleOf];
-
-            if (mappings.Keys.Contains(MachineField.Type))
-                MachineType = mappings[MachineField.Type].AsMachineType();
-
-            #endregion
-
-            #region AttractMode
-
-            if (mappings.Keys.Contains(MachineField.Players))
-                Players = mappings[MachineField.Players];
-
-            if (mappings.Keys.Contains(MachineField.Rotation))
-                Rotation = mappings[MachineField.Rotation];
-
-            if (mappings.Keys.Contains(MachineField.Control))
-                Control = mappings[MachineField.Control];
-
-            if (mappings.Keys.Contains(MachineField.Status))
-                Status = mappings[MachineField.Status];
-
-            if (mappings.Keys.Contains(MachineField.DisplayCount))
-                DisplayCount = mappings[MachineField.DisplayCount];
-
-            if (mappings.Keys.Contains(MachineField.DisplayType))
-                DisplayType = mappings[MachineField.DisplayType];
-
-            if (mappings.Keys.Contains(MachineField.Buttons))
-                Buttons = mappings[MachineField.Buttons];
-
-            #endregion
-
-            #region ListXML
-
-            if (mappings.Keys.Contains(MachineField.SourceFile))
-                SourceFile = mappings[MachineField.SourceFile];
-
-            if (mappings.Keys.Contains(MachineField.Runnable))
-                Runnable = mappings[MachineField.Runnable].AsRunnable();
-
-            #endregion
-
-            #region Logiqx
-
-            if (mappings.Keys.Contains(MachineField.Board))
-                Board = mappings[MachineField.Board];
-
-            if (mappings.Keys.Contains(MachineField.RebuildTo))
-                RebuildTo = mappings[MachineField.RebuildTo];
-
-            #endregion
-
-            #region Logiqx EmuArc
-
-            if (mappings.Keys.Contains(MachineField.TitleID))
-                TitleID = mappings[MachineField.TitleID];
-
-            if (mappings.Keys.Contains(MachineField.Developer))
-                Developer = mappings[MachineField.Developer];
-
-            if (mappings.Keys.Contains(MachineField.Genre))
-                Genre = mappings[MachineField.Genre];
-
-            if (mappings.Keys.Contains(MachineField.Subgenre))
-                Subgenre = mappings[MachineField.Subgenre];
-
-            if (mappings.Keys.Contains(MachineField.Ratings))
-                Ratings = mappings[MachineField.Ratings];
-
-            if (mappings.Keys.Contains(MachineField.Score))
-                Score = mappings[MachineField.Score];
-
-            if (mappings.Keys.Contains(MachineField.Enabled))
-                Enabled = mappings[MachineField.Enabled];
-
-            if (mappings.Keys.Contains(MachineField.CRC))
-                Crc = mappings[MachineField.CRC].AsYesNo();
-
-            if (mappings.Keys.Contains(MachineField.RelatedTo))
-                RelatedTo = mappings[MachineField.RelatedTo];
-
-            #endregion
-
-            #region OpenMSX
-
-            if (mappings.Keys.Contains(MachineField.GenMSXID))
-                GenMSXID = mappings[MachineField.GenMSXID];
-
-            if (mappings.Keys.Contains(MachineField.System))
-                System = mappings[MachineField.System];
-
-            if (mappings.Keys.Contains(MachineField.Country))
-                Country = mappings[MachineField.Country];
-
-            #endregion
-
-            #region SoftwareList
-
-            if (mappings.Keys.Contains(MachineField.Supported))
-                Supported = mappings[MachineField.Supported].AsSupported();
-
-            #endregion
-        }
-
-        #endregion
-
         #region Constructors
 
         /// <summary>
@@ -563,298 +413,5 @@ namespace SabreTools.DatItems
         }
 
         #endregion
-
-        #region Filtering
-
-        /// <summary>
-        /// Remove fields from the Machine
-        /// </summary>
-        /// <param name="fields">List of Fields to remove</param>
-        public void RemoveFields(List<MachineField> fields)
-        {
-            #region Common
-
-            if (fields.Contains(MachineField.Name))
-                Name = null;
-
-            if (fields.Contains(MachineField.Comment))
-                Comment = null;
-
-            if (fields.Contains(MachineField.Description))
-                Description = null;
-
-            if (fields.Contains(MachineField.Year))
-                Year = null;
-
-            if (fields.Contains(MachineField.Manufacturer))
-                Manufacturer = null;
-
-            if (fields.Contains(MachineField.Publisher))
-                Publisher = null;
-
-            if (fields.Contains(MachineField.Category))
-                Category = null;
-
-            if (fields.Contains(MachineField.RomOf))
-                RomOf = null;
-
-            if (fields.Contains(MachineField.CloneOf))
-                CloneOf = null;
-
-            if (fields.Contains(MachineField.SampleOf))
-                SampleOf = null;
-
-            if (fields.Contains(MachineField.Type))
-                MachineType = 0x0;
-
-            #endregion
-
-            #region AttractMode
-
-            if (fields.Contains(MachineField.Players))
-                Players = null;
-
-            if (fields.Contains(MachineField.Rotation))
-                Rotation = null;
-
-            if (fields.Contains(MachineField.Control))
-                Control = null;
-
-            if (fields.Contains(MachineField.Status))
-                Status = null;
-
-            if (fields.Contains(MachineField.DisplayCount))
-                DisplayCount = null;
-
-            if (fields.Contains(MachineField.DisplayType))
-                DisplayType = null;
-
-            if (fields.Contains(MachineField.Buttons))
-                Buttons = null;
-
-            #endregion
-
-            #region ListXML
-
-            if (fields.Contains(MachineField.SourceFile))
-                SourceFile = null;
-
-            if (fields.Contains(MachineField.Runnable))
-                Runnable = Runnable.NULL;
-
-            #endregion
-
-            #region Logiqx
-
-            if (fields.Contains(MachineField.Board))
-                Board = null;
-
-            if (fields.Contains(MachineField.RebuildTo))
-                RebuildTo = null;
-
-            #endregion
-
-            #region Logiqx EmuArc
-
-            if (fields.Contains(MachineField.TitleID))
-                TitleID = null;
-
-            if (fields.Contains(MachineField.Developer))
-                Developer = null;
-
-            if (fields.Contains(MachineField.Genre))
-                Genre = null;
-
-            if (fields.Contains(MachineField.Subgenre))
-                Subgenre = null;
-
-            if (fields.Contains(MachineField.Ratings))
-                Ratings = null;
-
-            if (fields.Contains(MachineField.Score))
-                Score = null;
-
-            if (fields.Contains(MachineField.Enabled))
-                Enabled = null;
-
-            if (fields.Contains(MachineField.CRC))
-                Crc = null;
-
-            if (fields.Contains(MachineField.RelatedTo))
-                RelatedTo = null;
-
-            #endregion
-
-            #region OpenMSX
-
-            if (fields.Contains(MachineField.GenMSXID))
-                GenMSXID = null;
-
-            if (fields.Contains(MachineField.System))
-                System = null;
-
-            if (fields.Contains(MachineField.Country))
-                Country = null;
-
-            #endregion
-
-            #region SoftwareList
-
-            if (fields.Contains(MachineField.Supported))
-                Supported = Supported.NULL;
-
-            #endregion
-        }
-
-        #endregion
-
-        #region Sorting and Merging
-
-        /// <summary>
-        /// Replace machine fields from another item
-        /// </summary>
-        /// <param name="item">DatItem to pull new information from</param>
-        /// <param name="fields">List of Fields representing what should be updated</param>
-        /// <param name="onlySame">True if descriptions should only be replaced if the game name is the same, false otherwise</param>
-        public void ReplaceFields(Machine machine, List<MachineField> fields, bool onlySame)
-        {
-            #region Common
-
-            if (fields.Contains(MachineField.Name))
-                Name = machine.Name;
-
-            if (fields.Contains(MachineField.Comment))
-                Comment = machine.Comment;
-
-            if (fields.Contains(MachineField.Description))
-            {
-                if (!onlySame || (onlySame && Name == Description))
-                    Description = machine.Description;
-            }
-
-            if (fields.Contains(MachineField.Year))
-                Year = machine.Year;
-
-            if (fields.Contains(MachineField.Manufacturer))
-                Manufacturer = machine.Manufacturer;
-
-            if (fields.Contains(MachineField.Publisher))
-                Publisher = machine.Publisher;
-
-            if (fields.Contains(MachineField.Category))
-                Category = machine.Category;
-
-            if (fields.Contains(MachineField.RomOf))
-                RomOf = machine.RomOf;
-
-            if (fields.Contains(MachineField.CloneOf))
-                CloneOf = machine.CloneOf;
-
-            if (fields.Contains(MachineField.SampleOf))
-                SampleOf = machine.SampleOf;
-
-            if (fields.Contains(MachineField.Type))
-                MachineType = machine.MachineType;
-
-            #endregion
-
-            #region AttractMode
-
-            if (fields.Contains(MachineField.Players))
-                Players = machine.Players;
-
-            if (fields.Contains(MachineField.Rotation))
-                Rotation = machine.Rotation;
-
-            if (fields.Contains(MachineField.Control))
-                Control = machine.Control;
-
-            if (fields.Contains(MachineField.Status))
-                Status = machine.Status;
-
-            if (fields.Contains(MachineField.DisplayCount))
-                DisplayCount = machine.DisplayCount;
-
-            if (fields.Contains(MachineField.DisplayType))
-                DisplayType = machine.DisplayType;
-
-            if (fields.Contains(MachineField.Buttons))
-                Buttons = machine.Buttons;
-
-            #endregion
-
-            #region ListXML
-
-            if (fields.Contains(MachineField.SourceFile))
-                SourceFile = machine.SourceFile;
-
-            if (fields.Contains(MachineField.Runnable))
-                Runnable = machine.Runnable;
-
-            #endregion
-
-            #region Logiqx
-
-            if (fields.Contains(MachineField.Board))
-                Board = machine.Board;
-
-            if (fields.Contains(MachineField.RebuildTo))
-                RebuildTo = machine.RebuildTo;
-
-            #endregion
-
-            #region Logiqx EmuArc
-
-            if (fields.Contains(MachineField.TitleID))
-                TitleID = machine.TitleID;
-
-            if (fields.Contains(MachineField.Developer))
-                Developer = machine.Developer;
-
-            if (fields.Contains(MachineField.Genre))
-                Genre = machine.Genre;
-
-            if (fields.Contains(MachineField.Subgenre))
-                Subgenre = machine.Subgenre;
-
-            if (fields.Contains(MachineField.Ratings))
-                Ratings = machine.Ratings;
-
-            if (fields.Contains(MachineField.Score))
-                Score = machine.Score;
-
-            if (fields.Contains(MachineField.Enabled))
-                Enabled = machine.Enabled;
-
-            if (fields.Contains(MachineField.CRC))
-                Crc = machine.Crc;
-
-            if (fields.Contains(MachineField.RelatedTo))
-                RelatedTo = machine.RelatedTo;
-
-            #endregion
-
-            #region OpenMSX
-
-            if (fields.Contains(MachineField.GenMSXID))
-                GenMSXID = machine.GenMSXID;
-
-            if (fields.Contains(MachineField.System))
-                System = machine.System;
-
-            if (fields.Contains(MachineField.Country))
-                Country = machine.Country;
-
-            #endregion
-
-            #region SoftwareList
-
-            if (fields.Contains(MachineField.Supported))
-                Supported = machine.Supported;
-
-            #endregion
-        }
-
-        #endregion
     }
 }
diff --git a/SabreTools.DatTools/DatTool.cs b/SabreTools.DatTools/DatTool.cs
index 90f96273..21532a7f 100644
--- a/SabreTools.DatTools/DatTool.cs
+++ b/SabreTools.DatTools/DatTool.cs
@@ -6,6 +6,7 @@ using System.Threading.Tasks;
 using SabreTools.Core;
 using SabreTools.DatFiles;
 using SabreTools.DatItems;
+using SabreTools.Filtering;
 using SabreTools.IO;
 using SabreTools.Logging;
 
@@ -86,7 +87,7 @@ namespace SabreTools.DatTools
                     {
                         DatItem newDatItem = datItem.Clone() as DatItem;
                         if (datFile.Items.ContainsKey(key) && datFile.Items[key].Count() > 0)
-                            newDatItem.Machine.ReplaceFields(datFile.Items[key][0].Machine, machineFields, onlySame);
+                            Cleaner.ReplaceFields(newDatItem.Machine, datFile.Items[key][0].Machine, machineFields, onlySame);
 
                         newDatItems.Add(newDatItem);
                     }
diff --git a/SabreTools.DatTools/Modification.cs b/SabreTools.DatTools/Modification.cs
index 311442ba..b3572523 100644
--- a/SabreTools.DatTools/Modification.cs
+++ b/SabreTools.DatTools/Modification.cs
@@ -146,7 +146,7 @@ namespace SabreTools.DatTools
 
                     foreach (var datItem in datItems)
                     {
-                        datItem.SetFields(null, mappings);
+                        Cleaner.SetFields(datItem.Machine, mappings);
                     }
                 }
 
@@ -524,7 +524,8 @@ namespace SabreTools.DatTools
                 List<DatItem> items = datFile.Items[key];
                 for (int j = 0; j < items.Count; j++)
                 {
-                    items[j].RemoveFields(datItemFields, machineFields);
+                    items[j].RemoveFields(datItemFields, null);
+                    Cleaner.RemoveFields(items[j].Machine, machineFields);
                 }
 
                 datFile.Items.Remove(key);
diff --git a/SabreTools.Filtering/Cleaner.cs b/SabreTools.Filtering/Cleaner.cs
index 3011dafe..2dea6469 100644
--- a/SabreTools.Filtering/Cleaner.cs
+++ b/SabreTools.Filtering/Cleaner.cs
@@ -4,6 +4,7 @@ using System.Linq;
 using System.Text.RegularExpressions;
 
 using SabreTools.Core;
+using SabreTools.Core.Tools;
 using SabreTools.DatItems;
 
 namespace SabreTools.Filtering
@@ -328,6 +329,474 @@ namespace SabreTools.Filtering
 
         #endregion
     
+        // TODO: Use these instead of the baked in ones
+        // TODO: Move to new class?
+        #region Field Manipulation
+
+        /// <summary>
+        /// Remove fields with given values
+        /// </summary>
+        /// <param name="datItem">DatItem to remove fields from</param>
+        /// <param name="fields">List of fields to remove</param>
+        public static void RemoveFields(DatItem datItem, List<DatItemField> fields)
+        {
+            
+        }
+
+        /// <summary>
+        /// Remove fields with given values
+        /// </summary>
+        /// <param name="machine">Machine to remove fields from</param>
+        /// <param name="fields">List of fields to remove</param>
+        public static void RemoveFields(Machine machine, List<MachineField> fields)
+        {
+            #region Common
+
+            if (fields.Contains(MachineField.Name))
+                machine.Name = null;
+
+            if (fields.Contains(MachineField.Comment))
+                machine.Comment = null;
+
+            if (fields.Contains(MachineField.Description))
+                machine.Description = null;
+
+            if (fields.Contains(MachineField.Year))
+                machine.Year = null;
+
+            if (fields.Contains(MachineField.Manufacturer))
+                machine.Manufacturer = null;
+
+            if (fields.Contains(MachineField.Publisher))
+                machine.Publisher = null;
+
+            if (fields.Contains(MachineField.Category))
+                machine.Category = null;
+
+            if (fields.Contains(MachineField.RomOf))
+                machine.RomOf = null;
+
+            if (fields.Contains(MachineField.CloneOf))
+                machine.CloneOf = null;
+
+            if (fields.Contains(MachineField.SampleOf))
+                machine.SampleOf = null;
+
+            if (fields.Contains(MachineField.Type))
+                machine.MachineType = 0x0;
+
+            #endregion
+
+            #region AttractMode
+
+            if (fields.Contains(MachineField.Players))
+                machine.Players = null;
+
+            if (fields.Contains(MachineField.Rotation))
+                machine.Rotation = null;
+
+            if (fields.Contains(MachineField.Control))
+                machine.Control = null;
+
+            if (fields.Contains(MachineField.Status))
+                machine.Status = null;
+
+            if (fields.Contains(MachineField.DisplayCount))
+                machine.DisplayCount = null;
+
+            if (fields.Contains(MachineField.DisplayType))
+                machine.DisplayType = null;
+
+            if (fields.Contains(MachineField.Buttons))
+                machine.Buttons = null;
+
+            #endregion
+
+            #region ListXML
+
+            if (fields.Contains(MachineField.SourceFile))
+                machine.SourceFile = null;
+
+            if (fields.Contains(MachineField.Runnable))
+                machine.Runnable = Runnable.NULL;
+
+            #endregion
+
+            #region Logiqx
+
+            if (fields.Contains(MachineField.Board))
+                machine.Board = null;
+
+            if (fields.Contains(MachineField.RebuildTo))
+                machine.RebuildTo = null;
+
+            #endregion
+
+            #region Logiqx EmuArc
+
+            if (fields.Contains(MachineField.TitleID))
+                machine.TitleID = null;
+
+            if (fields.Contains(MachineField.Developer))
+                machine.Developer = null;
+
+            if (fields.Contains(MachineField.Genre))
+                machine.Genre = null;
+
+            if (fields.Contains(MachineField.Subgenre))
+                machine.Subgenre = null;
+
+            if (fields.Contains(MachineField.Ratings))
+                machine.Ratings = null;
+
+            if (fields.Contains(MachineField.Score))
+                machine.Score = null;
+
+            if (fields.Contains(MachineField.Enabled))
+                machine.Enabled = null;
+
+            if (fields.Contains(MachineField.CRC))
+                machine.Crc = null;
+
+            if (fields.Contains(MachineField.RelatedTo))
+                machine.RelatedTo = null;
+
+            #endregion
+
+            #region OpenMSX
+
+            if (fields.Contains(MachineField.GenMSXID))
+                machine.GenMSXID = null;
+
+            if (fields.Contains(MachineField.System))
+                machine.System = null;
+
+            if (fields.Contains(MachineField.Country))
+                machine.Country = null;
+
+            #endregion
+
+            #region SoftwareList
+
+            if (fields.Contains(MachineField.Supported))
+                machine.Supported = Supported.NULL;
+
+            #endregion
+        }
+
+        /// <summary>
+        /// Replace fields with given values
+        /// </summary>
+        /// <param name="datItem">DatItem to replace fields in</param>
+        /// <param name="repMachine">DatItem to pull new information from</param>
+        /// <param name="fields">List of fields representing what should be updated</param>
+        public static void ReplaceFields(DatItem datItem, DatItem repDatItem, List<DatItemField> fields)
+        {
+
+        }
+
+        /// <summary>
+        /// Replace fields with given values
+        /// </summary>
+        /// <param name="machine">Machine to replace fields in</param>
+        /// <param name="repMachine">Machine to pull new information from</param>
+        /// <param name="fields">List of fields representing what should be updated</param>
+        /// <param name="onlySame">True if descriptions should only be replaced if the game name is the same, false otherwise</param>
+        public static void ReplaceFields(Machine machine, Machine repMachine, List<MachineField> fields, bool onlySame)
+        {
+            #region Common
+
+            if (fields.Contains(MachineField.Name))
+                machine.Name = repMachine.Name;
+
+            if (fields.Contains(MachineField.Comment))
+                machine.Comment = repMachine.Comment;
+
+            if (fields.Contains(MachineField.Description))
+            {
+                if (!onlySame || (onlySame && machine.Name == machine.Description))
+                    machine.Description = repMachine.Description;
+            }
+
+            if (fields.Contains(MachineField.Year))
+                machine.Year = repMachine.Year;
+
+            if (fields.Contains(MachineField.Manufacturer))
+                machine.Manufacturer = repMachine.Manufacturer;
+
+            if (fields.Contains(MachineField.Publisher))
+                machine.Publisher = repMachine.Publisher;
+
+            if (fields.Contains(MachineField.Category))
+                machine.Category = repMachine.Category;
+
+            if (fields.Contains(MachineField.RomOf))
+                machine.RomOf = repMachine.RomOf;
+
+            if (fields.Contains(MachineField.CloneOf))
+                machine.CloneOf = repMachine.CloneOf;
+
+            if (fields.Contains(MachineField.SampleOf))
+                machine.SampleOf = repMachine.SampleOf;
+
+            if (fields.Contains(MachineField.Type))
+                machine.MachineType = repMachine.MachineType;
+
+            #endregion
+
+            #region AttractMode
+
+            if (fields.Contains(MachineField.Players))
+                machine.Players = repMachine.Players;
+
+            if (fields.Contains(MachineField.Rotation))
+                machine.Rotation = repMachine.Rotation;
+
+            if (fields.Contains(MachineField.Control))
+                machine.Control = repMachine.Control;
+
+            if (fields.Contains(MachineField.Status))
+                machine.Status = repMachine.Status;
+
+            if (fields.Contains(MachineField.DisplayCount))
+                machine.DisplayCount = repMachine.DisplayCount;
+
+            if (fields.Contains(MachineField.DisplayType))
+                machine.DisplayType = repMachine.DisplayType;
+
+            if (fields.Contains(MachineField.Buttons))
+                machine.Buttons = repMachine.Buttons;
+
+            #endregion
+
+            #region ListXML
+
+            if (fields.Contains(MachineField.SourceFile))
+                machine.SourceFile = repMachine.SourceFile;
+
+            if (fields.Contains(MachineField.Runnable))
+                machine.Runnable = repMachine.Runnable;
+
+            #endregion
+
+            #region Logiqx
+
+            if (fields.Contains(MachineField.Board))
+                machine.Board = repMachine.Board;
+
+            if (fields.Contains(MachineField.RebuildTo))
+                machine.RebuildTo = repMachine.RebuildTo;
+
+            #endregion
+
+            #region Logiqx EmuArc
+
+            if (fields.Contains(MachineField.TitleID))
+                machine.TitleID = repMachine.TitleID;
+
+            if (fields.Contains(MachineField.Developer))
+                machine.Developer = repMachine.Developer;
+
+            if (fields.Contains(MachineField.Genre))
+                machine.Genre = repMachine.Genre;
+
+            if (fields.Contains(MachineField.Subgenre))
+                machine.Subgenre = repMachine.Subgenre;
+
+            if (fields.Contains(MachineField.Ratings))
+                machine.Ratings = repMachine.Ratings;
+
+            if (fields.Contains(MachineField.Score))
+                machine.Score = repMachine.Score;
+
+            if (fields.Contains(MachineField.Enabled))
+                machine.Enabled = repMachine.Enabled;
+
+            if (fields.Contains(MachineField.CRC))
+                machine.Crc = repMachine.Crc;
+
+            if (fields.Contains(MachineField.RelatedTo))
+                machine.RelatedTo = repMachine.RelatedTo;
+
+            #endregion
+
+            #region OpenMSX
+
+            if (fields.Contains(MachineField.GenMSXID))
+                machine.GenMSXID = repMachine.GenMSXID;
+
+            if (fields.Contains(MachineField.System))
+                machine.System = repMachine.System;
+
+            if (fields.Contains(MachineField.Country))
+                machine.Country = repMachine.Country;
+
+            #endregion
+
+            #region SoftwareList
+
+            if (fields.Contains(MachineField.Supported))
+                machine.Supported = repMachine.Supported;
+
+            #endregion
+        }
+
+        /// <summary>
+        /// Set fields with given values
+        /// </summary>
+        /// <param name="datItem">DatItem to set fields on</param>
+        /// <param name="mappings">Mappings dictionary</param>
+        public static void SetFields(DatItem datItem, Dictionary<DatItemField, string> mappings)
+        {
+
+        }
+
+        /// <summary>
+        /// Set fields with given values
+        /// </summary>
+        /// <param name="machine">Machine to set fields on</param>
+        /// <param name="mappings">Mappings dictionary</param>
+        public static void SetFields(Machine machine, Dictionary<MachineField, string> mappings)
+        {
+            if (machine == null || mappings == null)
+                return;
+
+            #region Common
+
+            if (mappings.Keys.Contains(MachineField.Name))
+                machine.Name = mappings[MachineField.Name];
+
+            if (mappings.Keys.Contains(MachineField.Comment))
+                machine.Comment = mappings[MachineField.Comment];
+
+            if (mappings.Keys.Contains(MachineField.Description))
+                machine.Description = mappings[MachineField.Description];
+
+            if (mappings.Keys.Contains(MachineField.Year))
+                machine.Year = mappings[MachineField.Year];
+
+            if (mappings.Keys.Contains(MachineField.Manufacturer))
+                machine.Manufacturer = mappings[MachineField.Manufacturer];
+
+            if (mappings.Keys.Contains(MachineField.Publisher))
+                machine.Publisher = mappings[MachineField.Publisher];
+
+            if (mappings.Keys.Contains(MachineField.Category))
+                machine.Category = mappings[MachineField.Category];
+
+            if (mappings.Keys.Contains(MachineField.RomOf))
+                machine.RomOf = mappings[MachineField.RomOf];
+
+            if (mappings.Keys.Contains(MachineField.CloneOf))
+                machine.CloneOf = mappings[MachineField.CloneOf];
+
+            if (mappings.Keys.Contains(MachineField.SampleOf))
+                machine.SampleOf = mappings[MachineField.SampleOf];
+
+            if (mappings.Keys.Contains(MachineField.Type))
+                machine.MachineType = mappings[MachineField.Type].AsMachineType();
+
+            #endregion
+
+            #region AttractMode
+
+            if (mappings.Keys.Contains(MachineField.Players))
+                machine.Players = mappings[MachineField.Players];
+
+            if (mappings.Keys.Contains(MachineField.Rotation))
+                machine.Rotation = mappings[MachineField.Rotation];
+
+            if (mappings.Keys.Contains(MachineField.Control))
+                machine.Control = mappings[MachineField.Control];
+
+            if (mappings.Keys.Contains(MachineField.Status))
+                machine.Status = mappings[MachineField.Status];
+
+            if (mappings.Keys.Contains(MachineField.DisplayCount))
+                machine.DisplayCount = mappings[MachineField.DisplayCount];
+
+            if (mappings.Keys.Contains(MachineField.DisplayType))
+                machine.DisplayType = mappings[MachineField.DisplayType];
+
+            if (mappings.Keys.Contains(MachineField.Buttons))
+                machine.Buttons = mappings[MachineField.Buttons];
+
+            #endregion
+
+            #region ListXML
+
+            if (mappings.Keys.Contains(MachineField.SourceFile))
+                machine.SourceFile = mappings[MachineField.SourceFile];
+
+            if (mappings.Keys.Contains(MachineField.Runnable))
+                machine.Runnable = mappings[MachineField.Runnable].AsRunnable();
+
+            #endregion
+
+            #region Logiqx
+
+            if (mappings.Keys.Contains(MachineField.Board))
+                machine.Board = mappings[MachineField.Board];
+
+            if (mappings.Keys.Contains(MachineField.RebuildTo))
+                machine.RebuildTo = mappings[MachineField.RebuildTo];
+
+            #endregion
+
+            #region Logiqx EmuArc
+
+            if (mappings.Keys.Contains(MachineField.TitleID))
+                machine.TitleID = mappings[MachineField.TitleID];
+
+            if (mappings.Keys.Contains(MachineField.Developer))
+                machine.Developer = mappings[MachineField.Developer];
+
+            if (mappings.Keys.Contains(MachineField.Genre))
+                machine.Genre = mappings[MachineField.Genre];
+
+            if (mappings.Keys.Contains(MachineField.Subgenre))
+                machine.Subgenre = mappings[MachineField.Subgenre];
+
+            if (mappings.Keys.Contains(MachineField.Ratings))
+                machine.Ratings = mappings[MachineField.Ratings];
+
+            if (mappings.Keys.Contains(MachineField.Score))
+                machine.Score = mappings[MachineField.Score];
+
+            if (mappings.Keys.Contains(MachineField.Enabled))
+                machine.Enabled = mappings[MachineField.Enabled];
+
+            if (mappings.Keys.Contains(MachineField.CRC))
+                machine.Crc = mappings[MachineField.CRC].AsYesNo();
+
+            if (mappings.Keys.Contains(MachineField.RelatedTo))
+                machine.RelatedTo = mappings[MachineField.RelatedTo];
+
+            #endregion
+
+            #region OpenMSX
+
+            if (mappings.Keys.Contains(MachineField.GenMSXID))
+                machine.GenMSXID = mappings[MachineField.GenMSXID];
+
+            if (mappings.Keys.Contains(MachineField.System))
+                machine.System = mappings[MachineField.System];
+
+            if (mappings.Keys.Contains(MachineField.Country))
+                machine.Country = mappings[MachineField.Country];
+
+            #endregion
+
+            #region SoftwareList
+
+            if (mappings.Keys.Contains(MachineField.Supported))
+                machine.Supported = mappings[MachineField.Supported].AsSupported();
+
+            #endregion
+        }
+
+        #endregion
+
         #region Filtering
 
         /// <summary>