diff --git a/csharp/Platform.Data.Doublets.Sequences.Tests/GarbageCollectionTests.cs b/csharp/Platform.Data.Doublets.Sequences.Tests/GarbageCollectionTests.cs
new file mode 100644
index 0000000..54ed80a
--- /dev/null
+++ b/csharp/Platform.Data.Doublets.Sequences.Tests/GarbageCollectionTests.cs
@@ -0,0 +1,56 @@
+using System.Collections.Generic;
+using Platform.Data.Doublets.Memory.United.Generic;
+using Platform.Data.Doublets.Sequences.Converters;
+using Platform.Memory;
+using TLinkAddress = System.UInt64;
+using Xunit;
+
+namespace Platform.Data.Doublets.Sequences.Tests;
+
+public class GarbageCollectionTests
+{
+    public IResizableDirectMemory LinksMemory;
+    public ILinks<TLinkAddress> LinksStorage;
+    public BalancedVariantConverter<TLinkAddress> BalancedVariantConverter;
+
+    public GarbageCollectionTests()
+    {
+        LinksMemory = new HeapResizableDirectMemory();
+        LinksStorage = new UnitedMemoryLinks<TLinkAddress>(LinksMemory);
+        BalancedVariantConverter = new BalancedVariantConverter<TLinkAddress>(LinksStorage);
+    }
+    
+    [Fact]
+    public void FullPointsSequence()
+    {
+        TLinkAddress link1 = LinksStorage.CreatePoint();
+        TLinkAddress link2 = LinksStorage.CreatePoint();
+        TLinkAddress link3 = LinksStorage.CreatePoint();
+        TLinkAddress sequence =  BalancedVariantConverter.Convert(new List<TLinkAddress>{link1, link2, link3});
+        LinksStorage.ClearGarbage(sequence);
+        Assert.True(LinksStorage.Exists(link1));
+        Assert.True(LinksStorage.Exists(link2));
+        Assert.True(LinksStorage.Exists(link3));
+        Assert.False(LinksStorage.Exists(sequence));
+    }
+    
+    [Fact]
+    public void Test()
+    {
+        TLinkAddress link1 = LinksStorage.CreatePoint();
+        TLinkAddress link2 = LinksStorage.CreatePoint();
+        TLinkAddress link3 = LinksStorage.GetOrCreate(link1, link2);
+        TLinkAddress link4 = LinksStorage.CreatePoint();
+        TLinkAddress link5 = LinksStorage.CreatePoint();
+        TLinkAddress link6 = LinksStorage.GetOrCreate(link4, link5);
+        TLinkAddress sequence =  BalancedVariantConverter.Convert(new List<TLinkAddress>{link3, link6});
+        LinksStorage.ClearGarbage(sequence);
+        Assert.True(LinksStorage.Exists(link1));
+        Assert.True(LinksStorage.Exists(link2));
+        Assert.False(LinksStorage.Exists(link3));
+        Assert.True(LinksStorage.Exists(link4));
+        Assert.True(LinksStorage.Exists(link5));
+        Assert.False(LinksStorage.Exists(link6));
+        Assert.False(LinksStorage.Exists(sequence));
+    }
+}
diff --git a/csharp/Platform.Data.Doublets.Sequences/UInt64LinksExtensions.cs b/csharp/Platform.Data.Doublets.Sequences/LinksExtensions.cs
similarity index 71%
rename from csharp/Platform.Data.Doublets.Sequences/UInt64LinksExtensions.cs
rename to csharp/Platform.Data.Doublets.Sequences/LinksExtensions.cs
index 3c57841..7e17837 100644
--- a/csharp/Platform.Data.Doublets.Sequences/UInt64LinksExtensions.cs
+++ b/csharp/Platform.Data.Doublets.Sequences/LinksExtensions.cs
@@ -1,3 +1,5 @@
+using System;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using Platform.Data.Doublets.Sequences.Unicode;
 
@@ -24,6 +26,9 @@ public static class UInt64LinksExtensions
         /// <para></para>
         /// </param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void UseUnicode(this ILinks<ulong> links) => UnicodeMap.InitNew(links);
+        public static void UseUnicode<TLinkAddress>(this ILinks<TLinkAddress> links) where TLinkAddress : struct, IUnsignedNumber<TLinkAddress>, IComparisonOperators<TLinkAddress, TLinkAddress, bool>
+        {
+            UnicodeMap<TLinkAddress>.InitNew(links);
+        }
     }
 }
diff --git a/csharp/Platform.Data.Doublets.Sequences/Platform.Data.Doublets.Sequences.csproj b/csharp/Platform.Data.Doublets.Sequences/Platform.Data.Doublets.Sequences.csproj
index 28e9400..77d55a1 100644
--- a/csharp/Platform.Data.Doublets.Sequences/Platform.Data.Doublets.Sequences.csproj
+++ b/csharp/Platform.Data.Doublets.Sequences/Platform.Data.Doublets.Sequences.csproj
@@ -30,7 +30,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="All" />
-    <PackageReference Include="Platform.Data.Doublets" Version="0.17.0" />
+    <PackageReference Include="Platform.Data.Doublets" Version="0.17.1" />
     <PackageReference Include="Platform.Data.Sequences" Version="0.2.1" />
   </ItemGroup>
 
