diff --git a/DiscImageChef.Helpers.csproj b/DiscImageChef.Helpers.csproj
index 07d0ea1ff..5bf150a71 100644
--- a/DiscImageChef.Helpers.csproj
+++ b/DiscImageChef.Helpers.csproj
@@ -12,7 +12,7 @@
     <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
     <TargetFramework>net461</TargetFramework>
     <GenerateAssemblyInfo>true</GenerateAssemblyInfo>
-    <Version>4.5.1.1692</Version>
+    <Version>4.5.99.1693</Version>
     <Company>Claunia.com</Company>
     <Copyright>Copyright © 2011-2018 Natalia Portillo</Copyright>
     <Product>The Disc Image Chef</Product>
@@ -55,14 +55,6 @@
     <Compile Include="ArrayIsEmpty.cs" />
     <Compile Include="BigEndianMarshal.cs" />
     <Compile Include="CompareBytes.cs" />
-    <Compile Include="Extents\ExtentsLong.cs" />
-    <Compile Include="Extents\ExtentsULong.cs" />
-    <Compile Include="Extents\ExtentsInt.cs" />
-    <Compile Include="Extents\ExtentsUInt.cs" />
-    <Compile Include="Extents\ExtentsShort.cs" />
-    <Compile Include="Extents\ExtentsUShort.cs" />
-    <Compile Include="Extents\ExtentsByte.cs" />
-    <Compile Include="Extents\ExtentsSByte.cs" />
     <Compile Include="CountBits.cs" />
     <Compile Include="CHS.cs" />
   </ItemGroup>
@@ -77,9 +69,6 @@
       <Link>LICENSE.LGPL</Link>
     </EmbeddedResource>
   </ItemGroup>
-  <ItemGroup>
-    <Folder Include="Extents\" />
-  </ItemGroup>
   <ItemGroup>
     <PackageReference Include="Unclassified.NetRevisionTask" Version="0.2.2-beta" />
   </ItemGroup>
