diff --git a/Distance/Models/MapLogicSupport.cs b/Distance/Models/MapLogicSupport.cs
index 0323ad9..98f9c03 100644
--- a/Distance/Models/MapLogicSupport.cs
+++ b/Distance/Models/MapLogicSupport.cs
@@ -42,79 +42,83 @@ public class MapLogicSupport : Shared.Models.Methods.IMapLogicSupport
         List<SortingContainer> results = new();
         SortingContainer sortingContainer;
         Sorting[] collection = Shared.Models.Stateless.Methods.ISorting.Sort(sortingCollection);
+        double a;
+        double b;
+        double c;
+        double d;
         double faceDistancePermyriad;
         double sortingDaysDeltaTolerance;
         double faceDistanceMinimumConfidence;
         double faceDistanceAreaPermilleTolerance;
         if (useFiltersCounter is null)
         {
-            sortingDaysDeltaTolerance = _SortingDaysDeltaTolerance;
-            faceDistancePermyriad = _FaceDistancePermyriad;
-            faceDistanceAreaPermilleTolerance = _FaceDistanceAreaPermilleTolerance;
-            faceDistanceMinimumConfidence = _FaceDistanceMinimumConfidence;
+            a = 1f;
+            b = 1f;
+            c = 1f;
+            d = 1f;
         }
-        else if (useFiltersCounter.Value == 1)
+        else if (useFiltersCounter.Value < 5)
         {
-            sortingDaysDeltaTolerance = _SortingDaysDeltaTolerance * 1.5;
-            faceDistancePermyriad = _FaceDistancePermyriad;
-            faceDistanceAreaPermilleTolerance = _FaceDistanceAreaPermilleTolerance;
-            faceDistanceMinimumConfidence = _FaceDistanceMinimumConfidence;
+            a = 1.25f;
+            b = 0.8f;
+            c = a;
+            d = b;
         }
-        else if (useFiltersCounter.Value == 2)
+        else if (useFiltersCounter.Value < 9)
         {
-            sortingDaysDeltaTolerance = _SortingDaysDeltaTolerance;
-            faceDistancePermyriad = _FaceDistancePermyriad * 1.5;
-            faceDistanceAreaPermilleTolerance = _FaceDistanceAreaPermilleTolerance;
-            faceDistanceMinimumConfidence = _FaceDistanceMinimumConfidence;
+            a = 1.5f;
+            b = 0.667f;
+            c = a;
+            d = b;
         }
-        else if (useFiltersCounter.Value == 3)
+        else if (useFiltersCounter.Value < 13)
+        {
+            a = 1.75f;
+            b = 0.571f;
+            c = a;
+            d = b;
+        }
+        else
+        {
+            a = 2f;
+            b = 0.5f;
+            c = a;
+            d = b;
+        }
+        if (useFiltersCounter is null)
         {
             sortingDaysDeltaTolerance = _SortingDaysDeltaTolerance;
             faceDistancePermyriad = _FaceDistancePermyriad;
+            faceDistanceMinimumConfidence = _FaceDistanceMinimumConfidence;
             faceDistanceAreaPermilleTolerance = _FaceDistanceAreaPermilleTolerance;
-            faceDistanceMinimumConfidence = _FaceDistanceMinimumConfidence * .5;
         }
-        else if (useFiltersCounter.Value == 4)
+        else if (useFiltersCounter.Value is 1 or 5 or 9 or 13)
         {
-            sortingDaysDeltaTolerance = _SortingDaysDeltaTolerance * 2;
-            faceDistancePermyriad = _FaceDistancePermyriad * 1.5;
-            faceDistanceAreaPermilleTolerance = _FaceDistanceAreaPermilleTolerance;
-            faceDistanceMinimumConfidence = _FaceDistanceMinimumConfidence * .5;
+            sortingDaysDeltaTolerance = _SortingDaysDeltaTolerance * a;
+            faceDistancePermyriad = _FaceDistancePermyriad * c;
+            faceDistanceMinimumConfidence = _FaceDistanceMinimumConfidence * d;
+            faceDistanceAreaPermilleTolerance = _FaceDistanceAreaPermilleTolerance * d;
         }
-        else if (useFiltersCounter.Value == 5)
+        else if (useFiltersCounter.Value is 2 or 6 or 10 or 14)
         {
-            sortingDaysDeltaTolerance = _SortingDaysDeltaTolerance * 1.5;
-            faceDistancePermyriad = _FaceDistancePermyriad * 2;
-            faceDistanceAreaPermilleTolerance = _FaceDistanceAreaPermilleTolerance;
-            faceDistanceMinimumConfidence = _FaceDistanceMinimumConfidence * .5;
+            sortingDaysDeltaTolerance = _SortingDaysDeltaTolerance * c;
+            faceDistancePermyriad = _FaceDistancePermyriad * a;
+            faceDistanceMinimumConfidence = _FaceDistanceMinimumConfidence * d;
+            faceDistanceAreaPermilleTolerance = _FaceDistanceAreaPermilleTolerance * d;
         }
-        else if (useFiltersCounter.Value == 6)
+        else if (useFiltersCounter.Value is 3 or 7 or 11 or 15)
         {
-            sortingDaysDeltaTolerance = _SortingDaysDeltaTolerance * 1.5;
-            faceDistancePermyriad = _FaceDistancePermyriad * 1.5;
-            faceDistanceAreaPermilleTolerance = _FaceDistanceAreaPermilleTolerance;
-            faceDistanceMinimumConfidence = _FaceDistanceMinimumConfidence * .25;
+            sortingDaysDeltaTolerance = _SortingDaysDeltaTolerance * c;
+            faceDistancePermyriad = _FaceDistancePermyriad * c;
+            faceDistanceMinimumConfidence = _FaceDistanceMinimumConfidence * b;
+            faceDistanceAreaPermilleTolerance = _FaceDistanceAreaPermilleTolerance * d;
         }
-        else if (useFiltersCounter.Value == 7)
+        else if (useFiltersCounter.Value is 4 or 8 or 12 or 16)
         {
-            sortingDaysDeltaTolerance = _SortingDaysDeltaTolerance * 2.5;
-            faceDistancePermyriad = _FaceDistancePermyriad * 2;
-            faceDistanceAreaPermilleTolerance = _FaceDistanceAreaPermilleTolerance;
-            faceDistanceMinimumConfidence = _FaceDistanceMinimumConfidence * .25;
-        }
-        else if (useFiltersCounter.Value == 8)
-        {
-            sortingDaysDeltaTolerance = _SortingDaysDeltaTolerance * 2;
-            faceDistancePermyriad = _FaceDistancePermyriad * 2.5;
-            faceDistanceAreaPermilleTolerance = _FaceDistanceAreaPermilleTolerance;
-            faceDistanceMinimumConfidence = _FaceDistanceMinimumConfidence * .25;
-        }
-        else if (useFiltersCounter.Value == 9)
-        {
-            sortingDaysDeltaTolerance = _SortingDaysDeltaTolerance * 2;
-            faceDistancePermyriad = _FaceDistancePermyriad * 2;
-            faceDistanceAreaPermilleTolerance = _FaceDistanceAreaPermilleTolerance;
-            faceDistanceMinimumConfidence = 0;
+            sortingDaysDeltaTolerance = _SortingDaysDeltaTolerance * c;
+            faceDistancePermyriad = _FaceDistancePermyriad * c;
+            faceDistanceMinimumConfidence = _FaceDistanceMinimumConfidence * d;
+            faceDistanceAreaPermilleTolerance = _FaceDistanceAreaPermilleTolerance * b;
         }
         else
         {
@@ -297,4 +301,20 @@ public class MapLogicSupport : Shared.Models.Methods.IMapLogicSupport
         }
     }
 