diff --git a/csharp/Platform.Data.Doublets.Sequences/Sequences.cs b/csharp/Platform.Data.Doublets.Sequences/Sequences.cs
index 7470305..2eddf3d 100644
--- a/csharp/Platform.Data.Doublets.Sequences/Sequences.cs
+++ b/csharp/Platform.Data.Doublets.Sequences/Sequences.cs
@@ -732,22 +732,6 @@
 //
 //         #endregion
 //
-//         #region Garbage Collection
-//         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-//         private bool IsGarbage(LinkIndex link) => link != Options.SequenceMarkerLink && !Links.Unsync.IsPartialPoint(link) && Links.Count(Constants.Any, link) == 0;
-//         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-//         private void ClearGarbage(LinkIndex link)
-//         {
-//             if (IsGarbage(link))
-//             {
-//                 var contents = new Link<ulong>(Links.GetLink(link));
-//                 Links.Unsync.Delete(link);
-//                 ClearGarbage(contents.Source);
-//                 ClearGarbage(contents.Target);
-//             }
-//         }
-//
-//         #endregion
 //
 //         #region Walkers
 //
diff --git a/csharp/Platform.Data.Doublets.Sequences/Unicode/UnicodeMap.cs b/csharp/Platform.Data.Doublets.Sequences/Unicode/UnicodeMap.cs
index 998b5fb..33a05bb 100644
--- a/csharp/Platform.Data.Doublets.Sequences/Unicode/UnicodeMap.cs
+++ b/csharp/Platform.Data.Doublets.Sequences/Unicode/UnicodeMap.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Globalization;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Text;
 using Platform.Data.Sequences;
@@ -15,7 +16,7 @@ namespace Platform.Data.Doublets.Sequences.Unicode
     /// </para>
     /// <para></para>
     /// </summary>
