speed up Uint160.CompareTo and Uint256.CompareTo function

neo/UInt160.cs

@@ -31,26 +31,41 @@ public UInt160(byte[] value)
         /// Method CompareTo returns 1 if this UInt160 is bigger than other UInt160; -1 if it's smaller; 0 if it's equals
         /// Example: assume this is 01ff00ff00ff00ff00ff00ff00ff00ff00ff00a4, this.CompareTo(02ff00ff00ff00ff00ff00ff00ff00ff00ff00a3) returns 1
         /// </summary>
-        public int CompareTo(UInt160 other)
+        public unsafe int CompareTo(UInt160 other)
         {
-            byte[] x = ToArray();
-            byte[] y = other.ToArray();
-            for (int i = x.Length - 1; i >= 0; i--)
+            fixed (byte* px = ToArray(), py = other.ToArray())
             {
-                if (x[i] > y[i])
-                    return 1;
-                if (x[i] < y[i])
-                    return -1;
+                uint* lpx = (uint*)px;
+                uint* lpy = (uint*)py;
+                //160 bit / 32 bit step   -1
+                for (int i = (160 / 32 - 1); i >= 0; i--)
+                {
+                    if (lpx[i] > lpy[i])
+                        return 1;
+                    if (lpx[i] < lpy[i])
+                        return -1;
+                }
             }
             return 0;
         }
 
         /// <summary>
         /// Method Equals returns true if objects are equal, false otherwise
         /// </summary>
-        bool IEquatable<UInt160>.Equals(UInt160 other)
+        public unsafe bool Equals(UInt160 other)
         {
-            return Equals(other);
+            fixed (byte* px = ToArray(), py = other.ToArray())
+            {
+                uint* lpx = (uint*)px;
+                uint* lpy = (uint*)py;
+                //160 bit / 32 bit(uint step)   -1
+                for (int i = (160 / 32 - 1); i >= 0; i--)
+                {
+                    if (lpx[i] != lpy[i])
+                        return false;
+                }
+            }
+            return true;
         }
 
         /// <summary>

neo/UInt256.cs

@@ -32,26 +32,41 @@ public UInt256(byte[] value)
         /// Method CompareTo returns 1 if this UInt256 is bigger than other UInt256; -1 if it's smaller; 0 if it's equals
         /// Example: assume this is 01ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00a4, this.CompareTo(02ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00a3) returns 1
         /// </summary>
-        public int CompareTo(UInt256 other)
+        public unsafe int CompareTo(UInt256 other)
         {
-            byte[] x = ToArray();
-            byte[] y = other.ToArray();
-            for (int i = x.Length - 1; i >= 0; i--)
+            fixed (byte* px = ToArray(), py = other.ToArray())
             {
-                if (x[i] > y[i])
-                    return 1;
-                if (x[i] < y[i])
-                    return -1;
+                ulong* lpx = (ulong*)px;
+                ulong* lpy = (ulong*)py;
+                //256bit / 64bit(ulong step) -1
+                for (int i = (256 / 64 - 1); i >= 0; i--)
+                {
+                    if (lpx[i] > lpy[i])
+                        return 1;
+                    if (lpx[i] < lpy[i])
+                        return -1;
+                }
             }
             return 0;
         }
 
         /// <summary>
         /// Method Equals returns true if objects are equal, false otherwise
         /// </summary>
-        bool IEquatable<UInt256>.Equals(UInt256 other)
+        public unsafe bool Equals(UInt256 other)
         {
-            return Equals(other);
+            fixed (byte* px = ToArray(), py = other.ToArray())
+            {
+                ulong* lpx = (ulong*)px;
+                ulong* lpy = (ulong*)py;
+                //256bit / 64bit(ulong step) -1
+                for (int i = (256 / 64 - 1); i >= 0; i--)
+                {
+                    if (lpx[i] != lpy[i])
+                        return false;
+                }
+            }
+            return true;
         }
 
         /// <summary>