+    public static Dictionary<int, Dictionary<int, Mapping>> GetIdToNormalizedPixelPercentageToFace(Mapping[] mappingCollection)
+    {
+        Dictionary<int, Dictionary<int, Mapping>> results = new();
+        Dictionary<int, Mapping> keyValuePairs;
+        foreach (Mapping mapping in mappingCollection)
+        {
+            if (!results.ContainsKey(mapping.MappingFromItem.Id))
+                results.Add(mapping.MappingFromItem.Id, new());
+            keyValuePairs = results[mapping.MappingFromItem.Id];
+            if (keyValuePairs.ContainsKey(mapping.MappingFromLocation.NormalizedPixelPercentage))
+                throw new NotSupportedException();
+            keyValuePairs.Add(mapping.MappingFromLocation.NormalizedPixelPercentage, mapping);
+        }
+        return results;
+    }
+
 }
\ No newline at end of file
diff --git a/Distance/Models/_E_Distance.cs b/Distance/Models/_E_Distance.cs
index d35f5cf..59a5ad2 100644
--- a/Distance/Models/_E_Distance.cs
+++ b/Distance/Models/_E_Distance.cs
@@ -1,4 +1,5 @@
 using System.Text.Json;
+using View_by_Distance.Distance.Models.Stateless;
 using View_by_Distance.FaceRecognitionDotNet;
 using View_by_Distance.Shared.Models;
 
@@ -10,6 +11,7 @@ public partial class E_Distance
     private readonly List<string> _Moved;
     private readonly List<double?> _Debug;
     private readonly List<string> _Renamed;
+    private readonly Serilog.ILogger? _Log;
     private readonly bool _DistanceRenameToMatch;
     private readonly double _FaceDistanceTolerance;
     private readonly bool _DistanceMoveUnableToMatch;
@@ -26,6 +28,7 @@ public partial class E_Distance
         _AllMappedFaceFiles = new();
         _AllMappedFaceFileNames = new();
         _DuplicateMappedFaceFiles = new();
+        _Log = Serilog.Log.ForContext<E_Distance>();
         _DistanceRenameToMatch = distanceRenameToMatch;
         _FaceDistanceTolerance = faceDistanceTolerance;
         _DistanceMoveUnableToMatch = distanceMoveUnableToMatch;
@@ -438,8 +441,14 @@ public partial class E_Distance
 
     public void Clear()
     {
+        if (_Log is null)
+            throw new NullReferenceException(nameof(_Log));
         double?[] debug = (from l in _Debug where l is null or not 0 select l).ToArray();
-        string debugMessage = $"{_Debug.Count - debug.Length} - {debug.Min()} - {_Debug.Max()}";
+        if (debug.Any())
+        {
+            string debugMessage = $"{_Debug.Count - debug.Length} - {debug.Min()} - {_Debug.Max()}";
+            _Log.Info(debugMessage);
+        }
         if (_Moved.Any() || _Renamed.Any() || _DuplicateMappedFaceFiles.Any())
             throw new NotImplementedException("Restart!");
         _Debug.Clear();
diff --git a/Face/Models/_D_Face.cs b/Face/Models/_D_Face.cs
index 4c948b8..0eff5a9 100644
--- a/Face/Models/_D_Face.cs
+++ b/Face/Models/_D_Face.cs
@@ -1,8 +1,10 @@
+using System.Diagnostics;
 using System.Drawing;
 using System.Drawing.Imaging;
 using System.Reflection;
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using View_by_Distance.Face.Models.Stateless;
 using View_by_Distance.FaceRecognitionDotNet;
 using View_by_Distance.Metadata.Models;
 using View_by_Distance.Property.Models;
@@ -34,7 +36,6 @@ public class D_Face
     private readonly bool _RetryImagesWithoutAFace;
     private readonly Configuration _Configuration;
     private readonly int _NumberOfTimesToUpsample;
-    private readonly int _FaceDistanceAreaPermilleTolerance;
     private readonly ImageCodecInfo _ImageCodecInfo;
     private readonly ModelParameter _ModelParameter;
     private readonly PredictorModel _PredictorModel;
@@ -44,6 +45,7 @@ public class D_Face
     private readonly int _FaceDistanceHiddenImageFactor;
     private readonly EncoderParameters _EncoderParameters;
     private readonly ImageCodecInfo _HiddenImageCodecInfo;
+    private readonly int _FaceDistanceAreaPermilleTolerance;
     private readonly bool _ForceFaceLastWriteTimeToCreationTime;
     private readonly EncoderParameters _HiddenEncoderParameters;
     private readonly JsonSerializerOptions _WriteIndentedAndWhenWritingNull;
@@ -190,6 +192,8 @@ public class D_Face
 
     private List<Shared.Models.Face> GetFaces(Shared.Models.Property property, MappingFromItem mappingFromItem, int outputResolutionWidth, int outputResolutionHeight, int outputResolutionOrientation)
     {
+        if (_Log is null)
+            throw new NullReferenceException(nameof(_Log));
         List<Shared.Models.Face> results = new();
         FaceRecognitionDotNet.Image? unknownImage;
         if (!mappingFromItem.ResizedFileHolder.Exists)
@@ -199,7 +203,10 @@ public class D_Face
             try
             { unknownImage = FaceRecognition.LoadImageFile(mappingFromItem.ResizedFileHolder.FullName); }
             catch (Exception)
-            { unknownImage = null; }
+            {
+                unknownImage = null;
+                _Log.Info(string.Concat(new StackFrame().GetMethod()?.Name, " <", mappingFromItem.ResizedFileHolder.FullName, ">"));
+            }
         }
         if (unknownImage is null)
             results.Add(new(property, outputResolutionWidth, outputResolutionHeight, outputResolutionOrientation, mappingFromItem.RelativePath, location: null));
diff --git a/Instance/DlibDotNet.cs b/Instance/DlibDotNet.cs
index 85f389f..c0c5052 100644
--- a/Instance/DlibDotNet.cs
+++ b/Instance/DlibDotNet.cs
@@ -857,7 +857,6 @@ public partial class DlibDotNet
         int normalizedPixelPercentage;
         string deterministicHashCodeKey;
         MappingFromItem mappingFromItem;
-        MappingFromPerson mappingFromPerson;
         MappingFromLocation mappingFromLocation;
         List<Shared.Models.Face> collection = new();
         foreach (Container container in containers)
@@ -887,11 +886,10 @@ public partial class DlibDotNet
                     if (face.FaceEncoding is null || face.Location is null || face.OutputResolution is null)
                         continue;
                     areaPermille = Shared.Models.Stateless.Methods.IMapping.GetAreaPermille(face.Location, face.OutputResolution);
-                    mappingFromPerson = new(approximateYears: null, by: null, displayDirectoryName: string.Empty, personBirthday: null, segmentB: string.Empty);
                     normalizedPixelPercentage = Shared.Models.Stateless.Methods.ILocation.GetNormalizedPixelPercentage(face.Location, Shared.Models.Stateless.ILocation.Digits, Shared.Models.Stateless.ILocation.Factor, face.OutputResolution);
                     deterministicHashCodeKey = Shared.Models.Stateless.Methods.IMapping.GetDeterministicHashCodeKey(item.Property.Id.Value, face.Location, Shared.Models.Stateless.ILocation.Digits, Shared.Models.Stateless.ILocation.Factor, face.OutputResolution);
                     mappingFromLocation = new(areaPermille, face.Location.Confidence, deterministicHashCodeKey, normalizedPixelPercentage);
-                    mapping = new(mappingFromItem, mappingFromLocation, mappingFromPerson);
+                    mapping = new(mappingFromItem, mappingFromLocation);
                     face.SetMapping(mapping);
                     collection.Add(face);
                 }
