diff --git a/CHANGELOG.md b/CHANGELOG.md
index 40444c8..5004e74 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,12 @@
 # Changelog
 
+## /09/2021 - v2.21.2
+
+- (Add) Allow to choose custom locations for "Send to"
+- (Improvement) Better random generation for benchmark
+- (Fix) Outline - Hollow areas: Not outlining the second closing contour for contours with child
+- (Fix) Pixel editor - Eraser: It was selecting the whole blob even if have inner parents
+
 ## 06/09/2021 - v2.21.1
 
 - **(Add) Layer outline:**
diff --git a/UVtools.Core/CoreSettings.cs b/UVtools.Core/CoreSettings.cs
index 47f019c..62824f6 100644
--- a/UVtools.Core/CoreSettings.cs
+++ b/UVtools.Core/CoreSettings.cs
@@ -8,6 +8,7 @@
 
 using System;
 using System.Threading.Tasks;
+using Emgu.CV.Cuda;
 
 namespace UVtools.Core
 {
@@ -37,6 +38,16 @@ namespace UVtools.Core
         /// </summary>
         public static ParallelOptions ParallelOptions => new() {MaxDegreeOfParallelism = _maxDegreeOfParallelism};
 
+        /// <summary>
+        /// Gets or sets if operations run via cuda when possible
+        /// </summary>
+        public static bool EnableCuda { get; set; }
+
+        /// <summary>
+        /// Gets if we can use cuda on operations
+        /// </summary>
+        public static bool CanUseCuda => EnableCuda && CudaInvoke.HasCuda;
+
         #endregion
     }
 }
diff --git a/UVtools.Core/EmguCV/Contour.cs b/UVtools.Core/EmguCV/EmguContour.cs
similarity index 94%
rename from UVtools.Core/EmguCV/Contour.cs
rename to UVtools.Core/EmguCV/EmguContour.cs
index 291cad8..9b43995 100644
--- a/UVtools.Core/EmguCV/Contour.cs
+++ b/UVtools.Core/EmguCV/EmguContour.cs
@@ -21,8 +21,17 @@ namespace UVtools.Core.EmguCV
     /// <summary>
     /// A contour cache for OpenCV
     /// </summary>
-    public class Contour : IReadOnlyCollection<Point>, IDisposable
+    public class EmguContour : IReadOnlyCollection<Point>, IDisposable
     {
+        #region Constants
+
+        public const byte HierarchyNextSameLevel = 0;
+        public const byte HierarchyPreviousSameLevel = 1;
+        public const byte HierarchyFirstChild = 2;
+        public const byte HierarchyParent = 3;
+
+        #endregion
+
         #region Members
 
         private VectorOfPoint _points;
@@ -116,10 +125,10 @@ namespace UVtools.Core.EmguCV
         #endregion
 
         #region Constructor
-        public Contour(VectorOfPoint points) : this(points.ToArray())
+        public EmguContour(VectorOfPoint points) : this(points.ToArray())
         { }
 
-        public Contour(Point[] points)
+        public EmguContour(Point[] points)
         {
             Points = new VectorOfPoint(points);
         }
diff --git a/UVtools.Core/Extensions/EmguExtensions.cs b/UVtools.Core/Extensions/EmguExtensions.cs
index 5968786..a21ca9c 100644
--- a/UVtools.Core/Extensions/EmguExtensions.cs
+++ b/UVtools.Core/Extensions/EmguExtensions.cs
@@ -10,6 +10,7 @@ using System;
 using System.Drawing;
 using System.Runtime.InteropServices;
 using Emgu.CV;
+using Emgu.CV.Cuda;
 using Emgu.CV.CvEnum;
 using Emgu.CV.Structure;
 using Emgu.CV.Util;
@@ -125,6 +126,18 @@ namespace UVtools.Core.Extensions
 
             return layers;
         }
+
+        /// <summary>
+        /// Create a new <see cref="GpuMat"/> from <see cref="Mat"/>
+        /// </summary>
+        /// <param name="mat"></param>
+        /// <returns></returns>
+        public static GpuMat ToGpuMat(this Mat mat)
+        {
+            var gpuMat = new GpuMat(mat.Rows, mat.Cols, mat.Depth, mat.NumberOfChannels);
+            gpuMat.Upload(mat);
+            return gpuMat;
+        }
         #endregion
 
         #region Memory accessors
@@ -871,6 +884,71 @@ namespace UVtools.Core.Extensions
         #endregion
 
         #region Utilities methods
+
+        /// <summary>
+        /// Retrieves contours from the binary image as a contour tree. The pointer firstContour is filled by the function. It is provided as a convenient way to obtain the hierarchy value as int[,].
+        /// The function modifies the source image content
+        /// </summary>
+        /// <param name="mat">The source 8-bit single channel image. Non-zero pixels are treated as 1s, zero pixels remain 0s - that is image treated as binary. To get such a binary image from grayscale, one may use cvThreshold, cvAdaptiveThreshold or cvCanny. The function modifies the source image content</param>
+        /// <param name="mode">Retrieval mode</param>
+        /// <param name="method">Approximation method (for all the modes, except CV_RETR_RUNS, which uses built-in approximation). </param>
+        /// <param name="offset">Offset, by which every contour point is shifted. This is useful if the contours are extracted from the image ROI and then they should be analyzed in the whole image context</param>
+        /// <returns>The contour hierarchy</returns>
+        public static VectorOfVectorOfPoint FindContours(this Mat mat, RetrType mode = RetrType.List, ChainApproxMethod method = ChainApproxMethod.ChainApproxSimple, Point offset = default)
+        {
+            using var hierarchy = new Mat();
+            var contours = new VectorOfVectorOfPoint();
+            CvInvoke.FindContours(mat, contours, hierarchy, mode, method, offset);
+            return contours;
+        }
+
+        /*
+        /// <summary>
+        /// Retrieves contours from the binary image as a contour tree. The pointer firstContour is filled by the function. It is provided as a convenient way to obtain the hierarchy value as int[,].
+        /// The function modifies the source image content
+        /// </summary>
+        /// <param name="mat">The source 8-bit single channel image. Non-zero pixels are treated as 1s, zero pixels remain 0s - that is image treated as binary. To get such a binary image from grayscale, one may use cvThreshold, cvAdaptiveThreshold or cvCanny. The function modifies the source image content</param>
+        /// <param name="contours">Detected contours. Each contour is stored as a vector of points.</param>
+        /// <param name="mode">Retrieval mode</param>
+        /// <param name="method">Approximation method (for all the modes, except CV_RETR_RUNS, which uses built-in approximation). </param>
+        /// <param name="offset">Offset, by which every contour point is shifted. This is useful if the contours are extracted from the image ROI and then they should be analyzed in the whole image context</param>
+        /// <returns>The contour hierarchy</returns>
+        public static int[,] FindContours(this Mat mat, IOutputArray contours, RetrType mode, ChainApproxMethod method = ChainApproxMethod.ChainApproxSimple, Point offset = default)
+        {
+            using var hierarchy = new Mat();
+            CvInvoke.FindContours(mat, contours, hierarchy, mode, method, offset);
+            var numArray = new int[hierarchy.Cols, 4];
+            var gcHandle = GCHandle.Alloc(numArray, GCHandleType.Pinned);
+            using (var mat2 = new Mat(hierarchy.Rows, hierarchy.Cols, hierarchy.Depth, 4, gcHandle.AddrOfPinnedObject(), hierarchy.Step))
+                hierarchy.CopyTo(mat2);
+            gcHandle.Free();
+            return numArray;
+        }*/
+
+        /// <summary>
+        /// Retrieves contours from the binary image as a contour tree. The pointer firstContour is filled by the function. It is provided as a convenient way to obtain the hierarchy value as int[,].
+        /// The function modifies the source image content
+        /// </summary>
+        /// <param name="mat">The source 8-bit single channel image. Non-zero pixels are treated as 1s, zero pixels remain 0s - that is image treated as binary. To get such a binary image from grayscale, one may use cvThreshold, cvAdaptiveThreshold or cvCanny. The function modifies the source image content</param>
+        /// <param name="hierarchy">The contour hierarchy</param>
+        /// <param name="mode">Retrieval mode</param>
+        /// <param name="method">Approximation method (for all the modes, except CV_RETR_RUNS, which uses built-in approximation). </param>
+        /// <param name="offset">Offset, by which every contour point is shifted. This is useful if the contours are extracted from the image ROI and then they should be analyzed in the whole image context</param>
+        /// <returns>Detected contours. Each contour is stored as a vector of points.</returns>
+        public static VectorOfVectorOfPoint FindContours(this Mat mat, out int[,] hierarchy, RetrType mode, ChainApproxMethod method = ChainApproxMethod.ChainApproxSimple, Point offset = default)
+        {
+            var contours = new VectorOfVectorOfPoint();
+            using var hierarchyMat = new Mat();
+            CvInvoke.FindContours(mat, contours, hierarchyMat, mode, method, offset);
+            hierarchy = new int[hierarchyMat.Cols, 4];
+            var gcHandle = GCHandle.Alloc(hierarchy, GCHandleType.Pinned);
+            using (var mat2 = new Mat(hierarchyMat.Rows, hierarchyMat.Cols, hierarchyMat.Depth, 4, gcHandle.AddrOfPinnedObject(), hierarchyMat.Step))
+                hierarchyMat.CopyTo(mat2);
+            gcHandle.Free();
+            return contours;
+        }
+
+
         /// <summary>
         /// Determine the area (i.e. total number of pixels in the image),
         /// initialize the output skeletonized image, and construct the
