diff --git a/PersistentOrderedMap.sln b/PersistentOrderedMap.sln
index d13d62d..f313444 100644
--- a/PersistentOrderedMap.sln
+++ b/PersistentOrderedMap.sln
@@ -10,8 +10,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "benchmarks", "benchmarks",
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AgainstImmutableDict", "benchmarks\AgainstImmutableDict\AgainstImmutableDict.csproj", "{13304F19-7ED3-4C40-9A08-46D539667D50}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AgainstLanguageExt", "benchmarks\AgainstLanguageExt\AgainstLanguageExt.csproj", "{6C16526B-5139-4EA3-BF74-E6320F467198}"
-EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MyBenchMarks", "benchmarks\MyBenchMarks\MyBenchMarks.csproj", "{769E1CEA-7E01-405B-80A2-95CBF432A2BA}"
 EndProject
 Global
@@ -22,7 +20,6 @@ Global
 	GlobalSection(NestedProjects) = preSolution
 		{CA49AA3C-0CE6-4735-887F-FB3631D63CEE} = {B0432C7A-80E2-4EA6-8FAB-B8F23A8C39DE}
 		{13304F19-7ED3-4C40-9A08-46D539667D50} = {E38B3FCB-0D4D-401D-A2FC-EDF41B755E53}
-		{6C16526B-5139-4EA3-BF74-E6320F467198} = {E38B3FCB-0D4D-401D-A2FC-EDF41B755E53}
 		{769E1CEA-7E01-405B-80A2-95CBF432A2BA} = {E38B3FCB-0D4D-401D-A2FC-EDF41B755E53}
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
@@ -38,10 +35,6 @@ Global
 		{13304F19-7ED3-4C40-9A08-46D539667D50}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{13304F19-7ED3-4C40-9A08-46D539667D50}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{13304F19-7ED3-4C40-9A08-46D539667D50}.Release|Any CPU.Build.0 = Release|Any CPU