@@ -901,22 +899,6 @@ public partial class DlibDotNet
         return results;
     }
 
-    internal static Dictionary<int, Dictionary<int, Mapping>> GetIdToNormalizedPixelPercentageToFace(Mapping[] mappingCollection)
-    {
-        Dictionary<int, Dictionary<int, Mapping>> results = new();
-        Dictionary<int, Mapping> keyValuePairs;
-        foreach (Mapping mapping in mappingCollection)
-        {
-            if (!results.ContainsKey(mapping.MappingFromItem.Id))
-                results.Add(mapping.MappingFromItem.Id, new());
-            keyValuePairs = results[mapping.MappingFromItem.Id];
-            if (keyValuePairs.ContainsKey(mapping.MappingFromLocation.NormalizedPixelPercentage))
-                throw new NotSupportedException();
-            keyValuePairs.Add(mapping.MappingFromLocation.NormalizedPixelPercentage, mapping);
-        }
-        return results;
-    }
-
     private void MapLogic(string argZero, long ticks, PersonContainer[] personContainers, Container[] containers, string a2PeopleSingletonDirectory, string dResultsFullGroupDirectory, string d2FacePartsContentDirectory, string eDistanceContentDirectory, string outputResolution)
     {
         int? useFiltersCounter = null;
@@ -940,7 +922,7 @@ public partial class DlibDotNet
             eDistanceContentDirectory,
             mappingCollection,
             mapLogicSupport);
-        Dictionary<int, Dictionary<int, Mapping>> idToNormalizedPixelPercentageToMapping = GetIdToNormalizedPixelPercentageToFace(mappingCollection);
+        Dictionary<int, Dictionary<int, Mapping>> idToNormalizedPixelPercentageToMapping = MapLogicSupport.GetIdToNormalizedPixelPercentageToFace(mappingCollection);
         mapLogic.CopyManualFiles(dFacesContentDirectory, idToNormalizedPixelPercentageToMapping);
         int totalNotMapped = mapLogic.AddToMapping(mappingCollection);
         if (_Configuration.MappingSaveMapped)
@@ -949,7 +931,7 @@ public partial class DlibDotNet
         sortingContainers = mapLogicSupport.SetFaceMappingSortingCollectionThenGetSortingContainers(_AppSettings.MaxDegreeOfParallelism, ticks, mapLogic, distinctFilteredFaces, useFiltersCounter);
         if (!sortingContainers.Any())
         {
-            for (useFiltersCounter = 1; useFiltersCounter < 11; useFiltersCounter++)
+            for (useFiltersCounter = 1; useFiltersCounter < 17; useFiltersCounter++)
             {
                 sortingContainers = mapLogicSupport.SetFaceMappingSortingCollectionThenGetSortingContainers(_AppSettings.MaxDegreeOfParallelism, ticks, mapLogic, distinctFilteredFaces, useFiltersCounter);
                 if (sortingContainers.Any())
@@ -958,7 +940,7 @@ public partial class DlibDotNet
         }
         MapLogicSupport.SaveFaceDistances(_Configuration.PropertyConfiguration, sortingContainers);
         if (totalNotMapped > 0)
-            mapLogic.ForceSingleImageThenSaveSorting(dFacesContentDirectory, d2FacePartsContentDirectory, mappingCollection, idToNormalizedPixelPercentageToMapping, sortingContainers, useFiltersCounter, totalNotMapped);
+            mapLogic.UpdateFromSortingContainersThenSaveContainers(dFacesContentDirectory, d2FacePartsContentDirectory, mappingCollection, idToNormalizedPixelPercentageToMapping, useFiltersCounter, sortingContainers, totalNotMapped);
         if (_Configuration.MappingSaveNotMapped)
             mapLogic.SaveNotMappedTicks();
         if (_Configuration.SaveShortcutsForOutputResolutions.Contains(outputResolution))
diff --git a/Map/Models/MapLogic.cs b/Map/Models/MapLogic.cs
index 21c5199..0bd377c 100644
--- a/Map/Models/MapLogic.cs
+++ b/Map/Models/MapLogic.cs
@@ -1,6 +1,7 @@
 using Humanizer;
 using ShellProgressBar;
 using System.Text.Json;
+using View_by_Distance.Map.Models.Stateless;
 using View_by_Distance.Shared.Models;
 using View_by_Distance.Shared.Models.Stateless.Methods;
 using WindowsShortcutFactory;
@@ -112,9 +113,9 @@ public class MapLogic
         int result = 0;
         const int zero = 0;
         string mappingSegmentB;
+        int by = IMapLogic.Mapping;
         PersonBirthday personBirthday;
         PersonContainer[]? collection;
-        int by = Stateless.IMapLogic.Mapping;
         List<PersonContainer> personContainers = new();
         Dictionary<int, PersonContainer[]>? keyValuePairs;
         foreach (Mapping mapping in mappingCollection)
@@ -213,14 +214,193 @@ public class MapLogic
         }
     }
 