diff --git a/UVtools.Core/FileFormats/FlashForgeSVGXFile.cs b/UVtools.Core/FileFormats/FlashForgeSVGXFile.cs
index c153037..cfcb1da 100644
--- a/UVtools.Core/FileFormats/FlashForgeSVGXFile.cs
+++ b/UVtools.Core/FileFormats/FlashForgeSVGXFile.cs
@@ -21,6 +21,7 @@ using BinarySerialization;
 using Emgu.CV;
 using Emgu.CV.CvEnum;
 using Emgu.CV.Util;
+using UVtools.Core.EmguCV;
 using UVtools.Core.Extensions;
 using UVtools.Core.Operations;
 
@@ -514,10 +515,7 @@ namespace UVtools.Core.FileFormats
                 using var mat = this[layerIndex].LayerMat;
                 //CvInvoke.Threshold(mat, mat, 127, 255, ThresholdType.Binary); // no AA
 
-                using var contours = new VectorOfVectorOfPoint();
-                using var hierarchy = new Mat();
-                CvInvoke.FindContours(mat, contours, hierarchy, RetrType.Tree, ChainApproxMethod.ChainApproxSimple);
-                var hierarchyJagged = hierarchy.GetData();
+                using var contours = mat.FindContours(out var hierarchy, RetrType.Tree);
 
                 float minx = SVGDocument.PrintParameters.PrintRange.MinX;
                 float miny = SVGDocument.PrintParameters.PrintRange.MinY;