-		{6C16526B-5139-4EA3-BF74-E6320F467198}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{6C16526B-5139-4EA3-BF74-E6320F467198}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{6C16526B-5139-4EA3-BF74-E6320F467198}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{6C16526B-5139-4EA3-BF74-E6320F467198}.Release|Any CPU.Build.0 = Release|Any CPU
 		{769E1CEA-7E01-405B-80A2-95CBF432A2BA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{769E1CEA-7E01-405B-80A2-95CBF432A2BA}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{769E1CEA-7E01-405B-80A2-95CBF432A2BA}.Release|Any CPU.ActiveCfg = Release|Any CPU
diff --git a/PersistentOrderedMap/BTreeFunctions.cs b/PersistentOrderedMap/BTreeFunctions.cs
index 34c2222..0d7a7af 100644
--- a/PersistentOrderedMap/BTreeFunctions.cs
+++ b/PersistentOrderedMap/BTreeFunctions.cs
@@ -11,20 +11,20 @@ namespace PersistentOrderedMap
 
         /// <summary>TryGetValue tries to get the value at mapping key. If it finds the key it sets th
         /// out var to value and returns true. </summary>
-        public static bool TryGetValue<K, V, TStrategy>(Node<K> root, K key, TStrategy strategy, out V value)
-            where TStrategy : IKeyStrategy<K>
+        public static bool TryGetValue<TK, TV, TStrategy>(Node<TK> root, TK key, TStrategy strategy, out TV value)
+            where TStrategy : IKeyStrategy<TK>
         {
             // We always get a strategy to avoid branching already here
             long keyPrefix = strategy.UsesPrefixes ? strategy.GetPrefix(key) : 0;
 
-            Node<K> current = root;
+            Node<TK> current = root;
             while (true)
             {
                 if (current.IsLeaf)
                 {
-                    var leaf = current.AsLeaf<V>();
+                    var leaf = current.AsLeaf<TV>();
                     int index = FindIndex(leaf, key, keyPrefix, strategy);
-                    if (index < leaf.Header.Count && strategy.Compare(leaf.Keys[index], key) == 0)
+                    if (index < leaf.Header.Count && strategy.Compare(leaf.Keys![index], key) == 0)
                     {
                         value = leaf.Values[index];
                         return true;
@@ -41,8 +41,8 @@ namespace PersistentOrderedMap
             }
         }
 
-        public static Node<K> Set<K, V, TStrategy>(Node<K> root, K key, V value, TStrategy strategy, OwnerId owner, out bool countChanged)
-            where TStrategy : IKeyStrategy<K>
+        public static Node<TK> Set<TK, TV, TStrategy>(Node<TK> root, TK key, TV value, TStrategy strategy, OwnerId owner, out bool countChanged)
+            where TStrategy : IKeyStrategy<TK>
         {
             root = root.EnsureEditable(owner);
 
@@ -52,8 +52,8 @@ namespace PersistentOrderedMap
             if (newNode != null)
             {
                 var newRoot = strategy.UsesPrefixes 
-                    ? new PrefixInternalNode<K>(owner) 
-                    : new InternalNode<K>(owner);
+                    ? new PrefixInternalNode<TK>(owner) 
+                    : new InternalNode<TK>(owner);
                 
                 newRoot.Keys[0] = sep;
                 newRoot.Children[0] = root;
@@ -71,27 +71,27 @@ namespace PersistentOrderedMap
             return root;
         }
 
-        private static (Node<K>? newNode, K separator ) InsertRecursive<K, V>(Node<K> node, K key, V value, IKeyStrategy<K> strategy, OwnerId owner, out bool added)
+        private static (Node<TK>? newNode, TK separator ) InsertRecursive<TK, TV>(Node<TK> node, TK key, TV value, IKeyStrategy<TK> strategy, OwnerId owner, out bool added)
         {
             long keyPrefix = strategy.UsesPrefixes ? strategy.GetPrefix(key) : 0;
 
             if (node.IsLeaf)
             {
-                var leaf = node.AsLeaf<V>();
+                var leaf = node.AsLeaf<TV>();
                 int index = FindIndex(leaf, key, keyPrefix, strategy);
 
-                if (index < leaf.Header.Count && strategy.Compare(leaf.Keys[index], key) == 0)
+                if (index < leaf.Header.Count && strategy.Compare(leaf.Keys![index], key) == 0)
                 {
                     leaf.Values[index] = value;
                     added = false;
-                    return (null, default);
+                    return (null, default)!;
                 }
 
                 added = true;
-                if (leaf.Header.Count < LeafNode<K, V>.Capacity)
+                if (leaf.Header.Count < LeafNode<TK, TV>.Capacity)
                 {
                     InsertIntoLeaf(leaf, index, key, value, strategy);
-                    return (null, default);
+                    return (null, default)!;
                 }
                 else
                 {
@@ -110,26 +110,25 @@ namespace PersistentOrderedMap
 
                 if (newNode != null)
                 {
-                    if (internalNode.Header.Count < InternalNode<K>.Capacity - 1)
+                    if (internalNode.Header.Count < InternalNode<TK>.Capacity - 1)
                     {
                         InsertIntoInternal(internalNode, index, sep, newNode, strategy);
-                        return (null, default);
-                    }
-                    else
-                    {
-                        return SplitInternal(internalNode, index, sep, newNode, strategy, owner);
+                        return (null, default)!;
                     }
+                    
+                    return SplitInternal(internalNode, index, sep, newNode, strategy, owner);
+                    
                 }
-                return (null, default);
+                return (null, default)!;
             }
         }
 
-        public static Node<K> Remove<K, V, TStrategy>(Node<K> root, K key, TStrategy strategy, OwnerId owner, out bool countChanged)
-            where TStrategy : IKeyStrategy<K>
+        public static Node<TK> Remove<TK, TV, TStrategy>(Node<TK> root, TK key, TStrategy strategy, OwnerId owner, out bool countChanged)
+            where TStrategy : IKeyStrategy<TK>
         {
             root = root.EnsureEditable(owner);
 
-            bool rebalanceNeeded = RemoveRecursive<K, V, TStrategy>(root, key, strategy, owner, out countChanged);
+            bool rebalanceNeeded = RemoveRecursive<TK, TV, TStrategy>(root, key, strategy, owner, out countChanged);
 
             if (rebalanceNeeded)
             {
@@ -146,21 +145,21 @@ namespace PersistentOrderedMap
             return root;
         }
 
-        private static bool RemoveRecursive<K, V, TStrategy>(Node<K> node, K key, TStrategy strategy, OwnerId owner, out bool removed)
-            where TStrategy : IKeyStrategy<K>
+        private static bool RemoveRecursive<TK, TV, TStrategy>(Node<TK> node, TK key, TStrategy strategy, OwnerId owner, out bool removed)
+            where TStrategy : IKeyStrategy<TK>
         {
             long keyPrefix = strategy.UsesPrefixes ? strategy.GetPrefix(key) : 0;
 
             if (node.IsLeaf)
             {
-                var leaf = node.AsLeaf<V>();
+                var leaf = node.AsLeaf<TV>();
                 int index = FindIndex(leaf, key, keyPrefix, strategy);
 
-                if (index < leaf.Header.Count && strategy.Compare(leaf.Keys[index], key) == 0)
+                if (index < leaf.Header.Count && strategy.Compare(leaf.Keys![index], key) == 0)
                 {
                     RemoveFromLeaf(leaf, index, strategy);
                     removed = true;
-                    return leaf.Header.Count < LeafNode<K, V>.MergeThreshold;
+                    return leaf.Header.Count < LeafNode<TK, TV>.MergeThreshold;
                 }
 
                 removed = false;
@@ -174,11 +173,11 @@ namespace PersistentOrderedMap
                 var child = internalNode.Children[index]!.EnsureEditable(owner);
                 internalNode.Children[index] = child;
 
-                bool childUnderflow = RemoveRecursive<K, V, TStrategy>(child, key, strategy, owner, out removed);
+                bool childUnderflow = RemoveRecursive<TK, TV, TStrategy>(child, key, strategy, owner, out removed);
 
                 if (removed && childUnderflow)
                 {
-                    return HandleUnderflow<K, V, TStrategy>(internalNode, index, strategy, owner);
+                    return HandleUnderflow<TK, TV, TStrategy>(internalNode, index, strategy, owner);
                 }
                 return false;
             }
@@ -189,16 +188,16 @@ namespace PersistentOrderedMap
         // ---------------------------------------------------------
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static int FindIndex<K,V, TStrategy>(LeafNode<K,V> node, K key, long keyPrefix, TStrategy strategy)
-            where TStrategy : IKeyStrategy<K>
+        internal static int FindIndex<TK,TV, TStrategy>(LeafNode<TK,TV> node, TK key, long keyPrefix, TStrategy strategy)
+            where TStrategy : IKeyStrategy<TK>
         {
-            if (typeof(K) == typeof(int))
+            if (typeof(TK) == typeof(int))
             {
-                Span<K> keys = node.GetKeys();
-                ref K firstKeyRef = ref MemoryMarshal.GetReference(keys);
-                ref int firstIntRef = ref Unsafe.As<K, int>(ref firstKeyRef);
+                Span<TK> keys = node.GetKeys();
+                ref TK firstKeyRef = ref MemoryMarshal.GetReference(keys);
+                ref int firstIntRef = ref Unsafe.As<TK, int>(ref firstKeyRef);
                 ReadOnlySpan<int> intKeys = MemoryMarshal.CreateReadOnlySpan(ref firstIntRef, keys.Length);
-                int intKey = Unsafe.As<K, int>(ref key);
+                int intKey = Unsafe.As<TK, int>(ref key);
                 return IntScanner.FindFirstGreaterOrEqual(intKeys, intKey);
             }
             
@@ -212,17 +211,17 @@ namespace PersistentOrderedMap
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static int FindRoutingIndex<K, TStrategy>(InternalNode<K> node, K key, long keyPrefix, TStrategy strategy)
-            where TStrategy : IKeyStrategy<K>
+        internal static int FindRoutingIndex<TK, TStrategy>(InternalNode<TK> node, TK key, long keyPrefix, TStrategy strategy)
+            where TStrategy : IKeyStrategy<TK>
         {   
 
-            if (typeof(K) == typeof(int))
+            if (typeof(TK) == typeof(int))
             {
-                Span<K> keys = node.GetKeys();
-                ref K firstKeyRef = ref MemoryMarshal.GetReference(keys);
-                ref int firstIntRef = ref Unsafe.As<K, int>(ref firstKeyRef);
+                Span<TK> keys = node.GetKeys();
+                ref TK firstKeyRef = ref MemoryMarshal.GetReference(keys);
+                ref int firstIntRef = ref Unsafe.As<TK, int>(ref firstKeyRef);
                 ReadOnlySpan<int> intKeys = MemoryMarshal.CreateReadOnlySpan(ref firstIntRef, keys.Length);
-                int intKey = Unsafe.As<K, int>(ref key);
+                int intKey = Unsafe.As<TK, int>(ref key);
                 return IntScanner.FindFirstGreater(intKeys, intKey);
             }
             if (!strategy.UsesPrefixes)
@@ -235,8 +234,8 @@ namespace PersistentOrderedMap
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static int RefineSearch<K, TStrategy>(int startIndex, ReadOnlySpan<K> keys, K key, TStrategy strategy)
-            where TStrategy : IKeyStrategy<K>
+        private static int RefineSearch<TK, TStrategy>(int startIndex, ReadOnlySpan<TK> keys, TK key, TStrategy strategy)
+            where TStrategy : IKeyStrategy<TK>
         {
             int i = startIndex;
             while (i < keys.Length && strategy.Compare(keys[i], key) < 0) i++;
@@ -244,8 +243,8 @@ namespace PersistentOrderedMap
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static int RefineRouting<K, TStrategy>(int startIndex, ReadOnlySpan<K> keys, K key, TStrategy strategy)
-            where TStrategy : IKeyStrategy<K>
+        private static int RefineRouting<TK, TStrategy>(int startIndex, ReadOnlySpan<TK> keys, TK key, TStrategy strategy)
+            where TStrategy : IKeyStrategy<TK>
         {
             int i = startIndex;
             while (i < keys.Length && strategy.Compare(keys[i], key) <= 0) i++;
@@ -253,8 +252,8 @@ namespace PersistentOrderedMap
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static int FallbackSearchKeys<K, TStrategy>(ReadOnlySpan<K> keys, K key, TStrategy strategy)
-            where TStrategy : IKeyStrategy<K>
+        private static int FallbackSearchKeys<TK, TStrategy>(ReadOnlySpan<TK> keys, TK key, TStrategy strategy)
+            where TStrategy : IKeyStrategy<TK>
         {
             return strategy.UseBinarySearch 
                 ? BinarySearchKeys(keys, key, strategy) 
@@ -262,8 +261,8 @@ namespace PersistentOrderedMap
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static int FallbackRoutingKeys<K, TStrategy>(ReadOnlySpan<K> keys, K key, TStrategy strategy)
-            where TStrategy : IKeyStrategy<K>
+        private static int FallbackRoutingKeys<TK, TStrategy>(ReadOnlySpan<TK> keys, TK key, TStrategy strategy)
+            where TStrategy : IKeyStrategy<TK>
         {
             return strategy.UseBinarySearch 
                 ? BinaryRoutingKeys(keys, key, strategy) 
@@ -271,8 +270,8 @@ namespace PersistentOrderedMap
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static int LinearSearchKeys<K, TStrategy>(ReadOnlySpan<K> keys, K key, TStrategy strategy)
-            where TStrategy : IKeyStrategy<K>
+        private static int LinearSearchKeys<TK, TStrategy>(ReadOnlySpan<TK> keys, TK key, TStrategy strategy)
+            where TStrategy : IKeyStrategy<TK>
         {
             int i = 0;
             while (i < keys.Length && strategy.Compare(keys[i], key) < 0) i++;
@@ -280,8 +279,8 @@ namespace PersistentOrderedMap
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static int LinearRoutingKeys<K, TStrategy>(ReadOnlySpan<K> keys, K key, TStrategy strategy)
-            where TStrategy : IKeyStrategy<K>
+        private static int LinearRoutingKeys<TK, TStrategy>(ReadOnlySpan<TK> keys, TK key, TStrategy strategy)
+            where TStrategy : IKeyStrategy<TK>
         {
             int i = 0;
             while (i < keys.Length && strategy.Compare(keys[i], key) <= 0) i++;
@@ -290,17 +289,17 @@ namespace PersistentOrderedMap
 
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static int BinarySearchKeys<K, TStrategy>(ReadOnlySpan<K> keys, K key, TStrategy strategy)
-            where TStrategy : IKeyStrategy<K>
+        private static int BinarySearchKeys<TK, TStrategy>(ReadOnlySpan<TK> keys, TK key, TStrategy strategy)
+            where TStrategy : IKeyStrategy<TK>
         {
             int low = 0;
             int high = keys.Length - 1;
-            ref K keysRef = ref MemoryMarshal.GetReference(keys);
+            ref TK keysRef = ref MemoryMarshal.GetReference(keys);
 
             while (low <= high)
             {
                 int mid = low + ((high - low) >> 1);
-                K midKey = Unsafe.Add(ref keysRef, mid);
+                TK midKey = Unsafe.Add(ref keysRef, mid);
                 int cmp = strategy.Compare(midKey, key);
         
                 if (cmp == 0) return mid;
@@ -310,17 +309,17 @@ namespace PersistentOrderedMap
             return low;
         }
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static int BinaryRoutingKeys<K, TStrategy>(ReadOnlySpan<K> keys, K key, TStrategy strategy)
-            where TStrategy : IKeyStrategy<K>
+        private static int BinaryRoutingKeys<TK, TStrategy>(ReadOnlySpan<TK> keys, TK key, TStrategy strategy)
+            where TStrategy : IKeyStrategy<TK>
         {
             int low = 0;
             int high = keys.Length - 1;
-            ref K keysRef = ref MemoryMarshal.GetReference(keys);
+            ref TK keysRef = ref MemoryMarshal.GetReference(keys);
             
             while (low <= high)
             {
                 int mid = low + ((high - low) >> 1);
-                K midKey = Unsafe.Add(ref keysRef, mid);
+                TK midKey = Unsafe.Add(ref keysRef, mid);
                 int cmp = strategy.Compare(midKey, key);
                 
                 if (cmp <= 0) low = mid + 1;
@@ -333,19 +332,8 @@ namespace PersistentOrderedMap
         // Insertion Logic
         // ---------------------------------------------------------
 
-        private class SeplitResult<K>
-        {
-            public Node<K> NewNode;
-            public K Separator;
-            public SeplitResult(Node<K> newNode, K separator) 
-            { 
-                NewNode = newNode; 
-                Separator = separator; 
-            }
-        }
-
-        private static void InsertIntoLeaf<K, V, TStrategy>(LeafNode<K, V> leaf, int index, K key, V value, TStrategy strategy)
-            where TStrategy : IKeyStrategy<K>
+        private static void InsertIntoLeaf<TK, TV, TStrategy>(LeafNode<TK, TV> leaf, int index, TK key, TV value, TStrategy strategy)
+            where TStrategy : IKeyStrategy<TK>
         {
             int count = leaf.Header.Count;
             if (index < count)
@@ -360,7 +348,7 @@ namespace PersistentOrderedMap
                 }
             }
 
-            leaf.Keys[index] = key;
+            leaf.Keys![index] = key;
             leaf.Values[index] = value;
 
             if (strategy.UsesPrefixes)
@@ -371,10 +359,10 @@ namespace PersistentOrderedMap
             leaf.SetCount(count + 1);
         }
 
-        private static  (Node<K>, K) SplitLeaf<K, V, TStrategy>(LeafNode<K, V> left, int insertIndex, K key, V value, TStrategy strategy, OwnerId owner)
-            where TStrategy : IKeyStrategy<K>
+        private static  (Node<TK>, TK) SplitLeaf<TK, TV, TStrategy>(LeafNode<TK, TV> left, int insertIndex, TK key, TV value, TStrategy strategy, OwnerId owner)
+            where TStrategy : IKeyStrategy<TK>
         {
-            var right = new LeafNode<K, V>(owner, strategy.UsesPrefixes);
+            var right = new LeafNode<TK, TV>(owner, strategy.UsesPrefixes);
             int totalCount = left.Header.Count;
 
             int splitPoint = (insertIndex == totalCount) ? totalCount : (insertIndex == 0 ? 0 : totalCount / 2);
@@ -403,21 +391,21 @@ namespace PersistentOrderedMap
                 InsertIntoLeaf(right, insertIndex - splitPoint, key, value, strategy);
             }
 
-            return (right, right.Keys[0]);
+            return (right, right.Keys![0]);
         }
 
-        private static void InsertIntoInternal<K, TStrategy>(InternalNode<K> node, int index, K separator, Node<K> newChild, TStrategy strategy)
-            where TStrategy : IKeyStrategy<K>
+        private static void InsertIntoInternal<TK, TStrategy>(InternalNode<TK> node, int index, TK separator, Node<TK> newChild, TStrategy strategy)
+            where TStrategy : IKeyStrategy<TK>
         {
             int count = node.Header.Count;
 
             if (index < count)
             {
                 int moveCount = count - index;
-                Span<K> keysSpan = node.Keys;
+                Span<TK> keysSpan = node.Keys;
                 keysSpan.Slice(index, moveCount).CopyTo(keysSpan.Slice(index + 1));
                 
-                Span<Node<K>> childrenSpan = node.Children;
+                Span<Node<TK>> childrenSpan = node.Children!;
                 childrenSpan.Slice(index + 1, moveCount).CopyTo(childrenSpan.Slice(index + 2));
 
                 if (strategy.UsesPrefixes)
@@ -437,26 +425,26 @@ namespace PersistentOrderedMap
             node.SetCount(count + 1);
         }
 
-        private static (Node<K>, K) SplitInternal<K, TStrategy>(InternalNode<K> left, int insertIndex, K separator, Node<K> newChild, TStrategy strategy, OwnerId owner)
-            where TStrategy : IKeyStrategy<K>
+        private static (Node<TK>, TK) SplitInternal<TK, TStrategy>(InternalNode<TK> left, int insertIndex, TK separator, Node<TK> newChild, TStrategy strategy, OwnerId owner)
+            where TStrategy : IKeyStrategy<TK>
         {
             var right = strategy.UsesPrefixes 
-                ? new PrefixInternalNode<K>(owner) 
-                : new InternalNode<K>(owner);
+                ? new PrefixInternalNode<TK>(owner) 
+                : new InternalNode<TK>(owner);
             
             int count = left.Header.Count;
             int splitPoint = count / 2;
-            K upKey = left.Keys[splitPoint];
+            TK upKey = left.Keys[splitPoint];
             int moveCount = count - splitPoint - 1; 
 
             if (moveCount > 0)
             {
-                Span<K> leftKeys = left.Keys;
-                Span<K> rightKeys = right.Keys;
+                Span<TK> leftKeys = left.Keys;
+                Span<TK> rightKeys = right.Keys;
                 leftKeys.Slice(splitPoint + 1, moveCount).CopyTo(rightKeys); 
 
-                Span<Node<K>> leftChildren = left.Children;
-                Span<Node<K>> rightChildren = right.Children;
+                Span<Node<TK>> leftChildren = left.Children!;
+                Span<Node<TK>> rightChildren = right.Children!;
                 leftChildren.Slice(splitPoint + 1, moveCount + 1).CopyTo(rightChildren);
 
                 if (strategy.UsesPrefixes)
@@ -484,8 +472,8 @@ namespace PersistentOrderedMap
         // Removal Logic
         // ---------------------------------------------------------
 
-        private static void RemoveFromLeaf<K, V, TStrategy>(LeafNode<K, V> leaf, int index, TStrategy strategy)
-            where TStrategy : IKeyStrategy<K>
+        private static void RemoveFromLeaf<TK, TV, TStrategy>(LeafNode<TK, TV> leaf, int index, TStrategy strategy)
+            where TStrategy : IKeyStrategy<TK>
         {
             int count = leaf.Header.Count;
             int moveCount = count - index - 1;
@@ -504,8 +492,8 @@ namespace PersistentOrderedMap
             leaf.SetCount(count - 1);
         }
 
-        private static bool HandleUnderflow<K, V, TStrategy>(InternalNode<K> parent, int childIndex, TStrategy strategy, OwnerId owner)
-            where TStrategy : IKeyStrategy<K>
+        private static bool HandleUnderflow<TK, TV, TStrategy>(InternalNode<TK> parent, int childIndex, TStrategy strategy, OwnerId owner)
+            where TStrategy : IKeyStrategy<TK>
         {
             if (childIndex < parent.Header.Count)
             {
@@ -515,13 +503,13 @@ namespace PersistentOrderedMap
 
                 if (CanBorrow(rightSibling))
                 {
-                    RotateLeft<K, V, TStrategy>(parent, childIndex, leftChild, rightSibling, strategy);
+                    RotateLeft<TK, TV, TStrategy>(parent, childIndex, leftChild, rightSibling, strategy);
                     return false;
                 }
                 else
                 {
-                    Merge<K, V, TStrategy>(parent, childIndex, leftChild, rightSibling, strategy);
-                    return parent.Header.Count < LeafNode<K, V>.MergeThreshold;
+                    Merge<TK, TV, TStrategy>(parent, childIndex, leftChild, rightSibling, strategy);
+                    return parent.Header.Count < LeafNode<TK, TV>.MergeThreshold;
                 }
             }
             else if (childIndex > 0)
@@ -532,31 +520,31 @@ namespace PersistentOrderedMap
 
                 if (CanBorrow(leftSibling))
                 {
-                    RotateRight<K, V, TStrategy>(parent, childIndex - 1, leftSibling, rightChild, strategy);
+                    RotateRight<TK, TV, TStrategy>(parent, childIndex - 1, leftSibling, rightChild, strategy);
                     return false;
                 }
                 else
                 {
-                    Merge<K, V, TStrategy>(parent, childIndex - 1, leftSibling, rightChild, strategy);
-                    return parent.Header.Count < LeafNode<K, V>.MergeThreshold;
+                    Merge<TK, TV, TStrategy>(parent, childIndex - 1, leftSibling, rightChild, strategy);
+                    return parent.Header.Count < LeafNode<TK, TV>.MergeThreshold;
                 }
             }
 
             return true;
         }
 
-        private static bool CanBorrow<K>(Node<K> node)
+        private static bool CanBorrow<TK>(Node<TK> node)
         {
             return node.Header.Count > 8 + 1;
         }
 
-        private static void Merge<K, V, TStrategy>(InternalNode<K> parent, int separatorIndex, Node<K> left, Node<K> right, TStrategy strategy)
-            where TStrategy : IKeyStrategy<K>
+        private static void Merge<TK, TV, TStrategy>(InternalNode<TK> parent, int separatorIndex, Node<TK> left, Node<TK> right, TStrategy strategy)
+            where TStrategy : IKeyStrategy<TK>
         {
             if (left.IsLeaf)
             {
-                var leftLeaf = left.AsLeaf<V>();
-                var rightLeaf = right.AsLeaf<V>();
+                var leftLeaf = left.AsLeaf<TV>();
+                var rightLeaf = right.AsLeaf<TV>();
 
                 int lCount = leftLeaf.Header.Count;
                 int rCount = rightLeaf.Header.Count;
@@ -576,7 +564,7 @@ namespace PersistentOrderedMap
                 var leftInternal = left.AsInternal();
                 var rightInternal = right.AsInternal();
 
-                K separator = parent.Keys[separatorIndex];
+                TK separator = parent.Keys[separatorIndex];
 
                 int lCount = leftInternal.Header.Count;
                 leftInternal.Keys[lCount] = separator;
@@ -587,8 +575,8 @@ namespace PersistentOrderedMap
                 }
 
                 int rCount = rightInternal.Header.Count;
-                Span<K> rightKeys = rightInternal.Keys;
-                Span<K> leftKeys = leftInternal.Keys;
+                Span<TK> rightKeys = rightInternal.Keys;
+                Span<TK> leftKeys = leftInternal.Keys;
                 rightKeys.Slice(0, rCount).CopyTo(leftKeys.Slice(lCount + 1));
                 
                 if (strategy.UsesPrefixes)
@@ -596,8 +584,8 @@ namespace PersistentOrderedMap
                     rightInternal.AllPrefixes.Slice(0, rCount).CopyTo(leftInternal.AllPrefixes.Slice(lCount + 1));
                 }
 
-                Span<Node<K>> rightChildren = rightInternal.Children;
-                Span<Node<K>> leftChildren = leftInternal.Children;
+                Span<Node<TK>> rightChildren = rightInternal.Children!;
+                Span<Node<TK>> leftChildren = leftInternal.Children!;
                 rightChildren.Slice(0, rCount + 1).CopyTo(leftChildren.Slice(lCount + 1));
 
                 leftInternal.SetCount(lCount + 1 + rCount);
@@ -608,7 +596,7 @@ namespace PersistentOrderedMap
 
             if (moveCount > 0)
             {
-                Span<K> parentKeys = parent.Keys;
+                Span<TK> parentKeys = parent.Keys;
                 parentKeys.Slice(separatorIndex + 1, moveCount).CopyTo(parentKeys.Slice(separatorIndex));
 
                 if (strategy.UsesPrefixes)
@@ -616,22 +604,22 @@ namespace PersistentOrderedMap
                     parent.AllPrefixes.Slice(separatorIndex + 1, moveCount).CopyTo(parent.AllPrefixes.Slice(separatorIndex));
                 }
 
-                Span<Node<K>> parentChildren = parent.Children;
+                Span<Node<TK>> parentChildren = parent.Children!;
                 parentChildren.Slice(separatorIndex + 2, moveCount).CopyTo(parentChildren.Slice(separatorIndex + 1));
             }
 
             parent.SetCount(pCount - 1);
         }
 
-        private static void RotateLeft<K, V, TStrategy>(InternalNode<K> parent, int separatorIndex, Node<K> left, Node<K> right, TStrategy strategy)
-            where TStrategy : IKeyStrategy<K>
+        private static void RotateLeft<TK, TV, TStrategy>(InternalNode<TK> parent, int separatorIndex, Node<TK> left, Node<TK> right, TStrategy strategy)
+            where TStrategy : IKeyStrategy<TK>
         {
             if (left.IsLeaf)
             {
-                var leftLeaf = left.AsLeaf<V>();
-                var rightLeaf = right.AsLeaf<V>();
+                var leftLeaf = left.AsLeaf<TV>();
+                var rightLeaf = right.AsLeaf<TV>();
 
-                InsertIntoLeaf(leftLeaf, leftLeaf.Header.Count, rightLeaf.Keys[0], rightLeaf.Values[0], strategy);
+                InsertIntoLeaf(leftLeaf, leftLeaf.Header.Count, rightLeaf.Keys![0], rightLeaf.Values[0], strategy);
                 RemoveFromLeaf(rightLeaf, 0, strategy);
 
                 parent.Keys[separatorIndex] = rightLeaf.Keys[0];
@@ -645,7 +633,7 @@ namespace PersistentOrderedMap
                 var leftInternal = left.AsInternal();
                 var rightInternal = right.AsInternal();
 
-                K sep = parent.Keys[separatorIndex];
+                TK sep = parent.Keys[separatorIndex];
                 InsertIntoInternal(leftInternal, leftInternal.Header.Count, sep, rightInternal.Children[0]!, strategy);
 
                 parent.Keys[separatorIndex] = rightInternal.Keys[0];
@@ -656,12 +644,12 @@ namespace PersistentOrderedMap
 
                 int rCount = rightInternal.Header.Count;
 
-                Span<Node<K>> rightChildren = rightInternal.Children;
+                Span<Node<TK>> rightChildren = rightInternal.Children!;
                 rightChildren.Slice(1, rCount).CopyTo(rightChildren);
 
                 if (rCount > 1)
                 {
-                    Span<K> rightKeys = rightInternal.Keys;
+                    Span<TK> rightKeys = rightInternal.Keys;
                     rightKeys.Slice(1, rCount - 1).CopyTo(rightKeys); 
 
                     if (strategy.UsesPrefixes)
@@ -674,19 +662,19 @@ namespace PersistentOrderedMap
             }
         }
 
-        private static void RotateRight<K, V, TStrategy>(InternalNode<K> parent, int separatorIndex, Node<K> left, Node<K> right, TStrategy strategy)
-            where TStrategy : IKeyStrategy<K>
+        private static void RotateRight<TK, TV, TStrategy>(InternalNode<TK> parent, int separatorIndex, Node<TK> left, Node<TK> right, TStrategy strategy)
+            where TStrategy : IKeyStrategy<TK>
         {
             if (left.IsLeaf)
             {
-                var leftLeaf = left.AsLeaf<V>();
-                var rightLeaf = right.AsLeaf<V>();
+                var leftLeaf = left.AsLeaf<TV>();
+                var rightLeaf = right.AsLeaf<TV>();
                 int last = leftLeaf.Header.Count - 1;
 
-                InsertIntoLeaf(rightLeaf, 0, leftLeaf.Keys[last], leftLeaf.Values[last], strategy);
+                InsertIntoLeaf(rightLeaf, 0, leftLeaf.Keys![last], leftLeaf.Values[last], strategy);
                 RemoveFromLeaf(leftLeaf, last, strategy);
 
-                parent.Keys[separatorIndex] = rightLeaf.Keys[0];
+                parent.Keys[separatorIndex] = rightLeaf.Keys![0];
                 if (strategy.UsesPrefixes)
                 {
                     parent.AllPrefixes[separatorIndex] = strategy.GetPrefix(rightLeaf.Keys[0]);
@@ -698,7 +686,7 @@ namespace PersistentOrderedMap
                 var rightInternal = right.AsInternal();
                 int last = leftInternal.Header.Count - 1;
 
-                K sep = parent.Keys[separatorIndex];
+                TK sep = parent.Keys[separatorIndex];
                 InsertIntoInternal(rightInternal, 0, sep, leftInternal.Children[last + 1]!, strategy);
 
                 parent.Keys[separatorIndex] = leftInternal.Keys[last];
@@ -711,7 +699,7 @@ namespace PersistentOrderedMap
             }
         }
 
-        public static bool TryGetMin<K, V>(Node<K> root, out K key, out V value)
+        public static bool TryGetMin<TK, TV>(Node<TK> root, out TK key, out TV value)
         {
             var current = root;
             while (!current.IsLeaf)
@@ -719,7 +707,7 @@ namespace PersistentOrderedMap
                 current = current.AsInternal().Children[0]!;
             }
 
-            var leaf = current.AsLeaf<V>();
+            var leaf = current.AsLeaf<TV>();
             if (leaf.Header.Count == 0)
             {
                 key = default!;
@@ -727,12 +715,12 @@ namespace PersistentOrderedMap
                 return false;
             }
 
-            key = leaf.Keys[0];
+            key = leaf.Keys![0];
             value = leaf.Values[0];
             return true;
         }
 
-        public static bool TryGetMax<K, V>(Node<K> root, out K key, out V value)
+        public static bool TryGetMax<TK, TV>(Node<TK> root, out TK key, out TV value)
         {
             var current = root;
             while (!current.IsLeaf)
@@ -741,7 +729,7 @@ namespace PersistentOrderedMap
                 current = internalNode.Children[internalNode.Header.Count]!;
             }
 
-            var leaf = current.AsLeaf<V>();
+            var leaf = current.AsLeaf<TV>();
             if (leaf.Header.Count == 0)
             {
                 key = default!;
@@ -750,15 +738,15 @@ namespace PersistentOrderedMap
             }
 
             int last = leaf.Header.Count - 1;
-            key = leaf.Keys[last];
+            key = leaf.Keys![last];
             value = leaf.Values[last];
             return true;
         }
 
-        public static bool TryGetSuccessor<K, V, TStrategy>(Node<K> root, K key, TStrategy strategy, out K nextKey, out V nextValue)
-            where TStrategy : IKeyStrategy<K>
+        public static bool TryGetSuccessor<TK, TV, TStrategy>(Node<TK> root, TK key, TStrategy strategy, out TK nextKey, out TV nextValue)
+            where TStrategy : IKeyStrategy<TK>
         {
-            InternalNode<K>[] path = new InternalNode<K>[32];
+            InternalNode<TK>[] path = new InternalNode<TK>[32];
             int[] indices = new int[32];
             int depth = 0;
             long keyPrefix = strategy.UsesPrefixes ? strategy.GetPrefix(key) : 0;
@@ -774,14 +762,14 @@ namespace PersistentOrderedMap
                 current = internalNode.Children[idx]!;
             }
 
-            var leaf = current.AsLeaf<V>();
+            var leaf = current.AsLeaf<TV>();
             int index = FindIndex(leaf, key, keyPrefix, strategy);
 
-            if (index < leaf.Header.Count && strategy.Compare(leaf.Keys[index], key) == 0) index++;
+            if (index < leaf.Header.Count && strategy.Compare(leaf.Keys![index], key) == 0) index++;
 
             if (index < leaf.Header.Count)
             {
-                nextKey = leaf.Keys[index];
+                nextKey = leaf.Keys![index];
                 nextValue = leaf.Values[index];
                 return true;
             }
@@ -796,8 +784,8 @@ namespace PersistentOrderedMap
                         current = current.AsInternal().Children[0]!;
                     }
 
-                    var targetLeaf = current.AsLeaf<V>();
-                    nextKey = targetLeaf.Keys[0];
+                    var targetLeaf = current.AsLeaf<TV>();
+                    nextKey = targetLeaf.Keys![0];
                     nextValue = targetLeaf.Values[0];
                     return true;
                 }
@@ -808,10 +796,10 @@ namespace PersistentOrderedMap
             return false;
         }
 
-        public static bool TryGetPredecessor<K, V, TStrategy>(Node<K> root, K key, TStrategy strategy, out K prevKey, out V prevValue)
-            where TStrategy : IKeyStrategy<K>
+        public static bool TryGetPredecessor<TK, TV, TStrategy>(Node<TK> root, TK key, TStrategy strategy, out TK prevKey, out TV prevValue)
+            where TStrategy : IKeyStrategy<TK>
         {
-            InternalNode<K>[] path = new InternalNode<K>[32];
+            InternalNode<TK>[] path = new InternalNode<TK>[32];
             int[] indices = new int[32];
             int depth = 0;
             long keyPrefix = strategy.UsesPrefixes ? strategy.GetPrefix(key) : 0;
@@ -827,12 +815,12 @@ namespace PersistentOrderedMap
                 current = internalNode.Children[idx]!;
             }
 
-            var leaf = current.AsLeaf<V>();
+            var leaf = current.AsLeaf<TV>();
             int index = FindIndex(leaf, key, keyPrefix, strategy);
 
             if (index > 0)
             {
-                prevKey = leaf.Keys[index - 1];
+                prevKey = leaf.Keys![index - 1];
                 prevValue = leaf.Values[index - 1];
                 return true;
             }
@@ -848,9 +836,9 @@ namespace PersistentOrderedMap
                         current = internalNode.Children[internalNode.Header.Count]!;
                     }
 
-                    var targetLeaf = current.AsLeaf<V>();
+                    var targetLeaf = current.AsLeaf<TV>();
                     int last = targetLeaf.Header.Count - 1;
-                    prevKey = targetLeaf.Keys[last];
+                    prevKey = targetLeaf.Keys![last];
                     prevValue = targetLeaf.Values[last];
                     return true;
                 }
diff --git a/PersistentOrderedMap/BaseOrderedMap.cs b/PersistentOrderedMap/BaseOrderedMap.cs
index c3838eb..393e2ee 100644
--- a/PersistentOrderedMap/BaseOrderedMap.cs
+++ b/PersistentOrderedMap/BaseOrderedMap.cs
@@ -2,17 +2,17 @@ using System.Collections;
 
 namespace PersistentOrderedMap;
 
-public abstract class BaseOrderedMap<K, V, TStrategy> : IEnumerable<KeyValuePair<K, V>> where TStrategy : IKeyStrategy<K>
+public abstract class BaseOrderedMap<TK, TV, TStrategy> : IEnumerable<KeyValuePair<TK, TV>> where TStrategy : IKeyStrategy<TK>
 {
-    internal Node<K> _root;
-    internal readonly TStrategy _strategy;
+    internal Node<TK> Root;
+    internal readonly TStrategy Strategy;
     
     public int Count { get; protected set; }
 
-    protected BaseOrderedMap(Node<K> root, TStrategy strategy, int count)
+    protected BaseOrderedMap(Node<TK> root, TStrategy strategy, int count)
     {
-        _root = root ?? throw new ArgumentNullException(nameof(root));
-        _strategy = strategy ?? throw new ArgumentNullException(nameof(strategy));
+        Root = root ?? throw new ArgumentNullException(nameof(root));
+        Strategy = strategy ?? throw new ArgumentNullException(nameof(strategy));
         Count = count;
 
     }
@@ -21,14 +21,14 @@ public abstract class BaseOrderedMap<K, V, TStrategy> : IEnumerable<KeyValuePair
     // Read Operations (Shared)
     // ---------------------------------------------------------
 
-    public bool TryGetValue(K key, out V value)
+    public bool TryGetValue(TK key, out TV value)
     {
-        return BTreeFunctions.TryGetValue(_root, key, _strategy, out value);
+        return BTreeFunctions.TryGetValue(Root, key, Strategy, out value);
     }
 
-    public bool ContainsKey(K key)
+    public bool ContainsKey(TK key)
     {
-        return BTreeFunctions.TryGetValue<K,V, TStrategy>(_root, key, _strategy, out _);
+        return BTreeFunctions.TryGetValue<TK,TV, TStrategy>(Root, key, Strategy, out _);
     }
     
     
@@ -37,26 +37,26 @@ public abstract class BaseOrderedMap<K, V, TStrategy> : IEnumerable<KeyValuePair
     // Bootstrap / Factory Helpers
     // ---------------------------------------------------------
         
-    public static PersistentOrderedMap<K, V, TStrategy> Create(TStrategy strategy)
+    public static PersistentOrderedMap<TK, TV, TStrategy> Create(TStrategy strategy)
     {
         // Start with an empty leaf owned by None so the first write triggers CoW.
-        var emptyRoot = new LeafNode<K, V>(OwnerId.None, strategy.UsesPrefixes);
-        return new PersistentOrderedMap<K, V, TStrategy>(emptyRoot, strategy, 0);
+        var emptyRoot = new LeafNode<TK, TV>(OwnerId.None, strategy.UsesPrefixes);
+        return new PersistentOrderedMap<TK, TV, TStrategy>(emptyRoot, strategy, 0);
     }
 
-    public static TransientOrderedMap<K, V, TStrategy> CreateTransient(TStrategy strategy)
+    public static TransientOrderedMap<TK, TV, TStrategy> CreateTransient(TStrategy strategy)
     {
-        var emptyRoot = new LeafNode<K, V>(OwnerId.None, strategy.UsesPrefixes);
-        return new TransientOrderedMap<K, V, TStrategy>(emptyRoot, strategy,0);
+        var emptyRoot = new LeafNode<TK, TV>(OwnerId.None, strategy.UsesPrefixes);
+        return new TransientOrderedMap<TK, TV, TStrategy>(emptyRoot, strategy,0);
     }
     
     
-    public BTreeEnumerator<K, V, TStrategy> GetEnumerator()
+    public BTreeEnumerator<TK, TV, TStrategy> GetEnumerator()
     {
         return AsEnumerable().GetEnumerator();
     }
 
-    IEnumerator<KeyValuePair<K, V>> IEnumerable<KeyValuePair<K, V>>.GetEnumerator()
+    IEnumerator<KeyValuePair<TK, TV>> IEnumerable<KeyValuePair<TK, TV>>.GetEnumerator()
     {
         return GetEnumerator();
     }
@@ -67,19 +67,19 @@ public abstract class BaseOrderedMap<K, V, TStrategy> : IEnumerable<KeyValuePair
     }
     
     // 1. Full Scan
-    public BTreeEnumerable<K, V, TStrategy> AsEnumerable() 
-        => new(_root, _strategy, false, default, false, default);
+    public BTreeEnumerable<TK, TV, TStrategy> AsEnumerable() 
+        => new(Root, Strategy, false, default!, false, default!);
 
 // 2. Exact Range
-    public BTreeEnumerable<K, V, TStrategy> Range(K min, K max) 
-        => new(_root, _strategy, true, min, true, max);
+    public BTreeEnumerable<TK, TV, TStrategy> Range(TK min, TK max) 
+        => new(Root, Strategy, true, min, true, max);
 
 // 3. Start From (Open Ended)
-    public BTreeEnumerable<K, V, TStrategy> From(K min) => new(_root, _strategy, true, min, false, default);
+    public BTreeEnumerable<TK, TV, TStrategy> From(TK min) => new(Root, Strategy, true, min, false, default!);
 
 // 4. Until (Start at beginning)
-    public BTreeEnumerable<K, V, TStrategy> Until(K max) 
-        => new(_root, _strategy, false, default, true, max);
+    public BTreeEnumerable<TK, TV, TStrategy> Until(TK max) 
+        => new(Root, Strategy, false, default!, true, max);
 
 
 
@@ -87,19 +87,19 @@ public abstract class BaseOrderedMap<K, V, TStrategy> : IEnumerable<KeyValuePair
 // Navigation Operations
 // ---------------------------------------------------------
 
-public bool TryGetMin(out K key, out V value) => BTreeFunctions.TryGetMin(_root, out key, out value);
+public bool TryGetMin(out TK key, out TV value) => BTreeFunctions.TryGetMin(Root, out key, out value);
 
-public bool TryGetMax(out K key, out V value) => BTreeFunctions.TryGetMax(_root, out key, out value);
+public bool TryGetMax(out TK key, out TV value) => BTreeFunctions.TryGetMax(Root, out key, out value);
 
-public bool TryGetSuccessor(K key, out K nextKey, out V nextValue) => BTreeFunctions.TryGetSuccessor(_root, key, _strategy, out nextKey, out nextValue);
+public bool TryGetSuccessor(TK key, out TK nextKey, out TV nextValue) => BTreeFunctions.TryGetSuccessor(Root, key, Strategy, out nextKey, out nextValue);
 
-public bool TryGetPredecessor(K key, out K prevKey, out V prevValue) => BTreeFunctions.TryGetPredecessor(_root, key, _strategy, out prevKey, out prevValue);
+public bool TryGetPredecessor(TK key, out TK prevKey, out TV prevValue) => BTreeFunctions.TryGetPredecessor(Root, key, Strategy, out prevKey, out prevValue);
 
 // ---------------------------------------------------------
 // Set Operations (Linear Merge O(N+M))
 // ---------------------------------------------------------
 
-public IEnumerable<KeyValuePair<K, V>> Intersect(BaseOrderedMap<K, V, TStrategy> other)
+public IEnumerable<KeyValuePair<TK, TV>> Intersect(BaseOrderedMap<TK, TV, TStrategy> other)
 {
     using var enum1 = this.GetEnumerator();
     using var enum2 = other.GetEnumerator();
@@ -109,7 +109,7 @@ public IEnumerable<KeyValuePair<K, V>> Intersect(BaseOrderedMap<K, V, TStrategy>
 
     while (has1 && has2)
     {
-        int cmp = _strategy.Compare(enum1.Current.Key, enum2.Current.Key);
+        int cmp = Strategy.Compare(enum1.Current.Key, enum2.Current.Key);
         if (cmp == 0)
         {
             yield return enum1.Current;
@@ -121,7 +121,7 @@ public IEnumerable<KeyValuePair<K, V>> Intersect(BaseOrderedMap<K, V, TStrategy>
     }
 }
 
-public IEnumerable<KeyValuePair<K, V>> Except(BaseOrderedMap<K, V, TStrategy> other)
+public IEnumerable<KeyValuePair<TK, TV>> Except(BaseOrderedMap<TK, TV, TStrategy> other)
 {
     using var enum1 = this.GetEnumerator();
     using var enum2 = other.GetEnumerator();
@@ -131,7 +131,7 @@ public IEnumerable<KeyValuePair<K, V>> Except(BaseOrderedMap<K, V, TStrategy> ot
 
     while (has1 && has2)
     {
-        int cmp = _strategy.Compare(enum1.Current.Key, enum2.Current.Key);
+        int cmp = Strategy.Compare(enum1.Current.Key, enum2.Current.Key);
         if (cmp == 0)
         {
             has1 = enum1.MoveNext();
@@ -155,7 +155,7 @@ public IEnumerable<KeyValuePair<K, V>> Except(BaseOrderedMap<K, V, TStrategy> ot
     }
 }
 
-public IEnumerable<KeyValuePair<K, V>> SymmetricExcept(BaseOrderedMap<K, V, TStrategy> other)
+public IEnumerable<KeyValuePair<TK, TV>> SymmetricExcept(BaseOrderedMap<TK, TV, TStrategy> other)
 {
     using var enum1 = this.GetEnumerator();
     using var enum2 = other.GetEnumerator();
@@ -165,7 +165,7 @@ public IEnumerable<KeyValuePair<K, V>> SymmetricExcept(BaseOrderedMap<K, V, TStr
 
     while (has1 && has2)
     {
-        int cmp = _strategy.Compare(enum1.Current.Key, enum2.Current.Key);
+        int cmp = Strategy.Compare(enum1.Current.Key, enum2.Current.Key);
         if (cmp == 0)
         {
             has1 = enum1.MoveNext();
diff --git a/PersistentOrderedMap/Iterator.cs b/PersistentOrderedMap/Iterator.cs
index d8e776b..ef2073e 100644
--- a/PersistentOrderedMap/Iterator.cs
+++ b/PersistentOrderedMap/Iterator.cs
@@ -5,27 +5,27 @@ namespace PersistentOrderedMap;
 
 
 
-public struct BTreeEnumerable<K, V, TStrategy> : IEnumerable<KeyValuePair<K, V>>
-where TStrategy : IKeyStrategy<K>
+public struct BTreeEnumerable<TK, TV, TStrategy> : IEnumerable<KeyValuePair<TK, TV>>
+where TStrategy : IKeyStrategy<TK>
 {
-    private readonly Node<K> _root;
+    private readonly Node<TK> _root;
     private readonly TStrategy _strategy;
-    private readonly K _min, _max;
+    private readonly TK _min, _max;
     private readonly bool _hasMin, _hasMax;
 
-    public BTreeEnumerable(Node<K> root, TStrategy strategy, bool hasMin, K min, bool hasMax, K max)
+    public BTreeEnumerable(Node<TK> root, TStrategy strategy, bool hasMin, TK min, bool hasMax, TK max)
     {
         _root = root; _strategy = strategy;
         _hasMin = hasMin; _min = min;
         _hasMax = hasMax; _max = max;
     }
 
-    public BTreeEnumerator<K, V, TStrategy> GetEnumerator()
+    public BTreeEnumerator<TK, TV, TStrategy> GetEnumerator()
     {
-        return new BTreeEnumerator<K, V, TStrategy>(_root, _strategy, _hasMin, _min, _hasMax, _max);
+        return new BTreeEnumerator<TK, TV, TStrategy>(_root, _strategy, _hasMin, _min, _hasMax, _max);
     }
 
-    IEnumerator<KeyValuePair<K, V>> IEnumerable<KeyValuePair<K, V>>.GetEnumerator() => GetEnumerator();
+    IEnumerator<KeyValuePair<TK, TV>> IEnumerable<KeyValuePair<TK, TV>>.GetEnumerator() => GetEnumerator();
     IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 }
 
@@ -35,52 +35,52 @@ where TStrategy : IKeyStrategy<K>
 // all int-indexed data structures (or bit partitioned ones).
 // This should be enough for anyone.
 [InlineArray(16)]
-internal struct IterNodeBuffer<K>
+internal struct IterNodeBuffer<TK>
 {
-    private Node<K> _element0;
+    private Node<TK> _element0;
 }
 
 [InlineArray(16)]
-internal struct IterIndexBuffer<K>
+internal struct IterIndexBuffer
 {
     private int _element0;
 }
 
-public struct BTreeEnumerator<K, V, TStrategy> : IEnumerator<KeyValuePair<K, V>>
-        where TStrategy : IKeyStrategy<K>
+public struct BTreeEnumerator<TK, TV, TStrategy> : IEnumerator<KeyValuePair<TK, TV>>
+        where TStrategy : IKeyStrategy<TK>
     {
         private readonly TStrategy _strategy;
-        private readonly Node<K> _root;
+        private readonly Node<TK> _root;
         
         // --- BOUNDS ---
         private readonly bool _hasMax;
-        private readonly K _maxKey;
+        private readonly TK _maxKey;
         private readonly bool _hasMin;
-        private readonly K _minKey;
+        private readonly TK _minKey;
 
         // --- INLINE STACK ---
-        private IterNodeBuffer<K> _nodeStack; 
-        private IterIndexBuffer<K> _indexStack;
+        private IterNodeBuffer<TK> _nodeStack; 
+        private IterIndexBuffer _indexStack;
         private int _depth;
 
         // --- STATE ---
-        private LeafNode<K, V>? _currentLeaf;
+        private LeafNode<TK, TV>? _currentLeaf;
         private int _currentLeafIndex;
-        private KeyValuePair<K, V> _current;
+        private KeyValuePair<TK, TV> _current;
 
         // Unified Constructor
         // We use boolean flags because 'K' might be a struct where 'null' is impossible.
-        public BTreeEnumerator(Node<K> root, TStrategy strategy, bool hasMin, K minKey, bool hasMax, K maxKey)
+        public BTreeEnumerator(Node<TK>? root, TStrategy strategy, bool hasMin, TK minKey, bool hasMax, TK maxKey)
         {
-            _root = root;
+            _root = root!;
             _strategy = strategy;
             _hasMax = hasMax;
             _maxKey = maxKey;
             _hasMin = hasMin;
             _minKey = minKey;
             
-            _nodeStack = new IterNodeBuffer<K>();
-            _indexStack = new IterIndexBuffer<K>(); // Explicit struct init
+            _nodeStack = new IterNodeBuffer<TK>();
+            _indexStack = new IterIndexBuffer(); // Explicit struct init
             _depth = 0;
             _currentLeaf = null;
             _currentLeafIndex = -1;
@@ -102,7 +102,7 @@ public struct BTreeEnumerator<K, V, TStrategy> : IEnumerator<KeyValuePair<K, V>>
         // Logic 1: Unbounded Start (Go to very first item)
         private void DiveLeft()
         {
-            Node<K> node = _root;
+            Node<TK> node = _root;
             _depth = 0;
 
             while (!node.IsLeaf)
@@ -114,14 +114,14 @@ public struct BTreeEnumerator<K, V, TStrategy> : IEnumerator<KeyValuePair<K, V>>
                 node = internalNode.Children[0]!;
             }
 
-            _currentLeaf = node.AsLeaf<V>();
+            _currentLeaf = node.AsLeaf<TV>();
             _currentLeafIndex = -1; // Position before the first element (0)
         }
 
         // Logic 2: Bounded Start (Go to specific key)
-        private void Seek(K key)
+        private void Seek(TK key)
         {
-            Node<K> node = _root;
+            Node<TK> node = _root;
             _depth = 0;
             long keyPrefix = _strategy.UsesPrefixes ? _strategy.GetPrefix(key) : 0;
     
@@ -130,7 +130,7 @@ public struct BTreeEnumerator<K, V, TStrategy> : IEnumerator<KeyValuePair<K, V>>
             while (!node.IsLeaf)
             {
                 var internalNode = node.AsInternal();
-                int idx = BTreeFunctions.FindRoutingIndex<K, TStrategy>(internalNode, key, keyPrefix,  _strategy);
+                int idx = BTreeFunctions.FindRoutingIndex(internalNode, key, keyPrefix,  _strategy);
                 
                 _nodeStack[_depth] = internalNode;
                 _indexStack[_depth] = idx;
@@ -140,8 +140,8 @@ public struct BTreeEnumerator<K, V, TStrategy> : IEnumerator<KeyValuePair<K, V>>
             }
 
             // Find index in Leaf
-            _currentLeaf = node.AsLeaf<V>();
-            int index = BTreeFunctions.FindIndex<K,V, TStrategy>(_currentLeaf, key, keyPrefix, _strategy);
+            _currentLeaf = node.AsLeaf<TV>();
+            int index = BTreeFunctions.FindIndex(_currentLeaf, key, keyPrefix, _strategy);
             
             // Set position to (index - 1) so that the first MoveNext() lands on 'index'
             _currentLeafIndex = index - 1;
@@ -158,14 +158,14 @@ public struct BTreeEnumerator<K, V, TStrategy> : IEnumerator<KeyValuePair<K, V>>
                 if (_hasMax)
                 {
                      // If Current Key > Max Key, we are done.
-                     if (_strategy.Compare(_currentLeaf.Keys[_currentLeafIndex], _maxKey) > 0)
+                     if (_strategy.Compare(_currentLeaf.Keys![_currentLeafIndex], _maxKey) > 0)
                      {
                          _currentLeaf = null; // Close iterator
                          return false;
                      }
                 }
 
-                _current = new KeyValuePair<K, V>(_currentLeaf.Keys[_currentLeafIndex], _currentLeaf.Values[_currentLeafIndex]);
+                _current = new KeyValuePair<TK, TV>(_currentLeaf.Keys![_currentLeafIndex], _currentLeaf.Values[_currentLeafIndex]);
                 return true;
             }
 
@@ -176,14 +176,14 @@ public struct BTreeEnumerator<K, V, TStrategy> : IEnumerator<KeyValuePair<K, V>>
                 // Check Max Bound immediately for the first item
                 if (_hasMax)
                 {
-                    if (_strategy.Compare(_currentLeaf!.Keys[0], _maxKey) > 0)
+                    if (_strategy.Compare(_currentLeaf.Keys![0], _maxKey) > 0)
                     {
                         _currentLeaf = null;
                         return false;
                     }
                 }
 
-                _current = new KeyValuePair<K, V>(_currentLeaf.Keys[0], _currentLeaf.Values[0]);
+                _current = new KeyValuePair<TK, TV>(_currentLeaf.Keys![0], _currentLeaf.Values[0]);
                 return true;
             }
 
@@ -204,7 +204,7 @@ public struct BTreeEnumerator<K, V, TStrategy> : IEnumerator<KeyValuePair<K, V>>
                     _indexStack[_depth] = nextIndex;
                     _depth++;
 
-                    Node<K> node = internalNode.Children[nextIndex]!;
+                    Node<TK> node = internalNode.Children[nextIndex]!;
                     while (!node.IsLeaf)
                     {
                         _nodeStack[_depth] = node;
@@ -213,7 +213,7 @@ public struct BTreeEnumerator<K, V, TStrategy> : IEnumerator<KeyValuePair<K, V>>
                         node = node.AsInternal().Children[0]!;
                     }
 
-                    _currentLeaf = node.AsLeaf<V>();
+                    _currentLeaf = node.AsLeaf<TV>();
                     _currentLeafIndex = 0;
                     return true;
                 }
@@ -221,7 +221,7 @@ public struct BTreeEnumerator<K, V, TStrategy> : IEnumerator<KeyValuePair<K, V>>
             return false;
         }
 
-        public KeyValuePair<K, V> Current => _current;
+        public KeyValuePair<TK, TV> Current => _current;
         object IEnumerator.Current => _current;
         public void Reset()
         {
diff --git a/PersistentOrderedMap/KeyStrategies.cs b/PersistentOrderedMap/KeyStrategies.cs
index f960d1d..9ef540d 100644
--- a/PersistentOrderedMap/KeyStrategies.cs
+++ b/PersistentOrderedMap/KeyStrategies.cs
@@ -1,7 +1,3 @@
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
 
 namespace PersistentOrderedMap;
 
@@ -9,10 +5,10 @@ using System;
 using System.Buffers.Binary;
 using System.Runtime.CompilerServices;
 
-public interface IKeyStrategy<K>
+public interface IKeyStrategy<in TK>
 {
-    int Compare(K x, K y);
-    long GetPrefix(K key);
+    int Compare(TK x, TK y);
+    long GetPrefix(TK key);
 
     bool UsesPrefixes => true;
 
diff --git a/PersistentOrderedMap/KeyStrategies/ComparableStrategy.cs b/PersistentOrderedMap/KeyStrategies/ComparableStrategy.cs
index a9aa726..c41acab 100644
--- a/PersistentOrderedMap/KeyStrategies/ComparableStrategy.cs
+++ b/PersistentOrderedMap/KeyStrategies/ComparableStrategy.cs
@@ -4,14 +4,14 @@ using System.Runtime.CompilerServices;
 
 // This is a comparable strategy that may squeeze some extra time out of value types
 
-public readonly struct ComparableStrategy<K> : IKeyStrategy<K> where K : IComparable<K>
+public readonly struct ComparableStrategy<TK> : IKeyStrategy<TK> where TK : IComparable<TK>
 {
     public bool UsesPrefixes => false;
     public bool UseBinarySearch => true;
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public long GetPrefix(K key) => 0;
+    public long GetPrefix(TK key) => 0;
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public int Compare(K x, K y) => x.CompareTo(y);
+    public int Compare(TK x, TK y) => x.CompareTo(y);
 }
diff --git a/PersistentOrderedMap/KeyStrategies/StandardStrategy.cs b/PersistentOrderedMap/KeyStrategies/StandardStrategy.cs
index aefca25..996c808 100644
--- a/PersistentOrderedMap/KeyStrategies/StandardStrategy.cs
+++ b/PersistentOrderedMap/KeyStrategies/StandardStrategy.cs
@@ -5,21 +5,21 @@ using System.Runtime.CompilerServices;
 /// A universal key strategy for any type that relies on standard comparisons 
 /// (IComparable, IComparer, or custom StringComparers) without SIMD prefixes.
 /// </summary>
-public readonly struct StandardStrategy<K> : IKeyStrategy<K>
+public readonly struct StandardStrategy<TK> : IKeyStrategy<TK>
 {
-    private readonly IComparer<K> _comparer;
+    private readonly IComparer<TK> _comparer;
 
     // If no comparer is provided, it defaults to Comparer<K>.Default
     // which automatically uses IComparable<K> if the type implements it.
 
     public StandardStrategy()
     {
-        _comparer = Comparer<K>.Default;
+        _comparer = Comparer<TK>.Default;
     }
 
-    public StandardStrategy(IComparer<K>? comparer)
+    public StandardStrategy(IComparer<TK>? comparer)
     {
-        _comparer = comparer ?? Comparer<K>.Default;
+        _comparer = comparer ?? Comparer<TK>.Default;
     }
     // Tell the B-Tree to skip SIMD routing and just use LinearSearch
     public bool UsesPrefixes => false;
@@ -27,16 +27,16 @@ public readonly struct StandardStrategy<K> : IKeyStrategy<K>
     // This will never be called because UsesPrefixes is false, 
     // but we must satisfy the interface.
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public long GetPrefix(K key) => 0;
+    public long GetPrefix(TK key) => 0;
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public int Compare(K x, K y)
+    public int Compare(TK x, TK y)
     {
         return _comparer.Compare(x, y);
     }
 }
-public readonly struct StandardStrategy2<K, TComparer> : IKeyStrategy<K>
-    where TComparer : struct, IComparer<K>
+public readonly struct StandardStrategy2<TK, TComparer> : IKeyStrategy<TK>
+    where TComparer : struct, IComparer<TK>
                       {
                           private readonly TComparer _comparer;
 
@@ -46,8 +46,8 @@ public readonly struct StandardStrategy2<K, TComparer> : IKeyStrategy<K>
                           public bool UseBinarySearch => true;
 
 [MethodImpl(MethodImplOptions.AggressiveInlining)]
-public int Compare(K x, K y) => _comparer.Compare(x, y);
+public int Compare(TK x, TK y) => _comparer.Compare(x, y);
 
-                          public long GetPrefix(K key) => 0;
+                          public long GetPrefix(TK key) => 0;
     }
 
diff --git a/PersistentOrderedMap/Nodes.cs b/PersistentOrderedMap/Nodes.cs
index 8e1cc76..20499ca 100644
--- a/PersistentOrderedMap/Nodes.cs
+++ b/PersistentOrderedMap/Nodes.cs
@@ -33,17 +33,17 @@ public struct NodeHeader
 }
 
 [InlineArray(32)]
-public struct KeyBuffer<K>
+public struct KeyBuffer<TK>
 {
-    private K _element0;
+    private TK _element0;
 }
 
 // Constraint: Internal Nodes fixed at 32 children.
 // This removes the need for a separate array allocation for children references.
 [InlineArray(32)]
-public struct NodeBuffer<V>
+public struct NodeBuffer<TV>
 {
-    private Node<V>? _element0;
+    private Node<TV>? _element0;
 }
 
 [InlineArray(32)]
@@ -52,7 +52,7 @@ internal struct InternalPrefixBuffer
     private long _element0;
 }
 
-public abstract class Node<K>
+public abstract class Node<TK>
 {
     public NodeHeader Header;
 
@@ -61,7 +61,7 @@ public abstract class Node<K>
         Header = new NodeHeader(owner, 0, flags);
     }
 
-    public abstract Span<K> GetKeys(); 
+    public abstract Span<TK> GetKeys(); 
     
     // Abstract access to prefixes regardless of storage backing
     public abstract Span<long> AllPrefixes { get; }
@@ -71,47 +71,47 @@ public abstract class Node<K>
         
     public bool IsLeaf => (Header.Flags & NodeFlags.IsLeaf) != 0;
 
-    public abstract Node<K> EnsureEditable(OwnerId transactionId);
+    public abstract Node<TK> EnsureEditable(OwnerId transactionId);
         
     public void SetCount(int newCount) => Header.Count = (byte)newCount;
     
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public LeafNode<K, V> AsLeaf<V>()
+    public LeafNode<TK, TV> AsLeaf<TV>()
     {
         // Zero-overhead cast. Assumes you checked IsLeaf or know logic flow.
-        return Unsafe.As<LeafNode<K, V>>(this);
+        return Unsafe.As<LeafNode<TK, TV>>(this);
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public InternalNode<K> AsInternal()
+    public InternalNode<TK> AsInternal()
     {
         // Zero-overhead cast. Assumes you checked !IsLeaf or know logic flow.
-        return Unsafe.As<InternalNode<K>>(this);
+        return Unsafe.As<InternalNode<TK>>(this);
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public PrefixInternalNode<K> AsPrefixInternal()
+    public PrefixInternalNode<TK> AsPrefixInternal()
     {
-        return Unsafe.As<PrefixInternalNode<K>>(this);
+        return Unsafe.As<PrefixInternalNode<TK>>(this);
     }
 }
 
-public sealed class LeafNode<K, V> : Node<K>
+public sealed class LeafNode<TK, TV> : Node<TK>
 {
     public const int Capacity = 64;
     public const int MergeThreshold = 8;
     
-    public K[]? Keys;
-    public V[] Values;
+    public TK[]? Keys;
+    public TV[] Values;
 
-    internal long[]? _prefixes;
+    private long[]? _prefixes;
     
     public override Span<long> AllPrefixes => _prefixes != null ? _prefixes : Span<long>.Empty;
     
     public LeafNode(OwnerId owner, bool usePrefixes) : base(owner, NodeFlags.IsLeaf | (usePrefixes ? NodeFlags.HasPrefixes : NodeFlags.None))
     {
-        Keys = new K[Capacity];
-        Values = new V[Capacity];
+        Keys = new TK[Capacity];
+        Values = new TV[Capacity];
         if (usePrefixes)
         {
             _prefixes = new long[Capacity];
@@ -119,21 +119,21 @@ public sealed class LeafNode<K, V> : Node<K>
     }
 
     // Copy Constructor for CoW
-    private LeafNode(LeafNode<K, V> original, OwnerId newOwner)
+    private LeafNode(LeafNode<TK, TV> original, OwnerId newOwner)
         : base(newOwner, original.Header.Flags)
     {
-        Keys = new K[Capacity];
-        Values = new V[Capacity];
+        Keys = new TK[Capacity];
+        Values = new TV[Capacity];
         Header.Count = original.Header.Count;        _prefixes = new long[Capacity];
 
         // Copy data
-        Array.Copy(original.Keys, Keys, original.Header.Count);
+        Array.Copy(original.Keys!, Keys, original.Header.Count);
         Array.Copy(original.Values, Values, original.Header.Count);
         if (original._prefixes != null)
             Array.Copy(original._prefixes, _prefixes, original.Header.Count);
     }
 
-    public override Node<K> EnsureEditable(OwnerId transactionId)
+    public override Node<TK> EnsureEditable(OwnerId transactionId)
     {
         // CASE 1: Persistent Mode (transactionId is None).
         // We MUST create a copy, because we cannot distinguish "Shared Immutable Node (0)"
@@ -142,7 +142,7 @@ public sealed class LeafNode<K, V> : Node<K>
         // we won't copy the same fresh node twice.
         if (transactionId == OwnerId.None)
         {
-            return new LeafNode<K, V>(this, OwnerId.None);
+            return new LeafNode<TK, TV>(this, OwnerId.None);
         }
 
         // CASE 2: Transient Mode.
@@ -153,26 +153,26 @@ public sealed class LeafNode<K, V> : Node<K>
         }
 
         // CASE 3: CoW needed (Ownership mismatch).
-        return new LeafNode<K, V>(this, transactionId);
+        return new LeafNode<TK, TV>(this, transactionId);
     }
 
-    public override Span<K> GetKeys()
+    public override Span<TK> GetKeys()
     {
         return Keys.AsSpan(0, Header.Count);
     }
 
-    public Span<V> GetValues()
+    public Span<TV> GetValues()
     {
         return Values.AsSpan(0, Header.Count);
     }
 }
 
-public class InternalNode<K> : Node<K>
+public class InternalNode<TK> : Node<TK>
 {
     public const int Capacity = 32;
 
-    public KeyBuffer<K> Keys;
-    public NodeBuffer<K> Children;
+    public KeyBuffer<TK> Keys;
+    public NodeBuffer<TK> Children;
 
     public override Span<long> AllPrefixes => Span<long>.Empty;
 
@@ -182,7 +182,7 @@ public class InternalNode<K> : Node<K>
     }
 
     // Fixed CoW Constructor
-    protected InternalNode(InternalNode<K> original, OwnerId newOwner, NodeFlags flags)
+    protected InternalNode(InternalNode<TK> original, OwnerId newOwner, NodeFlags flags)
         : base(newOwner, flags)
     {
         Header.Count = original.Header.Count;
@@ -195,28 +195,28 @@ public class InternalNode<K> : Node<K>
 
     // The missing method needed by BTreeFunctions for routing
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public Span<Node<K>> GetChildren() 
+    public Span<Node<TK>> GetChildren() 
     {
         // An internal node always has (Count + 1) children
-        return MemoryMarshal.CreateSpan(ref Children[0], Header.Count + 1);
+        return MemoryMarshal.CreateSpan(ref Children[0]!, Header.Count + 1);
     }
 
-    public override Span<K> GetKeys() => MemoryMarshal.CreateSpan(ref Keys[0], Header.Count);
+    public override Span<TK> GetKeys() => MemoryMarshal.CreateSpan(ref Keys[0], Header.Count);
 
-    public override Node<K> EnsureEditable(OwnerId transactionId)
+    public override Node<TK> EnsureEditable(OwnerId transactionId)
     {
-        if (transactionId == OwnerId.None) return new InternalNode<K>(this, OwnerId.None, Header.Flags);
+        if (transactionId == OwnerId.None) return new InternalNode<TK>(this, OwnerId.None, Header.Flags);
         if (Header.Owner == transactionId) return this;
-        return new InternalNode<K>(this, transactionId, Header.Flags);
+        return new InternalNode<TK>(this, transactionId, Header.Flags);
     }
 }
 
 
-public sealed class PrefixInternalNode<K> : InternalNode<K>
+public sealed class PrefixInternalNode<TK> : InternalNode<TK>
 {
-    internal InternalPrefixBuffer _prefixBuffer;
+    internal InternalPrefixBuffer PrefixBuffer;
 
-    public override Span<long> AllPrefixes => MemoryMarshal.CreateSpan(ref _prefixBuffer[0], Capacity);
+    public override Span<long> AllPrefixes => MemoryMarshal.CreateSpan(ref PrefixBuffer[0], Capacity);
 
     public PrefixInternalNode(OwnerId owner) 
         : base(owner, NodeFlags.HasPrefixes)
@@ -224,18 +224,18 @@ public sealed class PrefixInternalNode<K> : InternalNode<K>
     }
 
     // CoW Constructor
-    private PrefixInternalNode(PrefixInternalNode<K> original, OwnerId newOwner)
+    private PrefixInternalNode(PrefixInternalNode<TK> original, OwnerId newOwner)
         : base(original, newOwner, original.Header.Flags)
     {
         // Copy the base Keys and Children, then blit the prefix buffer
-        this._prefixBuffer = original._prefixBuffer;
+        this.PrefixBuffer = original.PrefixBuffer;
     }
 
-    public override Node<K> EnsureEditable(OwnerId transactionId)
+    public override Node<TK> EnsureEditable(OwnerId transactionId)
     {
-        if (transactionId == OwnerId.None) return new PrefixInternalNode<K>(this, OwnerId.None);
+        if (transactionId == OwnerId.None) return new PrefixInternalNode<TK>(this, OwnerId.None);
         if (Header.Owner == transactionId) return this;
-        return new PrefixInternalNode<K>(this, transactionId);
+        return new PrefixInternalNode<TK>(this, transactionId);
     }
 }
 
diff --git a/PersistentOrderedMap/PersistentOrderedMap.cs b/PersistentOrderedMap/PersistentOrderedMap.cs
index 5d45114..9731141 100644
--- a/PersistentOrderedMap/PersistentOrderedMap.cs
+++ b/PersistentOrderedMap/PersistentOrderedMap.cs
@@ -1,44 +1,43 @@
-using System.Collections;
 
 namespace PersistentOrderedMap;
 
-public sealed class PersistentOrderedMap<K, V, TStrategy> : BaseOrderedMap<K, V, TStrategy>, IEnumerable, IEnumerable<KeyValuePair<K, V>> where TStrategy : IKeyStrategy<K>
+public sealed class PersistentOrderedMap<TK, TV, TStrategy> : BaseOrderedMap<TK, TV, TStrategy> where TStrategy : IKeyStrategy<TK>
 {
-    internal PersistentOrderedMap(Node<K> root, TStrategy strategy, int count) 
+    internal PersistentOrderedMap(Node<TK> root, TStrategy strategy, int count) 
         : base(root, strategy, count) { }
 
     // ---------------------------------------------------------
     // Immutable Write API (Returns new Map)
     // ---------------------------------------------------------
-    public PersistentOrderedMap<K, V, TStrategy> Set(K key, V value)
+    public PersistentOrderedMap<TK, TV, TStrategy> Set(TK key, TV value)
     {
         // OPTIMIZATION: Use OwnerId.None (0).
         // This signals EnsureEditable to always copy the root path, 
         // producing a new tree of nodes that also have OwnerId.None.
-        var newRoot = BTreeFunctions.Set(_root, key, value, _strategy, OwnerId.None, out bool countChanged);
-        return new PersistentOrderedMap<K, V, TStrategy>(newRoot, _strategy, countChanged ? Count + 1 : Count);
+        var newRoot = BTreeFunctions.Set(Root, key, value, Strategy, OwnerId.None, out bool countChanged);
+        return new PersistentOrderedMap<TK, TV, TStrategy>(newRoot, Strategy, countChanged ? Count + 1 : Count);
     }
    
-    public static PersistentOrderedMap<K, V, TStrategy> Empty(TStrategy strategy)
+    public static PersistentOrderedMap<TK, TV, TStrategy> Empty(TStrategy strategy)
     {
         // Create an empty Leaf Node.
         // 'default(OwnerId)' (usually 0) marks this node as Immutable/Persistent.
         // This ensures that any subsequent Set/Remove will clone this node 
         // instead of modifying it in place.
-        var emptyRoot = new LeafNode<K, V>(default(OwnerId), strategy.UsesPrefixes);
+        var emptyRoot = new LeafNode<TK, TV>(default(OwnerId), strategy.UsesPrefixes);
     
-        return new PersistentOrderedMap<K, V, TStrategy>(emptyRoot, strategy, 0);
+        return new PersistentOrderedMap<TK, TV, TStrategy>(emptyRoot, strategy, 0);
     }
 
-    public PersistentOrderedMap<K, V, TStrategy> Remove(K key)
+    public PersistentOrderedMap<TK, TV, TStrategy> Remove(TK key)
     {
-        var newRoot = BTreeFunctions.Remove<K,V, TStrategy>(_root, key, _strategy, OwnerId.None, out bool removed);
+        var newRoot = BTreeFunctions.Remove<TK,TV, TStrategy>(Root, key, Strategy, OwnerId.None, out bool removed);
         if (!removed) return this;
-        return new PersistentOrderedMap<K, V, TStrategy>(newRoot, _strategy, Count - 1);
+        return new PersistentOrderedMap<TK, TV, TStrategy>(newRoot, Strategy, Count - 1);
     }
 
-    public TransientOrderedMap<K, V, TStrategy> ToTransient()
+    public TransientOrderedMap<TK, TV, TStrategy> ToTransient()
     {
-        return new TransientOrderedMap<K, V, TStrategy>(_root, _strategy, Count);
+        return new TransientOrderedMap<TK, TV, TStrategy>(Root, Strategy, Count);
     }
 }
diff --git a/PersistentOrderedMap/TransientOrderedMap.cs b/PersistentOrderedMap/TransientOrderedMap.cs
index 48d4248..93786f8 100644
--- a/PersistentOrderedMap/TransientOrderedMap.cs
+++ b/PersistentOrderedMap/TransientOrderedMap.cs
@@ -1,35 +1,34 @@
-using System.Collections;
 
 namespace PersistentOrderedMap;
 
-public sealed class TransientOrderedMap<K, V, TStrategy> : BaseOrderedMap<K, V, TStrategy> where TStrategy : IKeyStrategy<K>
+public sealed class TransientOrderedMap<TK, TV, TStrategy> : BaseOrderedMap<TK, TV, TStrategy> where TStrategy : IKeyStrategy<TK>
 {
     // This is mutable, but we treat it as readonly for the ID generation logic usually.
     private OwnerId _transactionId;
 
-    public TransientOrderedMap(Node<K> root, TStrategy strategy, int count) 
+    public TransientOrderedMap(Node<TK> root, TStrategy strategy, int count) 
         : base(root, strategy, count) 
     {
         _transactionId = OwnerId.Next();
     }
 
-    public void Set(K key, V value)
+    public void Set(TK key, TV value)
     {
-        _root = BTreeFunctions.Set(_root, key, value, _strategy, _transactionId, out bool countChanged);
+        Root = BTreeFunctions.Set(Root, key, value, Strategy, _transactionId, out bool countChanged);
         if (countChanged) Count++;
     }
 
-    public void Remove(K key)
+    public void Remove(TK key)
     {
-        _root = BTreeFunctions.Remove<K,V, TStrategy>(_root, key, _strategy, _transactionId, out bool removed);
+        Root = BTreeFunctions.Remove<TK,TV, TStrategy>(Root, key, Strategy, _transactionId, out bool removed);
         if (removed) Count--;
     }
 
-    public PersistentOrderedMap<K, V, TStrategy> ToPersistent()
+    public PersistentOrderedMap<TK, TV, TStrategy> ToPersistent()
     {
         // 1. Create the snapshot by copying all relevant information
             
-        var snapshot = new PersistentOrderedMap<K, V, TStrategy>(_root, _strategy, Count);
+        var snapshot = new PersistentOrderedMap<TK, TV, TStrategy>(Root, Strategy, Count);
 
         // 2. Protect the snapshot from THIS TransientOrderedMap by getting a new ownerId 
         // so that future edits will be done by CoW
diff --git a/TestProject1/FuzzTest.cs b/TestProject1/FuzzTest.cs
index 643db48..bc4a081 100644
--- a/TestProject1/FuzzTest.cs
+++ b/TestProject1/FuzzTest.cs
@@ -19,25 +19,25 @@ public class BTreeFuzzTests
     public void Fuzz_Insert_And_Remove_consistency()
     {
         // CONFIGURATION
-        const int Iterations = 100_000; // High enough to trigger all splits/merges
-        const int KeyRange = 5000;      // Small enough to cause frequent collisions
+        const int iterations = 100_000; // High enough to trigger all splits/merges
+        const int keyRange = 5000;      // Small enough to cause frequent collisions
         const bool showOps = false;
-        int Seed = 2135974; // Environment.TickCount;
+        int seed = 2135974; // Environment.TickCount;
         
         // ORACLES
         var reference = new SortedDictionary<int, int>();
         var subject = BaseOrderedMap<int, int, IntStrategy>.CreateTransient(_strategy);
 
-        var random = new Random(Seed);
-        _output.WriteLine($"Starting Fuzz Test with Seed: {Seed}");
+        var random = new Random(seed);
+        _output.WriteLine($"Starting Fuzz Test with Seed: {seed}");
 
         try
         {
-            for (int i = 0; i < Iterations; i++)
+            for (int i = 0; i < iterations; i++)
             {
                 // 1. Pick an Action: 70% Insert/Update, 30% Remove
                 bool isInsert = random.NextDouble() < 0.7;
-                int key = random.Next(KeyRange);
+                int key = random.Next(keyRange);
                 int val = key * 100;
 
                 if (isInsert)
@@ -82,7 +82,7 @@ public class BTreeFuzzTests
         }
         catch (Exception)
         {
-            _output.WriteLine($"FAILED at iteration with SEED: {Seed}");
+            _output.WriteLine($"FAILED at iteration with SEED: {seed}");
             throw; // Re-throw to fail the test
         }
     }
@@ -91,28 +91,28 @@ public class BTreeFuzzTests
     public void Fuzz_Range_Queries()
     {
         // Validates that your Range Enumerator matches LINQ on the reference
-        const int Iterations = 1000; 
-        const int KeyRange = 2000;
-        int Seed = Environment.TickCount;
+        const int iterations = 1000; 
+        const int keyRange = 2000;
+        int seed = Environment.TickCount;
         
         var reference = new SortedDictionary<int, int>();
         var subject = BaseOrderedMap<int, int, IntStrategy>.CreateTransient(_strategy);
-        var random = new Random(Seed);
+        var random = new Random(seed);
 
         // Fill Data
-        for(int i=0; i<KeyRange; i++)
+        for(int i=0; i<keyRange; i++)
         {
-            int k = random.Next(KeyRange);
+            int k = random.Next(keyRange);
             reference[k] = k;
             subject.Set(k, k);
         }
         
         var persistent = subject.ToPersistent();
 
-        for (int i = 0; i < Iterations; i++)
+        for (int i = 0; i < iterations; i++)
         {
-            int min = random.Next(KeyRange);
-            int max = min + random.Next(KeyRange - min); // Ensure max >= min
+            int min = random.Next(keyRange);
+            int max = min + random.Next(keyRange - min); // Ensure max >= min
 
             // 1. Reference Result (LINQ)
             // Note: SortedDictionary doesn't have a direct Range query, so we filter memory.
diff --git a/TestProject1/FuzzTestStandardStrategy.cs b/TestProject1/FuzzTestStandardStrategy.cs
index 958498a..5c5ee61 100644
--- a/TestProject1/FuzzTestStandardStrategy.cs
+++ b/TestProject1/FuzzTestStandardStrategy.cs
@@ -19,25 +19,25 @@ public class BTreeFuzzTestStandardStrategy
     public void Fuzz_Insert_And_Remove_consistency()
     {
         // CONFIGURATION
-        const int Iterations = 100_000; // High enough to trigger all splits/merges
-        const int KeyRange = 5000;      // Small enough to cause frequent collisions
+        const int iterations = 100_000; // High enough to trigger all splits/merges
+        const int keyRange = 5000;      // Small enough to cause frequent collisions
         const bool showOps = false;
-        int Seed = 2135974; // Environment.TickCount;
+        int seed = 2135974; // Environment.TickCount;
         
         // ORACLES
         var reference = new SortedDictionary<int, int>();
         var subject = BaseOrderedMap<int, int, StandardStrategy<int>>.CreateTransient(_strategy);
 
-        var random = new Random(Seed);
-        _output.WriteLine($"Starting Fuzz Test with Seed: {Seed}");
+        var random = new Random(seed);
+        _output.WriteLine($"Starting Fuzz Test with Seed: {seed}");
 
         try
         {
-            for (int i = 0; i < Iterations; i++)
+            for (int i = 0; i < iterations; i++)
             {
                 // 1. Pick an Action: 70% Insert/Update, 30% Remove
                 bool isInsert = random.NextDouble() < 0.7;
-                int key = random.Next(KeyRange);
+                int key = random.Next(keyRange);
                 int val = key * 100;
 
                 if (isInsert)
@@ -82,7 +82,7 @@ public class BTreeFuzzTestStandardStrategy
         }
         catch (Exception)
         {
-            _output.WriteLine($"FAILED at iteration with SEED: {Seed}");
+            _output.WriteLine($"FAILED at iteration with SEED: {seed}");
             throw; // Re-throw to fail the test
         }
     }
@@ -91,28 +91,28 @@ public class BTreeFuzzTestStandardStrategy
     public void Fuzz_Range_Queries()
     {
         // Validates that your Range Enumerator matches LINQ on the reference
-        const int Iterations = 1000; 
-        const int KeyRange = 2000;
-        int Seed = Environment.TickCount;
+        const int iterations = 1000; 
+        const int keyRange = 2000;
+        int seed = Environment.TickCount;
         
         var reference = new SortedDictionary<int, int>();
         var subject = BaseOrderedMap<int, int, StandardStrategy<int>>.CreateTransient(_strategy);
-        var random = new Random(Seed);
+        var random = new Random(seed);
 
         // Fill Data
-        for(int i=0; i<KeyRange; i++)
+        for(int i=0; i<keyRange; i++)
         {
-            int k = random.Next(KeyRange);
+            int k = random.Next(keyRange);
             reference[k] = k;
             subject.Set(k, k);
         }
         
         var persistent = subject.ToPersistent();
 
-        for (int i = 0; i < Iterations; i++)
+        for (int i = 0; i < iterations; i++)
         {
-            int min = random.Next(KeyRange);
-            int max = min + random.Next(KeyRange - min); // Ensure max >= min
+            int min = random.Next(keyRange);
+            int max = min + random.Next(keyRange - min); // Ensure max >= min
 
             // 1. Reference Result (LINQ)
             // Note: SortedDictionary doesn't have a direct Range query, so we filter memory.
diff --git a/TestProject1/StandardStrategy.cs b/TestProject1/StandardStrategy.cs
index b5467b0..94cc484 100644
--- a/TestProject1/StandardStrategy.cs
+++ b/TestProject1/StandardStrategy.cs
@@ -13,26 +13,26 @@ public class StandardStrategy
     [Fact]
     public void Setup()
     {
-        var N = 1000;
-        var _stdStrategy = new StandardStrategy<string>();
-        var _uniStrategy = new UnicodeStrategy();
+        var n = 1000;
+        var stdStrategy = new StandardStrategy<string>();
+        var uniStrategy = new UnicodeStrategy();
         var rnd = new Random(42);
-        var StringLength = 10;
+        var stringLength = 10;
         // Build random strings
-        var _allKeys = Enumerable.Range(0, N).Select(_ => GenerateRandomString(StringLength, rnd)).Distinct().ToArray();
+        var allKeys = Enumerable.Range(0, n).Select(_ => GenerateRandomString(stringLength, rnd)).Distinct().ToArray();
         
         // Regenerate if Distinct() reduced array size (highly unlikely with length 8/50, but safe)
-        while (_allKeys.Length < N)
+        while (allKeys.Length < n)
         {
-            _allKeys = _allKeys.Concat(new[] { GenerateRandomString(StringLength, rnd) }).Distinct().ToArray();
+            allKeys = allKeys.Concat(new[] { GenerateRandomString(stringLength, rnd) }).Distinct().ToArray();
         }
 
-        var transStd = BaseOrderedMap<string, int, StandardStrategy<string>>.CreateTransient(_stdStrategy);
-        var transUni = BaseOrderedMap<string, int, UnicodeStrategy>.CreateTransient(_uniStrategy);
-        for (int i = 0; i < _allKeys.Length; i++)
+        var transStd = BaseOrderedMap<string, int, StandardStrategy<string>>.CreateTransient(stdStrategy);
+        var transUni = BaseOrderedMap<string, int, UnicodeStrategy>.CreateTransient(uniStrategy);
+        for (int i = 0; i < allKeys.Length; i++)
         {
-            transStd.Set(_allKeys[i], i);
-            transUni.Set(_allKeys[i], i);
+            transStd.Set(allKeys[i], i);
+            transUni.Set(allKeys[i], i);
         }
     }
 }
\ No newline at end of file