+    private SaveContainer? GetMatchSaveContainer(string dFacesContentDirectory, string d2FacePartsContentDirectory, string directory, Mapping mapping)
+    {
+        if (_Configuration is null)
+            throw new NullReferenceException(nameof(_Configuration));
+        SaveContainer? result;
+        string shortcutFile = string.Empty;
+        string? directoryName = Path.GetDirectoryName(mapping.MappingFromItem.RelativePath);
+        string facesDirectory = Path.Combine($"{dFacesContentDirectory}{directoryName}", mapping.MappingFromItem.ImageFileHolder.NameWithoutExtension);
+        FileHolder faceFileHolder = new(Path.Combine(facesDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_Configuration.FacesFileNameExtension}"));
+        if (directoryName is null || !faceFileHolder.Exists)
+            result = null;
+        else
+        {
+            string facePartsDirectory = Path.Combine($"{d2FacePartsContentDirectory}{directoryName}", mapping.MappingFromItem.ImageFileHolder.NameWithoutExtension);
+            string checkFile = Path.Combine(directory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}");
+            FileHolder hiddenFaceFileHolder = new(Path.Combine(facesDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_Configuration.FacesHiddenFileNameExtension}"));
+            FileHolder facePartsFileHolder = new(Path.Combine(facePartsDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_Configuration.FacePartsFileNameExtension}"));
+            result = new(checkFile, directory, faceFileHolder, hiddenFaceFileHolder, facePartsFileHolder, mapping.MappingFromItem.ResizedFileHolder, shortcutFile);
+        }
+        return result;
+    }
+
+    private static (string, bool, bool) Get(int? useFiltersCounter, string forceSingleImageHumanized, Mapping mapping)
+    {
+        string by;
+        bool isByMapping;
+        bool isBySorting;
+        if (mapping.By is null)
+        {
+            isByMapping = false;
+            isBySorting = false;
+            by = $"{nameof(IMapLogic.Mapping)}Null";
+        }
+        else
+        {
+            isByMapping = mapping.By == IMapLogic.Mapping;
+            isBySorting = mapping.By == IMapLogic.Sorting;
+            if (isBySorting && mapping.MappingFromPerson is null)
+                by = $"{nameof(IMapLogic.Sorting)} Without Person";
+            else if (isBySorting && useFiltersCounter.HasValue)
+                by = $"{nameof(IMapLogic.Sorting)} Modified Filters - {useFiltersCounter.Value}";
+            else
+            {
+                by = mapping.By.Value switch
+                {
+                    IMapLogic.Mapping => nameof(IMapLogic.Mapping),
+                    IMapLogic.Sorting => nameof(IMapLogic.Sorting),
+                    IMapLogic.ForceSingleImage => forceSingleImageHumanized,
+                    _ => throw new NotImplementedException()
+                };
+            }
+        }
+        return new(by, isByMapping, isBySorting);
+    }
+
+    private string GetDirectory(string by, MappingFromItem mappingFromItem, SortingContainer sortingContainer)
+    {
+        if (_Configuration is null)
+            throw new NullReferenceException(nameof(_Configuration));
+        string result;
+        const int zero = 0;
+        string mappingSegmentB;
+        string personKeyFormatted;
+        PersonBirthday personBirthday;
+        PersonContainer personContainer;
+        result = Path.Combine(_EDistanceContentTicksDirectory, by, sortingContainer.Sorting.Id.ToString(), sortingContainer.Sorting.NormalizedPixelPercentage.ToString());
+        for (int i = 0; i < _NotMappedPersonContainers.Count; i++)
+        {
+            personContainer = _NotMappedPersonContainers[i];
+            if (personContainer.Key is null || personContainer.Birthdays is null || !personContainer.Birthdays.Any())
+                continue;
+            personBirthday = personContainer.Birthdays[zero];
+            mappingSegmentB = Stateless.MapLogic.GetMappingSegmentB(_Ticks, personBirthday, personContainer.ApproximateYears, mappingFromItem);
+            personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, personBirthday);
+            result = Path.Combine(_EDistanceContentTicksDirectory, by, personKeyFormatted, mappingSegmentB);
+            _NotMappedPersonContainers.RemoveAt(i);
+            break;
+        }
+        return result;
+    }
+
+    private List<SaveContainer> GetSaveContainers(string dFacesContentDirectory, string d2FacePartsContentDirectory, Mapping[] mappingCollection, Dictionary<int, Dictionary<int, Mapping>> idToNormalizedPixelPercentageToMapping, int? useFiltersCounter, bool saveMapped)
+    {
+        if (_Configuration is null)
+            throw new NullReferenceException(nameof(_Configuration));
+        List<SaveContainer> results = new();
+        string by;
+        bool isByMapping;
+        bool isBySorting;
+        string checkFile;
+        string directory;
+        string shortcutFile;
+        string facesDirectory;
+        string? directoryName;
+        string personDirectory;
+        FileHolder faceFileHolder;
+        string facePartsDirectory;
+        string personKeyFormatted;
+        SaveContainer? saveContainer;
+        FileHolder facePartsFileHolder;
+        FileHolder hiddenFaceFileHolder;
+        Dictionary<int, Mapping>? normalizedPixelPercentageToMapping;
+        string forceSingleImageHumanized = nameof(IMapLogic.ForceSingleImage).Humanize(LetterCasing.Title);
+        foreach (Mapping mapping in mappingCollection)
+        {
+            directoryName = Path.GetDirectoryName(mapping.MappingFromItem.RelativePath);
+            if (directoryName is null)
+                throw new NotSupportedException();
+            (by, isByMapping, isBySorting) = Get(useFiltersCounter, forceSingleImageHumanized, mapping);
+            if (isByMapping && !saveMapped)
+                continue;
+            if (mapping.MappingFromPerson is null)
+            {
+                if (mapping.SortingContainer is null)
+                    continue;
+                directory = GetDirectory(by, mapping.MappingFromItem, mapping.SortingContainer);
+                personDirectory = Path.Combine(directory, _Configuration.MappingDefaultName);
+            }
+            else
+            {
+                if (string.IsNullOrEmpty(mapping.MappingFromPerson.SegmentB))
+                    throw new NotSupportedException();
+                if (string.IsNullOrEmpty(mapping.MappingFromPerson.DisplayDirectoryName))
+                    throw new NotSupportedException();
+                personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, mapping.MappingFromPerson.PersonBirthday);
+                directory = Path.Combine(_EDistanceContentTicksDirectory, by, personKeyFormatted, mapping.MappingFromPerson.SegmentB);
+                if (isByMapping)
+                    personDirectory = Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName);
+                else if (mapping.By is not null)
+                    personDirectory = Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName, "lnk");
+                else
+                    personDirectory = Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName[..1], "lnk");
+            }
+            saveContainer = new(personDirectory);
+            results.Add(saveContainer);
+            facesDirectory = Path.Combine($"{dFacesContentDirectory}{directoryName}", mapping.MappingFromItem.ImageFileHolder.NameWithoutExtension);
+            faceFileHolder = new(Path.Combine(facesDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_Configuration.FacesFileNameExtension}"));
+            if (!faceFileHolder.Exists)
+                continue;
+            if (isByMapping)
+            {
+                checkFile = Path.Combine(personDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}");
+                saveContainer = new(checkFile, directory, faceFileHolder);
+            }
+            else
+            {
+                facePartsDirectory = Path.Combine($"{d2FacePartsContentDirectory}{directoryName}", mapping.MappingFromItem.ImageFileHolder.NameWithoutExtension);
+                checkFile = Path.Combine(directory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}");
+                shortcutFile = Path.Combine(personDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}.lnk");
+                hiddenFaceFileHolder = new(Path.Combine(facesDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_Configuration.FacesHiddenFileNameExtension}"));
+                facePartsFileHolder = new(Path.Combine(facePartsDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_Configuration.FacePartsFileNameExtension}"));
+                saveContainer = new(checkFile, directory, faceFileHolder, hiddenFaceFileHolder, facePartsFileHolder, mapping.MappingFromItem.ResizedFileHolder, shortcutFile);
+            }
+            results.Add(saveContainer);
+            if (!isBySorting || mapping.SortingContainer is null)
+                continue;
+            if (!idToNormalizedPixelPercentageToMapping.TryGetValue(mapping.SortingContainer.Sorting.Id, out normalizedPixelPercentageToMapping))
+                continue;
+            if (!normalizedPixelPercentageToMapping.ContainsKey(mapping.SortingContainer.Sorting.NormalizedPixelPercentage))
+                continue;
+            if (isBySorting && mapping.MappingFromPerson is null)
+            {
+                saveContainer = GetMatchSaveContainer(dFacesContentDirectory, d2FacePartsContentDirectory, directory, normalizedPixelPercentageToMapping[mapping.SortingContainer.Sorting.NormalizedPixelPercentage]);
+                if (saveContainer is not null)
+                    results.Add(saveContainer);
+            }
+            saveContainer = Stateless.MapLogic.GetDebugSaveContainer(directory, mapping.SortingContainer, normalizedPixelPercentageToMapping[mapping.SortingContainer.Sorting.NormalizedPixelPercentage]);
+            results.Add(saveContainer);
+        }
+        return results;
+    }
+
+    public void UpdateFromSortingContainersThenSaveContainers(string dFacesContentDirectory, string d2FacePartsContentDirectory, Mapping[] mappingCollection, Dictionary<int, Dictionary<int, Mapping>> idToNormalizedPixelPercentageToMapping, int? useFiltersCounter, SortingContainer[] sortingContainers, int totalNotMapped)
+    {
+        int updated = UpdateFromSortingContainers(sortingContainers);
+        List<SaveContainer> saveContainers = GetSaveContainers(dFacesContentDirectory, d2FacePartsContentDirectory, mappingCollection, idToNormalizedPixelPercentageToMapping, useFiltersCounter, saveMapped: false);
+        SaveContainers(totalNotMapped, updated, saveContainers);
+    }
+
     public void SaveMapped(string dFacesContentDirectory, string d2FacePartsContentDirectory, Mapping[] mappingCollection, Dictionary<int, Dictionary<int, Mapping>> idToNormalizedPixelPercentageToMapping, int totalNotMapped)
     {
         if (_Configuration is null)
             throw new NullReferenceException(nameof(_Configuration));
         int? updated = null;
         int? useFiltersCounter = null;
-        string mappingDirectory = Path.Combine(_EDistanceContentTicksDirectory, nameof(Stateless.IMapLogic.Mapping));
-        List<SaveContainer> saveContainers = Stateless.MapLogic.GetSaveContainers(_Configuration, _EDistanceContentTicksDirectory, dFacesContentDirectory, d2FacePartsContentDirectory, mappingCollection, idToNormalizedPixelPercentageToMapping, useFiltersCounter, saveMapped: true);
+        string mappingDirectory = Path.Combine(_EDistanceContentTicksDirectory, nameof(IMapLogic.Mapping));
+        List<SaveContainer> saveContainers = GetSaveContainers(dFacesContentDirectory, d2FacePartsContentDirectory, mappingCollection, idToNormalizedPixelPercentageToMapping, useFiltersCounter, saveMapped: true);
         SaveContainers(totalNotMapped, updated, saveContainers);
         if (!string.IsNullOrEmpty(_EDistanceContentTicksDirectory) && Directory.Exists(mappingDirectory))
             Stateless.MapLogic.SaveMappingShortcuts(mappingDirectory);
@@ -293,10 +473,14 @@ public class MapLogic
             if (faceDistanceLength.Length == 0)
                 continue;
             if (!_IdThenNormalizedPixelPercentageToPersonContainers.TryGetValue(faceDistanceLength.Id, out normalizedPixelPercentageToPersonContainers))
-                continue;
-            if (!normalizedPixelPercentageToPersonContainers.ContainsKey(faceDistanceLength.NormalizedPixelPercentage.Value))
-                continue;
-            personKeysRangesCollection = GetPersonKeysRangesCollection(normalizedPixelPercentageToPersonContainers[faceDistanceLength.NormalizedPixelPercentage.Value]);
+                personKeysRangesCollection = new();
+            else
+            {
+                if (!normalizedPixelPercentageToPersonContainers.ContainsKey(faceDistanceLength.NormalizedPixelPercentage.Value))
+                    personKeysRangesCollection = new();
+                else
+                    personKeysRangesCollection = GetPersonKeysRangesCollection(normalizedPixelPercentageToPersonContainers[faceDistanceLength.NormalizedPixelPercentage.Value]);
+            }
             sorting = ISorting.Get(_Configuration.FaceDistancePermyriad, _Configuration.FaceDistanceTolerance, faceDistanceEncoding, faceDistanceLength, personKeysRangesCollection);
             if (sorting.DistancePermyriad == 0)
                 continue;
@@ -311,7 +495,7 @@ public class MapLogic
         return results;
     }
 
-    private int UpdateFromSortingContainers(SortingContainer[] sortingContainers)
+    public int UpdateFromSortingContainers(SortingContainer[] sortingContainers)
     {
         if (_Configuration is null)
             throw new NullReferenceException(nameof(_Configuration));
@@ -321,11 +505,13 @@ public class MapLogic
         string mappingSegmentB;
         string personKeyFormatted;
         PersonBirthday personBirthday;
+        const int by = IMapLogic.Sorting;
         PersonContainer[] personContainers;
-        const int by = Stateless.IMapLogic.Sorting;
-        List<int> normalizedPixelPercentageCollection;
+        List<int> normalizedPixelPercentageCollectionForA;
+        List<int> normalizedPixelPercentageCollectionForB;
         Dictionary<string, int> checkKeyValuePairs = new();
-        Dictionary<int, List<int>> idToNormalizedPixelPercentageCollection = new();
+        Dictionary<int, List<int>> idToNormalizedPixelPercentageCollectionForA = new();
+        Dictionary<int, List<int>> idToNormalizedPixelPercentageCollectionForB = new();
         Dictionary<int, PersonContainer[]>? normalizedPixelPercentageToPersonContainers;
         int totalSeconds = (int)Math.Floor(new TimeSpan(DateTime.Now.Ticks - _Ticks).TotalSeconds);
         string message = $") {sortingContainers.Length:000} Update From Sorting Container(s) - {totalSeconds} total second(s)";
@@ -336,94 +522,58 @@ public class MapLogic
             progressBar.Tick();
             if (sortingContainer.Mapping is null)
                 throw new NotSupportedException();
+            if (!idToNormalizedPixelPercentageCollectionForA.ContainsKey(sortingContainer.Mapping.MappingFromItem.Id))
+                idToNormalizedPixelPercentageCollectionForA.Add(sortingContainer.Mapping.MappingFromItem.Id, new());
+            normalizedPixelPercentageCollectionForA = idToNormalizedPixelPercentageCollectionForA[sortingContainer.Mapping.MappingFromItem.Id];
+            if (!idToNormalizedPixelPercentageCollectionForB.ContainsKey(sortingContainer.Mapping.MappingFromItem.Id))
+                idToNormalizedPixelPercentageCollectionForB.Add(sortingContainer.Mapping.MappingFromItem.Id, new());
+            normalizedPixelPercentageCollectionForB = idToNormalizedPixelPercentageCollectionForB[sortingContainer.Mapping.MappingFromItem.Id];
             if (!_IdThenNormalizedPixelPercentageToPersonContainers.TryGetValue(sortingContainer.Sorting.Id, out normalizedPixelPercentageToPersonContainers))
-                throw new NotSupportedException();
-            if (!normalizedPixelPercentageToPersonContainers.ContainsKey(sortingContainer.Sorting.NormalizedPixelPercentage))
-                throw new NotSupportedException();
-            if (!idToNormalizedPixelPercentageCollection.ContainsKey(sortingContainer.Mapping.MappingFromItem.Id))
-                idToNormalizedPixelPercentageCollection.Add(sortingContainer.Mapping.MappingFromItem.Id, new());
-            normalizedPixelPercentageCollection = idToNormalizedPixelPercentageCollection[sortingContainer.Mapping.MappingFromItem.Id];
-            if (normalizedPixelPercentageCollection.Contains(sortingContainer.Mapping.MappingFromLocation.NormalizedPixelPercentage))
-                continue;
-            personContainers = normalizedPixelPercentageToPersonContainers[sortingContainer.Sorting.NormalizedPixelPercentage];
-            foreach (PersonContainer personContainer in personContainers)
             {
-                if (personContainer.Key is null || personContainer.Birthdays is null || !personContainer.Birthdays.Any())
+                personContainers = Array.Empty<PersonContainer>();
+                if (normalizedPixelPercentageCollectionForA.Contains(sortingContainer.Mapping.MappingFromLocation.NormalizedPixelPercentage))
                     continue;
-                personBirthday = personContainer.Birthdays[zero];
-                personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, personBirthday);
-                mappingSegmentB = Stateless.MapLogic.GetMappingSegmentB(_Ticks, personBirthday, personContainer.ApproximateYears, sortingContainer.Mapping.MappingFromItem);
-                key = string.Concat(personKeyFormatted, '\t', mappingSegmentB);
+                key = string.Concat(sortingContainer.Mapping.MappingFromItem.Id, '\t', sortingContainer.Mapping.MappingFromLocation.NormalizedPixelPercentage);
                 if (!checkKeyValuePairs.ContainsKey(key))
                     checkKeyValuePairs.Add(key, new());
                 checkKeyValuePairs[key]++;
                 if (checkKeyValuePairs[key] > _Configuration.SortingMaximumPerKey)
                     continue;
-                normalizedPixelPercentageCollection.Add(sortingContainer.Mapping.MappingFromLocation.NormalizedPixelPercentage);
-                sortingContainer.Mapping.UpdateMappingFromPerson(personContainer.ApproximateYears, by, personContainer.DisplayDirectoryName, personBirthday, mappingSegmentB);
-                sortingContainer.Mapping.SetSortingContainer(sortingContainer);
+                sortingContainer.Mapping.UpdateMappingFromUnknownPerson(by, sortingContainer);
+                normalizedPixelPercentageCollectionForA.Add(sortingContainer.Mapping.MappingFromLocation.NormalizedPixelPercentage);
                 result += 1;
-                break;
+            }
+            else
+            {
+                if (normalizedPixelPercentageCollectionForB.Contains(sortingContainer.Mapping.MappingFromLocation.NormalizedPixelPercentage))
+                    continue;
+                if (!normalizedPixelPercentageToPersonContainers.ContainsKey(sortingContainer.Sorting.NormalizedPixelPercentage))
+                    personContainers = Array.Empty<PersonContainer>();
+                else
+                    personContainers = normalizedPixelPercentageToPersonContainers[sortingContainer.Sorting.NormalizedPixelPercentage];
+                foreach (PersonContainer personContainer in personContainers)
+                {
+                    if (personContainer.Key is null || personContainer.Birthdays is null || !personContainer.Birthdays.Any())
+                        continue;
+                    personBirthday = personContainer.Birthdays[zero];
+                    personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, personBirthday);
+                    mappingSegmentB = Stateless.MapLogic.GetMappingSegmentB(_Ticks, personBirthday, personContainer.ApproximateYears, sortingContainer.Mapping.MappingFromItem);
+                    key = string.Concat(personKeyFormatted, '\t', mappingSegmentB);
+                    if (!checkKeyValuePairs.ContainsKey(key))
+                        checkKeyValuePairs.Add(key, new());
+                    checkKeyValuePairs[key]++;
+                    if (checkKeyValuePairs[key] > _Configuration.SortingMaximumPerKey)
+                        continue;
+                    sortingContainer.Mapping.UpdateMappingFromPerson(personContainer.ApproximateYears, by, personContainer.DisplayDirectoryName, personBirthday, mappingSegmentB, sortingContainer);
+                    normalizedPixelPercentageCollectionForB.Add(sortingContainer.Mapping.MappingFromLocation.NormalizedPixelPercentage);
+                    result += 1;
+                    break;
+                }
             }
         }
         return result;
     }
 