diff --git a/Extents/ExtentsByte.cs b/Extents/ExtentsByte.cs
deleted file mode 100644
index ba2b3c678..000000000
--- a/Extents/ExtentsByte.cs
+++ /dev/null
@@ -1,248 +0,0 @@
-// /***************************************************************************
-// The Disc Image Chef
-// ----------------------------------------------------------------------------
-//
-// Filename       : ExtentsByte.cs
-// Author(s)      : Natalia Portillo <claunia@claunia.com>
-//
-// Component      : Extent helpers.
-//
-// --[ Description ] ----------------------------------------------------------
-//
-//     Provides extents for byte types.
-//
-// --[ License ] --------------------------------------------------------------
-//
-//     This library is free software; you can redistribute it and/or modify
-//     it under the terms of the GNU Lesser General Public License as
-//     published by the Free Software Foundation; either version 2.1 of the
-//     License, or (at your option) any later version.
-//
-//     This library is distributed in the hope that it will be useful, but
-//     WITHOUT ANY WARRANTY; without even the implied warranty of
-//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-//     Lesser General Public License for more details.
-//
-//     You should have received a copy of the GNU Lesser General Public
-//     License along with this library; if not, see <http://www.gnu.org/licenses/>.
-//
-// ----------------------------------------------------------------------------
-// Copyright © 2011-2018 Natalia Portillo
-// ****************************************************************************/
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace Extents
-{
-    /// <summary>
-    ///     Implements extents for <see cref="byte" />
-    /// </summary>
-    public class ExtentsByte
-    {
-        List<Tuple<byte, byte>> backend;
-
-        /// <summary>
-        ///     Initialize an empty list of extents
-        /// </summary>
-        public ExtentsByte()
-        {
-            backend = new List<Tuple<byte, byte>>();
-        }
-
-        /// <summary>
-        ///     Initializes extents with an specific list
-        /// </summary>
-        /// <param name="list">List of extents as tuples "start, end"</param>
-        public ExtentsByte(IEnumerable<Tuple<byte, byte>> list)
-        {
-            backend = list.OrderBy(t => t.Item1).ToList();
-        }
-
-        /// <summary>
-        ///     Gets a count of how many extents are stored
-        /// </summary>
-        public int Count => backend.Count;
-
-        /// <summary>
-        ///     Adds the specified number to the corresponding extent, or creates a new one
-        /// </summary>
-        /// <param name="item"></param>
-        public void Add(byte item)
-        {
-            Tuple<byte, byte> removeOne = null;
-            Tuple<byte, byte> removeTwo = null;
-            Tuple<byte, byte> itemToAdd = null;
-
-            for(int i = 0; i < backend.Count; i++)
-            {
-                // Already contained in an extent
-                if(item >= backend[i].Item1 && item <= backend[i].Item2) return;
-
-                // Expands existing extent start
-                if(item == backend[i].Item1 - 1)
-                {
-                    removeOne = backend[i];
-
-                    if(i > 0 && item == backend[i - 1].Item2 + 1)
-                    {
-                        removeTwo = backend[i - 1];
-                        itemToAdd = new Tuple<byte, byte>(backend[i - 1].Item1, backend[i].Item2);
-                    }
-                    else itemToAdd = new Tuple<byte, byte>(item, backend[i].Item2);
-
-                    break;
-                }
-
-                // Expands existing extent end
-                if(item != backend[i].Item2 + 1) continue;
-
-                removeOne = backend[i];
-
-                if(i < backend.Count - 1 && item == backend[i + 1].Item1 - 1)
-                {
-                    removeTwo = backend[i + 1];
-                    itemToAdd = new Tuple<byte, byte>(backend[i].Item1, backend[i + 1].Item2);
-                }
-                else itemToAdd = new Tuple<byte, byte>(backend[i].Item1, item);
-
-                break;
-            }
-
-            if(itemToAdd != null)
-            {
-                backend.Remove(removeOne);
-                backend.Remove(removeTwo);
-                backend.Add(itemToAdd);
-            }
-            else backend.Add(new Tuple<byte, byte>(item, item));
-
-            // Sort
-            backend = backend.OrderBy(t => t.Item1).ToList();
-        }
-
-        /// <summary>
-        ///     Adds a new extent
-        /// </summary>
-        /// <param name="start">First element of the extent</param>
-        /// <param name="end">
-        ///     Last element of the extent or if <see cref="run" /> is <c>true</c> how many elements the extent runs
-        ///     for
-        /// </param>
-        /// <param name="run">If set to <c>true</c>, <see cref="end" /> indicates how many elements the extent runs for</param>
-        public void Add(byte start, byte end, bool run = false)
-        {
-            byte realEnd;
-            if(run) realEnd = (byte)(start + end - 1);
-            else realEnd    = end;
-
-            // TODO: Optimize this
-            for(byte t = start; t <= realEnd; t++) Add(t);
-        }
-
-        /// <summary>
-        ///     Checks if the specified item is contained by an extent on this instance
-        /// </summary>
-        /// <param name="item">Item to seach for</param>
-        /// <returns><c>true</c> if any of the extents on this instance contains the item</returns>
-        public bool Contains(byte item)
-        {
-            return backend.Any(extent => item >= extent.Item1 && item <= extent.Item2);
-        }
-
-        /// <summary>
-        ///     Removes all extents from this instance
-        /// </summary>
-        public void Clear()
-        {
-            backend.Clear();
-        }
-
-        /// <summary>
-        ///     Removes an item from the extents in this instance
-        /// </summary>
-        /// <param name="item">Item to remove</param>
-        /// <returns><c>true</c> if the item was contained in a known extent and removed, false otherwise</returns>
-        public bool Remove(byte item)
-        {
-            Tuple<byte, byte> toRemove = null;
-            Tuple<byte, byte> toAddOne = null;
-            Tuple<byte, byte> toAddTwo = null;
-
-            foreach(Tuple<byte, byte> extent in backend)
-            {
-                // Extent is contained and not a border
-                if(item > extent.Item1 && item < extent.Item2)
-                {
-                    toRemove = extent;
-                    toAddOne = new Tuple<byte, byte>(extent.Item1, (byte)(item - 1));
-                    toAddTwo = new Tuple<byte, byte>((byte)(item               + 1), extent.Item2);
-                    break;
-                }
-
-                // Extent is left border, but not only element
-                if(item == extent.Item1 && item != extent.Item2)
-                {
-                    toRemove = extent;
-                    toAddOne = new Tuple<byte, byte>((byte)(item + 1), extent.Item2);
-                    break;
-                }
-
-                // Extent is right border, but not only element
-                if(item != extent.Item1 && item == extent.Item2)
-                {
-                    toRemove = extent;
-                    toAddOne = new Tuple<byte, byte>(extent.Item1, (byte)(item - 1));
-                    break;
-                }
-
-                // Extent is only element
-                if(item != extent.Item1 || item != extent.Item2) continue;
-
-                toRemove = extent;
-                break;
-            }
-
-            // Item not found
-            if(toRemove == null) return false;
-
-            backend.Remove(toRemove);
-            if(toAddOne != null) backend.Add(toAddOne);
-            if(toAddTwo != null) backend.Add(toAddTwo);
-
-            // Sort
-            backend = backend.OrderBy(t => t.Item1).ToList();
-
-            return true;
-        }
-
-        /// <summary>
-        ///     Converts the list of extents to an array of <see cref="Tuple" /> where T1 is first element of the extent and T2 is
-        ///     last element
-        /// </summary>
-        /// <returns>Array of <see cref="Tuple" /></returns>
-        public Tuple<byte, byte>[] ToArray()
-        {
-            return backend.ToArray();
-        }
-
-        /// <summary>
-        ///     Gets the first element of the extent that contains the specified item
-        /// </summary>
-        /// <param name="item">Item</param>
-        /// <param name="start">First element of extent</param>
-        /// <returns><c>true</c> if item was found in an extent, false otherwise</returns>
-        public bool GetStart(byte item, out byte start)
-        {
-            start = 0;
-            foreach(Tuple<byte, byte> extent in backend.Where(extent => item >= extent.Item1 && item <= extent.Item2))
-            {
-                start = extent.Item1;
-                return true;
-            }
-
-            return false;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Extents/ExtentsInt.cs b/Extents/ExtentsInt.cs
deleted file mode 100644
index 39b8dbae6..000000000
--- a/Extents/ExtentsInt.cs
+++ /dev/null
@@ -1,248 +0,0 @@
-// /***************************************************************************
-// The Disc Image Chef
-// ----------------------------------------------------------------------------
-//
-// Filename       : ExtentsInt.cs
-// Author(s)      : Natalia Portillo <claunia@claunia.com>
-//
-// Component      : Extent helpers.
-//
-// --[ Description ] ----------------------------------------------------------
-//
-//     Provides extents for int types.
-//
-// --[ License ] --------------------------------------------------------------
-//
-//     This library is free software; you can redistribute it and/or modify
-//     it under the terms of the GNU Lesser General Public License as
-//     published by the Free Software Foundation; either version 2.1 of the
-//     License, or (at your option) any later version.
-//
-//     This library is distributed in the hope that it will be useful, but
-//     WITHOUT ANY WARRANTY; without even the implied warranty of
-//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-//     Lesser General Public License for more details.
-//
-//     You should have received a copy of the GNU Lesser General Public
-//     License aint with this library; if not, see <http://www.gnu.org/licenses/>.
-//
-// ----------------------------------------------------------------------------
-// Copyright © 2011-2018 Natalia Portillo
-// ****************************************************************************/
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace Extents
-{
-    /// <summary>
-    ///     Implements extents for <see cref="int" />
-    /// </summary>
-    public class ExtentsInt
-    {
-        List<Tuple<int, int>> backend;
-
-        /// <summary>
-        ///     Initialize an empty list of extents
-        /// </summary>
-        public ExtentsInt()
-        {
-            backend = new List<Tuple<int, int>>();
-        }
-
-        /// <summary>
-        ///     Initializes extents with an specific list
-        /// </summary>
-        /// <param name="list">List of extents as tuples "start, end"</param>
-        public ExtentsInt(IEnumerable<Tuple<int, int>> list)
-        {
-            backend = list.OrderBy(t => t.Item1).ToList();
-        }
-
-        /// <summary>
-        ///     Gets a count of how many extents are stored
-        /// </summary>
-        public int Count => backend.Count;
-
-        /// <summary>
-        ///     Adds the specified number to the corresponding extent, or creates a new one
-        /// </summary>
-        /// <param name="item"></param>
-        public void Add(int item)
-        {
-            Tuple<int, int> removeOne = null;
-            Tuple<int, int> removeTwo = null;
-            Tuple<int, int> itemToAdd = null;
-
-            for(int i = 0; i < backend.Count; i++)
-            {
-                // Already contained in an extent
-                if(item >= backend[i].Item1 && item <= backend[i].Item2) return;
-
-                // Expands existing extent start
-                if(item == backend[i].Item1 - 1)
-                {
-                    removeOne = backend[i];
-
-                    if(i > 0 && item == backend[i - 1].Item2 + 1)
-                    {
-                        removeTwo = backend[i - 1];
-                        itemToAdd = new Tuple<int, int>(backend[i - 1].Item1, backend[i].Item2);
-                    }
-                    else itemToAdd = new Tuple<int, int>(item, backend[i].Item2);
-
-                    break;
-                }
-
-                // Expands existing extent end
-                if(item != backend[i].Item2 + 1) continue;
-
-                removeOne = backend[i];
-
-                if(i < backend.Count - 1 && item == backend[i + 1].Item1 - 1)
-                {
-                    removeTwo = backend[i + 1];
-                    itemToAdd = new Tuple<int, int>(backend[i].Item1, backend[i + 1].Item2);
-                }
-                else itemToAdd = new Tuple<int, int>(backend[i].Item1, item);
-
-                break;
-            }
-
-            if(itemToAdd != null)
-            {
-                backend.Remove(removeOne);
-                backend.Remove(removeTwo);
-                backend.Add(itemToAdd);
-            }
-            else backend.Add(new Tuple<int, int>(item, item));
-
-            // Sort
-            backend = backend.OrderBy(t => t.Item1).ToList();
-        }
-
-        /// <summary>
-        ///     Adds a new extent
-        /// </summary>
-        /// <param name="start">First element of the extent</param>
-        /// <param name="end">
-        ///     Last element of the extent or if <see cref="run" /> is <c>true</c> how many elements the extent runs
-        ///     for
-        /// </param>
-        /// <param name="run">If set to <c>true</c>, <see cref="end" /> indicates how many elements the extent runs for</param>
-        public void Add(int start, int end, bool run = false)
-        {
-            int realEnd;
-            if(run) realEnd = start + end - 1;
-            else realEnd    = end;
-
-            // TODO: Optimize this
-            for(int t = start; t <= realEnd; t++) Add(t);
-        }
-
-        /// <summary>
-        ///     Checks if the specified item is contained by an extent on this instance
-        /// </summary>
-        /// <param name="item">Item to seach for</param>
-        /// <returns><c>true</c> if any of the extents on this instance contains the item</returns>
-        public bool Contains(int item)
-        {
-            return backend.Any(extent => item >= extent.Item1 && item <= extent.Item2);
-        }
-
-        /// <summary>
-        ///     Removes all extents from this instance
-        /// </summary>
-        public void Clear()
-        {
-            backend.Clear();
-        }
-
-        /// <summary>
-        ///     Removes an item from the extents in this instance
-        /// </summary>
-        /// <param name="item">Item to remove</param>
-        /// <returns><c>true</c> if the item was contained in a known extent and removed, false otherwise</returns>
-        public bool Remove(int item)
-        {
-            Tuple<int, int> toRemove = null;
-            Tuple<int, int> toAddOne = null;
-            Tuple<int, int> toAddTwo = null;
-
-            foreach(Tuple<int, int> extent in backend)
-            {
-                // Extent is contained and not a border
-                if(item > extent.Item1 && item < extent.Item2)
-                {
-                    toRemove = extent;
-                    toAddOne = new Tuple<int, int>(extent.Item1, item - 1);
-                    toAddTwo = new Tuple<int, int>(item               + 1, extent.Item2);
-                    break;
-                }
-
-                // Extent is left border, but not only element
-                if(item == extent.Item1 && item != extent.Item2)
-                {
-                    toRemove = extent;
-                    toAddOne = new Tuple<int, int>(item + 1, extent.Item2);
-                    break;
-                }
-
-                // Extent is right border, but not only element
-                if(item != extent.Item1 && item == extent.Item2)
-                {
-                    toRemove = extent;
-                    toAddOne = new Tuple<int, int>(extent.Item1, item - 1);
-                    break;
-                }
-
-                // Extent is only element
-                if(item != extent.Item1 || item != extent.Item2) continue;
-
-                toRemove = extent;
-                break;
-            }
-
-            // Item not found
-            if(toRemove == null) return false;
-
-            backend.Remove(toRemove);
-            if(toAddOne != null) backend.Add(toAddOne);
-            if(toAddTwo != null) backend.Add(toAddTwo);
-
-            // Sort
-            backend = backend.OrderBy(t => t.Item1).ToList();
-
-            return true;
-        }
-
-        /// <summary>
-        ///     Converts the list of extents to an array of <see cref="Tuple" /> where T1 is first element of the extent and T2 is
-        ///     last element
-        /// </summary>
-        /// <returns>Array of <see cref="Tuple" /></returns>
-        public Tuple<int, int>[] ToArray()
-        {
-            return backend.ToArray();
-        }
-
-        /// <summary>
-        ///     Gets the first element of the extent that contains the specified item
-        /// </summary>
-        /// <param name="item">Item</param>
-        /// <param name="start">First element of extent</param>
-        /// <returns><c>true</c> if item was found in an extent, false otherwise</returns>
-        public bool GetStart(int item, out int start)
-        {
-            start = 0;
-            foreach(Tuple<int, int> extent in backend.Where(extent => item >= extent.Item1 && item <= extent.Item2))
-            {
-                start = extent.Item1;
-                return true;
-            }
-
-            return false;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Extents/ExtentsLong.cs b/Extents/ExtentsLong.cs
deleted file mode 100644
index 5ccef4389..000000000
--- a/Extents/ExtentsLong.cs
+++ /dev/null
@@ -1,248 +0,0 @@
-// /***************************************************************************
-// The Disc Image Chef
-// ----------------------------------------------------------------------------
-//
-// Filename       : ExtentsLong.cs
-// Author(s)      : Natalia Portillo <claunia@claunia.com>
-//
-// Component      : Extent helpers.
-//
-// --[ Description ] ----------------------------------------------------------
-//
-//     Provides extents for long types.
-//
-// --[ License ] --------------------------------------------------------------
-//
-//     This library is free software; you can redistribute it and/or modify
-//     it under the terms of the GNU Lesser General Public License as
-//     published by the Free Software Foundation; either version 2.1 of the
-//     License, or (at your option) any later version.
-//
-//     This library is distributed in the hope that it will be useful, but
-//     WITHOUT ANY WARRANTY; without even the implied warranty of
-//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-//     Lesser General Public License for more details.
-//
-//     You should have received a copy of the GNU Lesser General Public
-//     License along with this library; if not, see <http://www.gnu.org/licenses/>.
-//
-// ----------------------------------------------------------------------------
-// Copyright © 2011-2018 Natalia Portillo
-// ****************************************************************************/
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace Extents
-{
-    /// <summary>
-    ///     Implements extents for <see cref="long" />
-    /// </summary>
-    public class ExtentsLong
-    {
-        List<Tuple<long, long>> backend;
-
-        /// <summary>
-        ///     Initialize an empty list of extents
-        /// </summary>
-        public ExtentsLong()
-        {
-            backend = new List<Tuple<long, long>>();
-        }
-
-        /// <summary>
-        ///     Initializes extents with an specific list
-        /// </summary>
-        /// <param name="list">List of extents as tuples "start, end"</param>
-        public ExtentsLong(IEnumerable<Tuple<long, long>> list)
-        {
-            backend = list.OrderBy(t => t.Item1).ToList();
-        }
-
-        /// <summary>
-        ///     Gets a count of how many extents are stored
-        /// </summary>
-        public int Count => backend.Count;
-
-        /// <summary>
-        ///     Adds the specified number to the corresponding extent, or creates a new one
-        /// </summary>
-        /// <param name="item"></param>
-        public void Add(long item)
-        {
-            Tuple<long, long> removeOne = null;
-            Tuple<long, long> removeTwo = null;
-            Tuple<long, long> itemToAdd = null;
-
-            for(int i = 0; i < backend.Count; i++)
-            {
-                // Already contained in an extent
-                if(item >= backend[i].Item1 && item <= backend[i].Item2) return;
-
-                // Expands existing extent start
-                if(item == backend[i].Item1 - 1)
-                {
-                    removeOne = backend[i];
-
-                    if(i > 0 && item == backend[i - 1].Item2 + 1)
-                    {
-                        removeTwo = backend[i - 1];
-                        itemToAdd = new Tuple<long, long>(backend[i - 1].Item1, backend[i].Item2);
-                    }
-                    else itemToAdd = new Tuple<long, long>(item, backend[i].Item2);
-
-                    break;
-                }
-
-                // Expands existing extent end
-                if(item != backend[i].Item2 + 1) continue;
-
-                removeOne = backend[i];
-
-                if(i < backend.Count - 1 && item == backend[i + 1].Item1 - 1)
-                {
-                    removeTwo = backend[i + 1];
-                    itemToAdd = new Tuple<long, long>(backend[i].Item1, backend[i + 1].Item2);
-                }
-                else itemToAdd = new Tuple<long, long>(backend[i].Item1, item);
-
-                break;
-            }
-
-            if(itemToAdd != null)
-            {
-                backend.Remove(removeOne);
-                backend.Remove(removeTwo);
-                backend.Add(itemToAdd);
-            }
-            else backend.Add(new Tuple<long, long>(item, item));
-
-            // Sort
-            backend = backend.OrderBy(t => t.Item1).ToList();
-        }
-
-        /// <summary>
-        ///     Adds a new extent
-        /// </summary>
-        /// <param name="start">First element of the extent</param>
-        /// <param name="end">
-        ///     Last element of the extent or if <see cref="run" /> is <c>true</c> how many elements the extent runs
-        ///     for
-        /// </param>
-        /// <param name="run">If set to <c>true</c>, <see cref="end" /> indicates how many elements the extent runs for</param>
-        public void Add(long start, long end, bool run = false)
-        {
-            long realEnd;
-            if(run) realEnd = start + end - 1;
-            else realEnd    = end;
-
-            // TODO: Optimize this
-            for(long t = start; t <= realEnd; t++) Add(t);
-        }
-
-        /// <summary>
-        ///     Checks if the specified item is contained by an extent on this instance
-        /// </summary>
-        /// <param name="item">Item to seach for</param>
-        /// <returns><c>true</c> if any of the extents on this instance contains the item</returns>
-        public bool Contains(long item)
-        {
-            return backend.Any(extent => item >= extent.Item1 && item <= extent.Item2);
-        }
-
-        /// <summary>
-        ///     Removes all extents from this instance
-        /// </summary>
-        public void Clear()
-        {
-            backend.Clear();
-        }
-
-        /// <summary>
-        ///     Removes an item from the extents in this instance
-        /// </summary>
-        /// <param name="item">Item to remove</param>
-        /// <returns><c>true</c> if the item was contained in a known extent and removed, false otherwise</returns>
-        public bool Remove(long item)
-        {
-            Tuple<long, long> toRemove = null;
-            Tuple<long, long> toAddOne = null;
-            Tuple<long, long> toAddTwo = null;
-
-            foreach(Tuple<long, long> extent in backend)
-            {
-                // Extent is contained and not a border
-                if(item > extent.Item1 && item < extent.Item2)
-                {
-                    toRemove = extent;
-                    toAddOne = new Tuple<long, long>(extent.Item1, item - 1);
-                    toAddTwo = new Tuple<long, long>(item               + 1, extent.Item2);
-                    break;
-                }
-
-                // Extent is left border, but not only element
-                if(item == extent.Item1 && item != extent.Item2)
-                {
-                    toRemove = extent;
-                    toAddOne = new Tuple<long, long>(item + 1, extent.Item2);
-                    break;
-                }
-
-                // Extent is right border, but not only element
-                if(item != extent.Item1 && item == extent.Item2)
-                {
-                    toRemove = extent;
-                    toAddOne = new Tuple<long, long>(extent.Item1, item - 1);
-                    break;
-                }
-
-                // Extent is only element
-                if(item != extent.Item1 || item != extent.Item2) continue;
-
-                toRemove = extent;
-                break;
-            }
-
-            // Item not found
-            if(toRemove == null) return false;
-
-            backend.Remove(toRemove);
-            if(toAddOne != null) backend.Add(toAddOne);
-            if(toAddTwo != null) backend.Add(toAddTwo);
-
-            // Sort
-            backend = backend.OrderBy(t => t.Item1).ToList();
-
-            return true;
-        }
-
-        /// <summary>
-        ///     Converts the list of extents to an array of <see cref="Tuple" /> where T1 is first element of the extent and T2 is
-        ///     last element
-        /// </summary>
-        /// <returns>Array of <see cref="Tuple" /></returns>
-        public Tuple<long, long>[] ToArray()
-        {
-            return backend.ToArray();
-        }
-
-        /// <summary>
-        ///     Gets the first element of the extent that contains the specified item
-        /// </summary>
-        /// <param name="item">Item</param>
-        /// <param name="start">First element of extent</param>
-        /// <returns><c>true</c> if item was found in an extent, false otherwise</returns>
-        public bool GetStart(long item, out long start)
-        {
-            start = 0;
-            foreach(Tuple<long, long> extent in backend.Where(extent => item >= extent.Item1 && item <= extent.Item2))
-            {
-                start = extent.Item1;
-                return true;
-            }
-
-            return false;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Extents/ExtentsSByte.cs b/Extents/ExtentsSByte.cs
deleted file mode 100644
index f77c2848e..000000000
--- a/Extents/ExtentsSByte.cs
+++ /dev/null
@@ -1,248 +0,0 @@
-// /***************************************************************************
-// The Disc Image Chef
-// ----------------------------------------------------------------------------
-//
-// Filename       : ExtentsSByte.cs
-// Author(s)      : Natalia Portillo <claunia@claunia.com>
-//
-// Component      : Extent helpers.
-//
-// --[ Description ] ----------------------------------------------------------
-//
-//     Provides extents for sbyte types.
-//
-// --[ License ] --------------------------------------------------------------
-//
-//     This library is free software; you can redistribute it and/or modify
-//     it under the terms of the GNU Lesser General Public License as
-//     published by the Free Software Foundation; either version 2.1 of the
-//     License, or (at your option) any later version.
-//
-//     This library is distributed in the hope that it will be useful, but
-//     WITHOUT ANY WARRANTY; without even the implied warranty of
-//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-//     Lesser General Public License for more details.
-//
-//     You should have received a copy of the GNU Lesser General Public
-//     License along with this library; if not, see <http://www.gnu.org/licenses/>.
-//
-// ----------------------------------------------------------------------------
-// Copyright © 2011-2018 Natalia Portillo
-// ****************************************************************************/
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace Extents
-{
-    /// <summary>
-    ///     Implements extents for <see cref="sbyte" />
-    /// </summary>
-    public class ExtentsSByte
-    {
-        List<Tuple<sbyte, sbyte>> backend;
-
-        /// <summary>
-        ///     Initialize an empty list of extents
-        /// </summary>
-        public ExtentsSByte()
-        {
-            backend = new List<Tuple<sbyte, sbyte>>();
-        }
-
-        /// <summary>
-        ///     Initializes extents with an specific list
-        /// </summary>
-        /// <param name="list">List of extents as tuples "start, end"</param>
-        public ExtentsSByte(IEnumerable<Tuple<sbyte, sbyte>> list)
-        {
-            backend = list.OrderBy(t => t.Item1).ToList();
-        }
-
-        /// <summary>
-        ///     Gets a count of how many extents are stored
-        /// </summary>
-        public int Count => backend.Count;
-
-        /// <summary>
-        ///     Adds the specified number to the corresponding extent, or creates a new one
-        /// </summary>
-        /// <param name="item"></param>
-        public void Add(sbyte item)
-        {
-            Tuple<sbyte, sbyte> removeOne = null;
-            Tuple<sbyte, sbyte> removeTwo = null;
-            Tuple<sbyte, sbyte> itemToAdd = null;
-
-            for(int i = 0; i < backend.Count; i++)
-            {
-                // Already contained in an extent
-                if(item >= backend[i].Item1 && item <= backend[i].Item2) return;
-
-                // Expands existing extent start
-                if(item == backend[i].Item1 - 1)
-                {
-                    removeOne = backend[i];
-
-                    if(i > 0 && item == backend[i - 1].Item2 + 1)
-                    {
-                        removeTwo = backend[i - 1];
-                        itemToAdd = new Tuple<sbyte, sbyte>(backend[i - 1].Item1, backend[i].Item2);
-                    }
-                    else itemToAdd = new Tuple<sbyte, sbyte>(item, backend[i].Item2);
-
-                    break;
-                }
-
-                // Expands existing extent end
-                if(item != backend[i].Item2 + 1) continue;
-
-                removeOne = backend[i];
-
-                if(i < backend.Count - 1 && item == backend[i + 1].Item1 - 1)
-                {
-                    removeTwo = backend[i + 1];
-                    itemToAdd = new Tuple<sbyte, sbyte>(backend[i].Item1, backend[i + 1].Item2);
-                }
-                else itemToAdd = new Tuple<sbyte, sbyte>(backend[i].Item1, item);
-
-                break;
-            }
-
-            if(itemToAdd != null)
-            {
-                backend.Remove(removeOne);
-                backend.Remove(removeTwo);
-                backend.Add(itemToAdd);
-            }
-            else backend.Add(new Tuple<sbyte, sbyte>(item, item));
-
-            // Sort
-            backend = backend.OrderBy(t => t.Item1).ToList();
-        }
-
-        /// <summary>
-        ///     Adds a new extent
-        /// </summary>
-        /// <param name="start">First element of the extent</param>
-        /// <param name="end">
-        ///     Last element of the extent or if <see cref="run" /> is <c>true</c> how many elements the extent runs
-        ///     for
-        /// </param>
-        /// <param name="run">If set to <c>true</c>, <see cref="end" /> indicates how many elements the extent runs for</param>
-        public void Add(sbyte start, sbyte end, bool run = false)
-        {
-            sbyte realEnd;
-            if(run) realEnd = (sbyte)(start + end - 1);
-            else realEnd    = end;
-
-            // TODO: Optimize this
-            for(sbyte t = start; t <= realEnd; t++) Add(t);
-        }
-
-        /// <summary>
-        ///     Checks if the specified item is contained by an extent on this instance
-        /// </summary>
-        /// <param name="item">Item to seach for</param>
-        /// <returns><c>true</c> if any of the extents on this instance contains the item</returns>
-        public bool Contains(sbyte item)
-        {
-            return backend.Any(extent => item >= extent.Item1 && item <= extent.Item2);
-        }
-
-        /// <summary>
-        ///     Removes all extents from this instance
-        /// </summary>
-        public void Clear()
-        {
-            backend.Clear();
-        }
-
-        /// <summary>
-        ///     Removes an item from the extents in this instance
-        /// </summary>
-        /// <param name="item">Item to remove</param>
-        /// <returns><c>true</c> if the item was contained in a known extent and removed, false otherwise</returns>
-        public bool Remove(sbyte item)
-        {
-            Tuple<sbyte, sbyte> toRemove = null;
-            Tuple<sbyte, sbyte> toAddOne = null;
-            Tuple<sbyte, sbyte> toAddTwo = null;
-
-            foreach(Tuple<sbyte, sbyte> extent in backend)
-            {
-                // Extent is contained and not a border
-                if(item > extent.Item1 && item < extent.Item2)
-                {
-                    toRemove = extent;
-                    toAddOne = new Tuple<sbyte, sbyte>(extent.Item1, (sbyte)(item - 1));
-                    toAddTwo = new Tuple<sbyte, sbyte>((sbyte)(item               + 1), extent.Item2);
-                    break;
-                }
-
-                // Extent is left border, but not only element
-                if(item == extent.Item1 && item != extent.Item2)
-                {
-                    toRemove = extent;
-                    toAddOne = new Tuple<sbyte, sbyte>((sbyte)(item + 1), extent.Item2);
-                    break;
-                }
-
-                // Extent is right border, but not only element
-                if(item != extent.Item1 && item == extent.Item2)
-                {
-                    toRemove = extent;
-                    toAddOne = new Tuple<sbyte, sbyte>(extent.Item1, (sbyte)(item - 1));
-                    break;
-                }
-
-                // Extent is only element
-                if(item != extent.Item1 || item != extent.Item2) continue;
-
-                toRemove = extent;
-                break;
-            }
-
-            // Item not found
-            if(toRemove == null) return false;
-
-            backend.Remove(toRemove);
-            if(toAddOne != null) backend.Add(toAddOne);
-            if(toAddTwo != null) backend.Add(toAddTwo);
-
-            // Sort
-            backend = backend.OrderBy(t => t.Item1).ToList();
-
-            return true;
-        }
-
-        /// <summary>
-        ///     Converts the list of extents to an array of <see cref="Tuple" /> where T1 is first element of the extent and T2 is
-        ///     last element
-        /// </summary>
-        /// <returns>Array of <see cref="Tuple" /></returns>
-        public Tuple<sbyte, sbyte>[] ToArray()
-        {
-            return backend.ToArray();
-        }
-
-        /// <summary>
-        ///     Gets the first element of the extent that contains the specified item
-        /// </summary>
-        /// <param name="item">Item</param>
-        /// <param name="start">First element of extent</param>
-        /// <returns><c>true</c> if item was found in an extent, false otherwise</returns>
-        public bool GetStart(sbyte item, out sbyte start)
-        {
-            start = 0;
-            foreach(Tuple<sbyte, sbyte> extent in backend.Where(extent => item >= extent.Item1 && item <= extent.Item2))
-            {
-                start = extent.Item1;
-                return true;
-            }
-
-            return false;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Extents/ExtentsShort.cs b/Extents/ExtentsShort.cs
deleted file mode 100644
index ae92ee891..000000000
--- a/Extents/ExtentsShort.cs
+++ /dev/null
@@ -1,248 +0,0 @@
-// /***************************************************************************
-// The Disc Image Chef
-// ----------------------------------------------------------------------------
-//
-// Filename       : ExtentsShort.cs
-// Author(s)      : Natalia Portillo <claunia@claunia.com>
-//
-// Component      : Extent helpers.
-//
-// --[ Description ] ----------------------------------------------------------
-//
-//     Provides extents for short types.
-//
-// --[ License ] --------------------------------------------------------------
-//
-//     This library is free software; you can redistribute it and/or modify
-//     it under the terms of the GNU Lesser General Public License as
-//     published by the Free Software Foundation; either version 2.1 of the
-//     License, or (at your option) any later version.
-//
-//     This library is distributed in the hope that it will be useful, but
-//     WITHOUT ANY WARRANTY; without even the implied warranty of
-//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-//     Lesser General Public License for more details.
-//
-//     You should have received a copy of the GNU Lesser General Public
-//     License ashort with this library; if not, see <http://www.gnu.org/licenses/>.
-//
-// ----------------------------------------------------------------------------
-// Copyright © 2011-2018 Natalia Portillo
-// ****************************************************************************/
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace Extents
-{
-    /// <summary>
-    ///     Implements extents for <see cref="short" />
-    /// </summary>
-    public class ExtentsShort
-    {
-        List<Tuple<short, short>> backend;
-
-        /// <summary>
-        ///     Initialize an empty list of extents
-        /// </summary>
-        public ExtentsShort()
-        {
-            backend = new List<Tuple<short, short>>();
-        }
-
-        /// <summary>
-        ///     Initializes extents with an specific list
-        /// </summary>
-        /// <param name="list">List of extents as tuples "start, end"</param>
-        public ExtentsShort(IEnumerable<Tuple<short, short>> list)
-        {
-            backend = list.OrderBy(t => t.Item1).ToList();
-        }
-
-        /// <summary>
-        ///     Gets a count of how many extents are stored
-        /// </summary>
-        public int Count => backend.Count;
-
-        /// <summary>
-        ///     Adds the specified number to the corresponding extent, or creates a new one
-        /// </summary>
-        /// <param name="item"></param>
-        public void Add(short item)
-        {
-            Tuple<short, short> removeOne = null;
-            Tuple<short, short> removeTwo = null;
-            Tuple<short, short> itemToAdd = null;
-
-            for(int i = 0; i < backend.Count; i++)
-            {
-                // Already contained in an extent
-                if(item >= backend[i].Item1 && item <= backend[i].Item2) return;
-
-                // Expands existing extent start
-                if(item == backend[i].Item1 - 1)
-                {
-                    removeOne = backend[i];
-
-                    if(i > 0 && item == backend[i - 1].Item2 + 1)
-                    {
-                        removeTwo = backend[i - 1];
-                        itemToAdd = new Tuple<short, short>(backend[i - 1].Item1, backend[i].Item2);
-                    }
-                    else itemToAdd = new Tuple<short, short>(item, backend[i].Item2);
-
-                    break;
-                }
-
-                // Expands existing extent end
-                if(item != backend[i].Item2 + 1) continue;
-
-                removeOne = backend[i];
-
-                if(i < backend.Count - 1 && item == backend[i + 1].Item1 - 1)
-                {
-                    removeTwo = backend[i + 1];
-                    itemToAdd = new Tuple<short, short>(backend[i].Item1, backend[i + 1].Item2);
-                }
-                else itemToAdd = new Tuple<short, short>(backend[i].Item1, item);
-
-                break;
-            }
-
-            if(itemToAdd != null)
-            {
-                backend.Remove(removeOne);
-                backend.Remove(removeTwo);
-                backend.Add(itemToAdd);
-            }
-            else backend.Add(new Tuple<short, short>(item, item));
-
-            // Sort
-            backend = backend.OrderBy(t => t.Item1).ToList();
-        }
-
-        /// <summary>
-        ///     Adds a new extent
-        /// </summary>
-        /// <param name="start">First element of the extent</param>
-        /// <param name="end">
-        ///     Last element of the extent or if <see cref="run" /> is <c>true</c> how many elements the extent runs
-        ///     for
-        /// </param>
-        /// <param name="run">If set to <c>true</c>, <see cref="end" /> indicates how many elements the extent runs for</param>
-        public void Add(short start, short end, bool run = false)
-        {
-            short realEnd;
-            if(run) realEnd = (short)(start + end - 1);
-            else realEnd    = end;
-
-            // TODO: Optimize this
-            for(short t = start; t <= realEnd; t++) Add(t);
-        }
-
-        /// <summary>
-        ///     Checks if the specified item is contained by an extent on this instance
-        /// </summary>
-        /// <param name="item">Item to seach for</param>
-        /// <returns><c>true</c> if any of the extents on this instance contains the item</returns>
-        public bool Contains(short item)
-        {
-            return backend.Any(extent => item >= extent.Item1 && item <= extent.Item2);
-        }
-
-        /// <summary>
-        ///     Removes all extents from this instance
-        /// </summary>
-        public void Clear()
-        {
-            backend.Clear();
-        }
-
-        /// <summary>
-        ///     Removes an item from the extents in this instance
-        /// </summary>
-        /// <param name="item">Item to remove</param>
-        /// <returns><c>true</c> if the item was contained in a known extent and removed, false otherwise</returns>
-        public bool Remove(short item)
-        {
-            Tuple<short, short> toRemove = null;
-            Tuple<short, short> toAddOne = null;
-            Tuple<short, short> toAddTwo = null;
-
-            foreach(Tuple<short, short> extent in backend)
-            {
-                // Extent is contained and not a border
-                if(item > extent.Item1 && item < extent.Item2)
-                {
-                    toRemove = extent;
-                    toAddOne = new Tuple<short, short>(extent.Item1, (short)(item - 1));
-                    toAddTwo = new Tuple<short, short>((short)(item               + 1), extent.Item2);
-                    break;
-                }
-
-                // Extent is left border, but not only element
-                if(item == extent.Item1 && item != extent.Item2)
-                {
-                    toRemove = extent;
-                    toAddOne = new Tuple<short, short>((short)(item + 1), extent.Item2);
-                    break;
-                }
-
-                // Extent is right border, but not only element
-                if(item != extent.Item1 && item == extent.Item2)
-                {
-                    toRemove = extent;
-                    toAddOne = new Tuple<short, short>(extent.Item1, (short)(item - 1));
-                    break;
-                }
-
-                // Extent is only element
-                if(item != extent.Item1 || item != extent.Item2) continue;
-
-                toRemove = extent;
-                break;
-            }
-
-            // Item not found
-            if(toRemove == null) return false;
-
-            backend.Remove(toRemove);
-            if(toAddOne != null) backend.Add(toAddOne);
-            if(toAddTwo != null) backend.Add(toAddTwo);
-
-            // Sort
-            backend = backend.OrderBy(t => t.Item1).ToList();
-
-            return true;
-        }
-
-        /// <summary>
-        ///     Converts the list of extents to an array of <see cref="Tuple" /> where T1 is first element of the extent and T2 is
-        ///     last element
-        /// </summary>
-        /// <returns>Array of <see cref="Tuple" /></returns>
-        public Tuple<short, short>[] ToArray()
-        {
-            return backend.ToArray();
-        }
-
-        /// <summary>
-        ///     Gets the first element of the extent that contains the specified item
-        /// </summary>
-        /// <param name="item">Item</param>
-        /// <param name="start">First element of extent</param>
-        /// <returns><c>true</c> if item was found in an extent, false otherwise</returns>
-        public bool GetStart(short item, out short start)
-        {
-            start = 0;
-            foreach(Tuple<short, short> extent in backend.Where(extent => item >= extent.Item1 && item <= extent.Item2))
-            {
-                start = extent.Item1;
-                return true;
-            }
-
-            return false;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Extents/ExtentsUInt.cs b/Extents/ExtentsUInt.cs
deleted file mode 100644
index 6a917d69d..000000000
--- a/Extents/ExtentsUInt.cs
+++ /dev/null
@@ -1,248 +0,0 @@
-// /***************************************************************************
-// The Disc Image Chef
-// ----------------------------------------------------------------------------
-//
-// Filename       : ExtentsUInt.cs
-// Author(s)      : Natalia Portillo <claunia@claunia.com>
-//
-// Component      : Extent helpers.
-//
-// --[ Description ] ----------------------------------------------------------
-//
-//     Provides extents for uint types.
-//
-// --[ License ] --------------------------------------------------------------
-//
-//     This library is free software; you can redistribute it and/or modify
-//     it under the terms of the GNU Lesser General Public License as
-//     published by the Free Software Foundation; either version 2.1 of the
-//     License, or (at your option) any later version.
-//
-//     This library is distributed in the hope that it will be useful, but
-//     WITHOUT ANY WARRANTY; without even the implied warranty of
-//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-//     Lesser General Public License for more details.
-//
-//     You should have received a copy of the GNU Lesser General Public
-//     License auint with this library; if not, see <http://www.gnu.org/licenses/>.
-//
-// ----------------------------------------------------------------------------
-// Copyright © 2011-2018 Natalia Portillo
-// ****************************************************************************/
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace Extents
-{
-    /// <summary>
-    ///     Implements extents for <see cref="uint" />
-    /// </summary>
-    public class ExtentsUInt
-    {
-        List<Tuple<uint, uint>> backend;
-
-        /// <summary>
-        ///     Initialize an empty list of extents
-        /// </summary>
-        public ExtentsUInt()
-        {
-            backend = new List<Tuple<uint, uint>>();
-        }
-
-        /// <summary>
-        ///     Initializes extents with an specific list
-        /// </summary>
-        /// <param name="list">List of extents as tuples "start, end"</param>
-        public ExtentsUInt(IEnumerable<Tuple<uint, uint>> list)
-        {
-            backend = list.OrderBy(t => t.Item1).ToList();
-        }
-
-        /// <summary>
-        ///     Gets a count of how many extents are stored
-        /// </summary>
-        public int Count => backend.Count;
-
-        /// <summary>
-        ///     Adds the specified number to the corresponding extent, or creates a new one
-        /// </summary>
-        /// <param name="item"></param>
-        public void Add(uint item)
-        {
-            Tuple<uint, uint> removeOne = null;
-            Tuple<uint, uint> removeTwo = null;
-            Tuple<uint, uint> itemToAdd = null;
-
-            for(int i = 0; i < backend.Count; i++)
-            {
-                // Already contained in an extent
-                if(item >= backend[i].Item1 && item <= backend[i].Item2) return;
-
-                // Expands existing extent start
-                if(item == backend[i].Item1 - 1)
-                {
-                    removeOne = backend[i];
-
-                    if(i > 0 && item == backend[i - 1].Item2 + 1)
-                    {
-                        removeTwo = backend[i - 1];
-                        itemToAdd = new Tuple<uint, uint>(backend[i - 1].Item1, backend[i].Item2);
-                    }
-                    else itemToAdd = new Tuple<uint, uint>(item, backend[i].Item2);
-
-                    break;
-                }
-
-                // Expands existing extent end
-                if(item != backend[i].Item2 + 1) continue;
-
-                removeOne = backend[i];
-
-                if(i < backend.Count - 1 && item == backend[i + 1].Item1 - 1)
-                {
-                    removeTwo = backend[i + 1];
-                    itemToAdd = new Tuple<uint, uint>(backend[i].Item1, backend[i + 1].Item2);
-                }
-                else itemToAdd = new Tuple<uint, uint>(backend[i].Item1, item);
-
-                break;
-            }
-
-            if(itemToAdd != null)
-            {
-                backend.Remove(removeOne);
-                backend.Remove(removeTwo);
-                backend.Add(itemToAdd);
-            }
-            else backend.Add(new Tuple<uint, uint>(item, item));
-
-            // Sort
-            backend = backend.OrderBy(t => t.Item1).ToList();
-        }
-
-        /// <summary>
-        ///     Adds a new extent
-        /// </summary>
-        /// <param name="start">First element of the extent</param>
-        /// <param name="end">
-        ///     Last element of the extent or if <see cref="run" /> is <c>true</c> how many elements the extent runs
-        ///     for
-        /// </param>
-        /// <param name="run">If set to <c>true</c>, <see cref="end" /> indicates how many elements the extent runs for</param>
-        public void Add(uint start, uint end, bool run = false)
-        {
-            uint realEnd;
-            if(run) realEnd = start + end - 1;
-            else realEnd    = end;
-
-            // TODO: Optimize this
-            for(uint t = start; t <= realEnd; t++) Add(t);
-        }
-
-        /// <summary>
-        ///     Checks if the specified item is contained by an extent on this instance
-        /// </summary>
-        /// <param name="item">Item to seach for</param>
-        /// <returns><c>true</c> if any of the extents on this instance contains the item</returns>
-        public bool Contains(uint item)
-        {
-            return backend.Any(extent => item >= extent.Item1 && item <= extent.Item2);
-        }
-
-        /// <summary>
-        ///     Removes all extents from this instance
-        /// </summary>
-        public void Clear()
-        {
-            backend.Clear();
-        }
-
-        /// <summary>
-        ///     Removes an item from the extents in this instance
-        /// </summary>
-        /// <param name="item">Item to remove</param>
-        /// <returns><c>true</c> if the item was contained in a known extent and removed, false otherwise</returns>
-        public bool Remove(uint item)
-        {
-            Tuple<uint, uint> toRemove = null;
-            Tuple<uint, uint> toAddOne = null;
-            Tuple<uint, uint> toAddTwo = null;
-
-            foreach(Tuple<uint, uint> extent in backend)
-            {
-                // Extent is contained and not a border
-                if(item > extent.Item1 && item < extent.Item2)
-                {
-                    toRemove = extent;
-                    toAddOne = new Tuple<uint, uint>(extent.Item1, item - 1);
-                    toAddTwo = new Tuple<uint, uint>(item               + 1, extent.Item2);
-                    break;
-                }
-
-                // Extent is left border, but not only element
-                if(item == extent.Item1 && item != extent.Item2)
-                {
-                    toRemove = extent;
-                    toAddOne = new Tuple<uint, uint>(item + 1, extent.Item2);
-                    break;
-                }
-
-                // Extent is right border, but not only element
-                if(item != extent.Item1 && item == extent.Item2)
-                {
-                    toRemove = extent;
-                    toAddOne = new Tuple<uint, uint>(extent.Item1, item - 1);
-                    break;
-                }
-
-                // Extent is only element
-                if(item != extent.Item1 || item != extent.Item2) continue;
-
-                toRemove = extent;
-                break;
-            }
-
-            // Item not found
-            if(toRemove == null) return false;
-
-            backend.Remove(toRemove);
-            if(toAddOne != null) backend.Add(toAddOne);
-            if(toAddTwo != null) backend.Add(toAddTwo);
-
-            // Sort
-            backend = backend.OrderBy(t => t.Item1).ToList();
-
-            return true;
-        }
-
-        /// <summary>
-        ///     Converts the list of extents to an array of <see cref="Tuple" /> where T1 is first element of the extent and T2 is
-        ///     last element
-        /// </summary>
-        /// <returns>Array of <see cref="Tuple" /></returns>
-        public Tuple<uint, uint>[] ToArray()
-        {
-            return backend.ToArray();
-        }
-
-        /// <summary>
-        ///     Gets the first element of the extent that contains the specified item
-        /// </summary>
-        /// <param name="item">Item</param>
-        /// <param name="start">First element of extent</param>
-        /// <returns><c>true</c> if item was found in an extent, false otherwise</returns>
-        public bool GetStart(uint item, out uint start)
-        {
-            start = 0;
-            foreach(Tuple<uint, uint> extent in backend.Where(extent => item >= extent.Item1 && item <= extent.Item2))
-            {
-                start = extent.Item1;
-                return true;
-            }
-
-            return false;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Extents/ExtentsULong.cs b/Extents/ExtentsULong.cs
deleted file mode 100644
index 09c76e8c8..000000000
--- a/Extents/ExtentsULong.cs
+++ /dev/null
@@ -1,248 +0,0 @@
-// /***************************************************************************
-// The Disc Image Chef
-// ----------------------------------------------------------------------------
-//
-// Filename       : ExtentsULong.cs
-// Author(s)      : Natalia Portillo <claunia@claunia.com>
-//
-// Component      : Extent helpers.
-//
-// --[ Description ] ----------------------------------------------------------
-//
-//     Provides extents for ulong types.
-//
-// --[ License ] --------------------------------------------------------------
-//
-//     This library is free software; you can redistribute it and/or modify
-//     it under the terms of the GNU Lesser General Public License as
-//     published by the Free Software Foundation; either version 2.1 of the
-//     License, or (at your option) any later version.
-//
-//     This library is distributed in the hope that it will be useful, but
-//     WITHOUT ANY WARRANTY; without even the implied warranty of
-//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-//     Lesser General Public License for more details.
-//
-//     You should have received a copy of the GNU Lesser General Public
-//     License aulong with this library; if not, see <http://www.gnu.org/licenses/>.
-//
-// ----------------------------------------------------------------------------
-// Copyright © 2011-2018 Natalia Portillo
-// ****************************************************************************/
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace Extents
-{
-    /// <summary>
-    ///     Implements extents for <see cref="ulong" />
-    /// </summary>
-    public class ExtentsULong
-    {
-        List<Tuple<ulong, ulong>> backend;
-
-        /// <summary>
-        ///     Initialize an empty list of extents
-        /// </summary>
-        public ExtentsULong()
-        {
-            backend = new List<Tuple<ulong, ulong>>();
-        }
-
-        /// <summary>
-        ///     Initializes extents with an specific list
-        /// </summary>
-        /// <param name="list">List of extents as tuples "start, end"</param>
-        public ExtentsULong(IEnumerable<Tuple<ulong, ulong>> list)
-        {
-            backend = list.OrderBy(t => t.Item1).ToList();
-        }
-
-        /// <summary>
-        ///     Gets a count of how many extents are stored
-        /// </summary>
-        public int Count => backend.Count;
-
-        /// <summary>
-        ///     Adds the specified number to the corresponding extent, or creates a new one
-        /// </summary>
-        /// <param name="item"></param>
-        public void Add(ulong item)
-        {
-            Tuple<ulong, ulong> removeOne = null;
-            Tuple<ulong, ulong> removeTwo = null;
-            Tuple<ulong, ulong> itemToAdd = null;
-
-            for(int i = 0; i < backend.Count; i++)
-            {
-                // Already contained in an extent
-                if(item >= backend[i].Item1 && item <= backend[i].Item2) return;
-
-                // Expands existing extent start
-                if(item == backend[i].Item1 - 1)
-                {
-                    removeOne = backend[i];
-
-                    if(i > 0 && item == backend[i - 1].Item2 + 1)
-                    {
-                        removeTwo = backend[i - 1];
-                        itemToAdd = new Tuple<ulong, ulong>(backend[i - 1].Item1, backend[i].Item2);
-                    }
-                    else itemToAdd = new Tuple<ulong, ulong>(item, backend[i].Item2);
-
-                    break;
-                }
-
-                // Expands existing extent end
-                if(item != backend[i].Item2 + 1) continue;
-
-                removeOne = backend[i];
-
-                if(i < backend.Count - 1 && item == backend[i + 1].Item1 - 1)
-                {
-                    removeTwo = backend[i + 1];
-                    itemToAdd = new Tuple<ulong, ulong>(backend[i].Item1, backend[i + 1].Item2);
-                }
-                else itemToAdd = new Tuple<ulong, ulong>(backend[i].Item1, item);
-
-                break;
-            }
-
-            if(itemToAdd != null)
-            {
-                backend.Remove(removeOne);
-                backend.Remove(removeTwo);
-                backend.Add(itemToAdd);
-            }
-            else backend.Add(new Tuple<ulong, ulong>(item, item));
-
-            // Sort
-            backend = backend.OrderBy(t => t.Item1).ToList();
-        }
-
-        /// <summary>
-        ///     Adds a new extent
-        /// </summary>
-        /// <param name="start">First element of the extent</param>
-        /// <param name="end">
-        ///     Last element of the extent or if <see cref="run" /> is <c>true</c> how many elements the extent runs
-        ///     for
-        /// </param>
-        /// <param name="run">If set to <c>true</c>, <see cref="end" /> indicates how many elements the extent runs for</param>
-        public void Add(ulong start, ulong end, bool run = false)
-        {
-            ulong realEnd;
-            if(run) realEnd = start + end - 1;
-            else realEnd    = end;
-
-            // TODO: Optimize this
-            for(ulong t = start; t <= realEnd; t++) Add(t);
-        }
-
-        /// <summary>
-        ///     Checks if the specified item is contained by an extent on this instance
-        /// </summary>
-        /// <param name="item">Item to seach for</param>
-        /// <returns><c>true</c> if any of the extents on this instance contains the item</returns>
-        public bool Contains(ulong item)
-        {
-            return backend.Any(extent => item >= extent.Item1 && item <= extent.Item2);
-        }
-
-        /// <summary>
-        ///     Removes all extents from this instance
-        /// </summary>
-        public void Clear()
-        {
-            backend.Clear();
-        }
-
-        /// <summary>
-        ///     Removes an item from the extents in this instance
-        /// </summary>
-        /// <param name="item">Item to remove</param>
-        /// <returns><c>true</c> if the item was contained in a known extent and removed, false otherwise</returns>
-        public bool Remove(ulong item)
-        {
-            Tuple<ulong, ulong> toRemove = null;
-            Tuple<ulong, ulong> toAddOne = null;
-            Tuple<ulong, ulong> toAddTwo = null;
-
-            foreach(Tuple<ulong, ulong> extent in backend)
-            {
-                // Extent is contained and not a border
-                if(item > extent.Item1 && item < extent.Item2)
-                {
-                    toRemove = extent;
-                    toAddOne = new Tuple<ulong, ulong>(extent.Item1, item - 1);
-                    toAddTwo = new Tuple<ulong, ulong>(item               + 1, extent.Item2);
-                    break;
-                }
-
-                // Extent is left border, but not only element
-                if(item == extent.Item1 && item != extent.Item2)
-                {
-                    toRemove = extent;
-                    toAddOne = new Tuple<ulong, ulong>(item + 1, extent.Item2);
-                    break;
-                }
-
-                // Extent is right border, but not only element
-                if(item != extent.Item1 && item == extent.Item2)
-                {
-                    toRemove = extent;
-                    toAddOne = new Tuple<ulong, ulong>(extent.Item1, item - 1);
-                    break;
-                }
-
-                // Extent is only element
-                if(item != extent.Item1 || item != extent.Item2) continue;
-
-                toRemove = extent;
-                break;
-            }
-
-            // Item not found
-            if(toRemove == null) return false;
-
-            backend.Remove(toRemove);
-            if(toAddOne != null) backend.Add(toAddOne);
-            if(toAddTwo != null) backend.Add(toAddTwo);
-
-            // Sort
-            backend = backend.OrderBy(t => t.Item1).ToList();
-
-            return true;
-        }
-
-        /// <summary>
-        ///     Converts the list of extents to an array of <see cref="Tuple" /> where T1 is first element of the extent and T2 is
-        ///     last element
-        /// </summary>
-        /// <returns>Array of <see cref="Tuple" /></returns>
-        public Tuple<ulong, ulong>[] ToArray()
-        {
-            return backend.ToArray();
-        }
-
-        /// <summary>
-        ///     Gets the first element of the extent that contains the specified item
-        /// </summary>
-        /// <param name="item">Item</param>
-        /// <param name="start">First element of extent</param>
-        /// <returns><c>true</c> if item was found in an extent, false otherwise</returns>
-        public bool GetStart(ulong item, out ulong start)
-        {
-            start = 0;
-            foreach(Tuple<ulong, ulong> extent in backend.Where(extent => item >= extent.Item1 && item <= extent.Item2))
-            {
-                start = extent.Item1;
-                return true;
-            }
-
-            return false;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Extents/ExtentsUShort.cs b/Extents/ExtentsUShort.cs
deleted file mode 100644
index 6a8689cf0..000000000
--- a/Extents/ExtentsUShort.cs
+++ /dev/null
@@ -1,249 +0,0 @@
-// /***************************************************************************
-// The Disc Image Chef
-// ----------------------------------------------------------------------------
-//
-// Filename       : ExtentsUShort.cs
-// Author(s)      : Natalia Portillo <claunia@claunia.com>
-//
-// Component      : Extent helpers.
-//
-// --[ Description ] ----------------------------------------------------------
-//
-//     Provides extents for ushort types.
-//
-// --[ License ] --------------------------------------------------------------
-//
-//     This library is free software; you can redistribute it and/or modify
-//     it under the terms of the GNU Lesser General Public License as
-//     published by the Free Software Foundation; either version 2.1 of the
-//     License, or (at your option) any later version.
-//
-//     This library is distributed in the hope that it will be useful, but
-//     WITHOUT ANY WARRANTY; without even the implied warranty of
-//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-//     Lesser General Public License for more details.
-//
-//     You should have received a copy of the GNU Lesser General Public
-//     License aushort with this library; if not, see <http://www.gnu.org/licenses/>.
-//
-// ----------------------------------------------------------------------------
-// Copyright © 2011-2018 Natalia Portillo
-// ****************************************************************************/
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace Extents
-{
-    /// <summary>
-    ///     Implements extents for <see cref="ushort" />
-    /// </summary>
-    public class ExtentsUShort
-    {
-        List<Tuple<ushort, ushort>> backend;
-
-        /// <summary>
-        ///     Initialize an empty list of extents
-        /// </summary>
-        public ExtentsUShort()
-        {
-            backend = new List<Tuple<ushort, ushort>>();
-        }
-
-        /// <summary>
-        ///     Initializes extents with an specific list
-        /// </summary>
-        /// <param name="list">List of extents as tuples "start, end"</param>
-        public ExtentsUShort(IEnumerable<Tuple<ushort, ushort>> list)
-        {
-            backend = list.OrderBy(t => t.Item1).ToList();
-        }
-
-        /// <summary>
-        ///     Gets a count of how many extents are stored
-        /// </summary>
-        public int Count => backend.Count;
-
-        /// <summary>
-        ///     Adds the specified number to the corresponding extent, or creates a new one
-        /// </summary>
-        /// <param name="item"></param>
-        public void Add(ushort item)
-        {
-            Tuple<ushort, ushort> removeOne = null;
-            Tuple<ushort, ushort> removeTwo = null;
-            Tuple<ushort, ushort> itemToAdd = null;
-
-            for(int i = 0; i < backend.Count; i++)
-            {
-                // Already contained in an extent
-                if(item >= backend[i].Item1 && item <= backend[i].Item2) return;
-
-                // Expands existing extent start
-                if(item == backend[i].Item1 - 1)
-                {
-                    removeOne = backend[i];
-
-                    if(i > 0 && item == backend[i - 1].Item2 + 1)
-                    {
-                        removeTwo = backend[i - 1];
-                        itemToAdd = new Tuple<ushort, ushort>(backend[i - 1].Item1, backend[i].Item2);
-                    }
-                    else itemToAdd = new Tuple<ushort, ushort>(item, backend[i].Item2);
-
-                    break;
-                }
-
-                // Expands existing extent end
-                if(item != backend[i].Item2 + 1) continue;
-
-                removeOne = backend[i];
-
-                if(i < backend.Count - 1 && item == backend[i + 1].Item1 - 1)
-                {
-                    removeTwo = backend[i + 1];
-                    itemToAdd = new Tuple<ushort, ushort>(backend[i].Item1, backend[i + 1].Item2);
-                }
-                else itemToAdd = new Tuple<ushort, ushort>(backend[i].Item1, item);
-
-                break;
-            }
-
-            if(itemToAdd != null)
-            {
-                backend.Remove(removeOne);
-                backend.Remove(removeTwo);
-                backend.Add(itemToAdd);
-            }
-            else backend.Add(new Tuple<ushort, ushort>(item, item));
-
-            // Sort
-            backend = backend.OrderBy(t => t.Item1).ToList();
-        }
-
-        /// <summary>
-        ///     Adds a new extent
-        /// </summary>
-        /// <param name="start">First element of the extent</param>
-        /// <param name="end">
-        ///     Last element of the extent or if <see cref="run" /> is <c>true</c> how many elements the extent runs
-        ///     for
-        /// </param>
-        /// <param name="run">If set to <c>true</c>, <see cref="end" /> indicates how many elements the extent runs for</param>
-        public void Add(ushort start, ushort end, bool run = false)
-        {
-            ushort realEnd;
-            if(run) realEnd = (ushort)(start + end - 1);
-            else realEnd    = end;
-
-            // TODO: Optimize this
-            for(ushort t = start; t <= realEnd; t++) Add(t);
-        }
-
-        /// <summary>
-        ///     Checks if the specified item is contained by an extent on this instance
-        /// </summary>
-        /// <param name="item">Item to seach for</param>
-        /// <returns><c>true</c> if any of the extents on this instance contains the item</returns>
-        public bool Contains(ushort item)
-        {
-            return backend.Any(extent => item >= extent.Item1 && item <= extent.Item2);
-        }
-
-        /// <summary>
-        ///     Removes all extents from this instance
-        /// </summary>
-        public void Clear()
-        {
-            backend.Clear();
-        }
-
-        /// <summary>
-        ///     Removes an item from the extents in this instance
-        /// </summary>
-        /// <param name="item">Item to remove</param>
-        /// <returns><c>true</c> if the item was contained in a known extent and removed, false otherwise</returns>
-        public bool Remove(ushort item)
-        {
-            Tuple<ushort, ushort> toRemove = null;
-            Tuple<ushort, ushort> toAddOne = null;
-            Tuple<ushort, ushort> toAddTwo = null;
-
-            foreach(Tuple<ushort, ushort> extent in backend)
-            {
-                // Extent is contained and not a border
-                if(item > extent.Item1 && item < extent.Item2)
-                {
-                    toRemove = extent;
-                    toAddOne = new Tuple<ushort, ushort>(extent.Item1, (ushort)(item - 1));
-                    toAddTwo = new Tuple<ushort, ushort>((ushort)(item               + 1), extent.Item2);
-                    break;
-                }
-
-                // Extent is left border, but not only element
-                if(item == extent.Item1 && item != extent.Item2)
-                {
-                    toRemove = extent;
-                    toAddOne = new Tuple<ushort, ushort>((ushort)(item + 1), extent.Item2);
-                    break;
-                }
-
-                // Extent is right border, but not only element
-                if(item != extent.Item1 && item == extent.Item2)
-                {
-                    toRemove = extent;
-                    toAddOne = new Tuple<ushort, ushort>(extent.Item1, (ushort)(item - 1));
-                    break;
-                }
-
-                // Extent is only element
-                if(item != extent.Item1 || item != extent.Item2) continue;
-
-                toRemove = extent;
-                break;
-            }
-
-            // Item not found
-            if(toRemove == null) return false;
-
-            backend.Remove(toRemove);
-            if(toAddOne != null) backend.Add(toAddOne);
-            if(toAddTwo != null) backend.Add(toAddTwo);
-
-            // Sort
-            backend = backend.OrderBy(t => t.Item1).ToList();
-
-            return true;
-        }
-
-        /// <summary>
-        ///     Converts the list of extents to an array of <see cref="Tuple" /> where T1 is first element of the extent and T2 is
-        ///     last element
-        /// </summary>
-        /// <returns>Array of <see cref="Tuple" /></returns>
-        public Tuple<ushort, ushort>[] ToArray()
-        {
-            return backend.ToArray();
-        }
-
-        /// <summary>
-        ///     Gets the first element of the extent that contains the specified item
-        /// </summary>
-        /// <param name="item">Item</param>
-        /// <param name="start">First element of extent</param>
-        /// <returns><c>true</c> if item was found in an extent, false otherwise</returns>
-        public bool GetStart(ushort item, out ushort start)
-        {
-            start = 0;
-            foreach(Tuple<ushort, ushort> extent in
-                backend.Where(extent => item >= extent.Item1 && item <= extent.Item2))
-            {
-                start = extent.Item1;
-                return true;
-            }
-
-            return false;
-        }
-    }
-}
\ No newline at end of file