@@ -527,8 +525,7 @@ namespace UVtools.Core.FileFormats
                 var path = new StringBuilder();
                 for (int i = 0; i < contours.Size; i++)
                 {
-                    if (contours[i].Size == 0) continue;
-                    if ((int)hierarchyJagged.GetValue(0, i, 3) == -1) // Top hierarchy
+                    if (hierarchy[i, EmguContour.HierarchyParent] == -1) // Top hierarchy
                     {
                         if (path.Length > 0)
                         {
diff --git a/UVtools.Core/Layer/LayerManager.cs b/UVtools.Core/Layer/LayerManager.cs
index ba1ed48..19e1f75 100644
--- a/UVtools.Core/Layer/LayerManager.cs
+++ b/UVtools.Core/Layer/LayerManager.cs
@@ -19,6 +19,7 @@ using Emgu.CV.CvEnum;
 using Emgu.CV.Structure;
 using Emgu.CV.Util;
 using MoreLinq.Extensions;
+using UVtools.Core.EmguCV;
 using UVtools.Core.Extensions;
 using UVtools.Core.FileFormats;
 using UVtools.Core.Objects;
@@ -737,215 +738,6 @@ namespace UVtools.Core
             return MutateGetIterationVar(isFade, iterationsStart, iterationsEnd, iterationSteps, maxIteration, startLayerIndex, layerIndex);
         }
 
-        public unsafe List<LayerIssue> GetAllIssuesBeta(
-            IslandDetectionConfiguration islandConfig = null,
-            OverhangDetectionConfiguration overhangConfig = null,
-            ResinTrapDetectionConfiguration resinTrapConfig = null,
-            TouchingBoundDetectionConfiguration touchBoundConfig = null,
-            PrintHeightDetectionConfiguration printHeightConfig = null,
-            bool emptyLayersConfig = true,
-            List<LayerIssue> ignoredIssues = null,
-            OperationProgress progress = null)
-        {
-            islandConfig ??= new IslandDetectionConfiguration();
-            overhangConfig ??= new OverhangDetectionConfiguration();
-            resinTrapConfig ??= new ResinTrapDetectionConfiguration();
-            touchBoundConfig ??= new TouchingBoundDetectionConfiguration();
-            printHeightConfig ??= new PrintHeightDetectionConfiguration();
-            progress ??= new OperationProgress();
-
-            var result = new ConcurrentBag<LayerIssue>();
-            if (!islandConfig.Enabled && !overhangConfig.Enabled && !resinTrapConfig.Enabled && !touchBoundConfig.Enabled && !emptyLayersConfig) return result.ToList();
-
-            ConcurrentDictionary<uint, List<LayerHollowArea>> layerHollowAreas = new();
-            List<uint> actionLayers = new();
-            bool checkedEmptyLayers = false;
-            Mat emptyMat = new ();
-            Mat[] cachedLayers = new Mat[LayerCount];
-            const uint cacheCount = 300;
-
-            bool IsIgnored(LayerIssue issue) => ignoredIssues is not null && ignoredIssues.Count > 0 && ignoredIssues.Contains(issue);
-            bool AddIssue(LayerIssue issue)
-            {
-                if (IsIgnored(issue)) return false;
-                result.Add(issue);
-                return true;
-            }
-
-            Mat GetCachedMat(uint layerIndex)
-            {
-                if (cachedLayers[layerIndex] is not null) return cachedLayers[layerIndex];
-                Parallel.For(layerIndex, Math.Min(layerIndex + cacheCount, LayerCount), CoreSettings.ParallelOptions, i =>
-                {
-                    if (this[i].IsEmpty) return; // empty layers
-                    cachedLayers[i] = this[i].LayerMat;
-                });
-                return cachedLayers[layerIndex];
-            }
-
-
-            if (touchBoundConfig.Enabled || resinTrapConfig.Enabled ||
-                (islandConfig.Enabled && islandConfig.WhiteListLayers is null) ||
-                (overhangConfig.Enabled && overhangConfig.WhiteListLayers is null)
-            )
-            {
-                checkedEmptyLayers = true;
-                for (uint layerIndex = 0; layerIndex < LayerCount; layerIndex++)
-                {
-                    var layer = this[layerIndex];
-                    if (layer.IsEmpty)
-                    {
-                        cachedLayers[layerIndex] = emptyMat;
-                        if (emptyLayersConfig)
-                        {
-                            AddIssue(new LayerIssue(layer, LayerIssue.IssueType.EmptyLayer));
-                        }
-                        continue;
-                    }
-                    actionLayers.Add(layerIndex);
-                }
-            }
-
-            if (!checkedEmptyLayers && emptyLayersConfig)
-            {
-                checkedEmptyLayers = true;
-                for (uint layerIndex = 0; layerIndex < LayerCount; layerIndex++)
-                {
-                    var layer = this[layerIndex];
-                    if (layer.IsEmpty)
-                    {
-                        AddIssue(new LayerIssue(layer, LayerIssue.IssueType.EmptyLayer));
-                    }
-                }
-            }
-
-            for (var i = 0; i < actionLayers.Count; i++)
-            {
-                var rootLayerIndex = actionLayers[i];
-                GetCachedMat(rootLayerIndex);
-                progress.Token.ThrowIfCancellationRequested();
-                uint layerAdvance = (uint) Math.Min(i + cacheCount, actionLayers.Count);
-                Parallel.For(i, layerAdvance, CoreSettings.ParallelOptions, l =>
-                {
-                    var layerIndex = actionLayers[(int) l];
-                    var layer = this[layerIndex];
-                    if (layer.IsEmpty)
-                    {
-                        progress.LockAndIncrement();
-
-                        return; // Empty layer
-                    }
-
-                    var image = cachedLayers[layerIndex];
-
-                    int step = image.Step;
-                    var span = image.GetBytePointer();
-
-                    if (touchBoundConfig.Enabled)
-                    {
-                        // TouchingBounds Checker
-                        List<Point> pixels = new();
-                        bool touchTop = layer.BoundingRectangle.Top <= touchBoundConfig.MarginTop;
-                        bool touchBottom = layer.BoundingRectangle.Bottom >= image.Height - touchBoundConfig.MarginBottom;
-                        bool touchLeft = layer.BoundingRectangle.Left <= touchBoundConfig.MarginLeft;
-                        bool touchRight = layer.BoundingRectangle.Right >= image.Width - touchBoundConfig.MarginRight;
-                        if (touchTop || touchBottom)
-                        {
-                            for (int x = 0; x < image.Width; x++) // Check Top and Bottom bounds
-                            {
-                                if (touchTop)
-                                {
-                                    for (int y = 0; y < touchBoundConfig.MarginTop; y++) // Top
-                                    {
-                                        if (span[image.GetPixelPos(x, y)] >=
-                                            touchBoundConfig.MinimumPixelBrightness)
-                                        {
-                                            pixels.Add(new Point(x, y));
-                                        }
-                                    }
-                                }
-
-                                if (touchBottom)
-                                {
-                                    for (int y = image.Height - touchBoundConfig.MarginBottom;
-                                        y < image.Height;
-                                        y++) // Bottom
-                                    {
-                                        if (span[image.GetPixelPos(x, y)] >=
-                                            touchBoundConfig.MinimumPixelBrightness)
-                                        {
-                                            pixels.Add(new Point(x, y));
-                                        }
-                                    }
-                                }
-                            }
-                        }
-
-                        if (touchLeft || touchRight)
-                        {
-                            for (int y = touchBoundConfig.MarginTop;
-                                y < image.Height - touchBoundConfig.MarginBottom;
-                                y++) // Check Left and Right bounds
-                            {
-                                if (touchLeft)
-                                {
-                                    for (int x = 0; x < touchBoundConfig.MarginLeft; x++) // Left
-                                    {
-                                        if (span[image.GetPixelPos(x, y)] >=
-                                            touchBoundConfig.MinimumPixelBrightness)
-                                        {
-                                            pixels.Add(new Point(x, y));
-                                        }
-                                    }
-                                }
-
-                                if (touchRight)
-                                {
-                                    for (int x = image.Width - touchBoundConfig.MarginRight; x < image.Width; x++) // Right
-                                    {
-                                        if (span[image.GetPixelPos(x, y)] >=
-                                            touchBoundConfig.MinimumPixelBrightness)
-                                        {
-                                            pixels.Add(new Point(x, y));
-                                        }
-                                    }
-                                }
-                            }
-                        }
-
-                        if (pixels.Count > 0)
-                        {
-                            AddIssue(new LayerIssue(layer, LayerIssue.IssueType.TouchingBound,
-                                pixels.ToArray()));
-                        }
-                    }
-
-                    progress.LockAndIncrement();
-                });
-
-                for (; i < layerAdvance - 1; i++)
-                {
-                    cachedLayers[actionLayers[i]].Dispose();
-                    cachedLayers[actionLayers[i]] = null;
-                }
-
-
-                // Wait for jobs
-                    /*foreach (var task in taskList)
-                    {
-                        task.Wait();
-                    }
-
-                    if (layerIndex > 0)
-                    {
-                        cachedLayers[layerIndex - 1].Dispose();
-                        cachedLayers[layerIndex - 1] = null;
-                    }*/
-            }
-
-            return result.ToList();
-        }
-
         public List<LayerIssue> GetAllIssues(
             IslandDetectionConfiguration islandConfig = null,
             OverhangDetectionConfiguration overhangConfig = null, 
@@ -1362,16 +1154,13 @@ namespace UVtools.Core
 
                             var listHollowArea = new List<LayerHollowArea>();
 
-                            using VectorOfVectorOfPoint contours = new();
-                            using Mat hierarchy = new();
-                            CvInvoke.FindContours(resinTrapImage, contours, hierarchy, RetrType.Ccomp, ChainApproxMethod.ChainApproxSimple);
+                            using var contours = resinTrapImage.FindContours(out var hierarchy, RetrType.Tree);
 
-                            if(needDispose)
+                            if (needDispose)
                             {
                                 resinTrapImage.Dispose();
                             }
 
-                            var arr = hierarchy.GetData();
                             //
                             //hierarchy[i][0]: the index of the next contour of the same level
                             //hierarchy[i][1]: the index of the previous contour of the same level
@@ -1381,7 +1170,7 @@ namespace UVtools.Core
 
                             for (int i = 0; i < contours.Size; i++)
                             {
-                                if ((int)arr.GetValue(0, i, 2) != -1 || (int)arr.GetValue(0, i, 3) == -1)
+                                if (hierarchy[i, EmguContour.HierarchyFirstChild] != -1 || hierarchy[i, EmguContour.HierarchyParent] == -1)
                                     continue;
 
                                 var rect = CvInvoke.BoundingRectangle(contours[i]);
@@ -1464,8 +1253,7 @@ namespace UVtools.Core
                                     var span = image.GetDataSpan<byte>();
                                     using (var emguImage = image.NewBlank())
                                     {
-                                        using (var vec =
-                                            new VectorOfVectorOfPoint(new VectorOfPoint(checkArea.Contour)))
+                                        using (var vec = new VectorOfVectorOfPoint(new VectorOfPoint(checkArea.Contour)))
                                         {
                                             CvInvoke.DrawContours(emguImage, vec, -1, EmguExtensions.WhiteColor, -1);
                                         }
@@ -1641,9 +1429,7 @@ namespace UVtools.Core
             for (var i = 0; i < drawings.Count; i++)
             {
                 var operation = drawings[i];
-                VectorOfVectorOfPoint layerContours = null;
-                Mat layerHierarchy = null;
-
+                
                 if (operation.OperationType == PixelOperation.PixelOperationType.Drawing)
                 {
                     var operationDrawing = (PixelDrawing) operation;
@@ -1681,24 +1467,27 @@ namespace UVtools.Core
                 {
                     var mat = modifiedLayers.GetOrAdd(operation.LayerIndex, u => this[operation.LayerIndex].LayerMat);
 
-                    if (layerContours is null)
-                    {
-                        layerContours = new VectorOfVectorOfPoint();
-                        layerHierarchy = new Mat();
-
-                        CvInvoke.FindContours(mat, layerContours, layerHierarchy, RetrType.Ccomp,
-                            ChainApproxMethod.ChainApproxSimple);
-                    }
-
+                    using var layerContours  = mat.FindContours(out var hierarchy, RetrType.Tree);
+                    
                     if (mat.GetByte(operation.Location) >= 10)
                     {
-                        for (int contourIdx = 0; contourIdx < layerContours.Size; contourIdx++)
+                        using var vec = new VectorOfVectorOfPoint();
+                        for (int index = layerContours.Size - 1; index >= 0; index--)
                         {
-                            if (!(CvInvoke.PointPolygonTest(layerContours[contourIdx], operation.Location, false) >= 0))
-                                continue;
-                            CvInvoke.DrawContours(mat, layerContours, contourIdx, new MCvScalar(operation.PixelBrightness), -1);
+                            if (CvInvoke.PointPolygonTest(layerContours[index], operation.Location, false) < 0) continue;
+                            vec.Push(layerContours[index]);
+                            for (int n = index + 1; n < layerContours.Size; n++)
+                            {
+                                if (hierarchy[n, EmguContour.HierarchyParent] != index) continue;
+                                vec.Push(layerContours[n]);
+                            }
                             break;
                         }
+
+                        if (vec.Size > 0)
+                        {
+                            CvInvoke.DrawContours(mat, vec, -1, new MCvScalar(operation.PixelBrightness), -1);
+                        }
                     }
                 }
                 else if (operation.OperationType == PixelOperation.PixelOperationType.Supports)
@@ -1773,10 +1562,7 @@ namespace UVtools.Core
                         drawnLayers++;
                     }
                 }
-
-                layerContours?.Dispose();
-                layerHierarchy?.Dispose();
-
+                
                 progress++;
             }
 
diff --git a/UVtools.Core/Operations/Operation.cs b/UVtools.Core/Operations/Operation.cs
index 6560de9..8821364 100644
--- a/UVtools.Core/Operations/Operation.cs
+++ b/UVtools.Core/Operations/Operation.cs
@@ -11,6 +11,7 @@ using System.Drawing;
 using System.IO;
 using System.Xml.Serialization;
 using Emgu.CV;
+using Emgu.CV.Cuda;
 using Emgu.CV.Util;
 using UVtools.Core.Extensions;
 using UVtools.Core.FileFormats;
diff --git a/UVtools.Core/Operations/OperationLayerExportImage.cs b/UVtools.Core/Operations/OperationLayerExportImage.cs
index 5748662..405693c 100644
--- a/UVtools.Core/Operations/OperationLayerExportImage.cs
+++ b/UVtools.Core/Operations/OperationLayerExportImage.cs
@@ -13,6 +13,8 @@ using System.Threading.Tasks;
 using Emgu.CV;
 using Emgu.CV.CvEnum;
 using Emgu.CV.Util;
+using UVtools.Core.EmguCV;
+using UVtools.Core.Extensions;
 using UVtools.Core.FileFormats;
 
 namespace UVtools.Core.Operations
@@ -206,11 +208,7 @@ namespace UVtools.Core.Operations
                     
                     CvInvoke.Threshold(matRoi, matRoi, 127, byte.MaxValue, ThresholdType.Binary); // Remove AA
 
-                    using var contours = new VectorOfVectorOfPoint();
-                    using var hierarchy = new Mat();
-                    CvInvoke.FindContours(matRoi, contours, hierarchy, RetrType.Tree, ChainApproxMethod.ChainApproxSimple);
-
-                    var hierarchyJagged = hierarchy.GetData();
+                    using var contours = matRoi.FindContours(out var hierarchy, RetrType.Tree);
                     
                     using TextWriter tw = new StreamWriter(fileFullPath);
                     tw.WriteLine("<!--");
@@ -254,8 +252,7 @@ namespace UVtools.Core.Operations
                     bool firstTime = true;
                     for (int i = 0; i < contours.Size; i++)
                     {
-                        if (contours[i].Size == 0) continue;
-                        if ((int)hierarchyJagged.GetValue(0, i, 3) == -1) // Top hierarchy
+                        if (hierarchy[i, EmguContour.HierarchyParent] == -1) // Top hierarchy
                         {
                             if (firstTime)
                             {
diff --git a/UVtools.Core/Operations/OperationMorph.cs b/UVtools.Core/Operations/OperationMorph.cs
index bdb29ad..27fc4ef 100644
--- a/UVtools.Core/Operations/OperationMorph.cs
+++ b/UVtools.Core/Operations/OperationMorph.cs
@@ -11,7 +11,9 @@ using System.ComponentModel;
 using System.Threading.Tasks;
 using System.Xml.Serialization;
 using Emgu.CV;
+using Emgu.CV.Cuda;
 using Emgu.CV.CvEnum;
+using UVtools.Core.Extensions;
 using UVtools.Core.FileFormats;
 using UVtools.Core.Objects;
 
@@ -177,10 +179,22 @@ namespace UVtools.Core.Operations
             {
                 iterations = (int) arguments[0];
             }
-
+            
             using var original = mat.Clone();
             var target = GetRoiOrDefault(mat);
-            CvInvoke.MorphologyEx(target, target, (MorphOp) MorphOperation, Kernel.Matrix, Kernel.Anchor, iterations, BorderType.Reflect101, default);
+
+            if (CoreSettings.CanUseCuda)
+            {
+                var gpuMat = target.ToGpuMat();
+                using var morph = new CudaMorphologyFilter((MorphOp)MorphOperation, target.Depth, target.NumberOfChannels, Kernel.Matrix, Kernel.Anchor, iterations);
+                morph.Apply(gpuMat, gpuMat);
+                gpuMat.Download(target);
+            }
+            else
+            {
+                CvInvoke.MorphologyEx(target, target, (MorphOp) MorphOperation, Kernel.Matrix, Kernel.Anchor, iterations, BorderType.Reflect101, default);
+            }
+
             ApplyMask(original, target);
             return true;
         }
diff --git a/UVtools.Core/Operations/OperationRedrawModel.cs b/UVtools.Core/Operations/OperationRedrawModel.cs
index cd23236..cd51814 100644
--- a/UVtools.Core/Operations/OperationRedrawModel.cs
+++ b/UVtools.Core/Operations/OperationRedrawModel.cs
@@ -184,9 +184,7 @@ namespace UVtools.Core.Operations
                 {
                     if (layerIndex + 1 >= otherFile.LayerCount) return;
                     CvInvoke.Subtract(fullMatRoi, bodyMatRoi, supportsMat); // Supports
-                    using var contours = new VectorOfVectorOfPoint();
-                    using var hierarchyMat = new Mat();
-                    CvInvoke.FindContours(supportsMat, contours, hierarchyMat, RetrType.List, ChainApproxMethod.ChainApproxSimple);
+                    using var contours = supportsMat.FindContours(RetrType.List);
                     if (contours.Size <= 0) return;
                     using var nextLayerMat = otherFile[layerIndex + 1].LayerMat;
                     using var nextLayerMatRoi = GetRoiOrDefault(nextLayerMat);
diff --git a/UVtools.Core/Operations/OperationSolidify.cs b/UVtools.Core/Operations/OperationSolidify.cs
index f108953..5695005 100644
--- a/UVtools.Core/Operations/OperationSolidify.cs
+++ b/UVtools.Core/Operations/OperationSolidify.cs
@@ -11,6 +11,7 @@ using System.Threading.Tasks;
 using Emgu.CV;
 using Emgu.CV.CvEnum;
 using Emgu.CV.Util;
+using UVtools.Core.EmguCV;
 using UVtools.Core.Extensions;
 using UVtools.Core.FileFormats;
 
@@ -101,17 +102,14 @@ namespace UVtools.Core.Operations
         public override bool Execute(Mat mat, params object[] arguments)
         {
             using Mat filteredMat = new();
-            using VectorOfVectorOfPoint contours = new();
-            using Mat hierarchy = new();
             using var original = mat.Clone();
             var target = GetRoiOrDefault(mat);
 
             CvInvoke.Threshold(target, filteredMat, 127, 255, ThresholdType.Binary); // Clean AA
-            CvInvoke.FindContours(filteredMat, contours, hierarchy, RetrType.Ccomp, ChainApproxMethod.ChainApproxSimple);
-            var arr = hierarchy.GetData();
+            using var contours = filteredMat.FindContours(out var hierarchy, RetrType.Ccomp);
             for (int i = 0; i < contours.Size; i++)
             {
-                if ((int)arr.GetValue(0, i, 2) != -1 || (int)arr.GetValue(0, i, 3) == -1) continue;
+                if (hierarchy[i, EmguContour.HierarchyFirstChild] != -1 || hierarchy[i, EmguContour.HierarchyParent] == -1) continue;
                 if (MinimumArea >= 1)
                 {
                     var rectangle = CvInvoke.BoundingRectangle(contours[i]);
diff --git a/UVtools.Core/UVtools.Core.csproj b/UVtools.Core/UVtools.Core.csproj
index 268f850..bf80391 100644
--- a/UVtools.Core/UVtools.Core.csproj
+++ b/UVtools.Core/UVtools.Core.csproj
@@ -10,7 +10,7 @@
     <RepositoryUrl>https://github.com/sn4k3/UVtools</RepositoryUrl>
     <PackageProjectUrl>https://github.com/sn4k3/UVtools</PackageProjectUrl>
     <Description>MSLA/DLP, file analysis, calibration, repair, conversion and manipulation</Description>
-    <Version>2.21.1</Version>
+    <Version>2.21.2</Version>
     <Copyright>Copyright © 2020 PTRTECH</Copyright>
     <PackageIcon>UVtools.png</PackageIcon>
     <Platforms>AnyCPU;x64</Platforms>
diff --git a/UVtools.ScriptSample/ScriptInsetSample.cs b/UVtools.ScriptSample/ScriptInsetSample.cs
index 9b6de73..60d5dec 100644
--- a/UVtools.ScriptSample/ScriptInsetSample.cs
+++ b/UVtools.ScriptSample/ScriptInsetSample.cs
@@ -7,13 +7,16 @@
  */
 
 using System;
+using System.Collections.Generic;
 using System.Drawing;
 using System.Text;
 using System.Threading.Tasks;
 using UVtools.Core.Scripting;
 using Emgu.CV;
 using Emgu.CV.CvEnum;
+using Emgu.CV.Util;
 using UVtools.Core;
+using UVtools.Core.Extensions;
 
 namespace UVtools.ScriptSample
 {
@@ -87,9 +90,11 @@ namespace UVtools.ScriptSample
         public bool ScriptExecute()
         {
             var anchor = new Point(-1, -1); // Kernel anchor, -1, -1 = center
-            var kernel = CvInvoke.GetStructuringElement(ElementShape.Rectangle, new Size(3, 3), anchor); // Rectangle 3x3 kernel
+            var kernel =
+                CvInvoke.GetStructuringElement(ElementShape.Rectangle, new Size(3, 3), anchor); // Rectangle 3x3 kernel
             Progress.Reset("Inset layers", Operation.LayerRangeCount); // Sets the progress name and number of items to process
 
+            
             // Loop user selected layers in parallel, this will put each core of CPU working here on parallel
             Parallel.For(Operation.LayerIndexStart, Operation.LayerIndexEnd+1, CoreSettings.ParallelOptions, layerIndex =>
             {
diff --git a/UVtools.ScriptSample/ScriptTester.cs b/UVtools.ScriptSample/ScriptTester.cs
index 2027740..5ea3789 100644
--- a/UVtools.ScriptSample/ScriptTester.cs
+++ b/UVtools.ScriptSample/ScriptTester.cs
@@ -7,8 +7,16 @@
  */
 
 using System;
+using System.Collections.Generic;
+using System.Drawing;
 using UVtools.Core.Scripting;
 using System.IO;
+using System.Threading.Tasks;
+using Emgu.CV;
+using Emgu.CV.CvEnum;
+using Emgu.CV.Util;
+using UVtools.Core;
+using UVtools.Core.EmguCV;
 using UVtools.Core.Extensions;
 
 namespace UVtools.ScriptSample
@@ -44,22 +52,55 @@ namespace UVtools.ScriptSample
         /// <returns>True if executes successfully to the end, otherwise false.</returns>
         public bool ScriptExecute()
         {
-            string path = @"c:\temp\UVToolAreaExp_" + DateTime.Now.ToString("yyyyMMddHHmmss") + ".txt";
-
-            Progress.Reset("Changing layers", Operation.LayerRangeCount); // Sets the progress name and number of items to process
-
-            using var sw = File.CreateText(path);
-            for (uint layerIndex = Operation.LayerIndexStart; layerIndex <= Operation.LayerIndexEnd; layerIndex++)
+            var dict = new Dictionary<uint, List<(Point[] points, Rectangle rect)>>();
+            Parallel.For(Operation.LayerIndexStart, Operation.LayerIndexEnd + 1, CoreSettings.ParallelOptions, layerIndex =>
             {
-                Progress.Token.ThrowIfCancellationRequested(); // Abort operation, user requested cancellation
-                var layer = SlicerFile[layerIndex]; // Unpack and expose layer variable for easier use
+                using var mat = SlicerFile[layerIndex].LayerMat;
+                using var contours = mat.FindContours(out var hierarchy, RetrType.Tree);
 
-                sw.WriteLine($@"{layerIndex}\{layer.NonZeroPixelCount}\{layer.BoundingRectangleMillimeters.Area()}");
-                //sw.WriteLine(SlicerFile.GetName);
-             
-                Progress++; // Increment progress bar by 1
+                var hollowContours = new List<(Point[] points, Rectangle rect)>();
+                dict.Add((uint)layerIndex, hollowContours);
+
+                for (int i = 0; i < contours.Size; i++)
+                {
+                    // Only hollow areas inside model
+                    if (hierarchy[i, EmguContour.HierarchyParent] == -1) continue;
+
+                    hollowContours.Add((contours[i].ToArray(), CvInvoke.BoundingRectangle(contours[i])));
+                }
+            });
+
+            foreach (var (layerIndex, contours) in dict)
+            {
+                if (!dict.TryGetValue(layerIndex + 1, out var nextContours)) continue; // No next layer with results
+
+                foreach (var tuple in contours)
+                {
+                    Mat thisContourMat = null;
+                    foreach (var nextTuple in nextContours)
+                    {
+                        if (!tuple.rect.IntersectsWith(nextTuple.rect)) continue;
+                        if (thisContourMat is null)
+                        {
+                            thisContourMat = EmguExtensions.InitMat(SlicerFile.Resolution);
+                            using var vec = new VectorOfPoint(tuple.points);
+                            CvInvoke.DrawContours(thisContourMat, vec, -1, EmguExtensions.WhiteColor, -1);
+                        }
+
+                        using var nextContourMat = thisContourMat.NewBlank();
+                        using var vecNext = new VectorOfPoint(nextTuple.points);
+                        CvInvoke.DrawContours(nextContourMat, vecNext, -1, EmguExtensions.WhiteColor, -1);
+
+                        CvInvoke.BitwiseAnd(thisContourMat, nextContourMat, nextContourMat);
+                        if (CvInvoke.CountNonZero(nextContourMat) == 0) continue; // Does not intersect!
+
+                        // Intersecting here!
+                    }
+
+                    thisContourMat?.Dispose();
+                }
             }
-            sw.Close();
+
 
             // return true if not cancelled by user
             return !Progress.Token.IsCancellationRequested;
diff --git a/UVtools.ScriptSample/UVtools.ScriptSample.csproj b/UVtools.ScriptSample/UVtools.ScriptSample.csproj
index 6c0dcf5..cf79ecd 100644
--- a/UVtools.ScriptSample/UVtools.ScriptSample.csproj
+++ b/UVtools.ScriptSample/UVtools.ScriptSample.csproj
@@ -10,6 +10,7 @@
     <RepositoryUrl>https://github.com/sn4k3/UVtools</RepositoryUrl>
     <RepositoryType>Git</RepositoryType>
     <Copyright>Copyright © 2020 PTRTECH</Copyright>
+    <Platforms>AnyCPU;x64</Platforms>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/UVtools.WPF/LayerCache.cs b/UVtools.WPF/LayerCache.cs
index dc5ae58..2c5103b 100644
--- a/UVtools.WPF/LayerCache.cs
+++ b/UVtools.WPF/LayerCache.cs
@@ -21,9 +21,8 @@ namespace UVtools.WPF
     public sealed class LayerCache
     {
         private Layer _layer;
-        private Array _layerHierarchyJagged;
         private VectorOfVectorOfPoint _layerContours;
-        private Mat _layerHierarchy;
+        private int[,] _layerContourHierarchy;
         //private SKCanvas _canvas;
         private WriteableBitmap _bitmap;
 
@@ -85,35 +84,21 @@ namespace UVtools.WPF
             private set => _layerContours = value;
         }
 
-        public Mat LayerHierarchy
+        public int[,] LayerContourHierarchy
         {
             get
             {
-                if (_layerHierarchy is null) CacheContours();
-                return _layerHierarchy;
+                if (_layerContourHierarchy is null) CacheContours();
+                return _layerContourHierarchy;
             }
-            private set => _layerHierarchy = value;
-        }
-
-        public Array LayerHierarchyJagged
-        {
-            get
-            {
-                if(_layerHierarchyJagged is null) CacheContours();
-                return _layerHierarchyJagged;
-            }
-            private set => _layerHierarchyJagged = value;
+            private set => _layerContourHierarchy = value;
         }
 
         public void CacheContours(bool refresh = false)
         {
             if(refresh) Clear();
             if (_layerContours is not null) return;
-            _layerContours = new VectorOfVectorOfPoint();
-            _layerHierarchy = new Mat();
-            CvInvoke.FindContours(Image, _layerContours, _layerHierarchy, RetrType.Ccomp,
-                ChainApproxMethod.ChainApproxSimple);
-            _layerHierarchyJagged = _layerHierarchy.GetData();
+            _layerContours = Image.FindContours(out _layerContourHierarchy, RetrType.Tree);
         }
         
 
@@ -127,9 +112,7 @@ namespace UVtools.WPF
             ImageBgr?.Dispose();
             _layerContours?.Dispose();
             _layerContours = null;
-            _layerHierarchy?.Dispose();
-            _layerHierarchy = null;
-            _layerHierarchyJagged = null;
+            _layerContourHierarchy = null;
         }
     }
 }
diff --git a/UVtools.WPF/MainWindow.LayerPreview.cs b/UVtools.WPF/MainWindow.LayerPreview.cs
index 06097c1..07181f4 100644
--- a/UVtools.WPF/MainWindow.LayerPreview.cs
+++ b/UVtools.WPF/MainWindow.LayerPreview.cs
@@ -1010,16 +1010,30 @@ namespace UVtools.WPF
 
                 if (_showLayerOutlineContourBoundary)
                 {
+                    int lastParent = -1;
+                    uint reps = 0;
                     for (int i = 0; i < LayerCache.LayerContours.Size; i++)
                     {
-                        if ((int)LayerCache.LayerHierarchyJagged.GetValue(0, i, 2) == -1 &&
-                            (int)LayerCache.LayerHierarchyJagged.GetValue(0, i, 3) != -1) continue;
+                        var parent = LayerCache.LayerContourHierarchy[i, EmguContour.HierarchyParent];
+                        if (parent == -1)
+                        {
+                            reps = 0;
+                        }
+                        if(parent == -1 || parent != lastParent) reps++;
+                        if (reps % 2 == 0)
+                        {
+                            lastParent = parent;
+                            continue;
+                        }
+
                         CvInvoke.Rectangle(LayerCache.ImageBgr, CvInvoke.BoundingRectangle(LayerCache.LayerContours[i]),
                             new MCvScalar(
                                 Settings.LayerPreview.ContourBoundsOutlineColor.B,
                                 Settings.LayerPreview.ContourBoundsOutlineColor.G, 
                                 Settings.LayerPreview.ContourBoundsOutlineColor.R),
                             Settings.LayerPreview.ContourBoundsOutlineThickness);
+
+                        lastParent = parent;
                     }
                 }
 
@@ -1028,37 +1042,46 @@ namespace UVtools.WPF
                     //CvInvoke.Threshold(ActualLayerImage, grayscale, 1, 255, ThresholdType.Binary);
 
                     /*
-                         * hierarchy[i][0]: the index of the next contour of the same level
-                         * hierarchy[i][1]: the index of the previous contour of the same level
-                         * hierarchy[i][2]: the index of the first child
-                         * hierarchy[i][3]: the index of the parent
-                         */
+                     * hierarchy[i][0]: the index of the next contour of the same level
+                     * hierarchy[i][1]: the index of the previous contour of the same level
+                     * hierarchy[i][2]: the index of the first child
+                     * hierarchy[i][3]: the index of the parent
+                     */
+                    using var vec = new VectorOfVectorOfPoint();
                     for (int i = 0; i < LayerCache.LayerContours.Size; i++)
                     {
-                        if ((int)LayerCache.LayerHierarchyJagged.GetValue(0, i, 2) == -1 &&
-                            (int)LayerCache.LayerHierarchyJagged.GetValue(0, i, 3) != -1)
-                        {
-                            //var r = CvInvoke.BoundingRectangle(contours[i]);
-                            //CvInvoke.Rectangle(ActualLayerImageBgr, r, new MCvScalar(0, 0, 255), 2);
-                            CvInvoke.DrawContours(LayerCache.ImageBgr, LayerCache.LayerContours, i,
-                                new MCvScalar(Settings.LayerPreview.HollowOutlineColor.B,
-                                    Settings.LayerPreview.HollowOutlineColor.G,
-                                    Settings.LayerPreview.HollowOutlineColor.R),
-                                Settings.LayerPreview.HollowOutlineLineThickness);
-                        }
+                        if (LayerCache.LayerContourHierarchy[i, EmguContour.HierarchyParent] < 0) continue;
+                        // We need a parent, meaning we are alternating from white and black after this point
+                        vec.Push(LayerCache.LayerContours[i]);
+                    }
+
+                    if (vec.Size > 0)
+                    {
+                        CvInvoke.DrawContours(LayerCache.ImageBgr, vec, -1,
+                            new MCvScalar(Settings.LayerPreview.HollowOutlineColor.B,
+                                Settings.LayerPreview.HollowOutlineColor.G,
+                                Settings.LayerPreview.HollowOutlineColor.R),
+                            Settings.LayerPreview.HollowOutlineLineThickness);
                     }
                 }
 
                 if (_showLayerOutlineCentroids)
                 {
+                    int lastParent = -1;
+                    uint reps = 0;
                     for (int i = 0; i < LayerCache.LayerContours.Size; i++)
                     {
-                        if ((int)LayerCache.LayerHierarchyJagged.GetValue(0, i, 2) == -1 &&
-                            (int)LayerCache.LayerHierarchyJagged.GetValue(0, i, 3) != -1)
+                        var parent = LayerCache.LayerContourHierarchy[i, EmguContour.HierarchyParent];
+                        if (parent == -1)
+                        {
+                            reps = 0;
+                        }
+                        if (parent == -1 || parent != lastParent) reps++;
+                        if (reps % 2 == 0)
                         {
                             if (Settings.LayerPreview.CentroidOutlineHollow)
                             {
-                                CvInvoke.Circle(LayerCache.ImageBgr, Contour.GetCentroid(LayerCache.LayerContours[i]),
+                                CvInvoke.Circle(LayerCache.ImageBgr, EmguContour.GetCentroid(LayerCache.LayerContours[i]),
                                     Settings.LayerPreview.CentroidOutlineDiameter / 2, new MCvScalar(
                                         Settings.LayerPreview.HollowOutlineColor.B,
                                         Settings.LayerPreview.HollowOutlineColor.G,
@@ -1067,13 +1090,16 @@ namespace UVtools.WPF
                         }
                         else
                         {
-                            CvInvoke.Circle(LayerCache.ImageBgr, Contour.GetCentroid(LayerCache.LayerContours[i]),
-                                Settings.LayerPreview.CentroidOutlineDiameter / 2, new MCvScalar(
-                                    Settings.LayerPreview.CentroidOutlineColor.B,
-                                    Settings.LayerPreview.CentroidOutlineColor.G,
-                                    Settings.LayerPreview.CentroidOutlineColor.R), -1, LineType.AntiAlias);
+                            CvInvoke.Circle(LayerCache.ImageBgr, EmguContour.GetCentroid(LayerCache.LayerContours[i]),
+                            Settings.LayerPreview.CentroidOutlineDiameter / 2, new MCvScalar(
+                                Settings.LayerPreview.CentroidOutlineColor.B,
+                                Settings.LayerPreview.CentroidOutlineColor.G,
+                                Settings.LayerPreview.CentroidOutlineColor.R), -1, LineType.AntiAlias);
                         }
-                            
+
+                        
+
+                        lastParent = parent;
                     }
                 }
 
@@ -1153,20 +1179,24 @@ namespace UVtools.WPF
                         var color = DrawingsGrid.SelectedItems.Contains(operation)
                             ? Settings.PixelEditor.RemovePixelHighlightColor
                             : Settings.PixelEditor.RemovePixelColor;
-                        for (int i = 0; i < LayerCache.LayerContours.Size; i++)
-                        {
-                            /*if (pixelBrightness < 10 && (int) LayerCache.LayerHierarchyJagged.GetValue(0, i, 2) != -1 ||
-                                (int) LayerCache.LayerHierarchyJagged.GetValue(0, i, 3) == -1)
-                            {
-                                continue;
-                            }*/
 
-                            if (CvInvoke.PointPolygonTest(LayerCache.LayerContours[i], operation.Location, false) >= 0)
+                        using var vec = new VectorOfVectorOfPoint();
+                        for (int i = LayerCache.LayerContours.Size-1; i >= 0; i--)
+                        {
+                            if (CvInvoke.PointPolygonTest(LayerCache.LayerContours[i], operation.Location, false) < 0) continue;
+                            vec.Push(LayerCache.LayerContours[i]);
+                            for (int n = i+1; n < LayerCache.LayerContours.Size; n++)
                             {
-                                CvInvoke.DrawContours(LayerCache.ImageBgr, LayerCache.LayerContours, i,
-                                    new MCvScalar(color.B, color.G, color.R), -1);
-                                break;
+                                if(LayerCache.LayerContourHierarchy[n, EmguContour.HierarchyParent] != i) continue;
+                                vec.Push(LayerCache.LayerContours[n]);
                             }
+                            break;
+                        }
+
+                        if (vec.Size > 0)
+                        {
+                            CvInvoke.DrawContours(LayerCache.ImageBgr, vec, -1,
+                                new MCvScalar(color.B, color.G, color.R), -1);
                         }
                     }
                     else if (operation.OperationType == PixelOperation.PixelOperationType.Supports)
@@ -1872,21 +1902,13 @@ namespace UVtools.WPF
         public bool SelectObjectRoi(Point location)
         {
             var point = GetTransposedPoint(location);
-            var brightness = LayerCache.Image.GetByte(point);
 
-            for (int i = 0; i < LayerCache.LayerContours.Size; i++)
+            for (int i = LayerCache.LayerContours.Size-1; i >= 0; i--)
             {
-                if (brightness == 0 &&
-                    ((int) LayerCache.LayerHierarchyJagged.GetValue(0, i, 2) != -1 ||
-                    (int) LayerCache.LayerHierarchyJagged.GetValue(0, i, 3) == -1)) continue;
-
-                if (CvInvoke.PointPolygonTest(LayerCache.LayerContours[i], point, false) >= 0)
-                {
-                    var rectangle = CvInvoke.BoundingRectangle(LayerCache.LayerContours[i]);
-                    ROI = rectangle;
-
-                    return true;
-                }
+                if (CvInvoke.PointPolygonTest(LayerCache.LayerContours[i], point, false) < 0) continue;
+                var rectangle = CvInvoke.BoundingRectangle(LayerCache.LayerContours[i]);
+                ROI = rectangle;
+                return true;
             }
 
             return false;
@@ -1921,21 +1943,13 @@ namespace UVtools.WPF
         public bool SelectObjectMask(Point location)
         {
             var point = GetTransposedPoint(location);
-            var brightness = LayerCache.Image.GetByte(point);
-
-            for (int i = 0; i < LayerCache.LayerContours.Size; i++)
+            for (int i = LayerCache.LayerContours.Size-1; i >= 0; i--)
             {
-                if (brightness == 0 &&
-                    ((int)LayerCache.LayerHierarchyJagged.GetValue(0, i, 2) != -1 ||
-                     (int)LayerCache.LayerHierarchyJagged.GetValue(0, i, 3) == -1)) continue;
-                if (CvInvoke.PointPolygonTest(LayerCache.LayerContours[i], point, false) >= 0)
-                {
-                    //var rectangle = GetTransposedRectangle(CvInvoke.BoundingRectangle(LayerCache.LayerContours[i]));
-                    //ROI = rectangle;
-                    AddMaskPoints(LayerCache.LayerContours[i].ToArray());
-
-                    return true;
-                }
+                if (CvInvoke.PointPolygonTest(LayerCache.LayerContours[i], point, false) < 0) continue;
+                //var rectangle = GetTransposedRectangle(CvInvoke.BoundingRectangle(LayerCache.LayerContours[i]));
+                //ROI = rectangle;
+                AddMaskPoints(LayerCache.LayerContours[i].ToArray());
+                return true;
             }
 
             return false;
diff --git a/UVtools.WPF/MainWindow.axaml b/UVtools.WPF/MainWindow.axaml
index 35fe48c..30785b8 100644
--- a/UVtools.WPF/MainWindow.axaml
+++ b/UVtools.WPF/MainWindow.axaml
@@ -796,7 +796,7 @@
                           VerticalAlignment="Center"
                           Margin="10,0,0,0"
                           ToolTip.Tip="Starting layer index for resin trap detection which will also be considered a drain layer.
-&#x0a;Use this setting to bypass complicated rafts by selected the model first real layer."
+&#x0a;Use this setting to bypass complicated rafts by select the model first real layer."
                           Minimum="0"
                           Maximum="{Binding SlicerFile.LastLayerIndex}"
                           Increment="1"
diff --git a/UVtools.WPF/MainWindow.axaml.cs b/UVtools.WPF/MainWindow.axaml.cs
index efe024e..240f4d3 100644
--- a/UVtools.WPF/MainWindow.axaml.cs
+++ b/UVtools.WPF/MainWindow.axaml.cs
@@ -26,6 +26,7 @@ using UVtools.Core;
 using UVtools.Core.Extensions;
 using UVtools.Core.FileFormats;
 using UVtools.Core.Managers;
+using UVtools.Core.Network;
 using UVtools.Core.Operations;
 using UVtools.WPF.Controls;
 using UVtools.WPF.Controls.Calibrators;
@@ -631,6 +632,22 @@ namespace UVtools.WPF
                     menuItems.Add(menuItem);
                 }
 
+                if (Settings.General.SendToCustomLocations is not null)
+                {
+                    foreach (var location in Settings.General.SendToCustomLocations)
+                    {
+                        var menuItem = new MenuItem
+                        {
+                            Header = location.ToString(),
+                            Tag = location,
+                        };
+                        menuItem.Click += FileSendToItemClick;
+
+                        menuItems.Add(menuItem);
+                    }
+                }
+
+
                 MenuFileSendToItems = menuItems.ToArray();
                 _menuFileSendTo.IsVisible = _menuFileSendTo.IsEnabled = menuItems.Count > 0;
             };
@@ -639,11 +656,27 @@ namespace UVtools.WPF
         private async void FileSendToItemClick(object? sender, RoutedEventArgs e)
         {
             if (sender is not MenuItem menuItem) return;
-            if (menuItem.Tag is not DriveInfo drive) return;
-            
-            if (!drive.IsReady)
+
+
+            string path;
+            if (menuItem.Tag is DriveInfo drive)
+            {
+
+                if (!drive.IsReady)
+                {
+                    await this.MessageBoxError($"The device {drive.Name} is not ready/available at this time.",
+                        "Unable to copy the file");
+                    return;
+                }
+
+                path = drive.Name;
+            }
+            else if (menuItem.Tag is MappedDevice device)
+            {
+                path = device.Path;
+            }
+            else
             {
-                await this.MessageBoxError($"The device {drive.Name} is not ready/available at this time.", "Unable to copy the file");
                 return;
             }
 
@@ -664,18 +697,16 @@ namespace UVtools.WPF
                 }
             }
 
-            ShowProgressWindow($"Copying: {SlicerFile.Filename} to {drive.Name}", false);
+            ShowProgressWindow($"Copying: {SlicerFile.Filename} to {path}", false);
             Progress.ItemName = "Copying";
             await Task.Factory.StartNew(() =>
             {
                 try
                 {
-                    File.Copy(SlicerFile.FileFullPath, $"{drive.Name}{SlicerFile.Filename}", true);
+                    File.Copy(SlicerFile.FileFullPath, $"{Path.Combine(path, SlicerFile.Filename)}", true);
                     return true;
                 }
-                catch (OperationCanceledException)
-                {
-                }
+                catch (OperationCanceledException) { }
                 catch (Exception exception)
                 {
                     Dispatcher.UIThread.InvokeAsync(async () =>
@@ -1961,10 +1992,10 @@ namespace UVtools.WPF
             else ProcessFile(file);
         }
 
-#endregion
+    #endregion
 
-        
+            
 
-#endregion
-        }
+    #endregion
+    }
 }
diff --git a/UVtools.WPF/Program.cs b/UVtools.WPF/Program.cs
index b3ee62d..05333ae 100644
--- a/UVtools.WPF/Program.cs
+++ b/UVtools.WPF/Program.cs
@@ -2,6 +2,7 @@
 using System.Diagnostics;
 using System.Runtime.ExceptionServices;
 using Avalonia;
+using Emgu.CV;
 using UVtools.WPF.Extensions;
 
 namespace UVtools.WPF
diff --git a/UVtools.WPF/UVtools.WPF.csproj b/UVtools.WPF/UVtools.WPF.csproj
index 56a2dd8..10b60c7 100644
--- a/UVtools.WPF/UVtools.WPF.csproj
+++ b/UVtools.WPF/UVtools.WPF.csproj
@@ -12,17 +12,27 @@
     <PackageLicenseFile>LICENSE</PackageLicenseFile>
     <RepositoryUrl>https://github.com/sn4k3/UVtools</RepositoryUrl>
     <RepositoryType>Git</RepositoryType>
-    <Version>2.21.1</Version>
+    <Version>2.21.2</Version>
+    <Platforms>AnyCPU;x64</Platforms>
   </PropertyGroup>
   
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <NoWarn>1701;1702;</NoWarn>
   </PropertyGroup>
+  
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <NoWarn>1701;1702;</NoWarn>
+  </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <NoWarn>1701;1702;</NoWarn>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <NoWarn>1701;1702;</NoWarn>
+  </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="Avalonia" Version="0.10.7" />
     <PackageReference Include="Avalonia.Angle.Windows.Natives" Version="2.1.0.2020091801" />
diff --git a/UVtools.WPF/UserSettings.cs b/UVtools.WPF/UserSettings.cs
index a1aa260..ce79d6a 100644
--- a/UVtools.WPF/UserSettings.cs
+++ b/UVtools.WPF/UserSettings.cs
@@ -7,13 +7,16 @@
  */
 
 using System;
+using System.Collections.ObjectModel;
 using System.Diagnostics;
 using System.IO;
+using System.Linq;
 using System.Threading.Tasks;
 using System.Xml.Serialization;
 using Avalonia.Media;
 using JetBrains.Annotations;
 using UVtools.Core;
+using UVtools.Core.Network;
 using UVtools.Core.Objects;
 using Color=UVtools.WPF.Structures.Color;
 
@@ -51,6 +54,7 @@ namespace UVtools.WPF
             private bool _promptOverwriteFileSave = true;
             private string _fileSaveNamePrefix;
             private string _fileSaveNameSuffix = "_copy";
+            private RangeObservableCollection<MappedDevice> _sendToCustomLocations = new();
 
 
             public bool StartMaximized
@@ -165,11 +169,21 @@ namespace UVtools.WPF
                 set => RaiseAndSetIfChanged(ref _fileSaveNameSuffix, value);
             }
 
+            public RangeObservableCollection<MappedDevice> SendToCustomLocations
+            {
+                get => _sendToCustomLocations;
+                set => RaiseAndSetIfChanged(ref _sendToCustomLocations, value);
+            }
+
             public GeneralUserSettings() { }
 
             public GeneralUserSettings Clone()
             {
-                return MemberwiseClone() as GeneralUserSettings;
+                
+                var clone = MemberwiseClone() as GeneralUserSettings;
+                _sendToCustomLocations ??= new();
+                clone.SendToCustomLocations = new RangeObservableCollection<MappedDevice>(_sendToCustomLocations.ToArray());
+                return clone;
             }
         }
         #endregion
diff --git a/UVtools.WPF/Windows/BenchmarkWindow.axaml.cs b/UVtools.WPF/Windows/BenchmarkWindow.axaml.cs
index d3cb69f..762eafe 100644
--- a/UVtools.WPF/Windows/BenchmarkWindow.axaml.cs
+++ b/UVtools.WPF/Windows/BenchmarkWindow.axaml.cs
@@ -1,10 +1,7 @@
 using System;
 using System.Collections.Generic;
-using System.ComponentModel;
 using System.Diagnostics;
 using System.Drawing;
-using System.Reflection;
-using System.Security.Cryptography;
 using System.Threading;
 using System.Threading.Tasks;
 using Avalonia.Markup.Xaml;
@@ -33,7 +30,7 @@ namespace UVtools.WPF.Windows
         public const string RunsAbbreviation = "TDPS";
         public const string StressCPUTestName = "Stress CPU (Run until stop)";
 
-        private readonly RNGCryptoServiceProvider _randomProvider = new();
+        //private readonly RNGCryptoServiceProvider _randomProvider = new();
 
         private CancellationTokenSource _tokenSource;
         private CancellationToken _token => _tokenSource.Token;
@@ -133,16 +130,16 @@ namespace UVtools.WPF.Windows
             }
             else
             {
-                BenchmarkTest benchmark = Tests[_testSelectedIndex];
+                var benchmark = Tests[_testSelectedIndex];
                 SingleThreadTDPS = $"Running {SingleThreadTests} tests";
                 MultiThreadTDPS = $"Running {MultiThreadTests} tests";
                 
                 _tokenSource = new CancellationTokenSource();
-                MethodInfo theMethod = GetType().GetMethod(benchmark.FunctionName);
+                var theMethod = GetType().GetMethod(benchmark.FunctionName);
 
                 Task.Factory.StartNew(() =>
                 {
-                    Stopwatch sw = Stopwatch.StartNew();
+                    var sw = Stopwatch.StartNew();
                     try
                     {
                         if (benchmark.Name.Equals(StressCPUTestName))
@@ -422,47 +419,45 @@ namespace UVtools.WPF.Windows
 
         public Mat RandomMat(int width, int height)
         {
-            var bytes = new byte[width * height];
-            _randomProvider.GetBytes(bytes);
             Mat mat = new(new Size(width, height), DepthType.Cv8U, 1);
-            mat.SetBytes(bytes);
+            CvInvoke.Randu(mat, EmguExtensions.BlackColor, EmguExtensions.WhiteColor);
             return mat;
         }
 
         public void Test4KRandomCBBDLPEncode()
         {
-            using (var mat = RandomMat(3840, 2160))
-                EncodeCbddlpImage(mat);
+            using var mat = RandomMat(3840, 2160);
+            EncodeCbddlpImage(mat);
         }
 
         public void Test8KRandomCBBDLPEncode()
         {
-            using (var mat = RandomMat(7680, 4320))
-                EncodeCbddlpImage(mat);
+            using var mat = RandomMat(7680, 4320);
+            EncodeCbddlpImage(mat);
         }
 
         public void Test4KRandomCBTEncode()
         {
-            using (var mat = RandomMat(3840, 2160))
-                EncodeCbtImage(mat);
+            using var mat = RandomMat(3840, 2160);
+            EncodeCbtImage(mat);
         }
 
         public void Test8KRandomCBTEncode()
         {
-            using (var mat = RandomMat(7680, 4320))
-                EncodeCbtImage(mat);
+            using var mat = RandomMat(7680, 4320);
+            EncodeCbtImage(mat);
         }
 
         public void Test4KRandomPW0Encode()
         {
-            using (var mat = RandomMat(3840, 2160))
-                EncodePW0Image(mat);
+            using var mat = RandomMat(3840, 2160);
+            EncodePW0Image(mat);
         }
 
         public void Test8KRandomPW0Encode()
         {
-            using (var mat = RandomMat(7680, 4320))
-                EncodePW0Image(mat);
+            using var mat = RandomMat(7680, 4320);
+            EncodePW0Image(mat);
         }
 
         #endregion
diff --git a/UVtools.WPF/Windows/SettingsWindow.axaml b/UVtools.WPF/Windows/SettingsWindow.axaml
index 325cf21..aad4cc5 100644
--- a/UVtools.WPF/Windows/SettingsWindow.axaml
+++ b/UVtools.WPF/Windows/SettingsWindow.axaml
@@ -331,6 +331,60 @@
 
             </Border>
 
+            <Border
+                Classes="GroupBox"
+                Margin="5">
+
+              <StackPanel Orientation="Vertical">
+                  <Grid RowDefinitions="Auto" ColumnDefinitions="*,Auto"  Background="LightBlue">
+                    <TextBlock Grid.Row="0" Grid.Column="0"
+                               VerticalAlignment="Center"
+                               Padding="10" FontWeight="Bold" Text="Send to - Custom locations"/>
+
+                    <StackPanel Grid.Row="0" Grid.Column="1"  
+                                HorizontalAlignment="Right" Orientation="Horizontal" Spacing="2">
+                        <Button ToolTip.Tip="Add location" VerticalAlignment="Center"
+                                Command="{Binding SendToAddCustomLocation}">
+                            <Image Source="/Assets/Icons/plus-16x16.png"/>
+                        </Button>
+
+                        <Button ToolTip.Tip="Remove selected locations" VerticalAlignment="Center"
+                                IsEnabled="{Binding #SendToCustomLocationsGrid.SelectedItem, Converter={x:Static ObjectConverters.IsNotNull}}"
+                                Command="{Binding SendToRemoveCustomLocations}">
+                            <Image Source="/Assets/Icons/trash-16x16.png"/>
+                        </Button>
+                    </StackPanel>
+
+                  </Grid>
+
+                  <StackPanel Margin="10" Orientation="Vertical" Spacing="10">
+                    <DataGrid
+                        Name="SendToCustomLocationsGrid"
+                        CanUserReorderColumns="True"
+                        CanUserResizeColumns="True"
+                        CanUserSortColumns="True"
+                        GridLinesVisibility="Horizontal"
+                        IsReadOnly="False"
+                        SelectionMode="Extended"
+                        ClipboardCopyMode="IncludeHeader"
+                        Items="{Binding Settings.General.SendToCustomLocations}">
+                        <DataGrid.Columns>
+                            <DataGridTextColumn  Header="Path"
+                                                 Binding="{Binding Path}"
+                                                 IsReadOnly="True"
+                                                 Width="*" />
+                            <DataGridTextColumn Header="Alias name"
+                                                Binding="{Binding Name}"
+                                                IsReadOnly="False"
+                                                Width="200" />
+                        </DataGrid.Columns>
+
+                    </DataGrid>
+                </StackPanel>
+
+              </StackPanel>
+            </Border>
+
           </StackPanel>
         </ScrollViewer>
 
diff --git a/UVtools.WPF/Windows/SettingsWindow.axaml.cs b/UVtools.WPF/Windows/SettingsWindow.axaml.cs
index 99d5221..a2b0057 100644
--- a/UVtools.WPF/Windows/SettingsWindow.axaml.cs
+++ b/UVtools.WPF/Windows/SettingsWindow.axaml.cs
@@ -10,6 +10,7 @@ using Avalonia.Markup.Xaml;
 using Avalonia.Threading;
 using MessageBox.Avalonia.Enums;
 using UVtools.Core.FileFormats;
+using UVtools.Core.Network;
 using UVtools.WPF.Controls;
 using UVtools.WPF.Extensions;
 using Color = UVtools.WPF.Structures.Color;
@@ -20,6 +21,7 @@ namespace UVtools.WPF.Windows
     {
         private double _scrollViewerMaxHeight;
         private int _selectedTabIndex;
+        private DataGrid _sendToCustomLocationsGrid;
 
         public int MaxProcessorCount => Environment.ProcessorCount;
 
@@ -35,7 +37,7 @@ namespace UVtools.WPF.Windows
             {
                 if(!RaiseAndSetIfChanged(ref _selectedTabIndex, value)) return;
 
-                ScrollViewer scrollViewer = this.FindControl<ScrollViewer>($"ScrollViewer{_selectedTabIndex}");
+                var scrollViewer = this.FindControl<ScrollViewer>($"ScrollViewer{_selectedTabIndex}");
                 SizeToContent = SizeToContent.Manual;
                 Height = MaxHeight;
 
@@ -79,6 +81,8 @@ namespace UVtools.WPF.Windows
 
             DataContext = this;
             InitializeComponent();
+
+            _sendToCustomLocationsGrid = this.FindControl<DataGrid>("SendToCustomLocationsGrid");
         }
 
         private void InitializeComponent()
@@ -97,7 +101,7 @@ namespace UVtools.WPF.Windows
             );
 
             SelectedTabIndex = 1;
-            SelectedTabIndex = 0;
+            DispatcherTimer.RunOnce(() => SelectedTabIndex = 0, TimeSpan.FromMilliseconds(1));
         }
 
         protected override void OnClosed(EventArgs e)
@@ -169,6 +173,34 @@ namespace UVtools.WPF.Windows
             
         }
 
+        public async void SendToAddCustomLocation()
+        {
+            var openFolder = new OpenFolderDialog();
+            var result = await openFolder.ShowAsync(this);
+
+            if (string.IsNullOrWhiteSpace(result)) return;
+            var directory = new MappedDevice(result);
+            if (Settings.General.SendToCustomLocations.Contains(directory))
+            {
+                await this.MessageBoxError("The selected location already exists on the list:\n" +
+                                     $"{result}");
+                return;
+            }
+
+            Settings.General.SendToCustomLocations.Add(directory);
+        }
+
+        public async void SendToRemoveCustomLocations()
+        {
+            if (_sendToCustomLocationsGrid.SelectedItems.Count == 0) return;
+
+            if (await this.MessageBoxQuestion(
+                    $"Are you sure you want to remove the {_sendToCustomLocationsGrid.SelectedItems.Count} selected entries?") !=
+                ButtonResult.Yes) return;
+
+            Settings.General.SendToCustomLocations.RemoveRange(_sendToCustomLocationsGrid.SelectedItems.Cast<MappedDevice>());
+        }
+
         public async void SelectColor(string property)
         {
             foreach (var packObject in UserSettings.PackObjects)
diff --git a/UVtools.sln b/UVtools.sln
index 38d63d8..329a646 100644
--- a/UVtools.sln
+++ b/UVtools.sln
@@ -36,7 +36,7 @@ Global
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
 		{E53BAA5D-29A8-4287-B3AA-1AFF5A4BDC6C}.Debug|Any CPU.ActiveCfg = Debug|x86
-		{E53BAA5D-29A8-4287-B3AA-1AFF5A4BDC6C}.Debug|x64.ActiveCfg = Debug|x86
+		{E53BAA5D-29A8-4287-B3AA-1AFF5A4BDC6C}.Debug|x64.ActiveCfg = Debug|x64
 		{E53BAA5D-29A8-4287-B3AA-1AFF5A4BDC6C}.Debug|x86.ActiveCfg = Debug|x86
 		{E53BAA5D-29A8-4287-B3AA-1AFF5A4BDC6C}.Debug|x86.Build.0 = Debug|x86
 		{E53BAA5D-29A8-4287-B3AA-1AFF5A4BDC6C}.Release|Any CPU.ActiveCfg = Release|x86
@@ -44,7 +44,7 @@ Global
 		{E53BAA5D-29A8-4287-B3AA-1AFF5A4BDC6C}.Release|x86.ActiveCfg = Release|x86
 		{E53BAA5D-29A8-4287-B3AA-1AFF5A4BDC6C}.Release|x86.Build.0 = Release|x86
 		{41224896-08E9-4F22-9E56-5F9D46DEC7D2}.Debug|Any CPU.ActiveCfg = Debug|x86
-		{41224896-08E9-4F22-9E56-5F9D46DEC7D2}.Debug|x64.ActiveCfg = Debug|x86
+		{41224896-08E9-4F22-9E56-5F9D46DEC7D2}.Debug|x64.ActiveCfg = Debug|x64
 		{41224896-08E9-4F22-9E56-5F9D46DEC7D2}.Debug|x86.ActiveCfg = Debug|x86
 		{41224896-08E9-4F22-9E56-5F9D46DEC7D2}.Debug|x86.Build.0 = Debug|x86
 		{41224896-08E9-4F22-9E56-5F9D46DEC7D2}.Release|Any CPU.ActiveCfg = Release|x86
@@ -65,8 +65,8 @@ Global
 		{7C9927F8-132E-4A37-B894-440E0FD5AA3D}.Release|x86.Build.0 = Release|Any CPU
 		{B1B40A7B-D30B-4056-AE6F-C4F0519FD8D4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{B1B40A7B-D30B-4056-AE6F-C4F0519FD8D4}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{B1B40A7B-D30B-4056-AE6F-C4F0519FD8D4}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{B1B40A7B-D30B-4056-AE6F-C4F0519FD8D4}.Debug|x64.Build.0 = Debug|Any CPU
+		{B1B40A7B-D30B-4056-AE6F-C4F0519FD8D4}.Debug|x64.ActiveCfg = Debug|x64
+		{B1B40A7B-D30B-4056-AE6F-C4F0519FD8D4}.Debug|x64.Build.0 = Debug|x64
 		{B1B40A7B-D30B-4056-AE6F-C4F0519FD8D4}.Debug|x86.ActiveCfg = Debug|Any CPU
 		{B1B40A7B-D30B-4056-AE6F-C4F0519FD8D4}.Debug|x86.Build.0 = Debug|Any CPU
 		{B1B40A7B-D30B-4056-AE6F-C4F0519FD8D4}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -77,8 +77,8 @@ Global
 		{B1B40A7B-D30B-4056-AE6F-C4F0519FD8D4}.Release|x86.Build.0 = Release|Any CPU
 		{6CCAA18A-8810-42DF-B75B-4160B40B9DD5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{6CCAA18A-8810-42DF-B75B-4160B40B9DD5}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{6CCAA18A-8810-42DF-B75B-4160B40B9DD5}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{6CCAA18A-8810-42DF-B75B-4160B40B9DD5}.Debug|x64.Build.0 = Debug|Any CPU
+		{6CCAA18A-8810-42DF-B75B-4160B40B9DD5}.Debug|x64.ActiveCfg = Debug|x64
+		{6CCAA18A-8810-42DF-B75B-4160B40B9DD5}.Debug|x64.Build.0 = Debug|x64
 		{6CCAA18A-8810-42DF-B75B-4160B40B9DD5}.Debug|x86.ActiveCfg = Debug|Any CPU
 		{6CCAA18A-8810-42DF-B75B-4160B40B9DD5}.Debug|x86.Build.0 = Debug|Any CPU
 		{6CCAA18A-8810-42DF-B75B-4160B40B9DD5}.Release|Any CPU.ActiveCfg = Release|Any CPU