-    internal void ForceSingleImage(Mapping[] mappingCollection)
-    {
-        if (_Configuration is null)
-            throw new NullReferenceException(nameof(_Configuration));
-        const int zero = 0;
-        string mappingSegmentB;
-        PersonBirthday personBirthday;
-        List<int>? normalizedPixelPercentages;
-        int by = Stateless.IMapLogic.ForceSingleImage;
-        string displayDirectoryName = _Configuration.MappingDefaultName;
-        Mapping[] mappingCollectionOrderedConfidence = (from l in mappingCollection orderby l.MappingFromLocation.Confidence descending select l).ToArray();
-        foreach (Mapping mapping in mappingCollectionOrderedConfidence)
-        {
-            if (mapping.MappingFromPerson.PersonBirthday is not null)
-                continue;
-            if (_SkipCollection.TryGetValue(mapping.MappingFromItem.Id, out normalizedPixelPercentages))
-            {
-                if (normalizedPixelPercentages.Contains(mapping.MappingFromLocation.NormalizedPixelPercentage))
-                    continue;
-            }
-            foreach (PersonContainer personContainer in _NotMappedPersonContainers)
-            {
-                if (personContainer.Key is null || personContainer.Birthdays is null || !personContainer.Birthdays.Any())
-                    continue;
-                personBirthday = personContainer.Birthdays[zero];
-                mappingSegmentB = Stateless.MapLogic.GetMappingSegmentB(_Ticks, personBirthday, personContainer.ApproximateYears, mapping.MappingFromItem);
-                mapping.UpdateMappingFromPerson(personContainer.ApproximateYears, by, personContainer.DisplayDirectoryName, personBirthday, mappingSegmentB);
-                break;
-            }
-            break;
-        }
-    }
-
-    public void ForceSingleImageThenSaveSorting(string dFacesContentDirectory, string d2FacePartsContentDirectory, Mapping[] mappingCollection, Dictionary<int, Dictionary<int, Mapping>> idToNormalizedPixelPercentageToMapping, SortingContainer[] sortingContainers, int? useFiltersCounter, int totalNotMapped)
-    {
-        if (_Configuration is null)
-            throw new NullReferenceException(nameof(_Configuration));
-        int updated;
-        List<SaveContainer> saveContainers;
-        if (!sortingContainers.Any())
-        {
-            updated = 0;
-            ForceSingleImage(mappingCollection);
-            saveContainers = Stateless.MapLogic.GetSaveContainers(_Configuration, _EDistanceContentTicksDirectory, dFacesContentDirectory, d2FacePartsContentDirectory, mappingCollection, idToNormalizedPixelPercentageToMapping, useFiltersCounter, saveMapped: false);
-        }
-        else
-        {
-            updated = UpdateFromSortingContainers(sortingContainers);
-            if (useFiltersCounter is null && totalNotMapped - updated > 0)
-                ForceSingleImage(mappingCollection);
-            saveContainers = Stateless.MapLogic.GetSaveContainers(_Configuration, _EDistanceContentTicksDirectory, dFacesContentDirectory, d2FacePartsContentDirectory, mappingCollection, idToNormalizedPixelPercentageToMapping, useFiltersCounter, saveMapped: false);
-        }
-        SaveContainers(totalNotMapped, updated, saveContainers);
-    }
-
     public void CopyManualFiles(string dFacesContentDirectory, Dictionary<int, Dictionary<int, Mapping>> idToNormalizedPixelPercentageToMapping)
     {
         if (_Configuration is null)
@@ -447,10 +597,10 @@ public class MapLogic
         string? personDisplayDirectory;
         int? normalizedPixelPercentage;
         WindowsShortcut windowsShortcut;
+        string by = nameof(IMapLogic.ManualCopy);
         Dictionary<int, PersonContainer[]>? keyValuePairs;
-        string by = nameof(Stateless.IMapLogic.ManualCopy);
         Dictionary<int, Mapping>? normalizedPixelPercentageToMapping;
-        string successfull = $"_ {nameof(Stateless.IMapLogic.ManualCopy).Humanize(LetterCasing.Title)} Successfull";
+        string successfull = $"_ {nameof(IMapLogic.ManualCopy).Humanize(LetterCasing.Title)} Successfull";
         foreach (KeyValuePair<long, PersonContainer> keyValuePair in _PersonKeyToPersonContainer)
         {
             if (keyValuePair.Value.Key is null || keyValuePair.Value.Birthdays is null || !keyValuePair.Value.Birthdays.Any())
@@ -529,7 +679,7 @@ public class MapLogic
         SaveContainer saveContainer;
         PersonBirthday personBirthday;
         List<SaveContainer> saveContainers = new();
-        const string facePopulatedKey = nameof(Stateless.IMapLogic.Sorting);
+        const string facePopulatedKey = nameof(IMapLogic.Sorting);
         foreach (PersonContainer personContainer in _NotMappedPersonContainers)
         {
             if (personContainer.Key is null || personContainer.Birthdays is null || !personContainer.Birthdays.Any())
diff --git a/Map/Models/Stateless/MapLogic.cs b/Map/Models/Stateless/MapLogic.cs
index ad0ed7a..8341449 100644
--- a/Map/Models/Stateless/MapLogic.cs
+++ b/Map/Models/Stateless/MapLogic.cs
@@ -654,111 +654,18 @@ internal abstract class MapLogic
         return result;
     }
 
-    private static SaveContainer GetSaveContainer(string directory, SortingContainer sortingContainer, Mapping mapping)
+    internal static SaveContainer GetDebugSaveContainer(string directory, SortingContainer sortingContainer, Mapping mapping)
     {
         SaveContainer result;
         string checkFile = string.Empty;
         FileHolder? faceFileHolder = null;
         FileHolder? facePartsFileHolder = null;
         FileHolder? hiddenFaceFileHolder = null;
-        string shortcutFile = Path.Combine(directory, $"{sortingContainer.Mapping.MappingFromLocation.DeterministicHashCodeKey}{sortingContainer.Mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}.lnk");
+        string shortcutFile = Path.Combine(directory, $"{sortingContainer.Mapping.MappingFromLocation.DeterministicHashCodeKey}{sortingContainer.Mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}.debug.lnk");
         result = new(checkFile, directory, faceFileHolder, hiddenFaceFileHolder, facePartsFileHolder, mapping.MappingFromItem.ResizedFileHolder, shortcutFile);
         return result;
     }
 
-    internal static List<SaveContainer> GetSaveContainers(Configuration configuration, string eDistanceContentTicksDirectory, string dFacesContentDirectory, string d2FacePartsContentDirectory, Mapping[] mappingCollection, Dictionary<int, Dictionary<int, Mapping>> idToNormalizedPixelPercentageToMapping, int? useFiltersCounter, bool saveMapped)
-    {
-        List<SaveContainer> results = new();
-        string by;
-        string checkFile;
-        bool isByMapping;
-        bool isBySorting;
-        string directory;
-        string shortcutFile;
-        string facesDirectory;
-        string? directoryName;
-        string personDirectory;
-        FileHolder faceFileHolder;
-        string facePartsDirectory;
-        string personKeyFormatted;
-        SaveContainer saveContainer;
-        FileHolder facePartsFileHolder;
-        FileHolder hiddenFaceFileHolder;
-        Dictionary<int, Mapping>? normalizedPixelPercentageToMapping;
-        string forceSingleImageHumanized = nameof(IMapLogic.ForceSingleImage).Humanize(LetterCasing.Title);
-        foreach (Mapping mapping in mappingCollection)
-        {
-            directoryName = Path.GetDirectoryName(mapping.MappingFromItem.RelativePath);
-            if (directoryName is null)
-                throw new NotSupportedException();
-            if (mapping.MappingFromPerson.PersonBirthday is null)
-                continue;
-            if (string.IsNullOrEmpty(mapping.MappingFromPerson.SegmentB))
-                throw new NotSupportedException();
-            if (mapping.MappingFromPerson.By is null)
-            {
-                isByMapping = false;
-                isBySorting = false;
-                by = $"{nameof(IMapLogic.Mapping)}Null";
-            }
-            else
-            {
-                isByMapping = mapping.MappingFromPerson.By == IMapLogic.Mapping;
-                isBySorting = mapping.MappingFromPerson.By == IMapLogic.Sorting;
-                if (isByMapping && !saveMapped)
-                    continue;
-                if (isBySorting && useFiltersCounter.HasValue)
-                    by = $"{nameof(IMapLogic.Sorting)} Modified Filters - {useFiltersCounter.Value}";
-                else
-                {
-                    by = mapping.MappingFromPerson.By.Value switch
-                    {
-                        IMapLogic.Mapping => nameof(IMapLogic.Mapping),
-                        IMapLogic.Sorting => nameof(IMapLogic.Sorting),
-                        IMapLogic.ForceSingleImage => forceSingleImageHumanized,
-                        _ => throw new NotImplementedException()
-                    };
-                }
-            }
-            personKeyFormatted = IPersonBirthday.GetFormatted(configuration.PersonBirthdayFormat, mapping.MappingFromPerson.PersonBirthday);
-            directory = Path.Combine(eDistanceContentTicksDirectory, by, personKeyFormatted, mapping.MappingFromPerson.SegmentB);
-            if (isByMapping)
-                personDirectory = Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName);
-            else if (mapping.MappingFromPerson.By is not null)
-                personDirectory = Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName, "lnk");
-            else
-                personDirectory = Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName[..1], "lnk");
-            saveContainer = new(personDirectory);
-            results.Add(saveContainer);
-            facesDirectory = Path.Combine($"{dFacesContentDirectory}{directoryName}", mapping.MappingFromItem.ImageFileHolder.NameWithoutExtension);
-            faceFileHolder = new(Path.Combine(facesDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{configuration.FacesFileNameExtension}"));
-            if (isByMapping)
-            {
-                checkFile = Path.Combine(personDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}");
-                saveContainer = new(checkFile, directory, faceFileHolder);
-            }
-            else
-            {
-                facePartsDirectory = Path.Combine($"{d2FacePartsContentDirectory}{directoryName}", mapping.MappingFromItem.ImageFileHolder.NameWithoutExtension);
-                checkFile = Path.Combine(directory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}");
-                shortcutFile = Path.Combine(personDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}.lnk");
-                hiddenFaceFileHolder = new(Path.Combine(facesDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{configuration.FacesHiddenFileNameExtension}"));
-                facePartsFileHolder = new(Path.Combine(facePartsDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{configuration.FacePartsFileNameExtension}"));
-                saveContainer = new(checkFile, directory, faceFileHolder, hiddenFaceFileHolder, facePartsFileHolder, mapping.MappingFromItem.ResizedFileHolder, shortcutFile);
-            }
-            results.Add(saveContainer);
-            if (!isBySorting || mapping.SortingContainer is null)
-                continue;
-            if (!idToNormalizedPixelPercentageToMapping.TryGetValue(mapping.SortingContainer.Sorting.Id, out normalizedPixelPercentageToMapping))
-                continue;
-            if (!normalizedPixelPercentageToMapping.ContainsKey(mapping.SortingContainer.Sorting.NormalizedPixelPercentage))
-                continue;
-            saveContainer = GetSaveContainer(directory, mapping.SortingContainer, normalizedPixelPercentageToMapping[mapping.SortingContainer.Sorting.NormalizedPixelPercentage]);
-            results.Add(saveContainer);
-        }
-        return results;
-    }
-
     private static IEnumerable<(string, string)> GetCollection(string[] yearDirectories)
     {
         foreach (string l in yearDirectories)
diff --git a/Resize/Models/_C_Resize.cs b/Resize/Models/_C_Resize.cs
index ce21b05..6e5d047 100644
--- a/Resize/Models/_C_Resize.cs
+++ b/Resize/Models/_C_Resize.cs
@@ -20,7 +20,6 @@ public class C_Resize
     protected readonly string _FileNameExtension;
     public string FileNameExtension => _FileNameExtension;
 
-    private readonly Serilog.ILogger? _Log;
     private readonly int _TempResolutionWidth;
     private readonly int _TempResolutionHeight;
     private readonly string[] _ValidResolutions;
@@ -48,7 +47,6 @@ public class C_Resize
         _OutputResolutionOrientationIndex = 2;
         _EncoderParameters = encoderParameters;
         _FileNameExtension = filenameExtension;
-        _Log = Serilog.Log.ForContext<C_Resize>();
         AngleBracketCollection = new List<string>();
         _OverrideForResizeImages = overrideForResizeImages;
         _PropertiesChangedForResize = propertiesChangedForResize;
@@ -384,8 +382,6 @@ public class C_Resize
 
     private int[] GetCollection(string outputResolution)
     {
-        if (_Log is null)
-        { }
         List<int> results = new();
         string[] segments = outputResolution.Split('x');
         results.Add(int.Parse(segments[0]));
diff --git a/Shared/Models/Mapping.cs b/Shared/Models/Mapping.cs
index 6d2b872..d8f420d 100644
--- a/Shared/Models/Mapping.cs
+++ b/Shared/Models/Mapping.cs
@@ -61,16 +61,14 @@ public class MappingFromPerson : Properties.IMappingFromPerson
 {
 
     public int? ApproximateYears { init; get; }
-    public int? By { init; get; }
     public string DisplayDirectoryName { init; get; }
-    public PersonBirthday? PersonBirthday { init; get; }
+    public PersonBirthday PersonBirthday { init; get; }
     public string SegmentB { init; get; }
 
     [JsonConstructor]
-    public MappingFromPerson(int? approximateYears, int? by, string displayDirectoryName, PersonBirthday? personBirthday, string segmentB)
+    public MappingFromPerson(int? approximateYears, string displayDirectoryName, PersonBirthday personBirthday, string segmentB)
     {
         ApproximateYears = approximateYears;
-        By = by;
         DisplayDirectoryName = displayDirectoryName;
         PersonBirthday = personBirthday;
         SegmentB = segmentB;
@@ -87,24 +85,27 @@ public class MappingFromPerson : Properties.IMappingFromPerson
 public class Mapping : Properties.IMapping
 {
 
-    protected MappingFromPerson _MappingFromPerson;
+    protected int? _By;
+    protected MappingFromPerson? _MappingFromPerson;
     protected SortingContainer? _SortingContainer;
+    public int? By => _By;
     public MappingFromItem MappingFromItem { init; get; }
     public MappingFromLocation MappingFromLocation { init; get; }
-    public MappingFromPerson MappingFromPerson => _MappingFromPerson;
+    public MappingFromPerson? MappingFromPerson => _MappingFromPerson;
     public SortingContainer? SortingContainer => _SortingContainer;
 
     [JsonConstructor]
-    public Mapping(MappingFromItem mappingFromItem, MappingFromLocation mappingFromLocation, MappingFromPerson mappingFromPerson, SortingContainer? sortingContainer)
+    public Mapping(int? by, MappingFromItem mappingFromItem, MappingFromLocation mappingFromLocation, MappingFromPerson? mappingFromPerson, SortingContainer? sortingContainer)
     {
+        _By = by;
         MappingFromItem = mappingFromItem;
         MappingFromLocation = mappingFromLocation;
         _MappingFromPerson = mappingFromPerson;
         _SortingContainer = sortingContainer;
     }
 
-    public Mapping(MappingFromItem mappingFromItem, MappingFromLocation mappingFromLocation, MappingFromPerson mappingFromPerson) :
-        this(mappingFromItem, mappingFromLocation, mappingFromPerson, null)
+    public Mapping(MappingFromItem mappingFromItem, MappingFromLocation mappingFromLocation) :
+        this(null, mappingFromItem, mappingFromLocation, null, null)
     { }
 
     public override string ToString()
@@ -113,8 +114,24 @@ public class Mapping : Properties.IMapping
         return result;
     }
 
-    public void UpdateMappingFromPerson(int? approximateYears, int? by, string displayDirectoryName, PersonBirthday personBirthday, string segmentB) => _MappingFromPerson = new(approximateYears, by, displayDirectoryName, personBirthday, segmentB);
+    public void UpdateMappingFromUnknownPerson(int? by, SortingContainer sortingContainer)
+    {
+        _By = by;
+        _SortingContainer = sortingContainer;
+    }
 
-    public void SetSortingContainer(SortingContainer sortingContainer) => _SortingContainer = sortingContainer;
+    public void UpdateMappingFromPerson(int? approximateYears, int? by, string displayDirectoryName, PersonBirthday personBirthday, string segmentB)
+    {
+        _By = by;
+        _SortingContainer = null;
+        _MappingFromPerson = new(approximateYears, displayDirectoryName, personBirthday, segmentB);
+    }
+
+    public void UpdateMappingFromPerson(int? approximateYears, int? by, string displayDirectoryName, PersonBirthday personBirthday, string segmentB, SortingContainer sortingContainer)
+    {
+        _By = by;
+        _SortingContainer = sortingContainer;
+        _MappingFromPerson = new(approximateYears, displayDirectoryName, personBirthday, segmentB);
+    }
 
 }
\ No newline at end of file
diff --git a/Shared/Models/Properties/IMapping.cs b/Shared/Models/Properties/IMapping.cs
index 96538e1..4a79ffb 100644
--- a/Shared/Models/Properties/IMapping.cs
+++ b/Shared/Models/Properties/IMapping.cs
@@ -26,9 +26,8 @@ public interface IMappingFromPerson
 {
 
     public int? ApproximateYears { init; get; }
-    public int? By { init; get; }
     public string DisplayDirectoryName { init; get; }
-    public PersonBirthday? PersonBirthday { init; get; }
+    public PersonBirthday PersonBirthday { init; get; }
     public string SegmentB { init; get; }
 
 }
@@ -36,9 +35,10 @@ public interface IMappingFromPerson
 public interface IMapping
 {
 
+    public int? By { get; }
     public MappingFromItem MappingFromItem { init; get; }
     public MappingFromLocation MappingFromLocation { init; get; }
-    public MappingFromPerson MappingFromPerson { get; }
+    public MappingFromPerson? MappingFromPerson { get; }
     public SortingContainer? SortingContainer { get; }
 
 }
\ No newline at end of file
diff --git a/Shared/Models/Stateless/Methods/Sorting.cs b/Shared/Models/Stateless/Methods/Sorting.cs
index e89cc55..2d34169 100644
--- a/Shared/Models/Stateless/Methods/Sorting.cs
+++ b/Shared/Models/Stateless/Methods/Sorting.cs
@@ -18,14 +18,19 @@ internal abstract class Sorting
         bool older = timeSpan.TotalMilliseconds < 0;
         int daysDelta = (int)Math.Round(Math.Abs(timeSpan.TotalDays), 0);
         int distancePermyriad = (int)(faceDistanceLength.Length.Value / faceDistanceTolerance * faceDistancePermyriad);
-        foreach ((long lcl, long minimum, long maximum, long ucl) in personKeysRangesCollection)
+        if (!personKeysRangesCollection.Any())
+            withinRanges.Add(0);
+        else
         {
-            if (ticks > minimum && ticks < maximum)
-                withinRanges.Add(0);
-            else if (ticks > lcl && ticks < ucl)
-                withinRanges.Add(1);
-            else
-                withinRanges.Add(2);
+            foreach ((long lcl, long minimum, long maximum, long ucl) in personKeysRangesCollection)
+            {
+                if (ticks > minimum && ticks < maximum)
+                    withinRanges.Add(0);
+                else if (ticks > lcl && ticks < ucl)
+                    withinRanges.Add(1);
+                else
+                    withinRanges.Add(2);
+            }
         }
         int withinRange = withinRanges.Max();
         result = new(daysDelta, distancePermyriad, faceDistanceLength.Id, faceDistanceLength.NormalizedPixelPercentage.Value, older, withinRange);