-    public class UnicodeMap
+    public class UnicodeMap<TLinkAddress> where TLinkAddress : struct, IUnsignedNumber<TLinkAddress>, IComparisonOperators<TLinkAddress, TLinkAddress, bool>
     {
         /// <summary>
         /// <para>
@@ -23,22 +24,22 @@ public class UnicodeMap
         /// </para>
         /// <para></para>
         /// </summary>
-        public static readonly ulong FirstCharLink = 1;
+        public static readonly TLinkAddress FirstCharLink = TLinkAddress.One;
         /// <summary>
         /// <para>
         /// The max value.
         /// </para>
         /// <para></para>
         /// </summary>
-        public static readonly ulong LastCharLink = FirstCharLink + char.MaxValue;
+        public static readonly TLinkAddress LastCharLink = FirstCharLink + TLinkAddress.CreateTruncating(char.MaxValue);
         /// <summary>
         /// <para>
         /// The max value.
         /// </para>
         /// <para></para>
         /// </summary>
-        public static readonly ulong MapSize = 1 + char.MaxValue;
-        private readonly ILinks<ulong> _links;
+        public static readonly TLinkAddress MapSize = TLinkAddress.One + TLinkAddress.CreateTruncating(char.MaxValue);
+        private readonly ILinks<TLinkAddress> _links;
         private bool _initialized;
 
         /// <summary>
@@ -52,7 +53,7 @@ public class UnicodeMap
         /// <para></para>
         /// </param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public UnicodeMap(ILinks<ulong> links) => _links = links;
+        public UnicodeMap(ILinks<TLinkAddress> links) => _links = links;
 
         /// <summary>
         /// <para>
@@ -69,9 +70,9 @@ public class UnicodeMap
         /// <para></para>
         /// </returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UnicodeMap InitNew(ILinks<ulong> links)
+        public static UnicodeMap<TLinkAddress> InitNew(ILinks<TLinkAddress> links)
         {
-            var map = new UnicodeMap(links);
+            var map = new UnicodeMap<TLinkAddress>(links);
             map.Init();
             return map;
         }
@@ -101,7 +102,7 @@ public void Init()
             }
             else
             {
-                for (var i = FirstCharLink + 1; i <= LastCharLink; i++)
+                for (var i = FirstCharLink + TLinkAddress.One; i <= LastCharLink; i++)
                 {
                     // From NIL to It (NIL -> Character) transformation meaning, (or infinite amount of NIL characters before actual Character)
                     var createdLink = _links.CreatePoint();
@@ -130,11 +131,11 @@ public void Init()
         /// <para></para>
         /// </param>
         /// <returns>
-        /// <para>The ulong</para>
+        /// <para>The TLinkAddress</para>
         /// <para></para>
         /// </returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ulong FromCharToLink(char character) => (ulong)character + 1;
+        public static TLinkAddress FromCharToLink(char character) => TLinkAddress.CreateTruncating(character) + TLinkAddress.One; 
 
         /// <summary>
         /// <para>
@@ -151,7 +152,7 @@ public void Init()
         /// <para></para>
         /// </returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static char FromLinkToChar(ulong link) => (char)(link - 1);
+        public static char FromLinkToChar(TLinkAddress link) => (char)(object)(link - TLinkAddress.One);
 
         /// <summary>
         /// <para>
@@ -168,7 +169,7 @@ public void Init()
         /// <para></para>
         /// </returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool IsCharLink(ulong link) => link <= MapSize;
+        public static bool IsCharLink(TLinkAddress link) => link <= MapSize;
 
         /// <summary>
         /// <para>
@@ -185,7 +186,7 @@ public void Init()
         /// <para></para>
         /// </returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static string FromLinksToString(IList<ulong> linksList)
+        public static string FromLinksToString(IList<TLinkAddress> linksList)
         {
             var sb = new StringBuilder();
             for (int i = 0; i < linksList.Count; i++)
@@ -214,7 +215,7 @@ public static string FromLinksToString(IList<ulong> linksList)
         /// <para></para>
         /// </returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static string FromSequenceLinkToString(ulong link, ILinks<ulong> links)
+        public static string FromSequenceLinkToString(TLinkAddress link, ILinks<TLinkAddress> links)
         {
             var sb = new StringBuilder();
             if (links.Exists(link))
@@ -240,11 +241,11 @@ public static string FromSequenceLinkToString(ulong link, ILinks<ulong> links)
         /// <para></para>
         /// </param>
         /// <returns>
-        /// <para>The ulong array</para>
+        /// <para>The TLinkAddress array</para>
         /// <para></para>
         /// </returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ulong[] FromCharsToLinkArray(char[] chars) => FromCharsToLinkArray(chars, chars.Length);
+        public static TLinkAddress[] FromCharsToLinkArray(char[] chars) => FromCharsToLinkArray(chars, chars.Length);
 
         /// <summary>
         /// <para>
@@ -265,10 +266,10 @@ public static string FromSequenceLinkToString(ulong link, ILinks<ulong> links)
         /// <para></para>
         /// </returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ulong[] FromCharsToLinkArray(char[] chars, int count)
+        public static TLinkAddress[] FromCharsToLinkArray(char[] chars, int count)
         {
-            // char array to ulong array
-            var linksSequence = new ulong[count];
+            // char array to TLinkAddress array
+            var linksSequence = new TLinkAddress[count];
             for (var i = 0; i < count; i++)
             {
                 linksSequence[i] = FromCharToLink(chars[i]);
@@ -291,10 +292,10 @@ public static ulong[] FromCharsToLinkArray(char[] chars, int count)
         /// <para></para>
         /// </returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ulong[] FromStringToLinkArray(string sequence)
+        public static TLinkAddress[] FromStringToLinkArray(string sequence)
         {
-            // char array to ulong array
-            var linksSequence = new ulong[sequence.Length];
+            // char array to TLinkAddress array
+            var linksSequence = new TLinkAddress[sequence.Length];
             for (var i = 0; i < sequence.Length; i++)
             {
                 linksSequence[i] = FromCharToLink(sequence[i]);
@@ -317,9 +318,9 @@ public static ulong[] FromStringToLinkArray(string sequence)
         /// <para></para>
         /// </returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static List<ulong[]> FromStringToLinkArrayGroups(string sequence)
+        public static List<TLinkAddress[]> FromStringToLinkArrayGroups(string sequence)
         {
-            var result = new List<ulong[]>();
+            var result = new List<TLinkAddress[]>();
             var offset = 0;
             while (offset < sequence.Length)
             {
@@ -332,8 +333,8 @@ public static List<ulong[]> FromStringToLinkArrayGroups(string sequence)
                     relativeLength++;
                     absoluteLength++;
                 }
-                // char array to ulong array
-                var innerSequence = new ulong[relativeLength];
+                // char array to TLinkAddress array
+                var innerSequence = new TLinkAddress[relativeLength];
                 var maxLength = offset + relativeLength;
                 for (var i = offset; i < maxLength; i++)
                 {
@@ -360,9 +361,9 @@ public static List<ulong[]> FromStringToLinkArrayGroups(string sequence)
         /// <para></para>
         /// </returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static List<ulong[]> FromLinkArrayToLinkArrayGroups(ulong[] array)
+        public static List<TLinkAddress[]> FromLinkArrayToLinkArrayGroups(TLinkAddress[] array)
         {
-            var result = new List<ulong[]>();
+            var result = new List<TLinkAddress[]>();
             var offset = 0;
             while (offset < array.Length)
             {
@@ -389,7 +390,7 @@ public static List<ulong[]> FromLinkArrayToLinkArrayGroups(ulong[] array)
                     }
                 }
                 // copy array
-                var innerSequence = new ulong[relativeLength];
+                var innerSequence = new TLinkAddress[relativeLength];
                 var maxLength = offset + relativeLength;
                 for (var i = offset; i < maxLength; i++)
                 {