diff --git a/lib/YANLib/Async/YANEnumerable.cs b/lib/YANLib/Async/YANEnumerable.cs
deleted file mode 100644
index ad650b07..00000000
--- a/lib/YANLib/Async/YANEnumerable.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-namespace YANLib.Async;
-
-public static partial class YANEnumerable
-{
-    public static async ValueTask<List<T>> ToListAsync<T>(this IAsyncEnumerable<T> srcs)
-    {
-        var rslts = new List<T>();
-        await foreach (var src in srcs.ConfigureAwait(false))
-        {
-            rslts.Add(src);
-        }
-        return rslts;
-    }
-}
diff --git a/lib/YANLib/Async/YANFunc.cs b/lib/YANLib/Async/YANFunc.cs
deleted file mode 100644
index 6e78f460..00000000
--- a/lib/YANLib/Async/YANFunc.cs
+++ /dev/null
@@ -1,133 +0,0 @@
-using static System.Environment;
-using static System.Threading.Tasks.Task;
-
-namespace YANLib.Async;
-
-public static partial class YANFunc
-{
-    public static async ValueTask<List<TResult>> AggregateResultsConcurrentlyAsync<T, TResult>(Func<T, IAsyncEnumerable<TResult>> func, IEnumerable<T> args)
-    {
-        var rslts = new List<TResult>();
-        var semSlim = new SemaphoreSlim(ProcessorCount);
-        var tasks = args.Select(async arg =>
-        {
-            var rng = await func(arg).ToListAsync();
-            await semSlim.WaitAsync();
-            try
-            {
-                rslts.AddRange(rng);
-            }
-            finally
-            {
-                _ = semSlim.Release();
-            }
-        });
-        await WhenAll(tasks);
-        return rslts;
-    }
-
-    public static async ValueTask<List<TResult>> AggregateResultsConcurrentlyAsync<T, Ts, TResult>(Func<T, IEnumerable<Ts>, IAsyncEnumerable<TResult>> func, IEnumerable<T> args, IEnumerable<Ts> coll)
-    {
-        var rslts = new List<TResult>();
-        var semSlim = new SemaphoreSlim(ProcessorCount);
-        var tasks = args.Select(async arg =>
-        {
-            var rng = await func(arg, coll).ToListAsync();
-            await semSlim.WaitAsync();
-            try
-            {
-                rslts.AddRange(rng);
-            }
-            finally
-            {
-                _ = semSlim.Release();
-            }
-        });
-        await WhenAll(tasks);
-        return rslts;
-    }
-
-    public static async ValueTask<List<TResult>> AggregateResultsConcurrentlyAsync<T, TResult>(Func<T, ValueTask<IAsyncEnumerable<TResult>>> func, IEnumerable<T> args)
-    {
-        var rslts = new List<TResult>();
-        var semSlim = new SemaphoreSlim(ProcessorCount);
-        var tasks = args.Select(async arg =>
-        {
-            var rng = await (await func(arg)).ToListAsync();
-            await semSlim.WaitAsync();
-            try
-            {
-                rslts.AddRange(rng);
-            }
-            finally
-            {
-                _ = semSlim.Release();
-            }
-        });
-        await WhenAll(tasks);
-        return rslts;
-    }
-
-    public static async ValueTask<List<TResult>> AggregateResultsConcurrentlyAsync<T, Ts, TResult>(Func<T, IEnumerable<Ts>, ValueTask<IAsyncEnumerable<TResult>>> func, IEnumerable<T> args, IEnumerable<Ts> coll)
-    {
-        var rslts = new List<TResult>();
-        var semSlim = new SemaphoreSlim(ProcessorCount);
-        var tasks = args.Select(async arg =>
-        {
-            var rng = await (await func(arg, coll)).ToListAsync();
-            await semSlim.WaitAsync();
-            try
-            {
-                rslts.AddRange(rng);
-            }
-            finally
-            {
-                _ = semSlim.Release();
-            }
-        });
-        await WhenAll(tasks);
-        return rslts;
-    }
-
-    public static async ValueTask<List<TResult>> AggregateResultsConcurrentlyAsync<T, TResult>(Func<T, Task<IAsyncEnumerable<TResult>>> func, IEnumerable<T> args)
-    {
-        var rslts = new List<TResult>();
-        var semSlim = new SemaphoreSlim(ProcessorCount);
-        var tasks = args.Select(async arg =>
-        {
-            var rng = await (await func(arg)).ToListAsync();
-            await semSlim.WaitAsync();
-            try
-            {
-                rslts.AddRange(rng);
-            }
-            finally
-            {
-                _ = semSlim.Release();
-            }
-        });
-        await WhenAll(tasks);
-        return rslts;
-    }
-
-    public static async ValueTask<List<TResult>> AggregateResultsConcurrentlyAsync<T, Ts, TResult>(Func<T, IEnumerable<Ts>, Task<IAsyncEnumerable<TResult>>> func, IEnumerable<T> args, IEnumerable<Ts> coll)
-    {
-        var rslts = new List<TResult>();
-        var semSlim = new SemaphoreSlim(ProcessorCount);
-        var tasks = args.Select(async arg =>
-        {
-            var rng = await (await func(arg, coll)).ToListAsync();
-            await semSlim.WaitAsync();
-            try
-            {
-                rslts.AddRange(rng);
-            }
-            finally
-            {
-                _ = semSlim.Release();
-            }
-        });
-        await WhenAll(tasks);
-        return rslts;
-    }
-}
diff --git a/lib/YANLib/Async/YANHttpClient.cs b/lib/YANLib/Demo/YANHttpClient.cs
similarity index 86%
rename from lib/YANLib/Async/YANHttpClient.cs
rename to lib/YANLib/Demo/YANHttpClient.cs
index 5babf421..f06a92b3 100644
--- a/lib/YANLib/Async/YANHttpClient.cs
+++ b/lib/YANLib/Demo/YANHttpClient.cs
@@ -11,11 +11,11 @@
 using System.Xml.Linq;
 using static System.Net.HttpStatusCode;
 
-namespace YANLib.Async;
+namespace YANLib.Demo;
 
 public static partial class YANHttpClient
 {
-    public static async ValueTask<T?> GetApiAsync<T>(this HttpClient httpClient, string uri, string param, string? path = null, string? authorization = null, JsonSerializerOptions? serializerOptions = null) where T : class, new()
+    private static async ValueTask<T?> GetApiAsync<T>(this HttpClient httpClient, string uri, string param, string? path = null, string? authorization = null, JsonSerializerOptions? serializerOptions = null) where T : class, new()
     {
         try
         {
@@ -52,7 +52,7 @@ public static partial class YANHttpClient
         }
     }
 
-    public static async Task<T?> PostApiAsync<T>(string uri, string param, object data, string? authorization = null) where T : class, new()
+    private static async Task<T?> PostApiAsync<T>(string uri, string param, object data, string? authorization = null) where T : class, new()
     {
         var httpCl = new HttpClient
         {
diff --git a/lib/YANLib/Nullable/YANDateTime.Nullable.cs b/lib/YANLib/Nullable/YANDateTime.Nullable.cs
index e597545d..f56620f2 100644
--- a/lib/YANLib/Nullable/YANDateTime.Nullable.cs
+++ b/lib/YANLib/Nullable/YANDateTime.Nullable.cs
@@ -4,26 +4,11 @@ namespace YANLib.Nullable;
 
 public static partial class YANDateTime
 {
-    /// <summary>
-    /// Parses the string representation of a date and time using <paramref name="fmt"/>.
-    /// Returns the parsed <see cref="DateTime"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="fmt">The format of the string representation.</param>
-    /// <param name="dfltVal">The default value to return if the parsing fails.</param>
-    /// <returns>The parsed <see cref="DateTime"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
+    
     public static DateTime? ToDateTime(this string str, string fmt, DateTime? dfltVal) => dfltVal.HasValue ? str.ToDateTime(fmt, dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings representing date/time values in a specified format to an <see cref="IEnumerable{DateTime}"/> containing the parsed DateTime values.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only whitespace strings.
-    /// If a string cannot be parsed to a valid DateTime value, the default value specified by <paramref name="dfltVal"/> is used instead.
-    /// </summary>
-    /// <param name="fmt">The format of the date/time values in the input strings.</param>
-    /// <param name="dfltVal">The default DateTime value to be used for strings that cannot be parsed to valid DateTime values.</param>
-    /// <param name="strs">The enumerable of strings to convert to DateTime values.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the parsed DateTime values.</returns>
-    public static IEnumerable<DateTime?> ToDateTime(IEnumerable<string> strs, string fmt, DateTime? dfltVal)
+    
+    public static IEnumerable<DateTime?> ToDateTime(this IEnumerable<string> strs, string fmt, DateTime? dfltVal)
     {
         if (strs.IsNullOrWhiteSpace())
         {
@@ -35,28 +20,10 @@ public static partial class YANDateTime
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="DateTime"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <param name="min">The minimum <see cref="DateTime"/> value.</param>
-    /// <param name="max">The maximum <see cref="DateTime"/> value.</param>
-    /// <returns>A random <see cref="DateTime"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
+    
     public static DateTime? GenerateRandomDateTime(DateTime? min, DateTime max) => min.HasValue ? GenerateRandomDateTime(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of DateTime values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of <paramref name="size"/>.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="min">The minimum DateTime value.</param>
-    /// <param name="max">The maximum DateTime value.</param>
-    /// <param name="size">The number of DateTime values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.</returns>
+    
     public static IEnumerable<DateTime?> GenerateRandomDateTimes<T>(DateTime? min, DateTime max, T size) where T : struct
     {
         for (var i = 0ul; i < YANNum.ToUlong(size); i++)
@@ -65,19 +32,7 @@ public static partial class YANDateTime
         }
     }
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of DateTime values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of <paramref name="size"/>.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="min">The minimum DateTime value.</param>
-    /// <param name="max">The maximum DateTime value.</param>
-    /// <param name="size">The number of DateTime values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.</returns>
+    
     public static IEnumerable<DateTime?> GenerateRandomDateTimes<T>(DateTime? min, DateTime max, T? size) where T : struct
     {
         for (var i = 0ul; i < YANNum.ToUlong(size); i++)
@@ -86,28 +41,10 @@ public static partial class YANDateTime
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="DateTime"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <param name="min">The minimum <see cref="DateTime"/> value.</param>
-    /// <param name="max">The maximum <see cref="DateTime"/> value.</param>
-    /// <returns>A random <see cref="DateTime"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
+    
     public static DateTime? GenerateRandomDateTime(DateTime min, DateTime? max) => max.HasValue ? GenerateRandomDateTime(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of DateTime values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of <paramref name="size"/>.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="min">The minimum DateTime value.</param>
-    /// <param name="max">The maximum DateTime value.</param>
-    /// <param name="size">The number of DateTime values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.</returns>
+    
     public static IEnumerable<DateTime?> GenerateRandomDateTimes<T>(DateTime min, DateTime? max, T size) where T : struct
     {
         for (var i = 0ul; i < YANNum.ToUlong(size); i++)
@@ -116,19 +53,7 @@ public static partial class YANDateTime
         }
     }
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of DateTime values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of <paramref name="size"/>.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="min">The minimum DateTime value.</param>
-    /// <param name="max">The maximum DateTime value.</param>
-    /// <param name="size">The number of DateTime values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.</returns>
+    
     public static IEnumerable<DateTime?> GenerateRandomDateTimes<T>(DateTime min, DateTime? max, T? size) where T : struct
     {
         for (var i = 0ul; i < YANNum.ToUlong(size); i++)
@@ -137,28 +62,10 @@ public static partial class YANDateTime
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="DateTime"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <param name="min">The minimum <see cref="DateTime"/> value.</param>
-    /// <param name="max">The maximum <see cref="DateTime"/> value.</param>
-    /// <returns>A random <see cref="DateTime"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
+    
     public static DateTime? GenerateRandomDateTime(DateTime? min, DateTime? max) => min.HasValue ? GenerateRandomDateTime(min.Value, max) : GenerateRandomDateTime(max);
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of DateTime values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of <paramref name="size"/>.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="min">The minimum DateTime value.</param>
-    /// <param name="max">The maximum DateTime value.</param>
-    /// <param name="size">The number of DateTime values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.</returns>
+    
     public static IEnumerable<DateTime?> GenerateRandomDateTimes<T>(DateTime? min, DateTime? max, T size) where T : struct
     {
         for (var i = 0ul; i < YANNum.ToUlong(size); i++)
@@ -167,19 +74,7 @@ public static partial class YANDateTime
         }
     }
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of DateTime values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of <paramref name="size"/>.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="min">The minimum DateTime value.</param>
-    /// <param name="max">The maximum DateTime value.</param>
-    /// <param name="size">The number of DateTime values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.</returns>
+    
     public static IEnumerable<DateTime?> GenerateRandomDateTimes<T>(DateTime? min, DateTime? max, T? size) where T : struct
     {
         for (var i = 0ul; i < YANNum.ToUlong(size); i++)
@@ -188,26 +83,13 @@ public static partial class YANDateTime
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="DateTime"/> value between <see cref="MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <param name="max">The maximum <see cref="DateTime"/> value.</param>
-    /// <returns>A random <see cref="DateTime"/> value between <see cref="MinValue"/> and <paramref name="max"/>.</returns>
+    
     public static DateTime? GenerateRandomDateTime(DateTime? max) => max.HasValue ? GenerateRandomDateTime(max.Value) : default;
 
-    /// <summary>
-    /// Returns the week of the year that the specified <see cref="DateTime"/> value falls in, according to the current culture's calendar, week rule, and first day of the week settings.
-    /// </summary>
-    /// <param name="dt">The <see cref="DateTime"/> value.</param>
-    /// <returns>The week of the year that the specified <see cref="DateTime"/> value falls in.</returns>
+    
     public static int? GetWeekOfYear(this DateTime? dt) => dt.HasValue ? dt.Value.GetWeekOfYear() : default;
 
-    /// <summary>
-    /// Gets the week of the year for an enumerable of DateTime values using the default calendar of the current culture.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/> or empty.
-    /// </summary>
-    /// <param name="dts">The enumerable of DateTime values for which to get the week of the year.</param>
-    /// <returns>An <see cref="IEnumerable{Int32}"/> containing the week of the year values for the input DateTime values.</returns>
+    
     public static IEnumerable<int?> GetWeekOfYear(this IEnumerable<DateTime?> dts)
     {
         if (dts is null || !dts.Any())
@@ -220,52 +102,19 @@ public static partial class YANDateTime
         }
     }
 
-    /// <summary>
-    /// Returns the total number of months between the two specified <see cref="DateTime"/> values, ignoring the day of the month.
-    /// </summary>
-    /// <param name="dt1">The first <see cref="DateTime"/> value.</param>
-    /// <param name="dt2">The second <see cref="DateTime"/> value.</param>
-    /// <returns>The total number of months between the two specified <see cref="DateTime"/> values, ignoring the day of the month.</returns>
+    
     public static int? TotalMonths(DateTime? dt1, DateTime dt2) => dt1.HasValue ? TotalMonths(dt1.Value, dt2) : default;
 
-    /// <summary>
-    /// Returns the total number of months between the two specified <see cref="DateTime"/> values, ignoring the day of the month.
-    /// </summary>
-    /// <param name="dt1">The first <see cref="DateTime"/> value.</param>
-    /// <param name="dt2">The second <see cref="DateTime"/> value.</param>
-    /// <returns>The total number of months between the two specified <see cref="DateTime"/> values, ignoring the day of the month.</returns>
+    
     public static int? TotalMonths(DateTime dt1, DateTime? dt2) => dt2.HasValue ? TotalMonths(dt1, dt2.Value) : default;
 
-    /// <summary>
-    /// Returns the total number of months between the two specified <see cref="DateTime"/> values, ignoring the day of the month.
-    /// </summary>
-    /// <param name="dt1">The first <see cref="DateTime"/> value.</param>
-    /// <param name="dt2">The second <see cref="DateTime"/> value.</param>
-    /// <returns>The total number of months between the two specified <see cref="DateTime"/> values, ignoring the day of the month.</returns>
+    
     public static int? TotalMonths(DateTime? dt1, DateTime? dt2) => dt1.HasValue ? TotalMonths(dt1.Value, dt2) : default;
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.
-    /// </summary>
-    /// <typeparam name="T1">The type of the original time zone offset, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone offset, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzSrc">The time zone offset of the original <see cref="DateTime"/> value, in hours.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.</returns>
+    
     public static DateTime? ChangeTimeZone<T1, T2>(this DateTime? dt, T1 tzSrc, T2 tzDst) where T1 : struct where T2 : struct => dt.HasValue ? dt.Value.ChangeTimeZone(tzSrc, tzDst) : default;
 
-    /// <summary>
-    /// Returns an <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to a different time zone, based on the source and destination time zones specified.
-    /// The source and destination time zones are specified as generic type parameters <typeparamref name="T1"/> and <typeparamref name="T2"/> respectively, and must be of a struct type that represents a valid time zone identifier.
-    /// If any of the input <see cref="DateTime"/> values is <see langword="null"/>, no value will be returned for that input.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="tzSrc">The source time zone.</param>
-    /// <param name="tzDst">The destination time zone.</param>
-    /// <param name="dts">The <see cref="DateTime"/> values to convert to the destination time zone.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to the destination time zone.</returns>
+    
     public static IEnumerable<DateTime?> ChangeTimeZone<T1, T2>(this IEnumerable<DateTime?> dts, T1 tzSrc, T2 tzDst) where T1 : struct where T2 : struct
     {
         if (dts is null || !dts.Any())
@@ -278,15 +127,7 @@ public static partial class YANDateTime
         }
     }
 
-    /// <summary>
-    /// Converts an list of DateTime values from one time zone to another using the specified source and destination time zones, and updates the original list in-place.
-    /// If the input list is <see langword="null"/> or empty, no action is taken.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The list of DateTime values to convert and update.</param>
-    /// <param name="tzSrc">The source time zone to convert from.</param>
-    /// <param name="tzDst">The destination time zone to convert to.</param>
+    
     public static void ChangeTimeZone<T1, T2>(this IList<DateTime?> dts, T1 tzSrc, T2 tzDst) where T1 : struct where T2 : struct
     {
         if (dts is not null && dts.Count > 0)
@@ -298,28 +139,10 @@ public static void ChangeTimeZone<T1, T2>(this IList<DateTime?> dts, T1 tzSrc, T
         }
     }
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.
-    /// </summary>
-    /// <typeparam name="T1">The type of the original time zone offset, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone offset, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzSrc">The time zone offset of the original <see cref="DateTime"/> value, in hours.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.</returns>
+    
     public static DateTime? ChangeTimeZone<T1, T2>(this DateTime dt, T1? tzSrc, T2 tzDst) where T1 : struct where T2 : struct => tzSrc.HasValue ? dt.ChangeTimeZone(tzSrc.Value, tzDst) : dt.ChangeTimeZone(tzDst);
 
-    /// <summary>
-    /// Returns an <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to a different time zone, based on the source and destination time zones specified.
-    /// The source and destination time zones are specified as generic type parameters <typeparamref name="T1"/> and <typeparamref name="T2"/> respectively, and must be of a struct type that represents a valid time zone identifier.
-    /// If any of the input <see cref="DateTime"/> values is <see langword="null"/>, no value will be returned for that input.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="tzSrc">The source time zone.</param>
-    /// <param name="tzDst">The destination time zone.</param>
-    /// <param name="dts">The <see cref="DateTime"/> values to convert to the destination time zone.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to the destination time zone.</returns>
+    
     public static IEnumerable<DateTime?> ChangeTimeZone<T1, T2>(this IEnumerable<DateTime> dts, T1? tzSrc, T2 tzDst) where T1 : struct where T2 : struct
     {
         if (dts is null || !dts.Any())
@@ -332,28 +155,10 @@ public static void ChangeTimeZone<T1, T2>(this IList<DateTime?> dts, T1 tzSrc, T
         }
     }
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.
-    /// </summary>
-    /// <typeparam name="T1">The type of the original time zone offset, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone offset, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzSrc">The time zone offset of the original <see cref="DateTime"/> value, in hours.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.</returns>
+    
     public static DateTime? ChangeTimeZone<T1, T2>(this DateTime dt, T1 tzSrc, T2? tzDst) where T1 : struct where T2 : struct => tzDst.HasValue ? dt.ChangeTimeZone(tzSrc, tzDst.Value) : dt;
 
-    /// <summary>
-    /// Returns an <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to a different time zone, based on the source and destination time zones specified.
-    /// The source and destination time zones are specified as generic type parameters <typeparamref name="T1"/> and <typeparamref name="T2"/> respectively, and must be of a struct type that represents a valid time zone identifier.
-    /// If any of the input <see cref="DateTime"/> values is <see langword="null"/>, no value will be returned for that input.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="tzSrc">The source time zone.</param>
-    /// <param name="tzDst">The destination time zone.</param>
-    /// <param name="dts">The <see cref="DateTime"/> values to convert to the destination time zone.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to the destination time zone.</returns>
+    
     public static IEnumerable<DateTime?> ChangeTimeZone<T1, T2>(this IEnumerable<DateTime> dts, T1 tzSrc, T2? tzDst) where T1 : struct where T2 : struct
     {
         if (dts is null || !dts.Any())
@@ -366,28 +171,10 @@ public static void ChangeTimeZone<T1, T2>(this IList<DateTime?> dts, T1 tzSrc, T
         }
     }
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.
-    /// </summary>
-    /// <typeparam name="T1">The type of the original time zone offset, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone offset, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzSrc">The time zone offset of the original <see cref="DateTime"/> value, in hours.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.</returns>
+    
     public static DateTime? ChangeTimeZone<T1, T2>(this DateTime? dt, T1? tzSrc, T2 tzDst) where T1 : struct where T2 : struct => dt.HasValue ? dt.Value.ChangeTimeZone(tzSrc, tzDst) : default;
 
-    /// <summary>
-    /// Returns an <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to a different time zone, based on the source and destination time zones specified.
-    /// The source and destination time zones are specified as generic type parameters <typeparamref name="T1"/> and <typeparamref name="T2"/> respectively, and must be of a struct type that represents a valid time zone identifier.
-    /// If any of the input <see cref="DateTime"/> values is <see langword="null"/>, no value will be returned for that input.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="tzSrc">The source time zone.</param>
-    /// <param name="tzDst">The destination time zone.</param>
-    /// <param name="dts">The <see cref="DateTime"/> values to convert to the destination time zone.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to the destination time zone.</returns>
+    
     public static IEnumerable<DateTime?> ChangeTimeZone<T1, T2>(this IEnumerable<DateTime?> dts, T1? tzSrc, T2 tzDst) where T1 : struct where T2 : struct
     {
         if (dts is null || !dts.Any())
@@ -400,15 +187,7 @@ public static void ChangeTimeZone<T1, T2>(this IList<DateTime?> dts, T1 tzSrc, T
         }
     }
 
-    /// <summary>
-    /// Converts an list of DateTime values from one time zone to another using the specified source and destination time zones, and updates the original list in-place.
-    /// If the input list is <see langword="null"/> or empty, no action is taken.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The list of DateTime values to convert and update.</param>
-    /// <param name="tzSrc">The source time zone to convert from.</param>
-    /// <param name="tzDst">The destination time zone to convert to.</param>
+    
     public static void ChangeTimeZone<T1, T2>(this IList<DateTime?> dts, T1? tzSrc, T2 tzDst) where T1 : struct where T2 : struct
     {
         if (dts is not null && dts.Count > 0)
@@ -420,28 +199,10 @@ public static void ChangeTimeZone<T1, T2>(this IList<DateTime?> dts, T1? tzSrc,
         }
     }
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.
-    /// </summary>
-    /// <typeparam name="T1">The type of the original time zone offset, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone offset, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzSrc">The time zone offset of the original <see cref="DateTime"/> value, in hours.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.</returns>
+    
     public static DateTime? ChangeTimeZone<T1, T2>(this DateTime? dt, T1 tzSrc, T2? tzDst) where T1 : struct where T2 : struct => dt.HasValue ? dt.Value.ChangeTimeZone(tzSrc, tzDst) : default;
 
-    /// <summary>
-    /// Returns an <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to a different time zone, based on the source and destination time zones specified.
-    /// The source and destination time zones are specified as generic type parameters <typeparamref name="T1"/> and <typeparamref name="T2"/> respectively, and must be of a struct type that represents a valid time zone identifier.
-    /// If any of the input <see cref="DateTime"/> values is <see langword="null"/>, no value will be returned for that input.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="tzSrc">The source time zone.</param>
-    /// <param name="tzDst">The destination time zone.</param>
-    /// <param name="dts">The <see cref="DateTime"/> values to convert to the destination time zone.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to the destination time zone.</returns>
+    
     public static IEnumerable<DateTime?> ChangeTimeZone<T1, T2>(this IEnumerable<DateTime?> dts, T1 tzSrc, T2? tzDst) where T1 : struct where T2 : struct
     {
         if (dts is null || !dts.Any())
@@ -454,15 +215,7 @@ public static void ChangeTimeZone<T1, T2>(this IList<DateTime?> dts, T1? tzSrc,
         }
     }
 
-    /// <summary>
-    /// Converts an list of DateTime values from one time zone to another using the specified source and destination time zones, and updates the original list in-place.
-    /// If the input list is <see langword="null"/> or empty, no action is taken.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The list of DateTime values to convert and update.</param>
-    /// <param name="tzSrc">The source time zone to convert from.</param>
-    /// <param name="tzDst">The destination time zone to convert to.</param>
+    
     public static void ChangeTimeZone<T1, T2>(this IList<DateTime?> dts, T1 tzSrc, T2? tzDst) where T1 : struct where T2 : struct
     {
         if (dts is not null && dts.Count > 0)
@@ -474,28 +227,10 @@ public static void ChangeTimeZone<T1, T2>(this IList<DateTime?> dts, T1 tzSrc, T
         }
     }
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.
-    /// </summary>
-    /// <typeparam name="T1">The type of the original time zone offset, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone offset, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzSrc">The time zone offset of the original <see cref="DateTime"/> value, in hours.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.</returns>
+    
     public static DateTime? ChangeTimeZone<T1, T2>(this DateTime dt, T1? tzSrc, T2? tzDst) where T1 : struct where T2 : struct => tzSrc.HasValue ? dt.ChangeTimeZone(tzSrc.Value, tzDst) : dt.ChangeTimeZone(tzDst);
 
-    /// <summary>
-    /// Returns an <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to a different time zone, based on the source and destination time zones specified.
-    /// The source and destination time zones are specified as generic type parameters <typeparamref name="T1"/> and <typeparamref name="T2"/> respectively, and must be of a struct type that represents a valid time zone identifier.
-    /// If any of the input <see cref="DateTime"/> values is <see langword="null"/>, no value will be returned for that input.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="tzSrc">The source time zone.</param>
-    /// <param name="tzDst">The destination time zone.</param>
-    /// <param name="dts">The <see cref="DateTime"/> values to convert to the destination time zone.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to the destination time zone.</returns>
+    
     public static IEnumerable<DateTime?> ChangeTimeZone<T1, T2>(this IEnumerable<DateTime> dts, T1? tzSrc, T2? tzDst) where T1 : struct where T2 : struct
     {
         if (dts is null || !dts.Any())
@@ -508,28 +243,10 @@ public static void ChangeTimeZone<T1, T2>(this IList<DateTime?> dts, T1 tzSrc, T
         }
     }
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.
-    /// </summary>
-    /// <typeparam name="T1">The type of the original time zone offset, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone offset, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzSrc">The time zone offset of the original <see cref="DateTime"/> value, in hours.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.</returns>
+    
     public static DateTime? ChangeTimeZone<T1, T2>(this DateTime? dt, T1? tzSrc, T2? tzDst) where T1 : struct where T2 : struct => dt.HasValue ? dt.Value.ChangeTimeZone(tzSrc, tzDst) : default;
 
-    /// <summary>
-    /// Returns an <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to a different time zone, based on the source and destination time zones specified.
-    /// The source and destination time zones are specified as generic type parameters <typeparamref name="T1"/> and <typeparamref name="T2"/> respectively, and must be of a struct type that represents a valid time zone identifier.
-    /// If any of the input <see cref="DateTime"/> values is <see langword="null"/>, no value will be returned for that input.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="tzSrc">The source time zone.</param>
-    /// <param name="tzDst">The destination time zone.</param>
-    /// <param name="dts">The <see cref="DateTime"/> values to convert to the destination time zone.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to the destination time zone.</returns>
+    
     public static IEnumerable<DateTime?> ChangeTimeZone<T1, T2>(this IEnumerable<DateTime?> dts, T1? tzSrc, T2? tzDst) where T1 : struct where T2 : struct
     {
         if (dts is null || !dts.Any())
@@ -542,15 +259,7 @@ public static void ChangeTimeZone<T1, T2>(this IList<DateTime?> dts, T1 tzSrc, T
         }
     }
 
-    /// <summary>
-    /// Converts an list of DateTime values from one time zone to another using the specified source and destination time zones, and updates the original list in-place.
-    /// If the input list is <see langword="null"/> or empty, no action is taken.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The list of DateTime values to convert and update.</param>
-    /// <param name="tzSrc">The source time zone to convert from.</param>
-    /// <param name="tzDst">The destination time zone to convert to.</param>
+    
     public static void ChangeTimeZone<T1, T2>(this IList<DateTime?> dts, T1? tzSrc, T2? tzDst) where T1 : struct where T2 : struct
     {
         if (dts is not null && dts.Count > 0)
@@ -562,22 +271,10 @@ public static void ChangeTimeZone<T1, T2>(this IList<DateTime?> dts, T1? tzSrc,
         }
     }
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.
-    /// </summary>
-    /// <typeparam name="T">The type of the time zone offset to convert the original <see cref="DateTime"/> value to, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.</returns>
+    
     public static DateTime? ChangeTimeZone<T>(this DateTime? dt, T tzDst) where T : struct => dt.ChangeTimeZone(0, tzDst);
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.
-    /// </summary>
-    /// <typeparam name="T">The type of the time zone offset to convert the original <see cref="DateTime"/> value to, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.</returns>
+    
     public static IEnumerable<DateTime?> ChangeTimeZone<T>(this IEnumerable<DateTime?> dts, T tzDst) where T : struct
     {
         if (dts is null || !dts.Any())
@@ -590,13 +287,7 @@ public static void ChangeTimeZone<T1, T2>(this IList<DateTime?> dts, T1? tzSrc,
         }
     }
 
-    /// <summary>
-    /// Converts a list of DateTime values from one time zone to another using the specified destination time zone, and updates the original list in place with the DateTime values converted to the destination time zone.
-    /// If the input list is <see langword="null"/> or empty, no changes will be made.
-    /// </summary>
-    /// <typeparam name="T">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The list of DateTime values to convert.</param>
-    /// <param name="tzDst">The destination time zone to convert to.</param>
+
     public static void ChangeTimeZone<T>(this IList<DateTime?> dts, T tzDst) where T : struct
     {
         if (dts is not null && dts.Count > 0)
@@ -608,22 +299,10 @@ public static void ChangeTimeZone<T>(this IList<DateTime?> dts, T tzDst) where T
         }
     }
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.
-    /// </summary>
-    /// <typeparam name="T">The type of the time zone offset to convert the original <see cref="DateTime"/> value to, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.</returns>
+    
     public static DateTime? ChangeTimeZone<T>(this DateTime dt, T? tzDst) where T : struct => dt.ChangeTimeZone(0, tzDst);
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.
-    /// </summary>
-    /// <typeparam name="T">The type of the time zone offset to convert the original <see cref="DateTime"/> value to, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.</returns>
+    
     public static IEnumerable<DateTime?> ChangeTimeZone<T>(this IEnumerable<DateTime> dts, T? tzDst) where T : struct
     {
         if (dts is null || !dts.Any())
@@ -636,22 +315,10 @@ public static void ChangeTimeZone<T>(this IList<DateTime?> dts, T tzDst) where T
         }
     }
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.
-    /// </summary>
-    /// <typeparam name="T">The type of the time zone offset to convert the original <see cref="DateTime"/> value to, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.</returns>
+    
     public static DateTime? ChangeTimeZone<T>(this DateTime? dt, T? tzDst) where T : struct => dt.ChangeTimeZone(0, tzDst);
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.
-    /// </summary>
-    /// <typeparam name="T">The type of the time zone offset to convert the original <see cref="DateTime"/> value to, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.</returns>
+    
     public static IEnumerable<DateTime?> ChangeTimeZone<T>(this IEnumerable<DateTime?> dts, T? tzDst) where T : struct
     {
         if (dts is null || !dts.Any())
@@ -664,13 +331,7 @@ public static void ChangeTimeZone<T>(this IList<DateTime?> dts, T tzDst) where T
         }
     }
 
-    /// <summary>
-    /// Converts a list of DateTime values from one time zone to another using the specified destination time zone, and updates the original list in place with the DateTime values converted to the destination time zone.
-    /// If the input list is <see langword="null"/> or empty, no changes will be made.
-    /// </summary>
-    /// <typeparam name="T">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The list of DateTime values to convert.</param>
-    /// <param name="tzDst">The destination time zone to convert to.</param>
+
     public static void ChangeTimeZone<T>(this IList<DateTime?> dts, T? tzDst) where T : struct
     {
         if (dts is not null && dts.Count > 0)
diff --git a/lib/YANLib/Nullable/YANDateTime.cs b/lib/YANLib/Nullable/YANDateTime.cs
index 18dff697..d8162276 100644
--- a/lib/YANLib/Nullable/YANDateTime.cs
+++ b/lib/YANLib/Nullable/YANDateTime.cs
@@ -9,20 +9,10 @@ namespace YANLib.Nullable;
 
 public static partial class YANDateTime
 {
-    /// <summary>
-    /// Parses the string representation of a date and time using the default format.
-    /// Returns the parsed <see cref="DateTime"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="DateTime"/> value, or <see langword="default"/> if the parsing fails.</returns>
+    
     public static DateTime? ToDateTime(this string str) => TryParse(str, out var dt) ? dt : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings representing date/time values to an <see cref="IEnumerable{DateTime}"/> containing the parsed DateTime values.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only whitespace strings.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to convert to DateTime values.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the parsed DateTime values.</returns>
+    
     public static IEnumerable<DateTime?> ToDateTime(this IEnumerable<string> strs)
     {
         if (strs.IsNullOrWhiteSpace())
@@ -35,23 +25,11 @@ public static partial class YANDateTime
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a date and time using <paramref name="fmt"/>.
-    /// Returns the parsed <see cref="DateTime"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="fmt">The format of the string representation.</param>
-    /// <returns>The parsed <see cref="DateTime"/> value, or <see langword="default"/> if the parsing fails.</returns>
+    
     public static DateTime? ToDateTime(this string str, string fmt) => TryParseExact(str, fmt, InvariantCulture, None, out var dt) ? dt : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings representing date/time values in a specified format to an <see cref="IEnumerable{DateTime}"/> containing the parsed DateTime values.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only whitespace strings.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to convert to DateTime values.</param>
-    /// <param name="fmt">The format of the date/time values in the input strings.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the parsed DateTime values.</returns>
-    public static IEnumerable<DateTime?> ToDateTime(IEnumerable<string> strs, string fmt)
+    
+    public static IEnumerable<DateTime?> ToDateTime(this IEnumerable<string> strs, string fmt)
     {
         if (strs.IsNullOrWhiteSpace())
         {
@@ -63,26 +41,11 @@ public static partial class YANDateTime
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a date and time using <paramref name="fmt"/>.
-    /// Returns the parsed <see cref="DateTime"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="fmt">The format of the string representation.</param>
-    /// <param name="dfltVal">The default value to return if the parsing fails.</param>
-    /// <returns>The parsed <see cref="DateTime"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
+    
     public static DateTime? ToDateTime(this string str, string fmt, DateTime dfltVal) => TryParseExact(str, fmt, InvariantCulture, None, out var dt) ? dt : dfltVal;
 
-    /// <summary>
-    /// Converts an enumerable of strings representing date/time values in a specified format to an <see cref="IEnumerable{DateTime}"/> containing the parsed DateTime values.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only whitespace strings.
-    /// If a string cannot be parsed to a valid DateTime value, the default value specified by <paramref name="dfltVal"/> is used instead.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to convert to DateTime values.</param>
-    /// <param name="fmt">The format of the date/time values in the input strings.</param>
-    /// <param name="dfltVal">The default DateTime value to be used for strings that cannot be parsed to valid DateTime values.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the parsed DateTime values.</returns>
-    public static IEnumerable<DateTime?> ToDateTime(IEnumerable<string> strs, string fmt, DateTime dfltVal)
+    
+    public static IEnumerable<DateTime?> ToDateTime(this IEnumerable<string> strs, string fmt, DateTime dfltVal)
     {
         if (strs.IsNullOrWhiteSpace())
         {
@@ -94,28 +57,10 @@ public static partial class YANDateTime
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="DateTime"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <param name="min">The minimum <see cref="DateTime"/> value.</param>
-    /// <param name="max">The maximum <see cref="DateTime"/> value.</param>
-    /// <returns>A random <see cref="DateTime"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
+    
     public static DateTime? GenerateRandomDateTime(DateTime min, DateTime max) => min > max ? default : min.AddTicks(GenerateRandomLong((max - min).Ticks));
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of DateTime values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of <paramref name="size"/>.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="min">The minimum DateTime value.</param>
-    /// <param name="max">The maximum DateTime value.</param>
-    /// <param name="size">The number of DateTime values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.</returns>
+    
     public static IEnumerable<DateTime?> GenerateRandomDateTimes<T>(DateTime min, DateTime max, T size) where T : struct
     {
         for (var i = 0ul; i < YANNum.ToUlong(size); i++)
@@ -124,32 +69,16 @@ public static partial class YANDateTime
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="DateTime"/> value between <see cref="MinValue"/> and <see cref="MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="DateTime"/> value between <see cref="MinValue"/> and <see cref="MaxValue"/>.</returns>
+    
     public static DateTime? GenerateRandomDateTime() => GenerateRandomDateTime(MinValue, MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="DateTime"/> value between <see cref="MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <param name="max">The maximum <see cref="DateTime"/> value.</param>
-    /// <returns>A random <see cref="DateTime"/> value between <see cref="MinValue"/> and <paramref name="max"/>.</returns>
+    
     public static DateTime? GenerateRandomDateTime(DateTime max) => GenerateRandomDateTime(max > Today ? Today : MinValue, max);
 
-    /// <summary>
-    /// Returns the week of the year that the specified <see cref="DateTime"/> value falls in, according to the current culture's calendar, week rule, and first day of the week settings.
-    /// </summary>
-    /// <param name="dt">The <see cref="DateTime"/> value.</param>
-    /// <returns>The week of the year that the specified <see cref="DateTime"/> value falls in.</returns>
+    
     public static int? GetWeekOfYear(this DateTime dt) => CurrentInfo.Calendar.GetWeekOfYear(dt, CurrentInfo.CalendarWeekRule, CurrentInfo.FirstDayOfWeek);
 
-    /// <summary>
-    /// Gets the week of the year for an enumerable of DateTime values using the default calendar of the current culture.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/> or empty.
-    /// </summary>
-    /// <param name="dts">The enumerable of DateTime values for which to get the week of the year.</param>
-    /// <returns>An <see cref="IEnumerable{Int32}"/> containing the week of the year values for the input DateTime values.</returns>
+    
     public static IEnumerable<int?> GetWeekOfYear(this IEnumerable<DateTime> dts)
     {
         if (dts is null || !dts.Any())
@@ -162,23 +91,10 @@ public static partial class YANDateTime
         }
     }
 
-    /// <summary>
-    /// Returns the total number of months between the two specified <see cref="DateTime"/> values, ignoring the day of the month.
-    /// </summary>
-    /// <param name="dt1">The first <see cref="DateTime"/> value.</param>
-    /// <param name="dt2">The second <see cref="DateTime"/> value.</param>
-    /// <returns>The total number of months between the two specified <see cref="DateTime"/> values, ignoring the day of the month.</returns>
+    
     public static int? TotalMonths(DateTime dt1, DateTime dt2) => Abs((dt1.Year - dt2.Year) * 12 + dt1.Month - dt2.Month);
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.
-    /// </summary>
-    /// <typeparam name="T1">The type of the original time zone offset, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone offset, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzSrc">The time zone offset of the original <see cref="DateTime"/> value, in hours.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.</returns>
+    
     public static DateTime? ChangeTimeZone<T1, T2>(this DateTime dt, T1 tzSrc, T2 tzDst) where T1 : struct where T2 : struct
     {
         var diff = tzDst.ToInt() - tzSrc.ToInt();
@@ -190,16 +106,7 @@ public static partial class YANDateTime
         } : default;
     }
 
-    /// <summary>
-    /// Converts an enumerable of DateTime values from one time zone to another using the specified source and destination time zones.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/> or empty.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The enumerable of DateTime values to convert.</param>
-    /// <param name="tzSrc">The source time zone to convert from.</param>
-    /// <param name="tzDst">The destination time zone to convert to.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the DateTime values converted to the destination time zone.</returns>
+    
     public static IEnumerable<DateTime?> ChangeTimeZone<T1, T2>(this IEnumerable<DateTime> dts, T1 tzSrc, T2 tzDst) where T1 : struct where T2 : struct
     {
         if (dts is null || !dts.Any())
@@ -212,23 +119,10 @@ public static partial class YANDateTime
         }
     }
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.
-    /// </summary>
-    /// <typeparam name="T">The type of the time zone offset to convert the original <see cref="DateTime"/> value to, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.</returns>
+    
     public static DateTime? ChangeTimeZone<T>(this DateTime dt, T tzDst) where T : struct => dt.ChangeTimeZone(0, tzDst);
 
-    /// <summary>
-    /// Converts an array of DateTime values from one time zone to another using the specified destination time zone, and returns an <see cref="IEnumerable{DateTime}"/> containing the DateTime values converted to the destination time zone.
-    /// Returns an empty sequence if the input array is <see langword="null"/> or empty.
-    /// </summary>
-    /// <typeparam name="T">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The array of DateTime values to convert.</param>
-    /// <param name="tzDst">The destination time zone to convert to.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the DateTime values converted to the destination time zone.</returns>
+    
     public static IEnumerable<DateTime?> ChangeTimeZone<T>(this IEnumerable<DateTime> dts, T tzDst) where T : struct
     {
         if (dts is null || !dts.Any())
diff --git a/lib/YANLib/Nullable/YANNum.Byte.Nullable.cs b/lib/YANLib/Nullable/YANNum.Byte.Nullable.cs
index f4708153..8cca8796 100644
--- a/lib/YANLib/Nullable/YANNum.Byte.Nullable.cs
+++ b/lib/YANLib/Nullable/YANNum.Byte.Nullable.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a byte.
-    /// Returns the converted <see cref="byte"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="byte"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static byte? ToByte<T>(this T? num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{byte}"/> containing the byte representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the byte representations of the objects.</returns>
     public static IEnumerable<byte?> ToByte<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,27 +27,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a byte using the default format.
-    /// Returns the parsed <see cref="byte"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="byte"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static byte? ToByte<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToByte(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of string objects to an <see cref="IEnumerable{byte}"/> containing the byte representations of the strings, using a default value for invalid conversions.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for invalid conversions.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">The default value to be used for invalid conversions.</param>
-    /// <param name="strs">The enumerable of string objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the byte representations of the strings.</returns>
     public static IEnumerable<byte?> ToByte<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -76,28 +41,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="byte"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="byte"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static byte? GenerateRandomByte<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomByte(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates a sequence of random <see cref="byte"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of the generated sequence, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the generated sequence.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the random byte values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<byte?> GenerateRandomBytes<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -106,17 +51,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a sequence of random <see cref="byte"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of the generated sequence, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the generated sequence.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the random byte values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<byte?> GenerateRandomBytes<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -125,28 +59,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="byte"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="byte"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static byte? GenerateRandomByte<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomByte(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates a sequence of random <see cref="byte"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of the generated sequence, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the generated sequence.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the random byte values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<byte?> GenerateRandomBytes<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -155,17 +69,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a sequence of random <see cref="byte"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of the generated sequence, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the generated sequence.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the random byte values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<byte?> GenerateRandomBytes<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -174,28 +77,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="byte"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="byte"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static byte? GenerateRandomByte<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomByte(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates a sequence of random <see cref="byte"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of the generated sequence, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the generated sequence.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the random byte values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<byte?> GenerateRandomBytes<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -204,17 +87,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a sequence of random <see cref="byte"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of the generated sequence, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the generated sequence.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the random byte values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<byte?> GenerateRandomBytes<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -223,11 +95,5 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="byte"/> value between <see cref="byte.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="byte"/> value between <see cref="byte.MinValue"/> and <paramref name="max"/>.</returns>
     public static byte? GenerateRandomByte<T>(T? max) where T : struct => max.HasValue ? GenerateRandomByte(byte.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/Nullable/YANNum.Byte.cs b/lib/YANLib/Nullable/YANNum.Byte.cs
index 690a2858..da91dd0e 100644
--- a/lib/YANLib/Nullable/YANNum.Byte.cs
+++ b/lib/YANLib/Nullable/YANNum.Byte.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a byte.
-    /// Returns the converted <see cref="byte"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="byte"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static byte? ToByte<T>(this T num) where T : struct
     {
         try
@@ -21,16 +15,7 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{byte}"/> containing the byte representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the byte representations of the objects.</returns>
+    
     public static IEnumerable<byte?> ToByte<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,20 +28,10 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a byte using the default format.
-    /// Returns the parsed <see cref="byte"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="byte"/> value, or <see langword="default"/> if the parsing fails.</returns>
+    
     public static byte? ToByte(this string str) => byte.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of string objects to an <see cref="IEnumerable{byte}"/> containing the byte representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <param name="strs">The enumerable of string objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the byte representations of the strings.</returns>
+    
     public static IEnumerable<byte?> ToByte(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -69,27 +44,10 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a byte using the default format.
-    /// Returns the parsed <see cref="byte"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="byte"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
+    
     public static byte? ToByte<T>(this string str, T dfltVal) where T : struct => byte.TryParse(str, out var num) ? num : dfltVal.ToByte();
 
-    /// <summary>
-    /// Converts an enumerable of string objects to an <see cref="IEnumerable{byte}"/> containing the byte representations of the strings, using a default value for invalid conversions.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for invalid conversions.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">The default value to be used for invalid conversions.</param>
-    /// <param name="strs">The enumerable of string objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the byte representations of the strings.</returns>
+    
     public static IEnumerable<byte?> ToByte<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -102,15 +60,7 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="byte"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="byte"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
+    
     public static byte? GenerateRandomByte<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToByte();
@@ -118,17 +68,7 @@ public static partial class YANNum
         return minValue.HasValue && maxValue.HasValue ? minValue > maxValue ? default : new Random().Next(minValue.Value, maxValue.Value).ToByte() : default;
     }
 
-    /// <summary>
-    /// Generates a sequence of random <see cref="byte"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of the generated sequence, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the generated sequence.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the random byte values between <paramref name="min"/> and <paramref name="max"/>.</returns>
+    
     public static IEnumerable<byte?> GenerateRandomBytes<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -137,17 +77,9 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="byte"/> value between <see cref="byte.MinValue"/> and <see cref="byte.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="byte"/> value between <see cref="byte.MinValue"/> and <see cref="byte.MaxValue"/>.</returns>
+    
     public static byte? GenerateRandomByte() => GenerateRandomByte(byte.MinValue, byte.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="byte"/> value between <see cref="byte.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="byte"/> value between <see cref="byte.MinValue"/> and <paramref name="max"/>.</returns>
+    
     public static byte? GenerateRandomByte<T>(T max) where T : struct => GenerateRandomByte(byte.MinValue, max);
 }
diff --git a/lib/YANLib/Nullable/YANNum.Decimal.Nullable.cs b/lib/YANLib/Nullable/YANNum.Decimal.Nullable.cs
index 384b248c..c2a45307 100644
--- a/lib/YANLib/Nullable/YANNum.Decimal.Nullable.cs
+++ b/lib/YANLib/Nullable/YANNum.Decimal.Nullable.cs
@@ -2,13 +2,7 @@
 
 public partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a decimal.
-    /// Returns the converted <see cref="decimal"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="decimal"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static decimal? ToDecimal<T>(this T? num) where T : struct
     {
         try
@@ -21,15 +15,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of values of a generic value type to an <see cref="IEnumerable{decimal}"/> containing the decimal representations of the values.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/> or empty.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the values to be converted, which must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of values to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{decimal}"/> containing the decimal representations of the values.</returns>
     public static IEnumerable<decimal?> ToDecimal<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -42,27 +27,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a decimal using the default format.
-    /// Returns the parsed <see cref="decimal"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="decimal"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static decimal? ToDecimal<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToDecimal(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of string objects to an <see cref="IEnumerable{decimal}"/> containing the decimal representations of the strings, using a default value for invalid conversions.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/> or empty.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for invalid conversions.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">The default value to be used for invalid conversions.</param>
-    /// <param name="strs">The enumerable of string objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{decimal}"/> containing the decimal representations of the strings.</returns>
     public static IEnumerable<decimal?> ToDecimal<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -75,27 +41,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="decimal"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="decimal"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static decimal? GenerateRandomDecimal<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomDecimal(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{decimal}"/> sequence of random decimal values between <paramref name="min"/> and <paramref name="max"/>, with the number of values specified by <paramref name="size"/>, using a default value for invalid conversions.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random decimal values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{decimal}"/> containing the randomly generated decimal values.</returns>
     public static IEnumerable<decimal?> GenerateRandomDecimals<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -104,16 +51,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{decimal}"/> sequence of random decimal values between <paramref name="min"/> and <paramref name="max"/>, with the number of values specified by <paramref name="size"/>, using a default value for invalid conversions.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random decimal values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{decimal}"/> containing the randomly generated decimal values.</returns>
     public static IEnumerable<decimal?> GenerateRandomDecimals<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -122,27 +59,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="decimal"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="decimal"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static decimal? GenerateRandomDecimal<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomDecimal(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{decimal}"/> sequence of random decimal values between <paramref name="min"/> and <paramref name="max"/>, with the number of values specified by <paramref name="size"/>, using a default value for invalid conversions.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random decimal values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{decimal}"/> containing the randomly generated decimal values.</returns>
     public static IEnumerable<decimal?> GenerateRandomDecimals<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -151,16 +69,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{decimal}"/> sequence of random decimal values between <paramref name="min"/> and <paramref name="max"/>, with the number of values specified by <paramref name="size"/>, using a default value for invalid conversions.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random decimal values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{decimal}"/> containing the randomly generated decimal values.</returns>
     public static IEnumerable<decimal?> GenerateRandomDecimals<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -169,27 +77,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="decimal"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="decimal"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static decimal? GenerateRandomDecimal<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomDecimal(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{decimal}"/> sequence of random decimal values between <paramref name="min"/> and <paramref name="max"/>, with the number of values specified by <paramref name="size"/>, using a default value for invalid conversions.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random decimal values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{decimal}"/> containing the randomly generated decimal values.</returns>
     public static IEnumerable<decimal?> GenerateRandomDecimals<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -198,16 +87,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{decimal}"/> sequence of random decimal values between <paramref name="min"/> and <paramref name="max"/>, with the number of values specified by <paramref name="size"/>, using a default value for invalid conversions.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random decimal values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{decimal}"/> containing the randomly generated decimal values.</returns>
     public static IEnumerable<decimal?> GenerateRandomDecimals<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -216,11 +95,5 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="decimal"/> value between <see cref="decimal.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="decimal"/> value between <see cref="decimal.MinValue"/> and <paramref name="max"/>.</returns>
     public static decimal? GenerateRandomDecimal<T>(T? max) where T : struct => max.HasValue ? GenerateRandomDecimal(decimal.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/Nullable/YANNum.Decimal.cs b/lib/YANLib/Nullable/YANNum.Decimal.cs
index bd2bbeb4..89645441 100644
--- a/lib/YANLib/Nullable/YANNum.Decimal.cs
+++ b/lib/YANLib/Nullable/YANNum.Decimal.cs
@@ -2,13 +2,7 @@
 
 public partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a decimal.
-    /// Returns the converted <see cref="decimal"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="decimal"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static decimal? ToDecimal<T>(this T num) where T : struct
     {
         try
@@ -21,15 +15,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of values of a generic value type to an <see cref="IEnumerable{decimal}"/> containing the decimal representations of the values.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/> or empty.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the values to be converted, which must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of values to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{decimal}"/> containing the decimal representations of the values.</returns>
     public static IEnumerable<decimal?> ToDecimal<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -42,20 +27,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a decimal using the default format.
-    /// Returns the parsed <see cref="decimal"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="decimal"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static decimal? ToDecimal(this string str) => decimal.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of string objects to an <see cref="IEnumerable{decimal}"/> containing the decimal representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/> or empty.
-    /// </summary>
-    /// <param name="strs">The enumerable of string objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{decimal}"/> containing the decimal representations of the strings.</returns>
     public static IEnumerable<decimal?> ToDecimal(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -68,27 +41,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a decimal using the default format.
-    /// Returns the parsed <see cref="decimal"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="decimal"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static decimal? ToDecimal<T>(this string str, T dfltVal) where T : struct => decimal.TryParse(str, out var num) ? num : dfltVal.ToDecimal();
 
-    /// <summary>
-    /// Converts an enumerable of string objects to an <see cref="IEnumerable{decimal}"/> containing the decimal representations of the strings, using a default value for invalid conversions.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/> or empty.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for invalid conversions.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">The default value to be used for invalid conversions.</param>
-    /// <param name="strs">The enumerable of string objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{decimal}"/> containing the decimal representations of the strings.</returns>
     public static IEnumerable<decimal?> ToDecimal<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -101,15 +55,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="decimal"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="decimal"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static decimal? GenerateRandomDecimal<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToDecimal();
@@ -117,16 +62,6 @@ public partial class YANNum
         return minValue.HasValue && maxValue.HasValue ? minValue > maxValue ? default : new Random().NextDecimal(minValue.Value, maxValue.Value) : default;
     }
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{decimal}"/> sequence of random decimal values between <paramref name="min"/> and <paramref name="max"/>, with the number of values specified by <paramref name="size"/>, using a default value for invalid conversions.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random decimal values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{decimal}"/> containing the randomly generated decimal values.</returns>
     public static IEnumerable<decimal?> GenerateRandomDecimals<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -135,17 +70,7 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="decimal"/> value between <see cref="decimal.MinValue"/> and <see cref="decimal.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="decimal"/> value between <see cref="decimal.MinValue"/> and <see cref="decimal.MaxValue"/>.</returns>
     public static decimal? GenerateRandomDecimal() => GenerateRandomDecimal(decimal.MinValue, decimal.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="decimal"/> value between <see cref="decimal.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="decimal"/> value between <see cref="decimal.MinValue"/> and <paramref name="max"/>.</returns>
     public static decimal? GenerateRandomDecimal<T>(T max) where T : struct => GenerateRandomDecimal(decimal.MinValue, max);
 }
diff --git a/lib/YANLib/Nullable/YANNum.Double.Nullable.cs b/lib/YANLib/Nullable/YANNum.Double.Nullable.cs
index ffa69186..992d3e74 100644
--- a/lib/YANLib/Nullable/YANNum.Double.Nullable.cs
+++ b/lib/YANLib/Nullable/YANNum.Double.Nullable.cs
@@ -2,13 +2,7 @@
 
 public partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a double.
-    /// Returns the converted <see cref="double"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="double"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static double? ToDouble<T>(this T? num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{double}"/> containing the double representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{double}"/> containing the double representations of the objects.</returns>
     public static IEnumerable<double?> ToDouble<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,27 +27,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a double using the default format.
-    /// Returns the parsed <see cref="double"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="double"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static double? ToDouble<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToDouble(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{double}"/> containing the double representations of the strings, using a default value for conversion failures.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value for conversion failures.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">The default value to use for conversion failures.</param>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{double}"/> containing the double representations of the strings.</returns>
     public static IEnumerable<double?> ToDouble<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -76,28 +41,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="double"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="double"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static double? GenerateRandomDouble<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomDouble(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="double"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{double}"/> containing the random double values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<double?> GenerateRandomDoubles<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -106,17 +51,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="double"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{double}"/> containing the random double values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<double?> GenerateRandomDoubles<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -125,28 +59,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="double"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="double"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static double? GenerateRandomDouble<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomDouble(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="double"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{double}"/> containing the random double values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<double?> GenerateRandomDoubles<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -155,17 +69,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="double"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{double}"/> containing the random double values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<double?> GenerateRandomDoubles<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -174,28 +77,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="double"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="double"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static double? GenerateRandomDouble<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomDouble(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="double"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{double}"/> containing the random double values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<double?> GenerateRandomDoubles<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -204,17 +87,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="double"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{double}"/> containing the random double values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<double?> GenerateRandomDoubles<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -223,11 +95,5 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="double"/> value between <see cref="double.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="double"/> value between <see cref="double.MinValue"/> and <paramref name="max"/>.</returns>
     public static double? GenerateRandomDouble<T>(T? max) where T : struct => max.HasValue ? GenerateRandomDouble(double.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/Nullable/YANNum.Double.cs b/lib/YANLib/Nullable/YANNum.Double.cs
index ac66bd60..ecde846c 100644
--- a/lib/YANLib/Nullable/YANNum.Double.cs
+++ b/lib/YANLib/Nullable/YANNum.Double.cs
@@ -2,13 +2,7 @@
 
 public partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a double.
-    /// Returns the converted <see cref="double"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="double"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static double? ToDouble<T>(this T num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{double}"/> containing the double representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{double}"/> containing the double representations of the objects.</returns>
     public static IEnumerable<double?> ToDouble<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,20 +27,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a double using the default format.
-    /// Returns the parsed <see cref="double"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="double"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static double? ToDouble(this string str) => double.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{double}"/> containing the double representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{double}"/> containing the double representations of the strings.</returns>
     public static IEnumerable<double?> ToDouble(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -69,27 +41,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a double using the default format.
-    /// Returns the parsed <see cref="double"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="double"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static double? ToDouble<T>(this string str, T dfltVal) where T : struct => double.TryParse(str, out var num) ? num : dfltVal.ToDouble();
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{double}"/> containing the double representations of the strings, using a default value for conversion failures.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value for conversion failures.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">The default value to use for conversion failures.</param>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{double}"/> containing the double representations of the strings.</returns>
     public static IEnumerable<double?> ToDouble<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -102,15 +55,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="double"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="double"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static double? GenerateRandomDouble<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToDouble();
@@ -118,17 +62,6 @@ public partial class YANNum
         return minValue.HasValue && maxValue.HasValue ? minValue > maxValue ? default : new Random().NextDouble(minValue.Value, maxValue.Value) : default;
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="double"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{double}"/> containing the random double values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<double?> GenerateRandomDoubles<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -137,17 +70,7 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="double"/> value between <see cref="double.MinValue"/> and <see cref="double.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="double"/> value between <see cref="double.MinValue"/> and <see cref="double.MaxValue"/>.</returns>
     public static double? GenerateRandomDouble() => GenerateRandomDouble(double.MinValue, double.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="double"/> value between <see cref="double.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="double"/> value between <see cref="double.MinValue"/> and <paramref name="max"/>.</returns>
     public static double? GenerateRandomDouble<T>(T max) where T : struct => GenerateRandomDouble(double.MinValue, max);
 }
diff --git a/lib/YANLib/Nullable/YANNum.Float.Nullable.cs b/lib/YANLib/Nullable/YANNum.Float.Nullable.cs
index aac5dacb..898ac12f 100644
--- a/lib/YANLib/Nullable/YANNum.Float.Nullable.cs
+++ b/lib/YANLib/Nullable/YANNum.Float.Nullable.cs
@@ -2,13 +2,7 @@
 
 public partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a single-precision floating-point number.
-    /// Returns the converted <see cref="float"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="float"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static float? ToFloat<T>(this T? num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{float}"/> containing the float representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{float}"/> containing the float representations of the objects.</returns>
     public static IEnumerable<float?> ToFloat<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,27 +27,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a float using the default format.
-    /// Returns the parsed <see cref="float"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="float"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static float? ToFloat<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToFloat(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings <paramref name="strs"/> to an <see cref="IEnumerable{float}"/> containing the float representations of the strings, using a default value <paramref name="dfltVal"/> for parsing invalid or null strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value for parsing invalid or null strings.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">The default value to be used for parsing invalid or null strings.</param>
-    /// <param name="strs">The enumerable of strings to be converted to float.</param>
-    /// <returns>An <see cref="IEnumerable{float}"/> containing the float representations of the strings.</returns>
     public static IEnumerable<float?> ToFloat<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -76,28 +41,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="float"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="float"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static float? GenerateRandomFloat<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomFloat(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="float"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified <paramref name="size"/> of elements.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of elements, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of elements to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{float}"/> containing random float values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<float?> GenerateRandomFloats<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -106,17 +51,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="float"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified <paramref name="size"/> of elements.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of elements, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of elements to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{float}"/> containing random float values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<float?> GenerateRandomFloats<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -125,28 +59,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="float"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="float"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static float? GenerateRandomFloat<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomFloat(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="float"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified <paramref name="size"/> of elements.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of elements, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of elements to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{float}"/> containing random float values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<float?> GenerateRandomFloats<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -155,17 +69,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="float"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified <paramref name="size"/> of elements.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of elements, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of elements to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{float}"/> containing random float values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<float?> GenerateRandomFloats<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -174,28 +77,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="float"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="float"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static float? GenerateRandomFloat<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomFloat(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="float"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified <paramref name="size"/> of elements.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of elements, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of elements to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{float}"/> containing random float values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<float?> GenerateRandomFloats<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -204,17 +87,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="float"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified <paramref name="size"/> of elements.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of elements, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of elements to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{float}"/> containing random float values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<float?> GenerateRandomFloats<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -223,11 +95,5 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="float"/> value between <see cref="float.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="float"/> value between <see cref="float.MinValue"/> and <paramref name="max"/>.</returns>
     public static float? GenerateRandomFloat<T>(T? max) where T : struct => max.HasValue ? GenerateRandomFloat(float.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/Nullable/YANNum.Float.cs b/lib/YANLib/Nullable/YANNum.Float.cs
index 80a5bf0f..477a6b86 100644
--- a/lib/YANLib/Nullable/YANNum.Float.cs
+++ b/lib/YANLib/Nullable/YANNum.Float.cs
@@ -2,13 +2,7 @@
 
 public partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a single-precision floating-point number.
-    /// Returns the converted <see cref="float"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="float"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static float? ToFloat<T>(this T num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{float}"/> containing the float representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{float}"/> containing the float representations of the objects.</returns>
     public static IEnumerable<float?> ToFloat<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,20 +27,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a <see cref="float"/> using the default format.
-    /// Returns the parsed <see cref="float"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="float"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static float? ToFloat(this string str) => float.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings <paramref name="strs"/> to an <see cref="IEnumerable{float}"/> containing the float representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to be converted to float.</param>
-    /// <returns>An <see cref="IEnumerable{float}"/> containing the float representations of the strings.</returns>
     public static IEnumerable<float?> ToFloat(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -69,27 +41,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a float using the default format.
-    /// Returns the parsed <see cref="float"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="float"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static float? ToFloat<T>(this string str, T dfltVal) where T : struct => float.TryParse(str, out var num) ? num : dfltVal.ToFloat();
 
-    /// <summary>
-    /// Converts an enumerable of strings <paramref name="strs"/> to an <see cref="IEnumerable{float}"/> containing the float representations of the strings, using a default value <paramref name="dfltVal"/> for parsing invalid or null strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value for parsing invalid or null strings.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">The default value to be used for parsing invalid or null strings.</param>
-    /// <param name="strs">The enumerable of strings to be converted to float.</param>
-    /// <returns>An <see cref="IEnumerable{float}"/> containing the float representations of the strings.</returns>
     public static IEnumerable<float?> ToFloat<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -102,15 +55,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="float"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="float"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static float? GenerateRandomFloat<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToFloat();
@@ -118,17 +62,6 @@ public partial class YANNum
         return minValue.HasValue && maxValue.HasValue ? minValue > maxValue ? default : new Random().NextSingle(minValue.Value, maxValue.Value) : default;
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="float"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified <paramref name="size"/> of elements.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of elements, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of elements to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{float}"/> containing random float values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<float?> GenerateRandomFloats<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -137,17 +70,7 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="float"/> value between <see cref="float.MinValue"/> and <see cref="float.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="float"/> value between <see cref="float.MinValue"/> and <see cref="float.MaxValue"/>.</returns>
     public static float? GenerateRandomFloat() => GenerateRandomFloat(float.MinValue, float.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="float"/> value between <see cref="float.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="float"/> value between <see cref="float.MinValue"/> and <paramref name="max"/>.</returns>
     public static float? GenerateRandomFloat<T>(T max) where T : struct => GenerateRandomFloat(float.MinValue, max);
 }
diff --git a/lib/YANLib/Nullable/YANNum.Int.Nullable.cs b/lib/YANLib/Nullable/YANNum.Int.Nullable.cs
index 1fac46ac..d8c00828 100644
--- a/lib/YANLib/Nullable/YANNum.Int.Nullable.cs
+++ b/lib/YANLib/Nullable/YANNum.Int.Nullable.cs
@@ -2,13 +2,7 @@
 
 public partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to an integer.
-    /// Returns the converted <see cref="int"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="int"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static int? ToInt<T>(this T? num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{int}"/> containing the integer representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{int}"/> containing the integer representations of the objects.</returns>
     public static IEnumerable<int?> ToInt<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,27 +27,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of an integer using the default format.
-    /// Returns the parsed <see cref="int"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="int"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static int? ToInt<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToInt(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings <paramref name="strs"/> to an <see cref="IEnumerable{int}"/> containing the integer representations of the strings, using the specified default value <paramref name="dfltVal"/> for parsing strings that cannot be converted to integers.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for parsing strings that cannot be converted to integers.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">The default value to be used for parsing strings that cannot be converted to integers.</param>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{int}"/> containing the integer representations of the strings.</returns>
     public static IEnumerable<int?> ToInt<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -76,28 +41,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="int"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="int"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static int? GenerateRandomInt<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomInt(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="int"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{int}"/> containing the random integer values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<int?> GenerateRandomInts<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -106,17 +51,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="int"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{int}"/> containing the random integer values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<int?> GenerateRandomInts<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -125,28 +59,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="int"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="int"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static int? GenerateRandomInt<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomInt(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="int"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{int}"/> containing the random integer values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<int?> GenerateRandomInts<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -155,17 +69,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="int"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{int}"/> containing the random integer values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<int?> GenerateRandomInts<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -174,28 +77,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="int"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="int"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static int? GenerateRandomInt<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomInt(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="int"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{int}"/> containing the random integer values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<int?> GenerateRandomInts<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -204,17 +87,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="int"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{int}"/> containing the random integer values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<int?> GenerateRandomInts<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -223,11 +95,5 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="int"/> value between <see cref="int.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="int"/> value between <see cref="int.MinValue"/> and <paramref name="max"/>.</returns>
     public static int? GenerateRandomInt<T>(T? max) where T : struct => max.HasValue ? GenerateRandomInt(int.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/Nullable/YANNum.Int.cs b/lib/YANLib/Nullable/YANNum.Int.cs
index 6f3620d5..9308ae18 100644
--- a/lib/YANLib/Nullable/YANNum.Int.cs
+++ b/lib/YANLib/Nullable/YANNum.Int.cs
@@ -2,13 +2,7 @@
 
 public partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to an integer.
-    /// Returns the converted <see cref="int"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="int"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static int? ToInt<T>(this T num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{int}"/> containing the integer representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{int}"/> containing the integer representations of the objects.</returns>
     public static IEnumerable<int?> ToInt<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,20 +27,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of an integer using the default format.
-    /// Returns the parsed <see cref="int"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="int"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static int? ToInt(this string str) => int.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings <paramref name="strs"/> to an <see cref="IEnumerable{int}"/> containing the integer representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{int}"/> containing the integer representations of the strings.</returns>
     public static IEnumerable<int?> ToInt(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -69,27 +41,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of an integer using the default format.
-    /// Returns the parsed <see cref="int"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="int"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static int? ToInt<T>(this string str, T dfltVal) where T : struct => int.TryParse(str, out var num) ? num : dfltVal.ToInt();
 
-    /// <summary>
-    /// Converts an enumerable of strings <paramref name="strs"/> to an <see cref="IEnumerable{int}"/> containing the integer representations of the strings, using the specified default value <paramref name="dfltVal"/> for parsing strings that cannot be converted to integers.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for parsing strings that cannot be converted to integers.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">The default value to be used for parsing strings that cannot be converted to integers.</param>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{int}"/> containing the integer representations of the strings.</returns>
     public static IEnumerable<int?> ToInt<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -102,15 +55,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="int"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="int"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static int? GenerateRandomInt<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToInt();
@@ -118,17 +62,6 @@ public partial class YANNum
         return minValue.HasValue && maxValue.HasValue ? minValue > maxValue ? default : new Random().Next(minValue.Value, maxValue.Value) : default;
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="int"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{int}"/> containing the random integer values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<int?> GenerateRandomInts<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -137,17 +70,7 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="int"/> value between <see cref="int.MinValue"/> and <see cref="int.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="int"/> value between <see cref="int.MinValue"/> and <see cref="int.MaxValue"/>.</returns>
     public static int? GenerateRandomInt() => GenerateRandomInt(int.MinValue, int.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="int"/> value between <see cref="int.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="int"/> value between <see cref="int.MinValue"/> and <paramref name="max"/>.</returns>
     public static int? GenerateRandomInt<T>(T max) where T : struct => GenerateRandomInt(int.MinValue, max);
 }
diff --git a/lib/YANLib/Nullable/YANNum.Long.Nullable.cs b/lib/YANLib/Nullable/YANNum.Long.Nullable.cs
index 911d7c14..9eb44daa 100644
--- a/lib/YANLib/Nullable/YANNum.Long.Nullable.cs
+++ b/lib/YANLib/Nullable/YANNum.Long.Nullable.cs
@@ -2,13 +2,7 @@
 
 public partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a long integer.
-    /// Returns the converted <see cref="long"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="long"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static long? ToLong<T>(this T? num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{long}"/> containing the long integer representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{long}"/> containing the long integer representations of the objects.</returns>
     public static IEnumerable<long?> ToLong<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,27 +27,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a long using the default format.
-    /// Returns the parsed <see cref="long"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="long"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static long? ToLong<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToLong(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{long}"/> containing the long integer representations of the strings, using a default value for invalid or null strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for invalid or null strings.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">The default value to be used for invalid or null strings.</param>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{long}"/> containing the long integer representations of the strings.</returns>
     public static IEnumerable<long?> ToLong<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -76,28 +41,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="long"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="long"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static long? GenerateRandomLong<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomLong(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="long"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{long}"/> containing random long values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<long?> GenerateRandomLongs<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -106,17 +51,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="long"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{long}"/> containing random long values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<long?> GenerateRandomLongs<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -125,28 +59,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="long"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="long"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static long? GenerateRandomLong<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomLong(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="long"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{long}"/> containing random long values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<long?> GenerateRandomLongs<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -155,17 +69,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="long"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{long}"/> containing random long values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<long?> GenerateRandomLongs<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -174,28 +77,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="long"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="long"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static long? GenerateRandomLong<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomLong(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="long"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{long}"/> containing random long values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<long?> GenerateRandomLongs<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -204,17 +87,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="long"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{long}"/> containing random long values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<long?> GenerateRandomLongs<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -223,11 +95,5 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="long"/> value between <see cref="long.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="long"/> value between <see cref="long.MinValue"/> and <paramref name="max"/>.</returns>
     public static long? GenerateRandomLong<T>(T? max) where T : struct => max.HasValue ? GenerateRandomLong(long.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/Nullable/YANNum.Long.cs b/lib/YANLib/Nullable/YANNum.Long.cs
index ea15b879..f5568593 100644
--- a/lib/YANLib/Nullable/YANNum.Long.cs
+++ b/lib/YANLib/Nullable/YANNum.Long.cs
@@ -2,13 +2,7 @@
 
 public partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a long integer.
-    /// Returns the converted <see cref="long"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="long"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static long? ToLong<T>(this T num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{long}"/> containing the long integer representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{long}"/> containing the long integer representations of the objects.</returns>
     public static IEnumerable<long?> ToLong<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,20 +27,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a long using the default format.
-    /// Returns the parsed <see cref="long"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="long"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static long? ToLong(this string str) => long.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{long}"/> containing the long integer representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{long}"/> containing the long integer representations of the strings.</returns>
     public static IEnumerable<long?> ToLong(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -69,27 +41,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a long using the default format.
-    /// Returns the parsed <see cref="long"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="long"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static long? ToLong<T>(this string str, T dfltVal) where T : struct => long.TryParse(str, out var num) ? num : dfltVal.ToLong();
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{long}"/> containing the long integer representations of the strings, using a default value for invalid or null strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for invalid or null strings.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">The default value to be used for invalid or null strings.</param>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{long}"/> containing the long integer representations of the strings.</returns>
     public static IEnumerable<long?> ToLong<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -102,15 +55,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="long"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="long"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static long? GenerateRandomLong<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToLong();
@@ -118,17 +62,6 @@ public partial class YANNum
         return minValue.HasValue && maxValue.HasValue ? minValue > maxValue ? default : new Random().NextInt64(minValue.Value, maxValue.Value) : default;
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="long"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{long}"/> containing random long values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<long?> GenerateRandomLongs<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -137,17 +70,7 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="long"/> value between <see cref="long.MinValue"/> and <see cref="long.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="long"/> value between <see cref="long.MinValue"/> and <see cref="long.MaxValue"/>.</returns>
     public static long? GenerateRandomLong() => GenerateRandomLong(long.MinValue, long.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="long"/> value between <see cref="long.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="long"/> value between <see cref="long.MinValue"/> and <paramref name="max"/>.</returns>
     public static long? GenerateRandomLong<T>(T max) where T : struct => GenerateRandomLong(long.MinValue, max);
 }
diff --git a/lib/YANLib/Nullable/YANNum.Nint.Nullable.cs b/lib/YANLib/Nullable/YANNum.Nint.Nullable.cs
index b133ce36..508465a5 100644
--- a/lib/YANLib/Nullable/YANNum.Nint.Nullable.cs
+++ b/lib/YANLib/Nullable/YANNum.Nint.Nullable.cs
@@ -2,13 +2,7 @@
 
 public partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a native integer (nint).
-    /// Returns the converted <see cref="nint"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="nint"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static nint? ToNint<T>(this T? num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{nint}"/> containing the nint representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{nint}"/> containing the nint representations of the objects.</returns>
     public static IEnumerable<nint?> ToNint<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,30 +27,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a pointer-sized signed integer using the default format.
-    /// Returns the parsed <see cref="nint"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="nint"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static nint? ToNint<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToNint(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{nint}"/> containing the nint representations of the strings, with an optional default value for conversion.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value for conversion.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">
-    /// The default value for conversion if a string cannot be parsed to nint.
-    /// Used when conversion fails for a particular string.
-    /// </param>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{nint}"/> containing the nint representations of the strings.</returns>
     public static IEnumerable<nint?> ToNint<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -79,28 +41,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="nint"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="nint"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static nint? GenerateRandomNint<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomNint(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>, with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable, specifying the number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nint?> GenerateRandomNints<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -109,17 +51,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>, with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable, specifying the number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nint?> GenerateRandomNints<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -128,28 +59,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="nint"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="nint"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static nint? GenerateRandomNint<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomNint(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>, with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable, specifying the number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nint?> GenerateRandomNints<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -158,17 +69,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>, with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable, specifying the number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nint?> GenerateRandomNints<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -177,28 +77,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="nint"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="nint"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static nint? GenerateRandomNint<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomNint(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>, with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable, specifying the number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nint?> GenerateRandomNints<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -207,17 +87,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>, with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable, specifying the number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nint?> GenerateRandomNints<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -226,11 +95,5 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="nint"/> value between <see cref="nint.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="nint"/> value between <see cref="nint.MinValue"/> and <paramref name="max"/>.</returns>
     public static nint? GenerateRandomNint<T>(T? max) where T : struct => max.HasValue ? GenerateRandomNint(nint.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/Nullable/YANNum.Nint.cs b/lib/YANLib/Nullable/YANNum.Nint.cs
index d8d2b4fb..a0e8ffd4 100644
--- a/lib/YANLib/Nullable/YANNum.Nint.cs
+++ b/lib/YANLib/Nullable/YANNum.Nint.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a native integer (nint).
-    /// Returns the converted <see cref="nint"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="nint"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static nint? ToNint<T>(this T num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{nint}"/> containing the nint representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{nint}"/> containing the nint representations of the objects.</returns>
     public static IEnumerable<nint?> ToNint<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,20 +27,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a nint using the default format.
-    /// Returns the parsed <see cref="nint"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="nint"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static nint? ToNint(this string str) => nint.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{nint}"/> containing the nint representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{nint}"/> containing the nint representations of the strings.</returns>
     public static IEnumerable<nint?> ToNint(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -69,30 +41,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a nint using the default format.
-    /// Returns the parsed <see cref="nint"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="nint"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static nint? ToNint<T>(this string str, T dfltVal) where T : struct => nint.TryParse(str, out var num) ? num : dfltVal.ToNint();
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{nint}"/> containing the nint representations of the strings, with an optional default value for conversion.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value for conversion.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">
-    /// The default value for conversion if a string cannot be parsed to nint.
-    /// Used when conversion fails for a particular string.
-    /// </param>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{nint}"/> containing the nint representations of the strings.</returns>
     public static IEnumerable<nint?> ToNint<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -105,15 +55,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="IntPtr"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="IntPtr"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static nint? GenerateRandomNint<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToNint();
@@ -121,17 +62,6 @@ public static partial class YANNum
         return minValue.HasValue && maxValue.HasValue ? minValue > maxValue ? default : new Random().NextInt64(minValue.Value, maxValue.Value).ToNint() : default;
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>, with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable, specifying the number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nint?> GenerateRandomNints<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -140,17 +70,7 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="nint"/> value between <see cref="nint.MinValue"/> and <see cref="nint.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="nint"/> value between <see cref="nint.MinValue"/> and <see cref="nint.MaxValue"/>.</returns>
     public static nint? GenerateRandomNint() => GenerateRandomNint(nint.MinValue, nint.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="nint"/> value between <see cref="nint.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="nint"/> value between <see cref="nint.MinValue"/> and <paramref name="max"/>.</returns>
     public static nint? GenerateRandomNint<T>(T max) where T : struct => GenerateRandomNint(nint.MinValue, max);
 }
diff --git a/lib/YANLib/Nullable/YANNum.Nuint.Nullable.cs b/lib/YANLib/Nullable/YANNum.Nuint.Nullable.cs
index 55923c27..ad04c1c9 100644
--- a/lib/YANLib/Nullable/YANNum.Nuint.Nullable.cs
+++ b/lib/YANLib/Nullable/YANNum.Nuint.Nullable.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a <see cref="nuint"/> (an unsigned integer type representing a pointer or a handle).
-    /// Returns the converted <see cref="nuint"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="nuint"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static nuint? ToNuint<T>(this T? num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an enumerable of <see cref="nuint"/> values, which represent the unsigned integer equivalent of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An enumerable of <see cref="nuint"/> values representing the unsigned integer equivalent of the objects.</returns>
     public static IEnumerable<nuint?> ToNuint<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,27 +27,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a <see cref="nuint"/> using the default format.
-    /// Returns the parsed <see cref="nuint"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="nuint"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static nuint? ToNuint<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToNuint(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings <paramref name="strs"/> to an enumerable of <see cref="nuint"/> values, which represent the unsigned integer equivalent of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for conversion.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">The default value to be used for conversion in case of failure.</param>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An enumerable of <see cref="nuint"/> values representing the unsigned integer equivalent of the strings.</returns>
     public static IEnumerable<nuint?> ToNuint<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -76,28 +41,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="nuint"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="nuint"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static nuint? GenerateRandomNuint<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomNuint(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nuint?> GenerateRandomNuints<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -106,17 +51,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nuint?> GenerateRandomNuints<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -125,28 +59,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="nuint"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="nuint"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static nuint? GenerateRandomNuint<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomNuint(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nuint?> GenerateRandomNuints<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -155,17 +69,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nuint?> GenerateRandomNuints<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -174,28 +77,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="nuint"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="nuint"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static nuint? GenerateRandomNuint<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomNuint(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nuint?> GenerateRandomNuints<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -204,17 +87,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nuint?> GenerateRandomNuints<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -223,11 +95,5 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="nuint"/> value between <see cref="nuint.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="nuint"/> value between <see cref="nuint.MinValue"/> and <paramref name="max"/>.</returns>
     public static nuint? GenerateRandomNuint<T>(T? max) where T : struct => max.HasValue ? GenerateRandomNuint(nuint.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/Nullable/YANNum.Nuint.cs b/lib/YANLib/Nullable/YANNum.Nuint.cs
index f8bc90bf..190b6a0e 100644
--- a/lib/YANLib/Nullable/YANNum.Nuint.cs
+++ b/lib/YANLib/Nullable/YANNum.Nuint.cs
@@ -4,13 +4,7 @@ namespace YANLib.Nullable;
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a <see cref="nuint"/> (an unsigned integer type representing a pointer or a handle).
-    /// Returns the converted <see cref="nuint"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="nuint"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static nuint? ToNuint<T>(this T num) where T : struct
     {
         try
@@ -23,16 +17,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an enumerable of <see cref="nuint"/> values, which represent the unsigned integer equivalent of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An enumerable of <see cref="nuint"/> values representing the unsigned integer equivalent of the objects.</returns>
     public static IEnumerable<nuint?> ToNuint<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -45,20 +29,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a <see cref="nuint"/> using the default format.
-    /// Returns the parsed <see cref="nuint"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="nuint"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static nuint? ToNuint(this string str) => nuint.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings <paramref name="strs"/> to an enumerable of <see cref="nuint"/> values, which represent the unsigned integer equivalent of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An enumerable of <see cref="nuint"/> values representing the unsigned integer equivalent of the strings.</returns>
     public static IEnumerable<nuint?> ToNuint(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -71,27 +43,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a <see cref="nuint"/> using the default format.
-    /// Returns the parsed <see cref="nuint"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="nuint"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static nuint? ToNuint<T>(this string str, T dfltVal) where T : struct => nuint.TryParse(str, out var num) ? num : dfltVal.ToNuint();
 
-    /// <summary>
-    /// Converts an enumerable of strings <paramref name="strs"/> to an enumerable of <see cref="nuint"/> values, which represent the unsigned integer equivalent of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for conversion.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">The default value to be used for conversion in case of failure.</param>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An enumerable of <see cref="nuint"/> values representing the unsigned integer equivalent of the strings.</returns>
     public static IEnumerable<nuint?> ToNuint<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -104,15 +57,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="nuint"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="nuint"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static nuint? GenerateRandomNuint<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToNuint();
@@ -120,17 +64,6 @@ public static partial class YANNum
         return minValue.HasValue && maxValue.HasValue ? minValue > maxValue ? default : (new Random().NextInt64(nint.MinValue, (long)(maxValue - (minValue - (BigInteger)nint.MinValue))) - nint.MinValue).ToNuint() + minValue : default;
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nuint?> GenerateRandomNuints<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -139,17 +72,7 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="nuint"/> value between <see cref="nuint.MinValue"/> and <see cref="nuint.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="nuint"/> value between <see cref="nuint.MinValue"/> and <see cref="nuint.MaxValue"/>.</returns>
     public static nuint? GenerateRandomNuint() => GenerateRandomNuint(nuint.MinValue, nuint.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="nuint"/> value between <see cref="nuint.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="nuint"/> value between <see cref="nuint.MinValue"/> and <paramref name="max"/>.</returns>
     public static nuint? GenerateRandomNuint<T>(T max) where T : struct => GenerateRandomNuint(nuint.MinValue, max);
 }
diff --git a/lib/YANLib/Nullable/YANNum.Sbyte.Nullable.cs b/lib/YANLib/Nullable/YANNum.Sbyte.Nullable.cs
index 78b1aa7b..b5a76ee1 100644
--- a/lib/YANLib/Nullable/YANNum.Sbyte.Nullable.cs
+++ b/lib/YANLib/Nullable/YANNum.Sbyte.Nullable.cs
@@ -2,13 +2,7 @@
 
 public partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a signed byte (sbyte).
-    /// Returns the converted <see cref="sbyte"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="sbyte"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static sbyte? ToSbyte<T>(this T? num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{sbyte}"/> containing the signed byte representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{sbyte}"/> containing the signed byte representations of the objects.</returns>
     public static IEnumerable<sbyte?> ToSbyte<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,27 +27,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of an <see cref="sbyte"/> using the default format.
-    /// Returns the parsed <see cref="sbyte"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="sbyte"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static sbyte? ToSbyte<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToSbyte(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{sbyte}"/> containing the signed byte representations of the strings, using the specified default value for invalid string representations.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for invalid string representations.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">The default value to be used for invalid string representations.</param>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{sbyte}"/> containing the signed byte representations of the strings.</returns>
     public static IEnumerable<sbyte?> ToSbyte<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -76,28 +41,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="sbyte"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="sbyte"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static sbyte? GenerateRandomSbyte<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomSbyte(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate given by <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<sbyte?> GenerateRandomSbytes<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -106,17 +51,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate given by <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<sbyte?> GenerateRandomSbytes<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -125,28 +59,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="sbyte"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="sbyte"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static sbyte? GenerateRandomSbyte<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomSbyte(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate given by <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<sbyte?> GenerateRandomSbytes<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -155,17 +69,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate given by <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<sbyte?> GenerateRandomSbytes<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -174,28 +77,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="sbyte"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="sbyte"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static sbyte? GenerateRandomSbyte<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomSbyte(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate given by <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<sbyte?> GenerateRandomSbytes<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -204,17 +87,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate given by <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<sbyte?> GenerateRandomSbytes<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -223,11 +95,5 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="sbyte"/> value between <see cref="sbyte.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="sbyte"/> value between <see cref="sbyte.MinValue"/> and <paramref name="max"/>.</returns>
     public static sbyte? GenerateRandomSbyte<T>(T? max) where T : struct => max.HasValue ? GenerateRandomSbyte(sbyte.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/Nullable/YANNum.Sbyte.cs b/lib/YANLib/Nullable/YANNum.Sbyte.cs
index 518c3b51..6f88353e 100644
--- a/lib/YANLib/Nullable/YANNum.Sbyte.cs
+++ b/lib/YANLib/Nullable/YANNum.Sbyte.cs
@@ -2,13 +2,7 @@
 
 public partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a signed byte (sbyte).
-    /// Returns the converted <see cref="sbyte"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="sbyte"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static sbyte? ToSbyte<T>(this T num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{sbyte}"/> containing the signed byte representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{sbyte}"/> containing the signed byte representations of the objects.</returns>
     public static IEnumerable<sbyte?> ToSbyte<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,20 +27,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a signed byte using the default format.
-    /// Returns the parsed <see cref="sbyte"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="sbyte"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static sbyte? ToSbyte(this string str) => sbyte.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{sbyte}"/> containing the signed byte representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{sbyte}"/> containing the signed byte representations of the strings.</returns>
     public static IEnumerable<sbyte?> ToSbyte(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -69,27 +41,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a signed byte using the default format.
-    /// Returns the parsed <see cref="sbyte"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="sbyte"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static sbyte? ToSbyte<T>(this string str, T dfltVal) where T : struct => sbyte.TryParse(str, out var num) ? num : dfltVal.ToSbyte();
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{sbyte}"/> containing the signed byte representations of the strings, using the specified default value for invalid string representations.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for invalid string representations.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">The default value to be used for invalid string representations.</param>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{sbyte}"/> containing the signed byte representations of the strings.</returns>
     public static IEnumerable<sbyte?> ToSbyte<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -102,15 +55,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="sbyte"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="sbyte"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static sbyte? GenerateRandomSbyte<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToSbyte();
@@ -118,17 +62,6 @@ public partial class YANNum
         return minValue.HasValue && maxValue.HasValue ? minValue > maxValue ? default : new Random().Next(minValue.Value, maxValue.Value).ToSbyte() : default;
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate given by <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<sbyte?> GenerateRandomSbytes<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -137,17 +70,7 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="sbyte"/> value between <see cref="sbyte.MinValue"/> and <see cref="sbyte.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="sbyte"/> value between <see cref="sbyte.MinValue"/> and <see cref="sbyte.MaxValue"/>.</returns>
     public static sbyte? GenerateRandomSbyte() => GenerateRandomSbyte(sbyte.MinValue, sbyte.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="sbyte"/> value between <see cref="sbyte.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="sbyte"/> value between <see cref="sbyte.MinValue"/> and <paramref name="max"/>.</returns>
     public static sbyte? GenerateRandomSbyte<T>(T max) where T : struct => GenerateRandomSbyte(sbyte.MinValue, max);
 }
diff --git a/lib/YANLib/Nullable/YANNum.Short.Nullable.cs b/lib/YANLib/Nullable/YANNum.Short.Nullable.cs
index 56e9520d..57536e74 100644
--- a/lib/YANLib/Nullable/YANNum.Short.Nullable.cs
+++ b/lib/YANLib/Nullable/YANNum.Short.Nullable.cs
@@ -2,13 +2,7 @@
 
 public partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a <see cref="short"/>.
-    /// Returns the converted <see cref="short"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="short"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static short? ToShort<T>(this T? num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{short}"/> containing the short integer representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{short}"/> containing the short integer representations of the objects.</returns>
     public static IEnumerable<short?> ToShort<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,27 +27,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a short using the default format.
-    /// Returns the parsed <see cref="short"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="short"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static short? ToShort<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToShort(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{short}"/> containing the short integer representations of the strings, using the specified default value for invalid or null strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for invalid or null strings.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">The default value to be used for invalid or null strings.</param>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{short}"/> containing the short integer representations of the strings.</returns>
     public static IEnumerable<short?> ToShort<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -76,28 +41,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="short"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="short"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static short? GenerateRandomShort<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomShort(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="short"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{short}"/> containing the random short values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<short?> GenerateRandomShorts<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -106,17 +51,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="short"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{short}"/> containing the random short values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<short?> GenerateRandomShorts<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -125,28 +59,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="short"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="short"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static short? GenerateRandomShort<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomShort(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="short"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{short}"/> containing the random short values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<short?> GenerateRandomShorts<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -155,17 +69,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="short"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{short}"/> containing the random short values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<short?> GenerateRandomShorts<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -174,28 +77,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="short"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="short"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static short? GenerateRandomShort<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomShort(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="short"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{short}"/> containing the random short values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<short?> GenerateRandomShorts<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -204,17 +87,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="short"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{short}"/> containing the random short values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<short?> GenerateRandomShorts<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -223,11 +95,5 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="short"/> value between <see cref="short.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="short"/> value between <see cref="short.MinValue"/> and <paramref name="max"/>.</returns>
     public static short? GenerateRandomShort<T>(T? max) where T : struct => max.HasValue ? GenerateRandomShort(short.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/Nullable/YANNum.Short.cs b/lib/YANLib/Nullable/YANNum.Short.cs
index dfccec92..fd404513 100644
--- a/lib/YANLib/Nullable/YANNum.Short.cs
+++ b/lib/YANLib/Nullable/YANNum.Short.cs
@@ -2,13 +2,7 @@
 
 public partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a <see cref="short"/>.
-    /// Returns the converted <see cref="short"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="short"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static short? ToShort<T>(this T num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{short}"/> containing the short integer representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{short}"/> containing the short integer representations of the objects.</returns>
     public static IEnumerable<short?> ToShort<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,20 +27,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a short integer using the default format.
-    /// Returns the parsed <see cref="short"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="short"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static short? ToShort(this string str) => short.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{short}"/> containing the short integer representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{short}"/> containing the short integer representations of the strings.</returns>
     public static IEnumerable<short?> ToShort(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -69,27 +41,8 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a <see cref="short"/> using the default format.
-    /// Returns the parsed <see cref="short"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="short"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static short? ToShort<T>(this string str, T dfltVal) where T : struct => short.TryParse(str, out var num) ? num : dfltVal.ToShort();
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{short}"/> containing the short integer representations of the strings, using the specified default value for invalid or null strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for invalid or null strings.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">The default value to be used for invalid or null strings.</param>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{short}"/> containing the short integer representations of the strings.</returns>
     public static IEnumerable<short?> ToShort<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -102,15 +55,6 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="short"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="short"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static short? GenerateRandomShort<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToShort();
@@ -118,17 +62,6 @@ public partial class YANNum
         return minValue.HasValue && maxValue.HasValue ? minValue > maxValue ? default : new Random().Next(minValue.Value, maxValue.Value).ToShort() : default;
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="short"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{short}"/> containing the random short values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<short?> GenerateRandomShorts<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -137,17 +70,7 @@ public partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="short"/> value between <see cref="short.MinValue"/> and <see cref="short.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="short"/> value between <see cref="short.MinValue"/> and <see cref="short.MaxValue"/>.</returns>
     public static short? GenerateRandomShort() => GenerateRandomShort(short.MinValue, short.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="short"/> value between <see cref="short.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="short"/> value between <see cref="short.MinValue"/> and <paramref name="max"/>.</returns>
     public static short? GenerateRandomShort<T>(T max) where T : struct => GenerateRandomShort(short.MinValue, max);
 }
diff --git a/lib/YANLib/Nullable/YANNum.Uint.Nullable.cs b/lib/YANLib/Nullable/YANNum.Uint.Nullable.cs
index 8847330b..ab69bd24 100644
--- a/lib/YANLib/Nullable/YANNum.Uint.Nullable.cs
+++ b/lib/YANLib/Nullable/YANNum.Uint.Nullable.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to an unsigned integer.
-    /// Returns the converted <see cref="uint"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="uint"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static uint? ToUint<T>(this T? num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{byte}"/> containing the byte representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the byte representations of the objects.</returns>
     public static IEnumerable<uint?> ToUint<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,27 +27,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of an unsigned integer using the default format.
-    /// Returns the parsed <see cref="uint"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="uint"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static uint? ToUint<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToUint(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{uint}"/> containing the uint representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value for the conversion to uint.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">The default value for the conversion to uint.</param>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{uint}"/> containing the uint representations of the strings.</returns>
     public static IEnumerable<uint?> ToUint<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -76,29 +41,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="uint"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="uint"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static uint? GenerateRandomUint<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomUint(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The size of the enumerable is determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty enumerable is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable.</param>
-    /// <returns>An enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<uint?> GenerateRandomUints<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -107,18 +51,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The size of the enumerable is determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty enumerable is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable.</param>
-    /// <returns>An enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<uint?> GenerateRandomUints<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -127,29 +59,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="uint"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="uint"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static uint? GenerateRandomUint<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomUint(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The size of the enumerable is determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty enumerable is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable.</param>
-    /// <returns>An enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<uint?> GenerateRandomUints<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -158,18 +69,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The size of the enumerable is determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty enumerable is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable.</param>
-    /// <returns>An enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<uint?> GenerateRandomUints<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -178,29 +77,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="uint"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="uint"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static uint? GenerateRandomUint<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomUint(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The size of the enumerable is determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty enumerable is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable.</param>
-    /// <returns>An enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<uint?> GenerateRandomUints<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -209,18 +87,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The size of the enumerable is determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty enumerable is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable.</param>
-    /// <returns>An enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<uint?> GenerateRandomUints<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -229,11 +95,5 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="uint"/> value between <see cref="uint.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="uint"/> value between <see cref="uint.MinValue"/> and <paramref name="max"/>.</returns>
     public static uint? GenerateRandomUint<T>(T? max) where T : struct => max.HasValue ? GenerateRandomUint(uint.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/Nullable/YANNum.Uint.cs b/lib/YANLib/Nullable/YANNum.Uint.cs
index 9f28576e..ac00ebec 100644
--- a/lib/YANLib/Nullable/YANNum.Uint.cs
+++ b/lib/YANLib/Nullable/YANNum.Uint.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to an unsigned integer.
-    /// Returns the converted <see cref="uint"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="uint"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static uint? ToUint<T>(this T num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{byte}"/> containing the byte representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the byte representations of the objects.</returns>
     public static IEnumerable<uint?> ToUint<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,20 +27,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of an unsigned integer using the default format.
-    /// Returns the parsed <see cref="uint"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="uint"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static uint? ToUint(this string str) => uint.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{uint}"/> containing the uint representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{uint}"/> containing the uint representations of the strings.</returns>
     public static IEnumerable<uint?> ToUint(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -69,27 +41,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of an unsigned integer using the default format.
-    /// Returns the parsed <see cref="uint"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="uint"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static uint? ToUint<T>(this string str, T dfltVal) where T : struct => uint.TryParse(str, out var num) ? num : dfltVal.ToUint();
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{uint}"/> containing the uint representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value for the conversion to uint.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">The default value for the conversion to uint.</param>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{uint}"/> containing the uint representations of the strings.</returns>
     public static IEnumerable<uint?> ToUint<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -102,15 +55,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="uint"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="uint"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static uint? GenerateRandomUint<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToUint();
@@ -118,18 +62,6 @@ public static partial class YANNum
         return minValue.HasValue && maxValue.HasValue ? minValue > maxValue ? default : new Random().NextInt64(minValue.Value, maxValue.Value).ToUint() : default;
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The size of the enumerable is determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty enumerable is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable.</param>
-    /// <returns>An enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<uint?> GenerateRandomUints<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -138,17 +70,7 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="uint"/> value between <see cref="uint.MinValue"/> and <see cref="uint.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="uint"/> value between <see cref="uint.MinValue"/> and <see cref="uint.MaxValue"/>.</returns>
     public static uint? GenerateRandomUint() => GenerateRandomUint(uint.MinValue, uint.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="uint"/> value between <see cref="uint.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="uint"/> value between <see cref="uint.MinValue"/> and <paramref name="max"/>.</returns>
     public static uint? GenerateRandomUint<T>(T max) where T : struct => GenerateRandomUint(uint.MinValue, max);
 }
diff --git a/lib/YANLib/Nullable/YANNum.Ulong.Nullable.cs b/lib/YANLib/Nullable/YANNum.Ulong.Nullable.cs
index 04d9e375..173201d4 100644
--- a/lib/YANLib/Nullable/YANNum.Ulong.Nullable.cs
+++ b/lib/YANLib/Nullable/YANNum.Ulong.Nullable.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to an unsigned long integer.
-    /// Returns the converted <see cref="ulong"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="ulong"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static ulong? ToUlong<T>(this T? num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{ulong}"/> containing the ulong representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{ulong}"/> containing the ulong representations of the objects.</returns>
     public static IEnumerable<ulong?> ToUlong<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,27 +27,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of an unsigned long integer using the default format.
-    /// Returns the parsed <see cref="ulong"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="ulong"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static ulong? ToUlong<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToUlong(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings <paramref name="strs"/> to an <see cref="IEnumerable{ulong}"/> containing the ulong representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used when converting strings to ulong.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">The default value to be used when converting strings to ulong.</param>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{ulong}"/> containing the ulong representations of the strings.</returns>
     public static IEnumerable<ulong?> ToUlong<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -76,29 +41,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static ulong? GenerateRandomUlong<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomUlong(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="ulong"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{ulong}"/> containing the generated random ulong values.</returns>
     public static IEnumerable<ulong?> GenerateRandomUlongs<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -107,18 +51,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="ulong"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{ulong}"/> containing the generated random ulong values.</returns>
     public static IEnumerable<ulong?> GenerateRandomUlongs<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -127,29 +59,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static ulong? GenerateRandomUlong<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomUlong(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="ulong"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{ulong}"/> containing the generated random ulong values.</returns>
     public static IEnumerable<ulong?> GenerateRandomUlongs<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -158,18 +69,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="ulong"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{ulong}"/> containing the generated random ulong values.</returns>
     public static IEnumerable<ulong?> GenerateRandomUlongs<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -178,29 +77,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static ulong? GenerateRandomUlong<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomUlong(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="ulong"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{ulong}"/> containing the generated random ulong values.</returns>
     public static IEnumerable<ulong?> GenerateRandomUlongs<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -209,18 +87,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="ulong"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{ulong}"/> containing the generated random ulong values.</returns>
     public static IEnumerable<ulong?> GenerateRandomUlongs<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -229,11 +95,5 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="ulong"/> value between <see cref="ulong.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="ulong"/> value between <see cref="ulong.MinValue"/> and <paramref name="max"/>.</returns>
     public static ulong? GenerateRandomUlong<T>(T? max) where T : struct => max.HasValue ? GenerateRandomUlong(ulong.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/Nullable/YANNum.Ulong.cs b/lib/YANLib/Nullable/YANNum.Ulong.cs
index 341a82ae..dafc5b12 100644
--- a/lib/YANLib/Nullable/YANNum.Ulong.cs
+++ b/lib/YANLib/Nullable/YANNum.Ulong.cs
@@ -4,13 +4,7 @@ namespace YANLib.Nullable;
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to an unsigned long integer.
-    /// Returns the converted <see cref="ulong"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="ulong"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static ulong? ToUlong<T>(this T num) where T : struct
     {
         try
@@ -23,16 +17,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{ulong}"/> containing the ulong representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{ulong}"/> containing the ulong representations of the objects.</returns>
     public static IEnumerable<ulong?> ToUlong<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -45,20 +29,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of an unsigned long integer using the default format.
-    /// Returns the parsed <see cref="ulong"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="ulong"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static ulong? ToUlong(this string str) => ulong.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings <paramref name="strs"/> to an <see cref="IEnumerable{ulong}"/> containing the ulong representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{ulong}"/> containing the ulong representations of the strings.</returns>
     public static IEnumerable<ulong?> ToUlong(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -71,27 +43,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of an <see cref="ulong"/> using the default format.
-    /// Returns the parsed <see cref="ulong"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="ulong"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static ulong? ToUlong<T>(this string str, T dfltVal) where T : struct => ulong.TryParse(str, out var num) ? num : dfltVal.ToUlong();
 
-    /// <summary>
-    /// Converts an enumerable of strings <paramref name="strs"/> to an <see cref="IEnumerable{ulong}"/> containing the ulong representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used when converting strings to ulong.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">The default value to be used when converting strings to ulong.</param>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{ulong}"/> containing the ulong representations of the strings.</returns>
     public static IEnumerable<ulong?> ToUlong<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -104,15 +57,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static ulong? GenerateRandomUlong<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToUlong();
@@ -120,18 +64,6 @@ public static partial class YANNum
         return minValue.HasValue && maxValue.HasValue ? minValue > maxValue ? default : (new Random().NextInt64(long.MinValue, (long)(maxValue - (minValue - (BigInteger)long.MinValue))) - long.MinValue).ToUlong() + minValue : default;
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="ulong"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{ulong}"/> containing the generated random ulong values.</returns>
     public static IEnumerable<ulong?> GenerateRandomUlongs<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -140,17 +72,7 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="ulong"/> value between <see cref="ulong.MinValue"/> and <see cref="ulong.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="ulong"/> value between <see cref="ulong.MinValue"/> and <see cref="ulong.MaxValue"/>.</returns>
     public static ulong? GenerateRandomUlong() => GenerateRandomUlong(ulong.MinValue, ulong.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="ulong"/> value between <see cref="ulong.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="ulong"/> value between <see cref="ulong.MinValue"/> and <paramref name="max"/>.</returns>
     public static ulong? GenerateRandomUlong<T>(T max) where T : struct => GenerateRandomUlong(ulong.MinValue, max);
 }
diff --git a/lib/YANLib/Nullable/YANNum.Ushort.Nullable.cs b/lib/YANLib/Nullable/YANNum.Ushort.Nullable.cs
index 5331aee4..945162b3 100644
--- a/lib/YANLib/Nullable/YANNum.Ushort.Nullable.cs
+++ b/lib/YANLib/Nullable/YANNum.Ushort.Nullable.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a unsigned short integer.
-    /// Returns the converted <see cref="ushort"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="ushort"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static ushort? ToUshort<T>(this T? num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{ushort}"/> containing the ushort representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{ushort}"/> containing the ushort representations of the objects.</returns>
     public static IEnumerable<ushort?> ToUshort<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,27 +27,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a ushort using the default format.
-    /// Returns the parsed <see cref="ushort"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="ushort"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static ushort? ToUshort<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToUshort(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{ushort}"/> containing the ushort representations of the strings, using the specified default value for conversion failure.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value for conversion failure.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">The default value to be used for conversion failure.</param>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{ushort}"/> containing the ushort representations of the strings.</returns>
     public static IEnumerable<ushort?> ToUshort<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -76,28 +41,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static ushort? GenerateRandomUshort<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomUshort(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable sequence.</param>
-    /// <returns>An enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<ushort?> GenerateRandomUshorts<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -106,17 +51,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable sequence.</param>
-    /// <returns>An enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<ushort?> GenerateRandomUshorts<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -125,28 +59,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static ushort? GenerateRandomUshort<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomUshort(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable sequence.</param>
-    /// <returns>An enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<ushort?> GenerateRandomUshorts<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -155,17 +69,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable sequence.</param>
-    /// <returns>An enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<ushort?> GenerateRandomUshorts<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -174,28 +77,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static ushort? GenerateRandomUshort<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomUshort(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable sequence.</param>
-    /// <returns>An enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<ushort?> GenerateRandomUshorts<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -204,17 +87,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable sequence.</param>
-    /// <returns>An enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<ushort?> GenerateRandomUshorts<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -223,11 +95,5 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="ushort"/> value between <see cref="ushort.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="ushort"/> value between <see cref="ushort.MinValue"/> and <paramref name="max"/>.</returns>
     public static ushort? GenerateRandomUshort<T>(T? max) where T : struct => max.HasValue ? GenerateRandomUshort(ushort.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/Nullable/YANNum.Ushort.cs b/lib/YANLib/Nullable/YANNum.Ushort.cs
index 963493e5..8e05a6b7 100644
--- a/lib/YANLib/Nullable/YANNum.Ushort.cs
+++ b/lib/YANLib/Nullable/YANNum.Ushort.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a unsigned short integer.
-    /// Returns the converted <see cref="ushort"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="ushort"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static ushort? ToUshort<T>(this T num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{ushort}"/> containing the ushort representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{ushort}"/> containing the ushort representations of the objects.</returns>
     public static IEnumerable<ushort?> ToUshort<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,20 +27,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of an unsigned short integer using the default format.
-    /// Returns the parsed <see cref="ushort"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="ushort"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static ushort? ToUshort(this string str) => ushort.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{ushort}"/> containing the ushort representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{ushort}"/> containing the ushort representations of the strings.</returns>
     public static IEnumerable<ushort?> ToUshort(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -69,27 +41,8 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of an unsigned short using the default format.
-    /// Returns the parsed <see cref="ushort"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="ushort"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static ushort? ToUshort<T>(this string str, T dfltVal) where T : struct => ushort.TryParse(str, out var num) ? num : dfltVal.ToUshort();
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{ushort}"/> containing the ushort representations of the strings, using the specified default value for conversion failure.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value for conversion failure.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="dfltVal">The default value to be used for conversion failure.</param>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{ushort}"/> containing the ushort representations of the strings.</returns>
     public static IEnumerable<ushort?> ToUshort<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -102,15 +55,6 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="ushort"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="ushort"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static ushort? GenerateRandomUshort<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToUshort();
@@ -118,17 +62,6 @@ public static partial class YANNum
         return minValue.HasValue && maxValue.HasValue ? minValue > maxValue ? default : new Random().Next(minValue.Value, maxValue.Value).ToUshort() : default;
     }
 
-    /// <summary>
-    /// Generates an enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable sequence.</param>
-    /// <returns>An enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<ushort?> GenerateRandomUshorts<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < YANLib.YANNum.ToUlong(size); i++)
@@ -137,17 +70,7 @@ public static partial class YANNum
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="ushort"/> value between <see cref="ushort.MinValue"/> and <see cref="ushort.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="ushort"/> value between <see cref="ushort.MinValue"/> and <see cref="ushort.MaxValue"/>.</returns>
     public static ushort? GenerateRandomUshort() => GenerateRandomUshort(ushort.MinValue, ushort.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="ushort"/> value between <see cref="ushort.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="ushort"/> value between <see cref="ushort.MinValue"/> and <paramref name="max"/>.</returns>
     public static ushort? GenerateRandomUshort<T>(T max) where T : struct => GenerateRandomUshort(ushort.MinValue, max);
 }
diff --git a/lib/YANLib/YANDateTime.Nullable.cs b/lib/YANLib/YANDateTime.Nullable.cs
index ad1987a7..4cf2d76f 100644
--- a/lib/YANLib/YANDateTime.Nullable.cs
+++ b/lib/YANLib/YANDateTime.Nullable.cs
@@ -4,26 +4,10 @@ namespace YANLib;
 
 public static partial class YANDateTime
 {
-    /// <summary>
-    /// Parses the string representation of a date and time using <paramref name="fmt"/>.
-    /// Returns the parsed <see cref="DateTime"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="fmt">The format of the string representation.</param>
-    /// <param name="dfltVal">The default value to return if the parsing fails.</param>
-    /// <returns>The parsed <see cref="DateTime"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
+    
     public static DateTime ToDateTime(this string str, string fmt, DateTime? dfltVal) => dfltVal.HasValue ? str.ToDateTime(fmt, dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings representing date/time values in a specified format to an <see cref="IEnumerable{DateTime}"/> containing the parsed DateTime values.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only whitespace strings.
-    /// If a string cannot be parsed to a valid DateTime value, the default value specified by <paramref name="dfltVal"/> is used instead.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to convert to DateTime values.</param>
-    /// <param name="fmt">The format of the date/time values in the input strings.</param>
-    /// <param name="dfltVal">The default DateTime value to be used for strings that cannot be parsed to valid DateTime values.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the parsed DateTime values.</returns>
-    public static IEnumerable<DateTime> ToDateTime(IEnumerable<string> strs, string fmt, DateTime? dfltVal)
+    public static IEnumerable<DateTime> ToDateTime(this IEnumerable<string> strs, string fmt, DateTime? dfltVal)
     {
         if (strs.IsNullOrWhiteSpace())
         {
@@ -35,28 +19,8 @@ public static IEnumerable<DateTime> ToDateTime(IEnumerable<string> strs, string
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="DateTime"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <param name="min">The minimum <see cref="DateTime"/> value.</param>
-    /// <param name="max">The maximum <see cref="DateTime"/> value.</param>
-    /// <returns>A random <see cref="DateTime"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static DateTime GenerateRandomDateTime(DateTime? min, DateTime max) => min.HasValue ? GenerateRandomDateTime(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of DateTime values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of <paramref name="size"/>.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="min">The minimum DateTime value.</param>
-    /// <param name="max">The maximum DateTime value.</param>
-    /// <param name="size">The number of DateTime values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<DateTime> GenerateRandomDateTimes<T>(DateTime? min, DateTime max, T size) where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -65,19 +29,6 @@ public static IEnumerable<DateTime> GenerateRandomDateTimes<T>(DateTime? min, Da
         }
     }
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of DateTime values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of <paramref name="size"/>.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="min">The minimum DateTime value.</param>
-    /// <param name="max">The maximum DateTime value.</param>
-    /// <param name="size">The number of DateTime values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<DateTime> GenerateRandomDateTimes<T>(DateTime? min, DateTime max, T? size) where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -86,28 +37,8 @@ public static IEnumerable<DateTime> GenerateRandomDateTimes<T>(DateTime? min, Da
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="DateTime"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <param name="min">The minimum <see cref="DateTime"/> value.</param>
-    /// <param name="max">The maximum <see cref="DateTime"/> value.</param>
-    /// <returns>A random <see cref="DateTime"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static DateTime GenerateRandomDateTime(DateTime min, DateTime? max) => max.HasValue ? GenerateRandomDateTime(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of DateTime values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of <paramref name="size"/>.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="min">The minimum DateTime value.</param>
-    /// <param name="max">The maximum DateTime value.</param>
-    /// <param name="size">The number of DateTime values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<DateTime> GenerateRandomDateTimes<T>(DateTime min, DateTime? max, T size) where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -116,19 +47,6 @@ public static IEnumerable<DateTime> GenerateRandomDateTimes<T>(DateTime min, Dat
         }
     }
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of DateTime values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of <paramref name="size"/>.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="min">The minimum DateTime value.</param>
-    /// <param name="max">The maximum DateTime value.</param>
-    /// <param name="size">The number of DateTime values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<DateTime> GenerateRandomDateTimes<T>(DateTime min, DateTime? max, T? size) where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -137,28 +55,8 @@ public static IEnumerable<DateTime> GenerateRandomDateTimes<T>(DateTime min, Dat
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="DateTime"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <param name="min">The minimum <see cref="DateTime"/> value.</param>
-    /// <param name="max">The maximum <see cref="DateTime"/> value.</param>
-    /// <returns>A random <see cref="DateTime"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static DateTime GenerateRandomDateTime(DateTime? min, DateTime? max) => min.HasValue ? GenerateRandomDateTime(min.Value, max) : GenerateRandomDateTime(max);
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of DateTime values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of <paramref name="size"/>.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="min">The minimum DateTime value.</param>
-    /// <param name="max">The maximum DateTime value.</param>
-    /// <param name="size">The number of DateTime values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<DateTime> GenerateRandomDateTimes<T>(DateTime? min, DateTime? max, T size) where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -167,19 +65,6 @@ public static IEnumerable<DateTime> GenerateRandomDateTimes<T>(DateTime? min, Da
         }
     }
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of DateTime values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of <paramref name="size"/>.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="min">The minimum DateTime value.</param>
-    /// <param name="max">The maximum DateTime value.</param>
-    /// <param name="size">The number of DateTime values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<DateTime> GenerateRandomDateTimes<T>(DateTime? min, DateTime? max, T? size) where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -188,26 +73,10 @@ public static IEnumerable<DateTime> GenerateRandomDateTimes<T>(DateTime? min, Da
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="DateTime"/> value between <see cref="MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <param name="max">The maximum <see cref="DateTime"/> value.</param>
-    /// <returns>A random <see cref="DateTime"/> value between <see cref="MinValue"/> and <paramref name="max"/>.</returns>
     public static DateTime GenerateRandomDateTime(DateTime? max) => max.HasValue ? GenerateRandomDateTime(max.Value) : default;
 
-    /// <summary>
-    /// Returns the week of the year that the specified <see cref="DateTime"/> value falls in, according to the current culture's calendar, week rule, and first day of the week settings.
-    /// </summary>
-    /// <param name="dt">The <see cref="DateTime"/> value.</param>
-    /// <returns>The week of the year that the specified <see cref="DateTime"/> value falls in.</returns>
     public static int GetWeekOfYear(this DateTime? dt) => dt.HasValue ? dt.Value.GetWeekOfYear() : default;
 
-    /// <summary>
-    /// Gets the week of the year for an enumerable of DateTime values using the default calendar of the current culture.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/> or empty.
-    /// </summary>
-    /// <param name="dts">The enumerable of DateTime values for which to get the week of the year.</param>
-    /// <returns>An <see cref="IEnumerable{Int32}"/> containing the week of the year values for the input DateTime values.</returns>
     public static IEnumerable<int> GetWeekOfYear(this IEnumerable<DateTime?> dts)
     {
         if (dts is null || !dts.Any())
@@ -220,52 +89,14 @@ public static IEnumerable<int> GetWeekOfYear(this IEnumerable<DateTime?> dts)
         }
     }
 
-    /// <summary>
-    /// Returns the total number of months between the two specified <see cref="DateTime"/> values, ignoring the day of the month.
-    /// </summary>
-    /// <param name="dt1">The first <see cref="DateTime"/> value.</param>
-    /// <param name="dt2">The second <see cref="DateTime"/> value.</param>
-    /// <returns>The total number of months between the two specified <see cref="DateTime"/> values, ignoring the day of the month.</returns>
     public static int TotalMonths(DateTime? dt1, DateTime dt2) => dt1.HasValue ? TotalMonths(dt1.Value, dt2) : default;
 
-    /// <summary>
-    /// Returns the total number of months between the two specified <see cref="DateTime"/> values, ignoring the day of the month.
-    /// </summary>
-    /// <param name="dt1">The first <see cref="DateTime"/> value.</param>
-    /// <param name="dt2">The second <see cref="DateTime"/> value.</param>
-    /// <returns>The total number of months between the two specified <see cref="DateTime"/> values, ignoring the day of the month.</returns>
     public static int TotalMonths(DateTime dt1, DateTime? dt2) => dt2.HasValue ? TotalMonths(dt1, dt2.Value) : default;
 
-    /// <summary>
-    /// Returns the total number of months between the two specified <see cref="DateTime"/> values, ignoring the day of the month.
-    /// </summary>
-    /// <param name="dt1">The first <see cref="DateTime"/> value.</param>
-    /// <param name="dt2">The second <see cref="DateTime"/> value.</param>
-    /// <returns>The total number of months between the two specified <see cref="DateTime"/> values, ignoring the day of the month.</returns>
     public static int TotalMonths(DateTime? dt1, DateTime? dt2) => dt1.HasValue ? TotalMonths(dt1.Value, dt2) : default;
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.
-    /// </summary>
-    /// <typeparam name="T1">The type of the original time zone offset, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone offset, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzSrc">The time zone offset of the original <see cref="DateTime"/> value, in hours.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.</returns>
     public static DateTime ChangeTimeZone<T1, T2>(this DateTime? dt, T1 tzSrc, T2 tzDst) where T1 : struct where T2 : struct => dt.HasValue ? dt.Value.ChangeTimeZone(tzSrc, tzDst) : default;
 
-    /// <summary>
-    /// Returns an <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to a different time zone, based on the source and destination time zones specified.
-    /// The source and destination time zones are specified as generic type parameters <typeparamref name="T1"/> and <typeparamref name="T2"/> respectively, and must be of a struct type that represents a valid time zone identifier.
-    /// If any of the input <see cref="DateTime"/> values is <see langword="null"/>, no value will be returned for that input.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The <see cref="DateTime"/> values to convert to the destination time zone.</param>
-    /// <param name="tzSrc">The source time zone.</param>
-    /// <param name="tzDst">The destination time zone.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to the destination time zone.</returns>
     public static IEnumerable<DateTime> ChangeTimeZone<T1, T2>(this IEnumerable<DateTime?> dts, T1 tzSrc, T2 tzDst) where T1 : struct where T2 : struct
     {
         if (dts is null || !dts.Any())
@@ -278,15 +109,6 @@ public static IEnumerable<DateTime> ChangeTimeZone<T1, T2>(this IEnumerable<Date
         }
     }
 
-    /// <summary>
-    /// Converts an list of DateTime values from one time zone to another using the specified source and destination time zones, and updates the original list in-place.
-    /// If the input list is <see langword="null"/> or empty, no action is taken.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The list of DateTime values to convert and update.</param>
-    /// <param name="tzSrc">The source time zone to convert from.</param>
-    /// <param name="tzDst">The destination time zone to convert to.</param>
     public static void ChangeTimeZone<T1, T2>(this IList<DateTime?> dts, T1 tzSrc, T2 tzDst) where T1 : struct where T2 : struct
     {
         if (dts is not null && dts.Count > 0)
@@ -298,28 +120,8 @@ public static void ChangeTimeZone<T1, T2>(this IList<DateTime?> dts, T1 tzSrc, T
         }
     }
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.
-    /// </summary>
-    /// <typeparam name="T1">The type of the original time zone offset, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone offset, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzSrc">The time zone offset of the original <see cref="DateTime"/> value, in hours.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.</returns>
     public static DateTime ChangeTimeZone<T1, T2>(this DateTime dt, T1? tzSrc, T2 tzDst) where T1 : struct where T2 : struct => tzSrc.HasValue ? dt.ChangeTimeZone(tzSrc.Value, tzDst) : dt.ChangeTimeZone(tzDst);
 
-    /// <summary>
-    /// Returns an <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to a different time zone, based on the source and destination time zones specified.
-    /// The source and destination time zones are specified as generic type parameters <typeparamref name="T1"/> and <typeparamref name="T2"/> respectively, and must be of a struct type that represents a valid time zone identifier.
-    /// If any of the input <see cref="DateTime"/> values is <see langword="null"/>, no value will be returned for that input.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The <see cref="DateTime"/> values to convert to the destination time zone.</param>
-    /// <param name="tzSrc">The source time zone.</param>
-    /// <param name="tzDst">The destination time zone.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to the destination time zone.</returns>
     public static IEnumerable<DateTime> ChangeTimeZone<T1, T2>(this IEnumerable<DateTime> dts, T1? tzSrc, T2 tzDst) where T1 : struct where T2 : struct
     {
         if (dts is null || !dts.Any())
@@ -332,15 +134,6 @@ public static IEnumerable<DateTime> ChangeTimeZone<T1, T2>(this IEnumerable<Date
         }
     }
 
-    /// <summary>
-    /// Converts an list of DateTime values from one time zone to another using the specified source and destination time zones, and updates the original list in-place.
-    /// If the input list is <see langword="null"/> or empty, no action is taken.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The list of DateTime values to convert and update.</param>
-    /// <param name="tzSrc">The source time zone to convert from.</param>
-    /// <param name="tzDst">The destination time zone to convert to.</param>
     public static void ChangeTimeZone<T1, T2>(this IList<DateTime> dts, T1? tzSrc, T2 tzDst) where T1 : struct where T2 : struct
     {
         if (dts is not null && dts.Count > 0)
@@ -352,28 +145,8 @@ public static void ChangeTimeZone<T1, T2>(this IList<DateTime> dts, T1? tzSrc, T
         }
     }
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.
-    /// </summary>
-    /// <typeparam name="T1">The type of the original time zone offset, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone offset, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzSrc">The time zone offset of the original <see cref="DateTime"/> value, in hours.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.</returns>
     public static DateTime ChangeTimeZone<T1, T2>(this DateTime dt, T1 tzSrc, T2? tzDst) where T1 : struct where T2 : struct => tzDst.HasValue ? dt.ChangeTimeZone(tzSrc, tzDst.Value) : dt;
 
-    /// <summary>
-    /// Returns an <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to a different time zone, based on the source and destination time zones specified.
-    /// The source and destination time zones are specified as generic type parameters <typeparamref name="T1"/> and <typeparamref name="T2"/> respectively, and must be of a struct type that represents a valid time zone identifier.
-    /// If any of the input <see cref="DateTime"/> values is <see langword="null"/>, no value will be returned for that input.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The <see cref="DateTime"/> values to convert to the destination time zone.</param>
-    /// <param name="tzSrc">The source time zone.</param>
-    /// <param name="tzDst">The destination time zone.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to the destination time zone.</returns>
     public static IEnumerable<DateTime> ChangeTimeZone<T1, T2>(this IEnumerable<DateTime> dts, T1 tzSrc, T2? tzDst) where T1 : struct where T2 : struct
     {
         if (dts is null || !dts.Any())
@@ -386,15 +159,6 @@ public static IEnumerable<DateTime> ChangeTimeZone<T1, T2>(this IEnumerable<Date
         }
     }
 
-    /// <summary>
-    /// Converts an list of DateTime values from one time zone to another using the specified source and destination time zones, and updates the original list in-place.
-    /// If the input list is <see langword="null"/> or empty, no action is taken.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The list of DateTime values to convert and update.</param>
-    /// <param name="tzSrc">The source time zone to convert from.</param>
-    /// <param name="tzDst">The destination time zone to convert to.</param>
     public static void ChangeTimeZone<T1, T2>(this IList<DateTime> dts, T1 tzSrc, T2? tzDst) where T1 : struct where T2 : struct
     {
         if (dts is not null && dts.Count > 0)
@@ -406,28 +170,8 @@ public static void ChangeTimeZone<T1, T2>(this IList<DateTime> dts, T1 tzSrc, T2
         }
     }
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.
-    /// </summary>
-    /// <typeparam name="T1">The type of the original time zone offset, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone offset, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzSrc">The time zone offset of the original <see cref="DateTime"/> value, in hours.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.</returns>
     public static DateTime ChangeTimeZone<T1, T2>(this DateTime? dt, T1? tzSrc, T2 tzDst) where T1 : struct where T2 : struct => dt.HasValue ? dt.Value.ChangeTimeZone(tzSrc, tzDst) : default;
 
-    /// <summary>
-    /// Returns an <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to a different time zone, based on the source and destination time zones specified.
-    /// The source and destination time zones are specified as generic type parameters <typeparamref name="T1"/> and <typeparamref name="T2"/> respectively, and must be of a struct type that represents a valid time zone identifier.
-    /// If any of the input <see cref="DateTime"/> values is <see langword="null"/>, no value will be returned for that input.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The <see cref="DateTime"/> values to convert to the destination time zone.</param>
-    /// <param name="tzSrc">The source time zone.</param>
-    /// <param name="tzDst">The destination time zone.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to the destination time zone.</returns>
     public static IEnumerable<DateTime> ChangeTimeZone<T1, T2>(this IEnumerable<DateTime?> dts, T1? tzSrc, T2 tzDst) where T1 : struct where T2 : struct
     {
         if (dts is null || !dts.Any())
@@ -440,15 +184,6 @@ public static IEnumerable<DateTime> ChangeTimeZone<T1, T2>(this IEnumerable<Date
         }
     }
 
-    /// <summary>
-    /// Converts an list of DateTime values from one time zone to another using the specified source and destination time zones, and updates the original list in-place.
-    /// If the input list is <see langword="null"/> or empty, no action is taken.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The list of DateTime values to convert and update.</param>
-    /// <param name="tzSrc">The source time zone to convert from.</param>
-    /// <param name="tzDst">The destination time zone to convert to.</param>
     public static void ChangeTimeZone<T1, T2>(this IList<DateTime?> dts, T1? tzSrc, T2 tzDst) where T1 : struct where T2 : struct
     {
         if (dts is not null && dts.Count > 0)
@@ -460,28 +195,8 @@ public static void ChangeTimeZone<T1, T2>(this IList<DateTime?> dts, T1? tzSrc,
         }
     }
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.
-    /// </summary>
-    /// <typeparam name="T1">The type of the original time zone offset, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone offset, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzSrc">The time zone offset of the original <see cref="DateTime"/> value, in hours.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.</returns>
     public static DateTime ChangeTimeZone<T1, T2>(this DateTime? dt, T1 tzSrc, T2? tzDst) where T1 : struct where T2 : struct => dt.HasValue ? dt.Value.ChangeTimeZone(tzSrc, tzDst) : default;
 
-    /// <summary>
-    /// Returns an <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to a different time zone, based on the source and destination time zones specified.
-    /// The source and destination time zones are specified as generic type parameters <typeparamref name="T1"/> and <typeparamref name="T2"/> respectively, and must be of a struct type that represents a valid time zone identifier.
-    /// If any of the input <see cref="DateTime"/> values is <see langword="null"/>, no value will be returned for that input.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The <see cref="DateTime"/> values to convert to the destination time zone.</param>
-    /// <param name="tzSrc">The source time zone.</param>
-    /// <param name="tzDst">The destination time zone.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to the destination time zone.</returns>
     public static IEnumerable<DateTime> ChangeTimeZone<T1, T2>(this IEnumerable<DateTime?> dts, T1 tzSrc, T2? tzDst) where T1 : struct where T2 : struct
     {
         if (dts is null || !dts.Any())
@@ -494,15 +209,6 @@ public static IEnumerable<DateTime> ChangeTimeZone<T1, T2>(this IEnumerable<Date
         }
     }
 
-    /// <summary>
-    /// Converts an list of DateTime values from one time zone to another using the specified source and destination time zones, and updates the original list in-place.
-    /// If the input list is <see langword="null"/> or empty, no action is taken.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The list of DateTime values to convert and update.</param>
-    /// <param name="tzSrc">The source time zone to convert from.</param>
-    /// <param name="tzDst">The destination time zone to convert to.</param>
     public static void ChangeTimeZone<T1, T2>(this IList<DateTime?> dts, T1 tzSrc, T2? tzDst) where T1 : struct where T2 : struct
     {
         if (dts is not null && dts.Count > 0)
@@ -514,28 +220,8 @@ public static void ChangeTimeZone<T1, T2>(this IList<DateTime?> dts, T1 tzSrc, T
         }
     }
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.
-    /// </summary>
-    /// <typeparam name="T1">The type of the original time zone offset, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone offset, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzSrc">The time zone offset of the original <see cref="DateTime"/> value, in hours.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.</returns>
     public static DateTime ChangeTimeZone<T1, T2>(this DateTime dt, T1? tzSrc, T2? tzDst) where T1 : struct where T2 : struct => tzSrc.HasValue ? dt.ChangeTimeZone(tzSrc.Value, tzDst) : dt.ChangeTimeZone(tzDst);
 
-    /// <summary>
-    /// Returns an <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to a different time zone, based on the source and destination time zones specified.
-    /// The source and destination time zones are specified as generic type parameters <typeparamref name="T1"/> and <typeparamref name="T2"/> respectively, and must be of a struct type that represents a valid time zone identifier.
-    /// If any of the input <see cref="DateTime"/> values is <see langword="null"/>, no value will be returned for that input.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The <see cref="DateTime"/> values to convert to the destination time zone.</param>
-    /// <param name="tzSrc">The source time zone.</param>
-    /// <param name="tzDst">The destination time zone.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to the destination time zone.</returns>
     public static IEnumerable<DateTime> ChangeTimeZone<T1, T2>(this IEnumerable<DateTime> dts, T1? tzSrc, T2? tzDst) where T1 : struct where T2 : struct
     {
         if (dts is null || !dts.Any())
@@ -548,15 +234,6 @@ public static IEnumerable<DateTime> ChangeTimeZone<T1, T2>(this IEnumerable<Date
         }
     }
 
-    /// <summary>
-    /// Converts an list of DateTime values from one time zone to another using the specified source and destination time zones, and updates the original list in-place.
-    /// If the input list is <see langword="null"/> or empty, no action is taken.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The list of DateTime values to convert and update.</param>
-    /// <param name="tzSrc">The source time zone to convert from.</param>
-    /// <param name="tzDst">The destination time zone to convert to.</param>
     public static void ChangeTimeZone<T1, T2>(this IList<DateTime> dts, T1? tzSrc, T2? tzDst) where T1 : struct where T2 : struct
     {
         if (dts is not null && dts.Count > 0)
@@ -568,28 +245,8 @@ public static void ChangeTimeZone<T1, T2>(this IList<DateTime> dts, T1? tzSrc, T
         }
     }
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.
-    /// </summary>
-    /// <typeparam name="T1">The type of the original time zone offset, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone offset, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzSrc">The time zone offset of the original <see cref="DateTime"/> value, in hours.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.</returns>
     public static DateTime ChangeTimeZone<T1, T2>(this DateTime? dt, T1? tzSrc, T2? tzDst) where T1 : struct where T2 : struct => dt.HasValue ? dt.Value.ChangeTimeZone(tzSrc, tzDst) : default;
 
-    /// <summary>
-    /// Returns an <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to a different time zone, based on the source and destination time zones specified.
-    /// The source and destination time zones are specified as generic type parameters <typeparamref name="T1"/> and <typeparamref name="T2"/> respectively, and must be of a struct type that represents a valid time zone identifier.
-    /// If any of the input <see cref="DateTime"/> values is <see langword="null"/>, no value will be returned for that input.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The <see cref="DateTime"/> values to convert to the destination time zone.</param>
-    /// <param name="tzSrc">The source time zone.</param>
-    /// <param name="tzDst">The destination time zone.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the <see cref="DateTime"/> values converted to the destination time zone.</returns>
     public static IEnumerable<DateTime> ChangeTimeZone<T1, T2>(this IEnumerable<DateTime?> dts, T1? tzSrc, T2? tzDst) where T1 : struct where T2 : struct
     {
         if (dts is null || !dts.Any())
@@ -602,15 +259,6 @@ public static IEnumerable<DateTime> ChangeTimeZone<T1, T2>(this IEnumerable<Date
         }
     }
 
-    /// <summary>
-    /// Converts an list of DateTime values from one time zone to another using the specified source and destination time zones, and updates the original list in-place.
-    /// If the input list is <see langword="null"/> or empty, no action is taken.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The list of DateTime values to convert and update.</param>
-    /// <param name="tzSrc">The source time zone to convert from.</param>
-    /// <param name="tzDst">The destination time zone to convert to.</param>
     public static void ChangeTimeZone<T1, T2>(this IList<DateTime?> dts, T1? tzSrc, T2? tzDst) where T1 : struct where T2 : struct
     {
         if (dts is not null && dts.Count > 0)
@@ -622,22 +270,8 @@ public static void ChangeTimeZone<T1, T2>(this IList<DateTime?> dts, T1? tzSrc,
         }
     }
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.
-    /// </summary>
-    /// <typeparam name="T">The type of the time zone offset to convert the original <see cref="DateTime"/> value to, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.</returns>
     public static DateTime ChangeTimeZone<T>(this DateTime? dt, T tzDst) where T : struct => dt.ChangeTimeZone(0, tzDst);
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.
-    /// </summary>
-    /// <typeparam name="T">The type of the time zone offset to convert the original <see cref="DateTime"/> value to, which must be a value type.</typeparam>
-    /// <param name="dts">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.</returns>
     public static IEnumerable<DateTime> ChangeTimeZone<T>(this IEnumerable<DateTime?> dts, T tzDst) where T : struct
     {
         if (dts is null || !dts.Any())
@@ -650,13 +284,6 @@ public static IEnumerable<DateTime> ChangeTimeZone<T>(this IEnumerable<DateTime?
         }
     }
 
-    /// <summary>
-    /// Converts a list of DateTime values from one time zone to another using the specified destination time zone, and updates the original list in place with the DateTime values converted to the destination time zone.
-    /// If the input list is <see langword="null"/> or empty, no changes will be made.
-    /// </summary>
-    /// <typeparam name="T">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The list of DateTime values to convert.</param>
-    /// <param name="tzDst">The destination time zone to convert to.</param>
     public static void ChangeTimeZone<T>(this IList<DateTime?> dts, T tzDst) where T : struct
     {
         if (dts is not null && dts.Count > 0)
@@ -668,22 +295,8 @@ public static void ChangeTimeZone<T>(this IList<DateTime?> dts, T tzDst) where T
         }
     }
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.
-    /// </summary>
-    /// <typeparam name="T">The type of the time zone offset to convert the original <see cref="DateTime"/> value to, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.</returns>
     public static DateTime ChangeTimeZone<T>(this DateTime dt, T? tzDst) where T : struct => dt.ChangeTimeZone(0, tzDst);
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.
-    /// </summary>
-    /// <typeparam name="T">The type of the time zone offset to convert the original <see cref="DateTime"/> value to, which must be a value type.</typeparam>
-    /// <param name="dts">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.</returns>
     public static IEnumerable<DateTime> ChangeTimeZone<T>(this IEnumerable<DateTime> dts, T? tzDst) where T : struct
     {
         if (dts is null || !dts.Any())
@@ -696,13 +309,6 @@ public static IEnumerable<DateTime> ChangeTimeZone<T>(this IEnumerable<DateTime>
         }
     }
 
-    /// <summary>
-    /// Converts a list of DateTime values from one time zone to another using the specified destination time zone, and updates the original list in place with the DateTime values converted to the destination time zone.
-    /// If the input list is <see langword="null"/> or empty, no changes will be made.
-    /// </summary>
-    /// <typeparam name="T">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The list of DateTime values to convert.</param>
-    /// <param name="tzDst">The destination time zone to convert to.</param>
     public static void ChangeTimeZone<T>(this IList<DateTime> dts, T? tzDst) where T : struct
     {
         if (dts is not null && dts.Count > 0)
@@ -714,22 +320,8 @@ public static void ChangeTimeZone<T>(this IList<DateTime> dts, T? tzDst) where T
         }
     }
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.
-    /// </summary>
-    /// <typeparam name="T">The type of the time zone offset to convert the original <see cref="DateTime"/> value to, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.</returns>
     public static DateTime ChangeTimeZone<T>(this DateTime? dt, T? tzDst) where T : struct => dt.ChangeTimeZone(0, tzDst);
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.
-    /// </summary>
-    /// <typeparam name="T">The type of the time zone offset to convert the original <see cref="DateTime"/> value to, which must be a value type.</typeparam>
-    /// <param name="dts">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.</returns>
     public static IEnumerable<DateTime> ChangeTimeZone<T>(this IEnumerable<DateTime?> dts, T? tzDst) where T : struct
     {
         if (dts is null || !dts.Any())
@@ -742,13 +334,6 @@ public static IEnumerable<DateTime> ChangeTimeZone<T>(this IEnumerable<DateTime?
         }
     }
 
-    /// <summary>
-    /// Converts a list of DateTime values from one time zone to another using the specified destination time zone, and updates the original list in place with the DateTime values converted to the destination time zone.
-    /// If the input list is <see langword="null"/> or empty, no changes will be made.
-    /// </summary>
-    /// <typeparam name="T">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The list of DateTime values to convert.</param>
-    /// <param name="tzDst">The destination time zone to convert to.</param>
     public static void ChangeTimeZone<T>(this IList<DateTime?> dts, T? tzDst) where T : struct
     {
         if (dts is not null && dts.Count > 0)
diff --git a/lib/YANLib/YANDateTime.cs b/lib/YANLib/YANDateTime.cs
index ab847554..c4b3c845 100644
--- a/lib/YANLib/YANDateTime.cs
+++ b/lib/YANLib/YANDateTime.cs
@@ -9,21 +9,10 @@ namespace YANLib;
 
 public static partial class YANDateTime
 {
-    /// <summary>
-    /// Parses the string representation of a date and time using the default format.
-    /// Returns the parsed <see cref="DateTime"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="DateTime"/> value, or <see langword="default"/> if the parsing fails.</returns>
+    
     public static DateTime ToDateTime(this string str) => TryParse(str, out var dt) ? dt : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings representing date/time values to an <see cref="IEnumerable{DateTime}"/> containing the parsed DateTime values.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only whitespace strings.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to convert to DateTime values.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the parsed DateTime values.</returns>
-    public static IEnumerable<DateTime> ToDateTime(IEnumerable<string> strs)
+    public static IEnumerable<DateTime> ToDateTime(this IEnumerable<string> strs)
     {
         if (strs.IsNullOrWhiteSpace())
         {
@@ -35,23 +24,9 @@ public static IEnumerable<DateTime> ToDateTime(IEnumerable<string> strs)
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a date and time using <paramref name="fmt"/>.
-    /// Returns the parsed <see cref="DateTime"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="fmt">The format of the string representation.</param>
-    /// <returns>The parsed <see cref="DateTime"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static DateTime ToDateTime(this string str, string fmt) => TryParseExact(str, fmt, InvariantCulture, None, out var dt) ? dt : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings representing date/time values in a specified format to an <see cref="IEnumerable{DateTime}"/> containing the parsed DateTime values.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only whitespace strings.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to convert to DateTime values.</param>
-    /// <param name="fmt">The format of the date/time values in the input strings.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the parsed DateTime values.</returns>
-    public static IEnumerable<DateTime> ToDateTime(IEnumerable<string> strs, string fmt)
+    public static IEnumerable<DateTime> ToDateTime(this IEnumerable<string> strs, string fmt)
     {
         if (strs.IsNullOrWhiteSpace())
         {
@@ -63,26 +38,9 @@ public static IEnumerable<DateTime> ToDateTime(IEnumerable<string> strs, string
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a date and time using <paramref name="fmt"/>.
-    /// Returns the parsed <see cref="DateTime"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="fmt">The format of the string representation.</param>
-    /// <param name="dfltVal">The default value to return if the parsing fails.</param>
-    /// <returns>The parsed <see cref="DateTime"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static DateTime ToDateTime(this string str, string fmt, DateTime dfltVal) => TryParseExact(str, fmt, InvariantCulture, None, out var dt) ? dt : dfltVal;
 
-    /// <summary>
-    /// Converts an enumerable of strings representing date/time values in a specified format to an <see cref="IEnumerable{DateTime}"/> containing the parsed DateTime values.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only whitespace strings.
-    /// If a string cannot be parsed to a valid DateTime value, the default value specified by <paramref name="dfltVal"/> is used instead.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to convert to DateTime values.</param>
-    /// <param name="fmt">The format of the date/time values in the input strings.</param>
-    /// <param name="dfltVal">The default DateTime value to be used for strings that cannot be parsed to valid DateTime values.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the parsed DateTime values.</returns>
-    public static IEnumerable<DateTime> ToDateTime(IEnumerable<string> strs, string fmt, DateTime dfltVal)
+    public static IEnumerable<DateTime> ToDateTime(this IEnumerable<string> strs, string fmt, DateTime dfltVal)
     {
         if (strs.IsNullOrWhiteSpace())
         {
@@ -94,28 +52,8 @@ public static IEnumerable<DateTime> ToDateTime(IEnumerable<string> strs, string
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="DateTime"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <param name="min">The minimum <see cref="DateTime"/> value.</param>
-    /// <param name="max">The maximum <see cref="DateTime"/> value.</param>
-    /// <returns>A random <see cref="DateTime"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static DateTime GenerateRandomDateTime(DateTime min, DateTime max) => min > max ? default : min.AddTicks(GenerateRandomLong((max - min).Ticks));
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of DateTime values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of <paramref name="size"/>.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="min">The minimum DateTime value.</param>
-    /// <param name="max">The maximum DateTime value.</param>
-    /// <param name="size">The number of DateTime values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing random DateTime values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<DateTime> GenerateRandomDateTimes<T>(DateTime min, DateTime max, T size) where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -124,32 +62,12 @@ public static IEnumerable<DateTime> GenerateRandomDateTimes<T>(DateTime min, Dat
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="DateTime"/> value between <see cref="MinValue"/> and <see cref="MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="DateTime"/> value between <see cref="MinValue"/> and <see cref="MaxValue"/>.</returns>
     public static DateTime GenerateRandomDateTime() => GenerateRandomDateTime(MinValue, MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="DateTime"/> value between <see cref="MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <param name="max">The maximum <see cref="DateTime"/> value.</param>
-    /// <returns>A random <see cref="DateTime"/> value between <see cref="MinValue"/> and <paramref name="max"/>.</returns>
     public static DateTime GenerateRandomDateTime(DateTime max) => GenerateRandomDateTime(max > Today ? Today : MinValue, max);
 
-    /// <summary>
-    /// Returns the week of the year that the specified <see cref="DateTime"/> value falls in, according to the current culture's calendar, week rule, and first day of the week settings.
-    /// </summary>
-    /// <param name="dt">The <see cref="DateTime"/> value.</param>
-    /// <returns>The week of the year that the specified <see cref="DateTime"/> value falls in.</returns>
     public static int GetWeekOfYear(this DateTime dt) => CurrentInfo.Calendar.GetWeekOfYear(dt, CurrentInfo.CalendarWeekRule, CurrentInfo.FirstDayOfWeek);
 
-    /// <summary>
-    /// Gets the week of the year for an enumerable of DateTime values using the default calendar of the current culture.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/> or empty.
-    /// </summary>
-    /// <param name="dts">The enumerable of DateTime values for which to get the week of the year.</param>
-    /// <returns>An <see cref="IEnumerable{Int32}"/> containing the week of the year values for the input DateTime values.</returns>
     public static IEnumerable<int> GetWeekOfYear(this IEnumerable<DateTime> dts)
     {
         if (dts is null || !dts.Any())
@@ -162,23 +80,8 @@ public static IEnumerable<int> GetWeekOfYear(this IEnumerable<DateTime> dts)
         }
     }
 
-    /// <summary>
-    /// Returns the total number of months between the two specified <see cref="DateTime"/> values, ignoring the day of the month.
-    /// </summary>
-    /// <param name="dt1">The first <see cref="DateTime"/> value.</param>
-    /// <param name="dt2">The second <see cref="DateTime"/> value.</param>
-    /// <returns>The total number of months between the two specified <see cref="DateTime"/> values, ignoring the day of the month.</returns>
     public static int TotalMonths(DateTime dt1, DateTime dt2) => Abs((dt1.Year - dt2.Year) * 12 + dt1.Month - dt2.Month);
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.
-    /// </summary>
-    /// <typeparam name="T1">The type of the original time zone offset, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone offset, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzSrc">The time zone offset of the original <see cref="DateTime"/> value, in hours.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone.</returns>
     public static DateTime ChangeTimeZone<T1, T2>(this DateTime dt, T1 tzSrc, T2 tzDst) where T1 : struct where T2 : struct
     {
         var diff = tzDst.ToInt() - tzSrc.ToInt();
@@ -190,16 +93,6 @@ public static DateTime ChangeTimeZone<T1, T2>(this DateTime dt, T1 tzSrc, T2 tzD
         };
     }
 
-    /// <summary>
-    /// Converts an enumerable of DateTime values from one time zone to another using the specified source and destination time zones.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/> or empty.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The enumerable of DateTime values to convert.</param>
-    /// <param name="tzSrc">The source time zone to convert from.</param>
-    /// <param name="tzDst">The destination time zone to convert to.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the DateTime values converted to the destination time zone.</returns>
     public static IEnumerable<DateTime> ChangeTimeZone<T1, T2>(this IEnumerable<DateTime> dts, T1 tzSrc, T2 tzDst) where T1 : struct where T2 : struct
     {
         if (dts is null || !dts.Any())
@@ -212,15 +105,6 @@ public static IEnumerable<DateTime> ChangeTimeZone<T1, T2>(this IEnumerable<Date
         }
     }
 
-    /// <summary>
-    /// Converts an list of DateTime values from one time zone to another using the specified source and destination time zones, and updates the original list in-place.
-    /// If the input list is <see langword="null"/> or empty, no action is taken.
-    /// </summary>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The list of DateTime values to convert and update.</param>
-    /// <param name="tzSrc">The source time zone to convert from.</param>
-    /// <param name="tzDst">The destination time zone to convert to.</param>
     public static void ChangeTimeZone<T1, T2>(this IList<DateTime> dts, T1 tzSrc, T2 tzDst) where T1 : struct where T2 : struct
     {
         if (dts is not null && dts.Count > 0)
@@ -232,23 +116,8 @@ public static void ChangeTimeZone<T1, T2>(this IList<DateTime> dts, T1 tzSrc, T2
         }
     }
 
-    /// <summary>
-    /// Returns a new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.
-    /// </summary>
-    /// <typeparam name="T">The type of the time zone offset to convert the original <see cref="DateTime"/> value to, which must be a value type.</typeparam>
-    /// <param name="dt">The original <see cref="DateTime"/> value.</param>
-    /// <param name="tzDst">The time zone offset to convert the original <see cref="DateTime"/> value to, in hours.</param>
-    /// <returns>A new <see cref="DateTime"/> value representing the same point in time as the original <see cref="DateTime"/> value, but converted to a different time zone with a time zone offset of 0.</returns>
     public static DateTime ChangeTimeZone<T>(this DateTime dt, T tzDst) where T : struct => dt.ChangeTimeZone(0, tzDst);
 
-    /// <summary>
-    /// Converts an array of DateTime values from one time zone to another using the specified destination time zone, and returns an <see cref="IEnumerable{DateTime}"/> containing the DateTime values converted to the destination time zone.
-    /// Returns an empty sequence if the input array is <see langword="null"/> or empty.
-    /// </summary>
-    /// <typeparam name="T">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The array of DateTime values to convert.</param>
-    /// <param name="tzDst">The destination time zone to convert to.</param>
-    /// <returns>An <see cref="IEnumerable{DateTime}"/> containing the DateTime values converted to the destination time zone.</returns>
     public static IEnumerable<DateTime> ChangeTimeZone<T>(this IEnumerable<DateTime> dts, T tzDst) where T : struct
     {
         if (dts is null || !dts.Any())
@@ -261,13 +130,6 @@ public static IEnumerable<DateTime> ChangeTimeZone<T>(this IEnumerable<DateTime>
         }
     }
 
-    /// <summary>
-    /// Converts a list of DateTime values from one time zone to another using the specified destination time zone, and updates the original list in place with the DateTime values converted to the destination time zone.
-    /// If the input list is <see langword="null"/> or empty, no changes will be made.
-    /// </summary>
-    /// <typeparam name="T">The type of the destination time zone.</typeparam>
-    /// <param name="dts">The list of DateTime values to convert.</param>
-    /// <param name="tzDst">The destination time zone to convert to.</param>
     public static void ChangeTimeZone<T>(this IList<DateTime> dts, T tzDst) where T : struct
     {
         if (dts is not null && dts.Count > 0)
diff --git a/lib/YANLib/YANEnumerable.cs b/lib/YANLib/YANEnumerable.cs
index b52e1cfb..eb91848f 100644
--- a/lib/YANLib/YANEnumerable.cs
+++ b/lib/YANLib/YANEnumerable.cs
@@ -6,14 +6,7 @@ namespace YANLib;
 
 public static partial class YANEnumerable
 {
-    /// <summary>
-    /// Splits a given <see cref="List{T}"/> into smaller chunks of a specified size.
-    /// </summary>
-    /// <typeparam name="T">The type of elements in the list.</typeparam>
-    /// <typeparam name="T1">The type of the chunk size, which must be a value type.</typeparam>
-    /// <param name="srcs">The source list to be chunked.</param>
-    /// <param name="chunkSize">The maximum number of elements in each chunk.</param>
-    /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="List{T}"/>s, where each inner list has a maximum size of <paramref name="chunkSize"/>.</returns>
+    
     public static IEnumerable<List<T>> ChunkBySize<T, T1>(this List<T> srcs, T1 chunkSize) where T1 : struct
     {
         var size = chunkSize.ToInt();
@@ -28,14 +21,6 @@ public static IEnumerable<List<T>> ChunkBySize<T, T1>(this List<T> srcs, T1 chun
         }
     }
 
-    /// <summary>
-    /// Removes <see langword="null"/> values from the specified objects and returns an <see cref="IEnumerable{T}"/> containing the non-null values.
-    /// If the type <typeparamref name="T"/> is a class or a nullable value type, the method checks for <see langword="null"/> values and excludes them.
-    /// If <typeparamref name="T"/> is a non-nullable value type, the method returns all objects in the input enumerable without modification.
-    /// </summary>
-    /// <typeparam name="T">The type of the objects to clean.</typeparam>
-    /// <param name="srcs">The objects to clean.</param>
-    /// <returns>An <see cref="IEnumerable{T}"/> containing the non-null values.</returns>
     public static IEnumerable<T> Clean<T>(this IEnumerable<T> srcs)
     {
         if (srcs is null || !srcs.Any())
@@ -62,13 +47,6 @@ public static IEnumerable<T> Clean<T>(this IEnumerable<T> srcs)
         }
     }
 
-    /// <summary>
-    /// Removes <see langword="null"/> values from the specified collection of objects and modifies the collection in-place, by removing the null values.
-    /// If the type <typeparamref name="T"/> is a class or a nullable value type, the method checks for <see langword="null"/> values and removes them from the collection.
-    /// If <typeparamref name="T"/> is a non-nullable value type, the method does not modify the collection.
-    /// </summary>
-    /// <typeparam name="T">The type of the objects in the collection.</typeparam>
-    /// <param name="srcs">The collection of objects to clean.</param>
     public static void Clean<T>(this ICollection<T> srcs)
     {
         if (srcs is not null && srcs.Any())
@@ -87,11 +65,6 @@ public static void Clean<T>(this ICollection<T> srcs)
         }
     }
 
-    /// <summary>
-    /// Removes <see langword="null"/> values and empty strings from the specified enumerable of strings, and returns an <see cref="IEnumerable{string}"/> containing the non-null and non-empty strings.
-    /// </summary>
-    /// <param name="srcs">The enumerable of strings to clean.</param>
-    /// <returns>An <see cref="IEnumerable{string}"/> containing the non-null and non-empty strings.</returns>
     public static IEnumerable<string> Clean(this IEnumerable<string> srcs)
     {
         if (srcs is null || !srcs.Any())
@@ -107,11 +80,6 @@ public static IEnumerable<string> Clean(this IEnumerable<string> srcs)
         }
     }
 
-    /// <summary>
-    /// Removes <see langword="null"/> or whitespace values from the specified collection of strings and modifies the collection in-place, by removing the null or whitespace values.
-    /// If the string value is not null or whitespace, the method checks for whitespace values using <see cref="string.IsNullOrWhiteSpace"/> method and removes them from the collection.
-    /// </summary>
-    /// <param name="srcs">The collection of strings to clean.</param>
     public static void Clean(this ICollection<string> srcs)
     {
         if (srcs is not null && srcs.Any())
@@ -125,23 +93,4 @@ public static void Clean(this ICollection<string> srcs)
             }
         }
     }
-
-    public static Dictionary<TKey, TValue>? CreateDictionary<TKey, TValue>(IEnumerable<TKey> keys, IEnumerable<TValue> values) where TKey : notnull
-    {
-        if (keys is not null && values is not null && keys.Any() && values.Any())
-        {
-            var keyList = keys.ToList();
-            var valueList = values.ToList();
-            if (keyList.Count > 0 && keyList.Count == keyList.Distinct().Count() && valueList.Count >= keyList.Count)
-            {
-                var rslt = new Dictionary<TKey, TValue>(keyList.Count);
-                for (var i = 0; i < keyList.Count; i++)
-                {
-                    rslt.Add(keyList[i], valueList[i]);
-                }
-                return rslt;
-            }
-        }
-        return default;
-    }
 }
diff --git a/lib/YANLib/YANFunc.cs b/lib/YANLib/YANFunc.cs
deleted file mode 100644
index ce950532..00000000
--- a/lib/YANLib/YANFunc.cs
+++ /dev/null
@@ -1,133 +0,0 @@
-using static System.Environment;
-using static System.Threading.Tasks.Task;
-
-namespace YANLib;
-
-public static partial class YANFunc
-{
-    public static async ValueTask<List<TResult>> AggregateResultsConcurrently<T, TResult>(Func<T, TResult> func, IEnumerable<T> args)
-    {
-        var rslts = new List<TResult>();
-        var semSlim = new SemaphoreSlim(ProcessorCount);
-        var tasks = args.Select(async arg =>
-        {
-            var item = func(arg);
-            await semSlim.WaitAsync();
-            try
-            {
-                rslts.Add(item);
-            }
-            finally
-            {
-                _ = semSlim.Release();
-            }
-        });
-        await WhenAll(tasks);
-        return rslts;
-    }
-
-    public static async ValueTask<List<TResult>> AggregateResultsConcurrently<T, Ts, TResult>(Func<T, IEnumerable<Ts>, TResult> func, IEnumerable<T> args, IEnumerable<Ts> coll)
-    {
-        var rslts = new List<TResult>();
-        var semSlim = new SemaphoreSlim(ProcessorCount);
-        var tasks = args.Select(async arg =>
-        {
-            var item = func(arg, coll);
-            await semSlim.WaitAsync();
-            try
-            {
-                rslts.Add(item);
-            }
-            finally
-            {
-                _ = semSlim.Release();
-            }
-        });
-        await WhenAll(tasks);
-        return rslts;
-    }
-
-    public static async ValueTask<List<TResult>> AggregateResultsConcurrently<T, TResult>(Func<T, ValueTask<TResult>> func, IEnumerable<T> args)
-    {
-        var rslts = new List<TResult>();
-        var semSlim = new SemaphoreSlim(ProcessorCount);
-        var tasks = args.Select(async arg =>
-        {
-            var item = await func(arg);
-            await semSlim.WaitAsync();
-            try
-            {
-                rslts.Add(item);
-            }
-            finally
-            {
-                _ = semSlim.Release();
-            }
-        });
-        await WhenAll(tasks);
-        return rslts;
-    }
-
-    public static async ValueTask<List<TResult>> AggregateResultsConcurrently<T, Ts, TResult>(Func<T, IEnumerable<Ts>, ValueTask<TResult>> func, IEnumerable<T> args, IEnumerable<Ts> coll)
-    {
-        var rslts = new List<TResult>();
-        var semSlim = new SemaphoreSlim(ProcessorCount);
-        var tasks = args.Select(async arg =>
-        {
-            var item = await func(arg, coll);
-            await semSlim.WaitAsync();
-            try
-            {
-                rslts.Add(item);
-            }
-            finally
-            {
-                _ = semSlim.Release();
-            }
-        });
-        await WhenAll(tasks);
-        return rslts;
-    }
-
-    public static async ValueTask<List<TResult>> AggregateResultsConcurrently<T, TResult>(Func<T, Task<TResult>> func, IEnumerable<T> args)
-    {
-        var rslts = new List<TResult>();
-        var semSlim = new SemaphoreSlim(ProcessorCount);
-        var tasks = args.Select(async arg =>
-        {
-            var item = await func(arg);
-            await semSlim.WaitAsync();
-            try
-            {
-                rslts.Add(item);
-            }
-            finally
-            {
-                _ = semSlim.Release();
-            }
-        });
-        await WhenAll(tasks);
-        return rslts;
-    }
-
-    public static async ValueTask<List<TResult>> AggregateResultsConcurrently<T, Ts, TResult>(Func<T, IEnumerable<Ts>, Task<TResult>> func, IEnumerable<T> args, IEnumerable<Ts> coll)
-    {
-        var rslts = new List<TResult>();
-        var semSlim = new SemaphoreSlim(ProcessorCount);
-        var tasks = args.Select(async arg =>
-        {
-            var item = await func(arg, coll);
-            await semSlim.WaitAsync();
-            try
-            {
-                rslts.Add(item);
-            }
-            finally
-            {
-                _ = semSlim.Release();
-            }
-        });
-        await WhenAll(tasks);
-        return rslts;
-    }
-}
diff --git a/lib/YANLib/YANJson.cs b/lib/YANLib/YANJson.cs
index 154b5032..cdae2aab 100644
--- a/lib/YANLib/YANJson.cs
+++ b/lib/YANLib/YANJson.cs
@@ -5,28 +5,10 @@ namespace YANLib;
 
 public static partial class YANJson
 {
-    /// <summary>
-    /// Serializes the given object of type <typeparamref name="T"/> to a JSON string using the default JSON serialization settings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the object to be serialized.
-    /// Must be a reference type.
-    /// </typeparam>
-    /// <param name="mdl">The object to be serialized.</param>
-    /// <returns>A JSON string representing the serialized object.</returns>
+    
     public static string Serialize<T>(this T mdl) where T : class => JsonSerializer.Serialize(mdl);
 
-    /// <summary>
-    /// Serializes an enumerable of objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{string}"/> containing JSON strings representing the serialized objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the objects to be serialized.
-    /// Must be a reference type.
-    /// </typeparam>
-    /// <param name="mdls">The enumerable of objects to be serialized.</param>
-    /// <returns>An <see cref="IEnumerable{string}"/> containing JSON strings representing the serialized objects.</returns>
-    public static IEnumerable<string> Serialize<T>(this IEnumerable<T> mdls) where T : class
+    public static IEnumerable<string> Serializes<T>(this IEnumerable<T> mdls) where T : class
     {
         if (mdls is null || !mdls.Any())
         {
@@ -38,34 +20,13 @@ public static IEnumerable<string> Serialize<T>(this IEnumerable<T> mdls) where T
         }
     }
 
-    /// <summary>
-    /// Serializes the given object of type <typeparamref name="T"/> to a JSON string using the default JSON serialization settings,
-    /// with the property names in camelCase and case sensitivity for property names set to false.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the object to be serialized.
-    /// Must be a reference type.
-    /// </typeparam>
-    /// <param name="mdl">The object to be serialized.</param>
-    /// <returns>A JSON string representing the serialized object with camelCase property names and case sensitivity for property names set to false.</returns>
     public static string SerializeCamel<T>(this T mdl) where T : class => JsonSerializer.Serialize(mdl, new JsonSerializerOptions
     {
         PropertyNameCaseInsensitive = false,
         PropertyNamingPolicy = CamelCase
     });
 
-    /// <summary>
-    /// Serializes an enumerable of objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{string}"/> containing JSON strings representing the serialized objects,
-    /// with the property names in camelCase and case sensitivity for property names set to false.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the objects to be serialized.
-    /// Must be a reference type.
-    /// </typeparam>
-    /// <param name="mdls">The enumerable of objects to be serialized.</param>
-    /// <returns>An <see cref="IEnumerable{string}"/> containing JSON strings representing the serialized objects with camelCase property names and case sensitivity for property names set to false.</returns>
-    public static IEnumerable<string> SerializeCamel<T>(this IEnumerable<T> mdls) where T : class
+    public static IEnumerable<string> SerializeCamels<T>(this IEnumerable<T> mdls) where T : class
     {
         if (mdls is null || !mdls.Any())
         {
@@ -77,16 +38,6 @@ public static IEnumerable<string> SerializeCamel<T>(this IEnumerable<T> mdls) wh
         }
     }
 
-    /// <summary>
-    /// Deserializes a JSON string to an object of type <typeparamref name="T"/> using the default JSON deserialization settings.
-    /// Returns the deserialized object, or <see langword="default"/> if the deserialization fails.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the object to be deserialized.
-    /// Must be a reference type.
-    /// </typeparam>
-    /// <param name="str">The JSON string to be deserialized.</param>
-    /// <returns>The deserialized object, or <see langword="default"/> if the deserialization fails.</returns>
     public static T? Deserialize<T>(this string str) where T : class
     {
         try
@@ -99,17 +50,7 @@ public static IEnumerable<string> SerializeCamel<T>(this IEnumerable<T> mdls) wh
         }
     }
 
-    /// <summary>
-    /// Deserializes an array of JSON strings to an enumerable of objects of type <typeparamref name="T"/> using the default JSON deserialization settings.
-    /// Returns an enumerable of deserialized objects, or <see langword="default"/> if the deserialization fails for any of the input strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the objects to be deserialized.
-    /// Must be a reference type.
-    /// </typeparam>
-    /// <param name="strs">The array of JSON strings to be deserialized.</param>
-    /// <returns>An enumerable of deserialized objects, or <see langword="default"/> if the deserialization fails for any of the input strings.</returns>
-    public static IEnumerable<T?> Deserialize<T>(this IEnumerable<string> strs) where T : class
+    public static IEnumerable<T?> Deserializes<T>(this IEnumerable<string> strs) where T : class
     {
         if (strs is null || !strs.Any())
         {
@@ -121,16 +62,6 @@ public static IEnumerable<string> SerializeCamel<T>(this IEnumerable<T> mdls) wh
         }
     }
 
-    /// <summary>
-    /// Deserializes a JSON string to an object of type <typeparamref name="T"/> using the default JSON deserialization settings, with camelCase property names and case sensitivity for property names set to false.
-    /// Returns the deserialized object, or <see langword="default"/> if the deserialization fails.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the object to be deserialized.
-    /// Must be a reference type.
-    /// </typeparam>
-    /// <param name="str">The JSON string to be deserialized.</param>
-    /// <returns>The deserialized object, or <see langword="default"/> if the deserialization fails.</returns>
     public static T? DeserializeCamel<T>(this string str) where T : class
     {
         try
@@ -147,17 +78,7 @@ public static IEnumerable<string> SerializeCamel<T>(this IEnumerable<T> mdls) wh
         }
     }
 
-    /// <summary>
-    /// Deserializes an array of JSON strings to an enumerable of objects of type <typeparamref name="T"/> using the default JSON deserialization settings, with camelCase property names and case sensitivity for property names set to false.
-    /// Returns an enumerable of deserialized objects, or an empty sequence if the input array is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the objects to be deserialized.
-    /// Must be a reference type.
-    /// </typeparam>
-    /// <param name="strs">The array of JSON strings to be deserialized.</param>
-    /// <returns>An enumerable of deserialized objects, or an empty sequence if the input array is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.</returns>
-    public static IEnumerable<T?> DeserializeCamel<T>(this IEnumerable<string> strs) where T : class
+    public static IEnumerable<T?> DeserializeCamels<T>(this IEnumerable<string> strs) where T : class
     {
         if (strs is null || !strs.Any())
         {
@@ -169,16 +90,6 @@ public static IEnumerable<string> SerializeCamel<T>(this IEnumerable<T> mdls) wh
         }
     }
 
-    /// <summary>
-    /// Deserializes a JSON string to an object of type <typeparamref name="T"/> using the default JSON deserialization settings, with camelCase property names and case sensitivity for property names set to false as additional options.
-    /// If the deserialization fails, returns <see langword="default"/>.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the object to be deserialized.
-    /// Must be a reference type.
-    /// </typeparam>
-    /// <param name="str">The JSON string to be deserialized.</param>
-    /// <returns>The deserialized object, or <see langword="default"/> if the deserialization fails.</returns>
     public static T? DeserializeDuo<T>(this string str) where T : class
     {
         T? rslt;
@@ -207,17 +118,7 @@ public static IEnumerable<string> SerializeCamel<T>(this IEnumerable<T> mdls) wh
         }
     }
 
-    /// <summary>
-    /// Deserializes an array of JSON strings to an enumerable of objects of type <typeparamref name="T"/> using the default JSON deserialization settings, with camelCase property names and case sensitivity for property names set to false as additional options.
-    /// Returns an enumerable of deserialized objects, or <see langword="default"/> if the deserialization fails for any of the input strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the objects to be deserialized.
-    /// Must be a reference type.
-    /// </typeparam>
-    /// <param name="strs">The array of JSON strings to be deserialized.</param>
-    /// <returns>An enumerable of deserialized objects, or <see langword="default"/> if the deserialization fails for any of the input strings.</returns>
-    public static IEnumerable<T?> DeserializeDuo<T>(this IEnumerable<string> strs) where T : class
+    public static IEnumerable<T?> DeserializeDuos<T>(this IEnumerable<string> strs) where T : class
     {
         if (strs is null || !strs.Any())
         {
@@ -229,16 +130,6 @@ public static IEnumerable<string> SerializeCamel<T>(this IEnumerable<T> mdls) wh
         }
     }
 
-    /// <summary>
-    /// Deserializes a JSON string to an object of type <typeparamref name="T"/> using the default JSON deserialization settings, with camelCase property names and case sensitivity for property names set to false as additional options.
-    /// If the deserialization fails, returns <see langword="default"/>.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the object to be deserialized.
-    /// Must be a reference type.
-    /// </typeparam>
-    /// <param name="str">The JSON string to be deserialized.</param>
-    /// <returns>The deserialized object, or <see langword="default"/> if the deserialization fails.</returns>
     public static T? DeserializeDuoCamelPriority<T>(this string str) where T : class
     {
         T? rslt;
@@ -267,17 +158,7 @@ public static IEnumerable<string> SerializeCamel<T>(this IEnumerable<T> mdls) wh
         }
     }
 
-    /// <summary>
-    /// Deserializes an array of JSON strings to an enumerable of objects of type <typeparamref name="T"/> using the default JSON deserialization settings, with camelCase property names and case sensitivity for property names set to false as additional options.
-    /// Returns an enumerable of deserialized objects, or <see langword="default"/> if the deserialization fails for any of the input strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the objects to be deserialized.
-    /// Must be a reference type.
-    /// </typeparam>
-    /// <param name="strs">The array of JSON strings to be deserialized.</param>
-    /// <returns>An enumerable of deserialized objects, or <see langword="default"/> if the deserialization fails for any of the input strings.</returns>
-    public static IEnumerable<T?> DeserializeDuoCamelPriority<T>(this IEnumerable<string> strs) where T : class
+    public static IEnumerable<T?> DeserializeDuoCamelPriorities<T>(this IEnumerable<string> strs) where T : class
     {
         if (strs is null || !strs.Any())
         {
@@ -289,16 +170,6 @@ public static IEnumerable<string> SerializeCamel<T>(this IEnumerable<T> mdls) wh
         }
     }
 
-    /// <summary>
-    /// Deserializes a JSON string to an object of type <typeparamref name="T"/> using the default JSON deserialization settings, with camelCase property names and case sensitivity for property names set to false as additional options.
-    /// If the deserialization fails, returns <see langword="default"/>.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the object to be deserialized.
-    /// Must be a reference type.
-    /// </typeparam>
-    /// <param name="str">The JSON string to be deserialized.</param>
-    /// <returns>The deserialized object, or <see langword="default"/> if the deserialization fails.</returns>
     public static T? DeserializeStandard<T>(this string str) where T : class
     {
         try
@@ -315,17 +186,7 @@ public static IEnumerable<string> SerializeCamel<T>(this IEnumerable<T> mdls) wh
         }
     }
 
-    /// <summary>
-    /// Deserializes an array of JSON strings to an enumerable of objects of type <typeparamref name="T"/> using the default JSON deserialization settings, with camelCase property names and case sensitivity for property names set to false as additional options.
-    /// Returns an enumerable of deserialized objects, or <see langword="default"/> if the deserialization fails for any of the input strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the objects to be deserialized.
-    /// Must be a reference type.
-    /// </typeparam>
-    /// <param name="strs">The array of JSON strings to be deserialized.</param>
-    /// <returns>An enumerable of deserialized objects, or <see langword="default"/> if the deserialization fails for any of the input strings.</returns>
-    public static IEnumerable<T?> DeserializeStandard<T>(this IEnumerable<string> strs) where T : class
+    public static IEnumerable<T?> DeserializeStandards<T>(this IEnumerable<string> strs) where T : class
     {
         if (strs is null || !strs.Any())
         {
diff --git a/lib/YANLib/YANModel.Property.cs b/lib/YANLib/YANModel.Property.cs
index 95112b2c..cfcd51a4 100644
--- a/lib/YANLib/YANModel.Property.cs
+++ b/lib/YANLib/YANModel.Property.cs
@@ -5,13 +5,7 @@ namespace YANLib;
 
 public static partial class YANModel
 {
-    /// <summary>
-    /// Checks whether all properties of the specified object have non-default values, including all its nested properties and properties in lists.
-    /// If the object is <see langword="null"/>, returns <see langword="false"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the object to check.</typeparam>
-    /// <param name="mdl">The object to check.</param>
-    /// <returns><see langword="true"/> if all properties of the specified object have non-default values; otherwise, <see langword="false"/>.</returns>
+    
     public static bool AllPropertiesNotDefault<T>(this T mdl) where T : class
     {
         if (mdl is null)
@@ -29,13 +23,6 @@ public static bool AllPropertiesNotDefault<T>(this T mdl) where T : class
         return true;
     }
 
-    /// <summary>
-    /// Checks whether all properties of the specified objects have non-default values, including all their nested properties and properties in lists.
-    /// If any of the objects is <see langword="null"/>, returns <see langword="false"/> for that object.
-    /// </summary>
-    /// <typeparam name="T">The type of the objects to check.</typeparam>
-    /// <param name="mdls">The objects to check.</param>
-    /// <returns>An <see cref="IEnumerable{bool}"/> containing <see langword="true"/> or <see langword="false"/> for each object, indicating whether all properties have non-default values.</returns>
     public static IEnumerable<bool> AllPropertiesNotDefault<T>(this IEnumerable<T> mdls) where T : class
     {
         if (mdls is null || !mdls.Any())
@@ -48,13 +35,6 @@ public static IEnumerable<bool> AllPropertiesNotDefault<T>(this IEnumerable<T> m
         }
     }
 
-    /// <summary>
-    /// Checks whether all properties of the specified object have default values, including all its nested properties and properties in lists.
-    /// If the object is <see langword="null"/>, returns <see langword="false"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the object to check.</typeparam>
-    /// <param name="mdl">The object to check.</param>
-    /// <returns><see langword="true"/> if all properties of the specified object have default values; otherwise, <see langword="false"/>.</returns>
     public static bool AllPropertiesDefault<T>(this T mdl) where T : class
     {
         if (mdl is null)
@@ -72,13 +52,6 @@ public static bool AllPropertiesDefault<T>(this T mdl) where T : class
         return true;
     }
 
-    /// <summary>
-    /// Checks whether all properties of the specified objects have default values, including all their nested properties and properties in lists.
-    /// If any of the objects is <see langword="null"/>, returns <see langword="false"/> for that object.
-    /// </summary>
-    /// <typeparam name="T">The type of the objects to check.</typeparam>
-    /// <param name="mdls">The objects to check.</param>
-    /// <returns>An <see cref="IEnumerable{bool}"/> containing <see langword="true"/> or <see langword="false"/> for each object, indicating whether all properties have default values.</returns>
     public static IEnumerable<bool> AllPropertiesDefault<T>(this IEnumerable<T> mdls) where T : class
     {
         if (mdls is null || !mdls.Any())
@@ -91,13 +64,6 @@ public static IEnumerable<bool> AllPropertiesDefault<T>(this IEnumerable<T> mdls
         }
     }
 
-    /// <summary>
-    /// Checks whether any property of the specified object has a value other than the default value, including all its nested properties and properties in lists.
-    /// If the object is <see langword="null"/>, returns <see langword="false"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the object to check.</typeparam>
-    /// <param name="mdl">The object to check.</param>
-    /// <returns><see langword="true"/> if any property of the specified object has a value other than the default value; otherwise, <see langword="false"/>.</returns>
     public static bool AnyPropertiesNotDefault<T>(this T mdl) where T : class
     {
         if (mdl is null)
@@ -115,13 +81,6 @@ public static bool AnyPropertiesNotDefault<T>(this T mdl) where T : class
         return false;
     }
 
-    /// <summary>
-    /// Checks whether any property of the specified objects has a non-default value, including all their nested properties and properties in lists.
-    /// If any of the objects is <see langword="null"/>, returns <see langword="false"/> for that object.
-    /// </summary>
-    /// <typeparam name="T">The type of the objects to check.</typeparam>
-    /// <param name="mdls">The objects to check.</param>
-    /// <returns>An <see cref="IEnumerable{bool}"/> containing <see langword="true"/> or <see langword="false"/> for each object, indicating whether any property has a non-default value.</returns>
     public static IEnumerable<bool> AnyPropertiesNotDefault<T>(this IEnumerable<T> mdls) where T : class
     {
         if (mdls is null || !mdls.Any())
@@ -134,13 +93,6 @@ public static IEnumerable<bool> AnyPropertiesNotDefault<T>(this IEnumerable<T> m
         }
     }
 
-    /// <summary>
-    /// Checks whether any property of the specified object has a value equal to the default value, including all its nested properties and properties in lists.
-    /// If the object is <see langword="null"/>, returns <see langword="false"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the object to check.</typeparam>
-    /// <param name="mdl">The object to check.</param>
-    /// <returns><see langword="true"/> if any property of the specified object has a value equal to the default value; otherwise, <see langword="false"/>.</returns>
     public static bool AnyPropertiesDefault<T>(this T mdl) where T : class
     {
         if (mdl is null)
@@ -158,13 +110,6 @@ public static bool AnyPropertiesDefault<T>(this T mdl) where T : class
         return false;
     }
 
-    /// <summary>
-    /// Checks whether any property of the specified objects has a default value, including all their nested properties and properties in lists.
-    /// If any of the objects is <see langword="null"/>, returns <see langword="false"/> for that object.
-    /// </summary>
-    /// <typeparam name="T">The type of the objects to check.</typeparam>
-    /// <param name="mdls">The objects to check.</param>
-    /// <returns>An <see cref="IEnumerable{bool}"/> containing <see langword="true"/> or <see langword="false"/> for each object, indicating whether any property has a default value.</returns>
     public static IEnumerable<bool> AnyPropertiesDefault<T>(this IEnumerable<T> mdls) where T : class
     {
         if (mdls is null || !mdls.Any())
@@ -177,14 +122,6 @@ public static IEnumerable<bool> AnyPropertiesDefault<T>(this IEnumerable<T> mdls
         }
     }
 
-    /// <summary>
-    /// Checks whether all properties with the specified names of the specified object have values that are not equal to the default value, including all its nested properties and properties in lists.
-    /// If the object is <see langword="null"/>, returns <see langword="false"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the object to check.</typeparam>
-    /// <param name="mdl">The object to check.</param>
-    /// <param name="names">The names of the properties to check.</param>
-    /// <returns><see langword="true"/> if all properties with the specified names of the specified object have values that are not equal to the default value; otherwise, <see langword="false"/>.</returns>
     public static bool AllPropertiesNotDefault<T>(this T mdl, params string[] names) where T : class
     {
         if (mdl is null || names.IsNullOrWhiteSpace())
@@ -202,14 +139,6 @@ public static bool AllPropertiesNotDefault<T>(this T mdl, params string[] names)
         return true;
     }
 
-    /// <summary>
-    /// Checks whether all properties of the specified objects have non-default values, including all their nested properties and properties in lists, except for properties with the specified names.
-    /// If any of the objects is <see langword="null"/>, returns <see langword="false"/> for that object.
-    /// </summary>
-    /// <typeparam name="T">The type of the objects to check.</typeparam>
-    /// <param name="mdls">The objects to check.</param>
-    /// <param name="names">The names of properties to exclude from the check.</param>
-    /// <returns>An <see cref="IEnumerable{bool}"/> containing <see langword="true"/> or <see langword="false"/> for each object, indicating whether all properties, except for the specified names, have non-default values.</returns>
     public static IEnumerable<bool> AllPropertiesNotDefault<T>(this IEnumerable<T> mdls, params string[] names) where T : class
     {
         if (mdls is null || !mdls.Any())
@@ -222,14 +151,6 @@ public static IEnumerable<bool> AllPropertiesNotDefault<T>(this IEnumerable<T> m
         }
     }
 
-    /// <summary>
-    /// Checks whether all properties with the specified names of the specified object have values that are equal to the default value, including all its nested properties and properties in lists.
-    /// If the object is <see langword="null"/>, returns <see langword="true"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the object to check.</typeparam>
-    /// <param name="mdl">The object to check.</param>
-    /// <param name="names">The names of the properties to check.</param>
-    /// <returns><see langword="true"/> if all properties with the specified names of the specified object have values that are equal to the default value; otherwise, <see langword="false"/>.</returns>
     public static bool AllPropertiesDefault<T>(this T mdl, params string[] names) where T : class
     {
         if (mdl is null || names.IsNullOrWhiteSpace())
@@ -247,14 +168,6 @@ public static bool AllPropertiesDefault<T>(this T mdl, params string[] names) wh
         return true;
     }
 
-    /// <summary>
-    /// Checks whether all properties of the specified objects have default values, including all their nested properties and properties in lists, except for properties with the specified names.
-    /// If any of the objects is <see langword="null"/>, returns <see langword="false"/> for that object.
-    /// </summary>
-    /// <typeparam name="T">The type of the objects to check.</typeparam>
-    /// <param name="mdls">The objects to check.</param>
-    /// <param name="names">The names of properties to exclude from the check.</param>
-    /// <returns>An <see cref="IEnumerable{bool}"/> containing <see langword="true"/> or <see langword="false"/> for each object, indicating whether all properties, except for the specified names, have default values.</returns>
     public static IEnumerable<bool> AllPropertiesDefault<T>(this IEnumerable<T> mdls, params string[] names) where T : class
     {
         if (mdls is null || !mdls.Any())
@@ -267,14 +180,6 @@ public static IEnumerable<bool> AllPropertiesDefault<T>(this IEnumerable<T> mdls
         }
     }
 
-    /// <summary>
-    /// Checks whether any properties with the specified names of the specified object have values that are not equal to the default value, including all its nested properties and properties in lists.
-    /// If the object is <see langword="null"/>, returns <see langword="false"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the object to check.</typeparam>
-    /// <param name="mdl">The object to check.</param>
-    /// <param name="names">The names of the properties to check.</param>
-    /// <returns><see langword="true"/> if any properties with the specified names of the specified object have values that are not equal to the default value; otherwise, <see langword="false"/>.</returns>
     public static bool AnyPropertiesNotDefault<T>(this T mdl, params string[] names) where T : class
     {
         if (mdl is null || names.IsNullOrWhiteSpace())
@@ -292,14 +197,6 @@ public static bool AnyPropertiesNotDefault<T>(this T mdl, params string[] names)
         return false;
     }
 
-    /// <summary>
-    /// Checks whether any property of the specified objects has a non-default value, including all their nested properties and properties in lists, except for properties with the specified names.
-    /// If any of the objects is <see langword="null"/>, returns <see langword="false"/> for that object.
-    /// </summary>
-    /// <typeparam name="T">The type of the objects to check.</typeparam>
-    /// <param name="mdls">The objects to check.</param>
-    /// <param name="names">The names of properties to exclude from the check.</param>
-    /// <returns>An <see cref="IEnumerable{bool}"/> containing <see langword="true"/> or <see langword="false"/> for each object, indicating whether any property, except for the specified names, has a non-default value.</returns>
     public static IEnumerable<bool> AnyPropertiesNotDefault<T>(this IEnumerable<T> mdls, params string[] names) where T : class
     {
         if (mdls is null || !mdls.Any())
@@ -312,14 +209,6 @@ public static IEnumerable<bool> AnyPropertiesNotDefault<T>(this IEnumerable<T> m
         }
     }
 
-    /// <summary>
-    /// Checks whether any properties with the specified names of the specified object have values that are equal to the default value, including all its nested properties and properties in lists.
-    /// If the object is <see langword="null"/>, returns <see langword="false"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the object to check.</typeparam>
-    /// <param name="mdl">The object to check.</param>
-    /// <param name="names">The names of the properties to check.</param>
-    /// <returns><see langword="true"/> if any properties with the specified names of the specified object have values that are equal to the default value; otherwise, <see langword="false"/>.</returns>
     public static bool AnyPropertiesDefault<T>(this T mdl, params string[] names) where T : class
     {
         if (mdl is null || names.IsNullOrWhiteSpace())
@@ -337,14 +226,6 @@ public static bool AnyPropertiesDefault<T>(this T mdl, params string[] names) wh
         return false;
     }
 
-    /// <summary>
-    /// Checks whether any property of the specified objects has a default value, including all their nested properties and properties in lists, except for properties with the specified names.
-    /// If any of the objects is <see langword="null"/>, returns <see langword="false"/> for that object.
-    /// </summary>
-    /// <typeparam name="T">The type of the objects to check.</typeparam>
-    /// <param name="mdls">The objects to check.</param>
-    /// <param name="names">The names of properties to exclude from the check.</param>
-    /// <returns>An <see cref="IEnumerable{bool}"/> containing <see langword="true"/> or <see langword="false"/> for each object, indicating whether any property, except for the specified names, has a default value.</returns>
     public static IEnumerable<bool> AnyPropertiesDefault<T>(this IEnumerable<T> mdls, params string[] names) where T : class
     {
         if (mdls is null || !mdls.Any())
@@ -357,14 +238,6 @@ public static IEnumerable<bool> AnyPropertiesDefault<T>(this IEnumerable<T> mdls
         }
     }
 
-    /// <summary>
-    /// Checks whether all properties with the specified names of the specified object have values that are not equal to the default value, including all its nested properties and properties in lists.
-    /// If the object is <see langword="null"/>, returns <see langword="false"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the object to check.</typeparam>
-    /// <param name="mdl">The object to check.</param>
-    /// <param name="names">The names of the properties to check.</param>
-    /// <returns><see langword="true"/> if all properties with the specified names of the specified object have values that are not equal to the default value; otherwise, <see langword="false"/>.</returns>
     public static bool AllPropertiesNotDefault<T>(this T mdl, IEnumerable<string> names) where T : class
     {
         if (mdl is null || names.IsNullOrWhiteSpace())
@@ -382,14 +255,6 @@ public static bool AllPropertiesNotDefault<T>(this T mdl, IEnumerable<string> na
         return true;
     }
 
-    /// <summary>
-    /// Checks whether all properties of the specified objects have non-default values, including all their nested properties and properties in lists, except for properties with the specified names.
-    /// If any of the objects is <see langword="null"/>, returns <see langword="false"/> for that object.
-    /// </summary>
-    /// <typeparam name="T">The type of the objects to check.</typeparam>
-    /// <param name="mdls">The objects to check.</param>
-    /// <param name="names">The names of properties to exclude from the check.</param>
-    /// <returns>An <see cref="IEnumerable{bool}"/> containing <see langword="true"/> or <see langword="false"/> for each object, indicating whether all properties, except for the specified names, have non-default values.</returns>
     public static IEnumerable<bool> AllPropertiesNotDefault<T>(this IEnumerable<T> mdls, IEnumerable<string> names) where T : class
     {
         if (mdls is null || !mdls.Any())
@@ -402,14 +267,6 @@ public static IEnumerable<bool> AllPropertiesNotDefault<T>(this IEnumerable<T> m
         }
     }
 
-    /// <summary>
-    /// Checks whether all properties with the specified names of the specified object have values that are equal to the default value, including all its nested properties and properties in lists.
-    /// If the object is <see langword="null"/>, returns <see langword="true"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the object to check.</typeparam>
-    /// <param name="mdl">The object to check.</param>
-    /// <param name="names">The names of the properties to check.</param>
-    /// <returns><see langword="true"/> if all properties with the specified names of the specified object have values that are equal to the default value; otherwise, <see langword="false"/>.</returns>
     public static bool AllPropertiesDefault<T>(this T mdl, IEnumerable<string> names) where T : class
     {
         if (mdl is null || names.IsNullOrWhiteSpace())
@@ -427,14 +284,6 @@ public static bool AllPropertiesDefault<T>(this T mdl, IEnumerable<string> names
         return true;
     }
 
-    /// <summary>
-    /// Checks whether all properties of the specified objects have default values, including all their nested properties and properties in lists, except for properties with the specified names.
-    /// If any of the objects is <see langword="null"/>, returns <see langword="false"/> for that object.
-    /// </summary>
-    /// <typeparam name="T">The type of the objects to check.</typeparam>
-    /// <param name="mdls">The objects to check.</param>
-    /// <param name="names">The names of properties to exclude from the check.</param>
-    /// <returns>An <see cref="IEnumerable{bool}"/> containing <see langword="true"/> or <see langword="false"/> for each object, indicating whether all properties, except for the specified names, have default values.</returns>
     public static IEnumerable<bool> AllPropertiesDefault<T>(this IEnumerable<T> mdls, IEnumerable<string> names) where T : class
     {
         if (mdls is null || !mdls.Any())
@@ -447,14 +296,6 @@ public static IEnumerable<bool> AllPropertiesDefault<T>(this IEnumerable<T> mdls
         }
     }
 
-    /// <summary>
-    /// Checks whether any properties with the specified names of the specified object have values that are not equal to the default value, including all its nested properties and properties in lists.
-    /// If the object is <see langword="null"/>, returns <see langword="false"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the object to check.</typeparam>
-    /// <param name="mdl">The object to check.</param>
-    /// <param name="names">The names of the properties to check.</param>
-    /// <returns><see langword="true"/> if any properties with the specified names of the specified object have values that are not equal to the default value; otherwise, <see langword="false"/>.</returns>
     public static bool AnyPropertiesNotDefault<T>(this T mdl, IEnumerable<string> names) where T : class
     {
         if (mdl is null || names.IsNullOrWhiteSpace())
@@ -472,14 +313,6 @@ public static bool AnyPropertiesNotDefault<T>(this T mdl, IEnumerable<string> na
         return false;
     }
 
-    /// <summary>
-    /// Checks whether any property of the specified objects has a non-default value, including all their nested properties and properties in lists, except for properties with the specified names.
-    /// If any of the objects is <see langword="null"/>, returns <see langword="false"/> for that object.
-    /// </summary>
-    /// <typeparam name="T">The type of the objects to check.</typeparam>
-    /// <param name="mdls">The objects to check.</param>
-    /// <param name="names">The names of properties to exclude from the check.</param>
-    /// <returns>An <see cref="IEnumerable{bool}"/> containing <see langword="true"/> or <see langword="false"/> for each object, indicating whether any property, except for the specified names, has a non-default value.</returns>
     public static IEnumerable<bool> AnyPropertiesNotDefault<T>(this IEnumerable<T> mdls, IEnumerable<string> names) where T : class
     {
         if (mdls is null || !mdls.Any())
@@ -492,14 +325,6 @@ public static IEnumerable<bool> AnyPropertiesNotDefault<T>(this IEnumerable<T> m
         }
     }
 
-    /// <summary>
-    /// Checks whether any properties with the specified names of the specified object have values that are equal to the default value, including all its nested properties and properties in lists.
-    /// If the object is <see langword="null"/>, returns <see langword="false"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the object to check.</typeparam>
-    /// <param name="mdl">The object to check.</param>
-    /// <param name="names">The names of the properties to check.</param>
-    /// <returns><see langword="true"/> if any properties with the specified names of the specified object have values that are equal to the default value; otherwise, <see langword="false"/>.</returns>
     public static bool AnyPropertiesDefault<T>(this T mdl, IEnumerable<string> names) where T : class
     {
         if (mdl is null || names.IsNullOrWhiteSpace())
@@ -517,14 +342,6 @@ public static bool AnyPropertiesDefault<T>(this T mdl, IEnumerable<string> names
         return false;
     }
 
-    /// <summary>
-    /// Checks whether any property of the specified objects has a default value, including all their nested properties and properties in lists, except for properties with the specified names.
-    /// If any of the objects is <see langword="null"/>, returns <see langword="false"/> for that object.
-    /// </summary>
-    /// <typeparam name="T">The type of the objects to check.</typeparam>
-    /// <param name="mdls">The objects to check.</param>
-    /// <param name="names">The names of properties to exclude from the check.</param>
-    /// <returns>An <see cref="IEnumerable{bool}"/> containing <see langword="true"/> or <see langword="false"/> for each object, indicating whether any property, except for the specified names, has a default value.</returns>
     public static IEnumerable<bool> AnyPropertiesDefault<T>(this IEnumerable<T> mdls, IEnumerable<string> names) where T : class
     {
         if (mdls is null || !mdls.Any())
diff --git a/lib/YANLib/YANModel.cs b/lib/YANLib/YANModel.cs
index 935e4f2c..9e2147c8 100644
--- a/lib/YANLib/YANModel.cs
+++ b/lib/YANLib/YANModel.cs
@@ -5,15 +5,7 @@ namespace YANLib;
 
 public static partial class YANModel
 {
-    /// <summary>
-    /// Changes the time zone of all properties of the specified object with nullable value, including all its nested properties and properties in lists.
-    /// If the object is <see langword="null"/>, returns <see langword="null"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the object to change the time zone.</typeparam>
-    /// <param name="mdl">The nullable object to change the time zone.</param>
-    /// <param name="tzSrc">The source time zone.</param>
-    /// <param name="tzDst">The destination time zone.</param>
-    /// <returns>The nullable object with all its properties having the specified time zone; or <see langword="null"/> if the object is <see langword="null"/>.</returns>
+    
     public static T? ChangeTimeZoneAllProperties<T, T1, T2>(this T? mdl, T1 tzSrc, T2 tzDst) where T : class where T1 : struct where T2 : struct
     {
         if (mdl is not null)
@@ -69,17 +61,6 @@ public static partial class YANModel
         return mdl;
     }
 
-    /// <summary>
-    /// Changes the time zone of all properties of the specified objects in the enumerable with nullable values, including all their nested properties and properties in lists.
-    /// If any of the objects is <see langword="null"/>, returns <see langword="null"/> for that object.
-    /// </summary>
-    /// <typeparam name="T">The type of the objects to change the time zone.</typeparam>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="mdls">The nullable objects to change the time zone.</param>
-    /// <param name="tzSrc">The source time zone.</param>
-    /// <param name="tzDst">The destination time zone.</param>
-    /// <returns>An <see cref="IEnumerable{T}"/> containing the nullable objects with all their properties having the specified time zone; or <see langword="null"/> for each object that is <see langword="null"/> in the enumerable.</returns>
     public static IEnumerable<T?> ChangeTimeZoneAllProperties<T, T1, T2>(this IEnumerable<T?> mdls, T1 tzSrc, T2 tzDst) where T : class where T1 : struct where T2 : struct
     {
         if (mdls is null || !mdls.Any())
@@ -92,15 +73,6 @@ public static partial class YANModel
         }
     }
 
-    /// <summary>
-    /// Changes the time zone of all properties of the specified object with nullable value, including all its nested properties and properties in lists.
-    /// If the object is <see langword="null"/>, returns <see langword="null"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the object to change the time zone.</typeparam>
-    /// <param name="mdl">The nullable object to change the time zone.</param>
-    /// <param name="tzSrc">The source time zone.</param>
-    /// <param name="tzDst">The destination time zone.</param>
-    /// <returns>The nullable object with all its properties having the specified time zone; or <see langword="null"/> if the object is <see langword="null"/>.</returns>
     public static T? ChangeTimeZoneAllProperties<T, T1, T2>(this T? mdl, T1? tzSrc, T2 tzDst) where T : class where T1 : struct where T2 : struct
     {
         if (mdl is not null)
@@ -156,17 +128,6 @@ public static partial class YANModel
         return mdl;
     }
 
-    /// <summary>
-    /// Changes the time zone of all properties of the specified objects in the enumerable with nullable values, including all their nested properties and properties in lists.
-    /// If any of the objects is <see langword="null"/>, returns <see langword="null"/> for that object.
-    /// </summary>
-    /// <typeparam name="T">The type of the objects to change the time zone.</typeparam>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="mdls">The nullable objects to change the time zone.</param>
-    /// <param name="tzSrc">The source time zone.</param>
-    /// <param name="tzDst">The destination time zone.</param>
-    /// <returns>An <see cref="IEnumerable{T}"/> containing the nullable objects with all their properties having the specified time zone; or <see langword="null"/> for each object that is <see langword="null"/> in the enumerable.</returns>
     public static IEnumerable<T?> ChangeTimeZoneAllProperties<T, T1, T2>(this IEnumerable<T?> mdls, T1? tzSrc, T2 tzDst) where T : class where T1 : struct where T2 : struct
     {
         if (mdls is null || !mdls.Any())
@@ -179,15 +140,6 @@ public static partial class YANModel
         }
     }
 
-    /// <summary>
-    /// Changes the time zone of all properties of the specified object with nullable value, including all its nested properties and properties in lists.
-    /// If the object is <see langword="null"/>, returns <see langword="null"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the object to change the time zone.</typeparam>
-    /// <param name="mdl">The nullable object to change the time zone.</param>
-    /// <param name="tzSrc">The source time zone.</param>
-    /// <param name="tzDst">The destination time zone.</param>
-    /// <returns>The nullable object with all its properties having the specified time zone; or <see langword="null"/> if the object is <see langword="null"/>.</returns>
     public static T? ChangeTimeZoneAllProperties<T, T1, T2>(this T? mdl, T1 tzSrc, T2? tzDst) where T : class where T1 : struct where T2 : struct
     {
         if (mdl is not null)
@@ -243,17 +195,6 @@ public static partial class YANModel
         return mdl;
     }
 
-    /// <summary>
-    /// Changes the time zone of all properties of the specified objects in the enumerable with nullable values, including all their nested properties and properties in lists.
-    /// If any of the objects is <see langword="null"/>, returns <see langword="null"/> for that object.
-    /// </summary>
-    /// <typeparam name="T">The type of the objects to change the time zone.</typeparam>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="mdls">The nullable objects to change the time zone.</param>
-    /// <param name="tzSrc">The source time zone.</param>
-    /// <param name="tzDst">The destination time zone.</param>
-    /// <returns>An <see cref="IEnumerable{T}"/> containing the nullable objects with all their properties having the specified time zone; or <see langword="null"/> for each object that is <see langword="null"/> in the enumerable.</returns>
     public static IEnumerable<T?> ChangeTimeZoneAllProperties<T, T1, T2>(this IEnumerable<T?> mdls, T1 tzSrc, T2? tzDst) where T : class where T1 : struct where T2 : struct
     {
         if (mdls is null || !mdls.Any())
@@ -266,15 +207,6 @@ public static partial class YANModel
         }
     }
 
-    /// <summary>
-    /// Changes the time zone of all properties of the specified object with nullable value, including all its nested properties and properties in lists.
-    /// If the object is <see langword="null"/>, returns <see langword="null"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the object to change the time zone.</typeparam>
-    /// <param name="mdl">The nullable object to change the time zone.</param>
-    /// <param name="tzSrc">The source time zone.</param>
-    /// <param name="tzDst">The destination time zone.</param>
-    /// <returns>The nullable object with all its properties having the specified time zone; or <see langword="null"/> if the object is <see langword="null"/>.</returns>
     public static T? ChangeTimeZoneAllProperties<T, T1, T2>(this T? mdl, T1? tzSrc, T2? tzDst) where T : class where T1 : struct where T2 : struct
     {
         if (mdl is not null)
@@ -330,17 +262,6 @@ public static partial class YANModel
         return mdl;
     }
 
-    /// <summary>
-    /// Changes the time zone of all properties of the specified objects in the enumerable with nullable values, including all their nested properties and properties in lists.
-    /// If any of the objects is <see langword="null"/>, returns <see langword="null"/> for that object.
-    /// </summary>
-    /// <typeparam name="T">The type of the objects to change the time zone.</typeparam>
-    /// <typeparam name="T1">The type of the source time zone.</typeparam>
-    /// <typeparam name="T2">The type of the destination time zone.</typeparam>
-    /// <param name="mdls">The nullable objects to change the time zone.</param>
-    /// <param name="tzSrc">The source time zone.</param>
-    /// <param name="tzDst">The destination time zone.</param>
-    /// <returns>An <see cref="IEnumerable{T}"/> containing the nullable objects with all their properties having the specified time zone; or <see langword="null"/> for each object that is <see langword="null"/> in the enumerable.</returns>
     public static IEnumerable<T?> ChangeTimeZoneAllProperties<T, T1, T2>(this IEnumerable<T?> mdls, T1? tzSrc, T2? tzDst) where T : class where T1 : struct where T2 : struct
     {
         if (mdls is null || !mdls.Any())
diff --git a/lib/YANLib/YANNum.Byte.Nullable.cs b/lib/YANLib/YANNum.Byte.Nullable.cs
index 984547d6..8de94b1b 100644
--- a/lib/YANLib/YANNum.Byte.Nullable.cs
+++ b/lib/YANLib/YANNum.Byte.Nullable.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a byte.
-    /// Returns the converted <see cref="byte"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="byte"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static byte ToByte<T>(this T? num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static byte ToByte<T>(this T? num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{byte}"/> containing the byte representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the byte representations of the objects.</returns>
     public static IEnumerable<byte> ToByte<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,27 +27,8 @@ public static IEnumerable<byte> ToByte<T>(this IEnumerable<T?> nums) where T : s
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a byte using the default format.
-    /// Returns the parsed <see cref="byte"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="byte"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static byte ToByte<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToByte(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of string objects to an <see cref="IEnumerable{byte}"/> containing the byte representations of the strings, using a default value for invalid conversions.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for invalid conversions.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of string objects to be converted.</param>
-    /// <param name="dfltVal">The default value to be used for invalid conversions.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the byte representations of the strings.</returns>
     public static IEnumerable<byte> ToByte<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -76,28 +41,8 @@ public static IEnumerable<byte> ToByte<T>(this IEnumerable<string> strs, T? dflt
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="byte"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="byte"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static byte GenerateRandomByte<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomByte(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates a sequence of random <see cref="byte"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of the generated sequence, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the generated sequence.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the random byte values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<byte> GenerateRandomBytes<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -106,17 +51,6 @@ public static IEnumerable<byte> GenerateRandomBytes<T1, T2, T>(T1? min, T2 max,
         }
     }
 
-    /// <summary>
-    /// Generates a sequence of random <see cref="byte"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of the generated sequence, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the generated sequence.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the random byte values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<byte> GenerateRandomBytes<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -125,28 +59,8 @@ public static IEnumerable<byte> GenerateRandomBytes<T1, T2, T>(T1? min, T2 max,
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="byte"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="byte"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static byte GenerateRandomByte<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomByte(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates a sequence of random <see cref="byte"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of the generated sequence, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the generated sequence.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the random byte values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<byte> GenerateRandomBytes<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -155,17 +69,6 @@ public static IEnumerable<byte> GenerateRandomBytes<T1, T2, T>(T1 min, T2? max,
         }
     }
 
-    /// <summary>
-    /// Generates a sequence of random <see cref="byte"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of the generated sequence, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the generated sequence.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the random byte values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<byte> GenerateRandomBytes<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -174,28 +77,8 @@ public static IEnumerable<byte> GenerateRandomBytes<T1, T2, T>(T1 min, T2? max,
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="byte"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="byte"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static byte GenerateRandomByte<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomByte(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates a sequence of random <see cref="byte"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of the generated sequence, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the generated sequence.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the random byte values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<byte> GenerateRandomBytes<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -204,17 +87,6 @@ public static IEnumerable<byte> GenerateRandomBytes<T1, T2, T>(T1? min, T2? max,
         }
     }
 
-    /// <summary>
-    /// Generates a sequence of random <see cref="byte"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of the generated sequence, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the generated sequence.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the random byte values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<byte> GenerateRandomBytes<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -223,11 +95,5 @@ public static IEnumerable<byte> GenerateRandomBytes<T1, T2, T>(T1? min, T2? max,
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="byte"/> value between <see cref="byte.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="byte"/> value between <see cref="byte.MinValue"/> and <paramref name="max"/>.</returns>
     public static byte GenerateRandomByte<T>(T? max) where T : struct => max.HasValue ? GenerateRandomByte(byte.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/YANNum.Byte.cs b/lib/YANLib/YANNum.Byte.cs
index 0f7f550e..6e5566bb 100644
--- a/lib/YANLib/YANNum.Byte.cs
+++ b/lib/YANLib/YANNum.Byte.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a byte.
-    /// Returns the converted <see cref="byte"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="byte"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static byte ToByte<T>(this T num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static byte ToByte<T>(this T num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{byte}"/> containing the byte representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the byte representations of the objects.</returns>
     public static IEnumerable<byte> ToByte<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,20 +27,8 @@ public static IEnumerable<byte> ToByte<T>(this IEnumerable<T> nums) where T : st
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a byte using the default format.
-    /// Returns the parsed <see cref="byte"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="byte"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static byte ToByte(this string str) => byte.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of string objects to an <see cref="IEnumerable{byte}"/> containing the byte representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <param name="strs">The enumerable of string objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the byte representations of the strings.</returns>
     public static IEnumerable<byte> ToByte(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -69,27 +41,8 @@ public static IEnumerable<byte> ToByte(this IEnumerable<string> strs)
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a byte using the default format.
-    /// Returns the parsed <see cref="byte"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="byte"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static byte ToByte<T>(this string str, T dfltVal) where T : struct => byte.TryParse(str, out var num) ? num : dfltVal.ToByte();
 
-    /// <summary>
-    /// Converts an enumerable of string objects to an <see cref="IEnumerable{byte}"/> containing the byte representations of the strings, using a default value for invalid conversions.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for invalid conversions.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of string objects to be converted.</param>
-    /// <param name="dfltVal">The default value to be used for invalid conversions.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the byte representations of the strings.</returns>
     public static IEnumerable<byte> ToByte<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -102,15 +55,6 @@ public static IEnumerable<byte> ToByte<T>(this IEnumerable<string> strs, T dfltV
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="byte"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="byte"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static byte GenerateRandomByte<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToByte();
@@ -118,17 +62,6 @@ public static byte GenerateRandomByte<T1, T2>(T1 min, T2 max) where T1 : struct
         return minValue > maxValue ? default : new Random().Next(minValue, maxValue).ToByte();
     }
 
-    /// <summary>
-    /// Generates a sequence of random <see cref="byte"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of the generated sequence, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the generated sequence.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the random byte values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<byte> GenerateRandomBytes<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -137,17 +70,7 @@ public static IEnumerable<byte> GenerateRandomBytes<T1, T2, T>(T1 min, T2 max, T
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="byte"/> value between <see cref="byte.MinValue"/> and <see cref="byte.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="byte"/> value between <see cref="byte.MinValue"/> and <see cref="byte.MaxValue"/>.</returns>
     public static byte GenerateRandomByte() => GenerateRandomByte(byte.MinValue, byte.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="byte"/> value between <see cref="byte.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="byte"/> value between <see cref="byte.MinValue"/> and <paramref name="max"/>.</returns>
     public static byte GenerateRandomByte<T>(T max) where T : struct => GenerateRandomByte(byte.MinValue, max);
 }
diff --git a/lib/YANLib/YANNum.Decimal.Nullable.cs b/lib/YANLib/YANNum.Decimal.Nullable.cs
index b382267e..2b6c67ec 100644
--- a/lib/YANLib/YANNum.Decimal.Nullable.cs
+++ b/lib/YANLib/YANNum.Decimal.Nullable.cs
@@ -2,13 +2,7 @@
 
 public partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a decimal.
-    /// Returns the converted <see cref="decimal"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="decimal"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static decimal ToDecimal<T>(this T? num) where T : struct
     {
         try
@@ -21,15 +15,6 @@ public static decimal ToDecimal<T>(this T? num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of values of a generic value type to an <see cref="IEnumerable{decimal}"/> containing the decimal representations of the values.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/> or empty.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the values to be converted, which must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of values to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{decimal}"/> containing the decimal representations of the values.</returns>
     public static IEnumerable<decimal> ToDecimal<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -42,27 +27,8 @@ public static IEnumerable<decimal> ToDecimal<T>(this IEnumerable<T?> nums) where
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a decimal using the default format.
-    /// Returns the parsed <see cref="decimal"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="decimal"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static decimal ToDecimal<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToDecimal(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of string objects to an <see cref="IEnumerable{decimal}"/> containing the decimal representations of the strings, using a default value for invalid conversions.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/> or empty.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for invalid conversions.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of string objects to be converted.</param>
-    /// <param name="dfltVal">The default value to be used for invalid conversions.</param>
-    /// <returns>An <see cref="IEnumerable{decimal}"/> containing the decimal representations of the strings.</returns>
     public static IEnumerable<decimal> ToDecimal<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -75,27 +41,8 @@ public static IEnumerable<decimal> ToDecimal<T>(this IEnumerable<string> strs, T
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="decimal"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="decimal"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static decimal GenerateRandomDecimal<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomDecimal(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{decimal}"/> sequence of random decimal values between <paramref name="min"/> and <paramref name="max"/>, with the number of values specified by <paramref name="size"/>, using a default value for invalid conversions.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random decimal values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{decimal}"/> containing the randomly generated decimal values.</returns>
     public static IEnumerable<decimal> GenerateRandomDecimals<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -104,16 +51,6 @@ public static IEnumerable<decimal> GenerateRandomDecimals<T1, T2, T>(T1? min, T2
         }
     }
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{decimal}"/> sequence of random decimal values between <paramref name="min"/> and <paramref name="max"/>, with the number of values specified by <paramref name="size"/>, using a default value for invalid conversions.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random decimal values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{decimal}"/> containing the randomly generated decimal values.</returns>
     public static IEnumerable<decimal> GenerateRandomDecimals<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -122,27 +59,8 @@ public static IEnumerable<decimal> GenerateRandomDecimals<T1, T2, T>(T1? min, T2
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="decimal"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="decimal"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static decimal GenerateRandomDecimal<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomDecimal(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{decimal}"/> sequence of random decimal values between <paramref name="min"/> and <paramref name="max"/>, with the number of values specified by <paramref name="size"/>, using a default value for invalid conversions.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random decimal values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{decimal}"/> containing the randomly generated decimal values.</returns>
     public static IEnumerable<decimal> GenerateRandomDecimals<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -151,16 +69,6 @@ public static IEnumerable<decimal> GenerateRandomDecimals<T1, T2, T>(T1 min, T2?
         }
     }
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{decimal}"/> sequence of random decimal values between <paramref name="min"/> and <paramref name="max"/>, with the number of values specified by <paramref name="size"/>, using a default value for invalid conversions.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random decimal values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{decimal}"/> containing the randomly generated decimal values.</returns>
     public static IEnumerable<decimal> GenerateRandomDecimals<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -169,27 +77,8 @@ public static IEnumerable<decimal> GenerateRandomDecimals<T1, T2, T>(T1 min, T2?
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="decimal"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="decimal"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static decimal GenerateRandomDecimal<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomDecimal(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{decimal}"/> sequence of random decimal values between <paramref name="min"/> and <paramref name="max"/>, with the number of values specified by <paramref name="size"/>, using a default value for invalid conversions.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random decimal values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{decimal}"/> containing the randomly generated decimal values.</returns>
     public static IEnumerable<decimal> GenerateRandomDecimals<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -198,16 +87,6 @@ public static IEnumerable<decimal> GenerateRandomDecimals<T1, T2, T>(T1? min, T2
         }
     }
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{decimal}"/> sequence of random decimal values between <paramref name="min"/> and <paramref name="max"/>, with the number of values specified by <paramref name="size"/>, using a default value for invalid conversions.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random decimal values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{decimal}"/> containing the randomly generated decimal values.</returns>
     public static IEnumerable<decimal> GenerateRandomDecimals<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -216,11 +95,5 @@ public static IEnumerable<decimal> GenerateRandomDecimals<T1, T2, T>(T1? min, T2
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="decimal"/> value between <see cref="decimal.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="decimal"/> value between <see cref="decimal.MinValue"/> and <paramref name="max"/>.</returns>
     public static decimal GenerateRandomDecimal<T>(T? max) where T : struct => max.HasValue ? GenerateRandomDecimal(decimal.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/YANNum.Decimal.cs b/lib/YANLib/YANNum.Decimal.cs
index fd65a2cb..1caa1540 100644
--- a/lib/YANLib/YANNum.Decimal.cs
+++ b/lib/YANLib/YANNum.Decimal.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a decimal.
-    /// Returns the converted <see cref="decimal"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="decimal"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static decimal ToDecimal<T>(this T num) where T : struct
     {
         try
@@ -21,15 +15,6 @@ public static decimal ToDecimal<T>(this T num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of values of a generic value type to an <see cref="IEnumerable{decimal}"/> containing the decimal representations of the values.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/> or empty.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the values to be converted, which must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of values to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{decimal}"/> containing the decimal representations of the values.</returns>
     public static IEnumerable<decimal> ToDecimal<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -42,20 +27,8 @@ public static IEnumerable<decimal> ToDecimal<T>(this IEnumerable<T> nums) where
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a decimal using the default format.
-    /// Returns the parsed <see cref="decimal"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="decimal"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static decimal ToDecimal(this string str) => decimal.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of string objects to an <see cref="IEnumerable{decimal}"/> containing the decimal representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/> or empty.
-    /// </summary>
-    /// <param name="strs">The enumerable of string objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{decimal}"/> containing the decimal representations of the strings.</returns>
     public static IEnumerable<decimal> ToDecimal(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -68,27 +41,8 @@ public static IEnumerable<decimal> ToDecimal(this IEnumerable<string> strs)
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a decimal using the default format.
-    /// Returns the parsed <see cref="decimal"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="decimal"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static decimal ToDecimal<T>(this string str, T dfltVal) where T : struct => decimal.TryParse(str, out var num) ? num : dfltVal.ToDecimal();
 
-    /// <summary>
-    /// Converts an enumerable of string objects to an <see cref="IEnumerable{decimal}"/> containing the decimal representations of the strings, using a default value for invalid conversions.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/> or empty.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for invalid conversions.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of string objects to be converted.</param>
-    /// <param name="dfltVal">The default value to be used for invalid conversions.</param>
-    /// <returns>An <see cref="IEnumerable{decimal}"/> containing the decimal representations of the strings.</returns>
     public static IEnumerable<decimal> ToDecimal<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -101,15 +55,6 @@ public static IEnumerable<decimal> ToDecimal<T>(this IEnumerable<string> strs, T
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="decimal"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="decimal"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static decimal GenerateRandomDecimal<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToDecimal();
@@ -117,16 +62,6 @@ public static decimal GenerateRandomDecimal<T1, T2>(T1 min, T2 max) where T1 : s
         return minValue > maxValue ? default : new Random().NextDecimal(minValue, maxValue);
     }
 
-    /// <summary>
-    /// Generates an <see cref="IEnumerable{decimal}"/> sequence of random decimal values between <paramref name="min"/> and <paramref name="max"/>, with the number of values specified by <paramref name="size"/>, using a default value for invalid conversions.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random decimal values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{decimal}"/> containing the randomly generated decimal values.</returns>
     public static IEnumerable<decimal> GenerateRandomDecimals<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -135,17 +70,7 @@ public static IEnumerable<decimal> GenerateRandomDecimals<T1, T2, T>(T1 min, T2
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="decimal"/> value between <see cref="decimal.MinValue"/> and <see cref="decimal.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="decimal"/> value between <see cref="decimal.MinValue"/> and <see cref="decimal.MaxValue"/>.</returns>
     public static decimal GenerateRandomDecimal() => GenerateRandomDecimal(decimal.MinValue, decimal.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="decimal"/> value between <see cref="decimal.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="decimal"/> value between <see cref="decimal.MinValue"/> and <paramref name="max"/>.</returns>
     public static decimal GenerateRandomDecimal<T>(T max) where T : struct => GenerateRandomDecimal(decimal.MinValue, max);
 }
diff --git a/lib/YANLib/YANNum.Double.Nullable.cs b/lib/YANLib/YANNum.Double.Nullable.cs
index db6d3093..a3f43972 100644
--- a/lib/YANLib/YANNum.Double.Nullable.cs
+++ b/lib/YANLib/YANNum.Double.Nullable.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a double.
-    /// Returns the converted <see cref="double"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="double"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static double ToDouble<T>(this T? num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static double ToDouble<T>(this T? num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{double}"/> containing the double representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{double}"/> containing the double representations of the objects.</returns>
     public static IEnumerable<double> ToDouble<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,27 +27,8 @@ public static IEnumerable<double> ToDouble<T>(this IEnumerable<T?> nums) where T
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a double using the default format.
-    /// Returns the parsed <see cref="double"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="double"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static double ToDouble<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToDouble(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{double}"/> containing the double representations of the strings, using a default value for conversion failures.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value for conversion failures.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <param name="dfltVal">The default value to use for conversion failures.</param>
-    /// <returns>An <see cref="IEnumerable{double}"/> containing the double representations of the strings.</returns>
     public static IEnumerable<double> ToDouble<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -76,28 +41,8 @@ public static IEnumerable<double> ToDouble<T>(this IEnumerable<string> strs, T?
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="double"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="double"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static double GenerateRandomDouble<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomDouble(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="double"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{double}"/> containing the random double values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<double> GenerateRandomDoubles<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -106,17 +51,6 @@ public static IEnumerable<double> GenerateRandomDoubles<T1, T2, T>(T1? min, T2 m
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="double"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{double}"/> containing the random double values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<double> GenerateRandomDoubles<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -125,28 +59,8 @@ public static IEnumerable<double> GenerateRandomDoubles<T1, T2, T>(T1? min, T2 m
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="double"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="double"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static double GenerateRandomDouble<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomDouble(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="double"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{double}"/> containing the random double values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<double> GenerateRandomDoubles<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -155,17 +69,6 @@ public static IEnumerable<double> GenerateRandomDoubles<T1, T2, T>(T1 min, T2? m
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="double"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{double}"/> containing the random double values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<double> GenerateRandomDoubles<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -174,28 +77,8 @@ public static IEnumerable<double> GenerateRandomDoubles<T1, T2, T>(T1 min, T2? m
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="double"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="double"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static double GenerateRandomDouble<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomDouble(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="double"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{double}"/> containing the random double values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<double> GenerateRandomDoubles<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -204,17 +87,6 @@ public static IEnumerable<double> GenerateRandomDoubles<T1, T2, T>(T1? min, T2?
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="double"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{double}"/> containing the random double values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<double> GenerateRandomDoubles<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -223,11 +95,5 @@ public static IEnumerable<double> GenerateRandomDoubles<T1, T2, T>(T1? min, T2?
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="double"/> value between <see cref="double.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="double"/> value between <see cref="double.MinValue"/> and <paramref name="max"/>.</returns>
     public static double GenerateRandomDouble<T>(T? max) where T : struct => max.HasValue ? GenerateRandomDouble(double.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/YANNum.Double.cs b/lib/YANLib/YANNum.Double.cs
index 62628d3d..c7a1fddd 100644
--- a/lib/YANLib/YANNum.Double.cs
+++ b/lib/YANLib/YANNum.Double.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a double.
-    /// Returns the converted <see cref="double"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="double"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static double ToDouble<T>(this T num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static double ToDouble<T>(this T num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{double}"/> containing the double representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{double}"/> containing the double representations of the objects.</returns>
     public static IEnumerable<double> ToDouble<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,20 +27,8 @@ public static IEnumerable<double> ToDouble<T>(this IEnumerable<T> nums) where T
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a double using the default format.
-    /// Returns the parsed <see cref="double"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="double"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static double ToDouble(this string str) => double.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{double}"/> containing the double representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{double}"/> containing the double representations of the strings.</returns>
     public static IEnumerable<double> ToDouble(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -69,27 +41,8 @@ public static IEnumerable<double> ToDouble(this IEnumerable<string> strs)
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a double using the default format.
-    /// Returns the parsed <see cref="double"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="double"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static double ToDouble<T>(this string str, T dfltVal) where T : struct => double.TryParse(str, out var num) ? num : dfltVal.ToDouble();
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{double}"/> containing the double representations of the strings, using a default value for conversion failures.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value for conversion failures.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <param name="dfltVal">The default value to use for conversion failures.</param>
-    /// <returns>An <see cref="IEnumerable{double}"/> containing the double representations of the strings.</returns>
     public static IEnumerable<double> ToDouble<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -102,15 +55,6 @@ public static IEnumerable<double> ToDouble<T>(this IEnumerable<string> strs, T d
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="double"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="double"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static double GenerateRandomDouble<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToDouble();
@@ -118,17 +62,6 @@ public static double GenerateRandomDouble<T1, T2>(T1 min, T2 max) where T1 : str
         return minValue > maxValue ? default : new Random().NextDouble(minValue, maxValue);
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="double"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{double}"/> containing the random double values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<double> GenerateRandomDoubles<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -137,17 +70,7 @@ public static IEnumerable<double> GenerateRandomDoubles<T1, T2, T>(T1 min, T2 ma
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="double"/> value between <see cref="double.MinValue"/> and <see cref="double.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="double"/> value between <see cref="double.MinValue"/> and <see cref="double.MaxValue"/>.</returns>
     public static double GenerateRandomDouble() => GenerateRandomDouble(double.MinValue, double.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="double"/> value between <see cref="double.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="double"/> value between <see cref="double.MinValue"/> and <paramref name="max"/>.</returns>
     public static double GenerateRandomDouble<T>(T max) where T : struct => GenerateRandomDouble(double.MinValue, max);
 }
diff --git a/lib/YANLib/YANNum.Float.Nullable.cs b/lib/YANLib/YANNum.Float.Nullable.cs
index 874923a9..6cc44980 100644
--- a/lib/YANLib/YANNum.Float.Nullable.cs
+++ b/lib/YANLib/YANNum.Float.Nullable.cs
@@ -2,13 +2,7 @@
 
 public partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a single-precision floating-point number.
-    /// Returns the converted <see cref="float"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="float"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static float ToFloat<T>(this T? num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static float ToFloat<T>(this T? num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{float}"/> containing the float representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{float}"/> containing the float representations of the objects.</returns>
     public static IEnumerable<float> ToFloat<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,27 +27,8 @@ public static IEnumerable<float> ToFloat<T>(this IEnumerable<T?> nums) where T :
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a float using the default format.
-    /// Returns the parsed <see cref="float"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="float"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static float ToFloat<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToFloat(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings <paramref name="strs"/> to an <see cref="IEnumerable{float}"/> containing the float representations of the strings, using a default value <paramref name="dfltVal"/> for parsing invalid or null strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value for parsing invalid or null strings.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of strings to be converted to float.</param>
-    /// <param name="dfltVal">The default value to be used for parsing invalid or null strings.</param>
-    /// <returns>An <see cref="IEnumerable{float}"/> containing the float representations of the strings.</returns>
     public static IEnumerable<float> ToFloat<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -76,28 +41,8 @@ public static IEnumerable<float> ToFloat<T>(this IEnumerable<string> strs, T? df
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="float"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="float"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static float GenerateRandomFloat<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomFloat(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="float"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified <paramref name="size"/> of elements.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of elements, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of elements to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{float}"/> containing random float values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<float> GenerateRandomFloats<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -106,17 +51,6 @@ public static IEnumerable<float> GenerateRandomFloats<T1, T2, T>(T1? min, T2 max
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="float"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified <paramref name="size"/> of elements.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of elements, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of elements to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{float}"/> containing random float values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<float> GenerateRandomFloats<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -125,28 +59,8 @@ public static IEnumerable<float> GenerateRandomFloats<T1, T2, T>(T1? min, T2 max
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="float"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="float"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static float GenerateRandomFloat<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomFloat(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="float"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified <paramref name="size"/> of elements.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of elements, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of elements to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{float}"/> containing random float values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<float> GenerateRandomFloats<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -155,17 +69,6 @@ public static IEnumerable<float> GenerateRandomFloats<T1, T2, T>(T1 min, T2? max
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="float"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified <paramref name="size"/> of elements.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of elements, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of elements to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{float}"/> containing random float values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<float> GenerateRandomFloats<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -174,28 +77,8 @@ public static IEnumerable<float> GenerateRandomFloats<T1, T2, T>(T1 min, T2? max
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="float"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="float"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static float GenerateRandomFloat<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomFloat(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="float"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified <paramref name="size"/> of elements.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of elements, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of elements to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{float}"/> containing random float values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<float> GenerateRandomFloats<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -204,17 +87,6 @@ public static IEnumerable<float> GenerateRandomFloats<T1, T2, T>(T1? min, T2? ma
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="float"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified <paramref name="size"/> of elements.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of elements, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of elements to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{float}"/> containing random float values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<float> GenerateRandomFloats<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -223,11 +95,5 @@ public static IEnumerable<float> GenerateRandomFloats<T1, T2, T>(T1? min, T2? ma
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="float"/> value between <see cref="float.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="float"/> value between <see cref="float.MinValue"/> and <paramref name="max"/>.</returns>
     public static float GenerateRandomFloat<T>(T? max) where T : struct => max.HasValue ? GenerateRandomFloat(float.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/YANNum.Float.cs b/lib/YANLib/YANNum.Float.cs
index 86ee43ae..a57f3290 100644
--- a/lib/YANLib/YANNum.Float.cs
+++ b/lib/YANLib/YANNum.Float.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a single-precision floating-point number.
-    /// Returns the converted <see cref="float"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="float"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static float ToFloat<T>(this T num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static float ToFloat<T>(this T num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{float}"/> containing the float representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{float}"/> containing the float representations of the objects.</returns>
     public static IEnumerable<float> ToFloat<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,20 +27,8 @@ public static IEnumerable<float> ToFloat<T>(this IEnumerable<T> nums) where T :
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a <see cref="float"/> using the default format.
-    /// Returns the parsed <see cref="float"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="float"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static float ToFloat(this string str) => float.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings <paramref name="strs"/> to an <see cref="IEnumerable{float}"/> containing the float representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to be converted to float.</param>
-    /// <returns>An <see cref="IEnumerable{float}"/> containing the float representations of the strings.</returns>
     public static IEnumerable<float> ToFloat(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -69,27 +41,8 @@ public static IEnumerable<float> ToFloat(this IEnumerable<string> strs)
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a float using the default format.
-    /// Returns the parsed <see cref="float"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="float"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static float ToFloat<T>(this string str, T dfltVal) where T : struct => float.TryParse(str, out var num) ? num : dfltVal.ToFloat();
 
-    /// <summary>
-    /// Converts an enumerable of strings <paramref name="strs"/> to an <see cref="IEnumerable{float}"/> containing the float representations of the strings, using a default value <paramref name="dfltVal"/> for parsing invalid or null strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value for parsing invalid or null strings.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of strings to be converted to float.</param>
-    /// <param name="dfltVal">The default value to be used for parsing invalid or null strings.</param>
-    /// <returns>An <see cref="IEnumerable{float}"/> containing the float representations of the strings.</returns>
     public static IEnumerable<float> ToFloat<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -102,15 +55,6 @@ public static IEnumerable<float> ToFloat<T>(this IEnumerable<string> strs, T dfl
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="float"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="float"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static float GenerateRandomFloat<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToFloat();
@@ -118,17 +62,6 @@ public static float GenerateRandomFloat<T1, T2>(T1 min, T2 max) where T1 : struc
         return minValue > maxValue ? default : new Random().NextSingle(minValue, maxValue);
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="float"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified <paramref name="size"/> of elements.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size of elements, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of elements to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{float}"/> containing random float values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<float> GenerateRandomFloats<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -137,17 +70,7 @@ public static IEnumerable<float> GenerateRandomFloats<T1, T2, T>(T1 min, T2 max,
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="float"/> value between <see cref="float.MinValue"/> and <see cref="float.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="float"/> value between <see cref="float.MinValue"/> and <see cref="float.MaxValue"/>.</returns>
     public static float GenerateRandomFloat() => GenerateRandomFloat(float.MinValue, float.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="float"/> value between <see cref="float.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="float"/> value between <see cref="float.MinValue"/> and <paramref name="max"/>.</returns>
     public static float GenerateRandomFloat<T>(T max) where T : struct => GenerateRandomFloat(float.MinValue, max);
 }
diff --git a/lib/YANLib/YANNum.Int.Nullable.cs b/lib/YANLib/YANNum.Int.Nullable.cs
index 9fa7f4e6..9b860938 100644
--- a/lib/YANLib/YANNum.Int.Nullable.cs
+++ b/lib/YANLib/YANNum.Int.Nullable.cs
@@ -2,13 +2,7 @@
 
 public partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to an integer.
-    /// Returns the converted <see cref="int"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="int"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static int ToInt<T>(this T? num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static int ToInt<T>(this T? num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{int}"/> containing the integer representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{int}"/> containing the integer representations of the objects.</returns>
     public static IEnumerable<int> ToInt<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,27 +27,8 @@ public static IEnumerable<int> ToInt<T>(this IEnumerable<T?> nums) where T : str
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of an integer using the default format.
-    /// Returns the parsed <see cref="int"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="int"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static int ToInt<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToInt(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings <paramref name="strs"/> to an <see cref="IEnumerable{int}"/> containing the integer representations of the strings, using the specified default value <paramref name="dfltVal"/> for parsing strings that cannot be converted to integers.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for parsing strings that cannot be converted to integers.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <param name="dfltVal">The default value to be used for parsing strings that cannot be converted to integers.</param>
-    /// <returns>An <see cref="IEnumerable{int}"/> containing the integer representations of the strings.</returns>
     public static IEnumerable<int> ToInt<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -76,28 +41,8 @@ public static IEnumerable<int> ToInt<T>(this IEnumerable<string> strs, T? dfltVa
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="int"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="int"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static int GenerateRandomInt<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomInt(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="int"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{int}"/> containing the random integer values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<int> GenerateRandomInts<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -106,17 +51,6 @@ public static IEnumerable<int> GenerateRandomInts<T1, T2, T>(T1? min, T2 max, T
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="int"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{int}"/> containing the random integer values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<int> GenerateRandomInts<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -125,28 +59,8 @@ public static IEnumerable<int> GenerateRandomInts<T1, T2, T>(T1? min, T2 max, T?
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="int"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="int"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static int GenerateRandomInt<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomInt(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="int"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{int}"/> containing the random integer values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<int> GenerateRandomInts<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -155,17 +69,6 @@ public static IEnumerable<int> GenerateRandomInts<T1, T2, T>(T1 min, T2? max, T
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="int"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{int}"/> containing the random integer values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<int> GenerateRandomInts<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -174,28 +77,8 @@ public static IEnumerable<int> GenerateRandomInts<T1, T2, T>(T1 min, T2? max, T?
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="int"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="int"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static int GenerateRandomInt<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomInt(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="int"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{int}"/> containing the random integer values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<int> GenerateRandomInts<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -204,17 +87,6 @@ public static IEnumerable<int> GenerateRandomInts<T1, T2, T>(T1? min, T2? max, T
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="int"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{int}"/> containing the random integer values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<int> GenerateRandomInts<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -223,11 +95,5 @@ public static IEnumerable<int> GenerateRandomInts<T1, T2, T>(T1? min, T2? max, T
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="int"/> value between <see cref="int.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="int"/> value between <see cref="int.MinValue"/> and <paramref name="max"/>.</returns>
     public static int GenerateRandomInt<T>(T? max) where T : struct => max.HasValue ? GenerateRandomInt(int.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/YANNum.Int.cs b/lib/YANLib/YANNum.Int.cs
index 99cdc108..337955c1 100644
--- a/lib/YANLib/YANNum.Int.cs
+++ b/lib/YANLib/YANNum.Int.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to an integer.
-    /// Returns the converted <see cref="int"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="int"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static int ToInt<T>(this T num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static int ToInt<T>(this T num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{int}"/> containing the integer representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{int}"/> containing the integer representations of the objects.</returns>
     public static IEnumerable<int> ToInt<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,20 +27,8 @@ public static IEnumerable<int> ToInt<T>(this IEnumerable<T> nums) where T : stru
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of an integer using the default format.
-    /// Returns the parsed <see cref="int"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="int"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static int ToInt(this string str) => int.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings <paramref name="strs"/> to an <see cref="IEnumerable{int}"/> containing the integer representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{int}"/> containing the integer representations of the strings.</returns>
     public static IEnumerable<int> ToInt(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -69,27 +41,8 @@ public static IEnumerable<int> ToInt(this IEnumerable<string> strs)
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of an integer using the default format.
-    /// Returns the parsed <see cref="int"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="int"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static int ToInt<T>(this string str, T dfltVal) where T : struct => int.TryParse(str, out var num) ? num : dfltVal.ToInt();
 
-    /// <summary>
-    /// Converts an enumerable of strings <paramref name="strs"/> to an <see cref="IEnumerable{int}"/> containing the integer representations of the strings, using the specified default value <paramref name="dfltVal"/> for parsing strings that cannot be converted to integers.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for parsing strings that cannot be converted to integers.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <param name="dfltVal">The default value to be used for parsing strings that cannot be converted to integers.</param>
-    /// <returns>An <see cref="IEnumerable{int}"/> containing the integer representations of the strings.</returns>
     public static IEnumerable<int> ToInt<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -102,15 +55,6 @@ public static IEnumerable<int> ToInt<T>(this IEnumerable<string> strs, T dfltVal
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="int"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="int"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static int GenerateRandomInt<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToInt();
@@ -118,17 +62,6 @@ public static int GenerateRandomInt<T1, T2>(T1 min, T2 max) where T1 : struct wh
         return minValue > maxValue ? default : new Random().Next(minValue, maxValue);
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="int"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An <see cref="IEnumerable{int}"/> containing the random integer values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<int> GenerateRandomInts<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -137,17 +70,7 @@ public static IEnumerable<int> GenerateRandomInts<T1, T2, T>(T1 min, T2 max, T s
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="int"/> value between <see cref="int.MinValue"/> and <see cref="int.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="int"/> value between <see cref="int.MinValue"/> and <see cref="int.MaxValue"/>.</returns>
     public static int GenerateRandomInt() => GenerateRandomInt(int.MinValue, int.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="int"/> value between <see cref="int.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="int"/> value between <see cref="int.MinValue"/> and <paramref name="max"/>.</returns>
     public static int GenerateRandomInt<T>(T max) where T : struct => GenerateRandomInt(int.MinValue, max);
 }
diff --git a/lib/YANLib/YANNum.Long.Nullable.cs b/lib/YANLib/YANNum.Long.Nullable.cs
index 647f3261..84ecdc92 100644
--- a/lib/YANLib/YANNum.Long.Nullable.cs
+++ b/lib/YANLib/YANNum.Long.Nullable.cs
@@ -2,13 +2,7 @@
 
 public partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a long integer.
-    /// Returns the converted <see cref="long"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="long"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static long ToLong<T>(this T? num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static long ToLong<T>(this T? num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{long}"/> containing the long integer representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{long}"/> containing the long integer representations of the objects.</returns>
     public static IEnumerable<long> ToLong<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,27 +27,8 @@ public static IEnumerable<long> ToLong<T>(this IEnumerable<T?> nums) where T : s
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a long using the default format.
-    /// Returns the parsed <see cref="long"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="long"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static long ToLong<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToLong(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{long}"/> containing the long integer representations of the strings, using a default value for invalid or null strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for invalid or null strings.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <param name="dfltVal">The default value to be used for invalid or null strings.</param>
-    /// <returns>An <see cref="IEnumerable{long}"/> containing the long integer representations of the strings.</returns>
     public static IEnumerable<long> ToLong<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -76,28 +41,8 @@ public static IEnumerable<long> ToLong<T>(this IEnumerable<string> strs, T? dflt
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="long"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="long"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static long GenerateRandomLong<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomLong(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="long"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{long}"/> containing random long values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<long> GenerateRandomLongs<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -106,17 +51,6 @@ public static IEnumerable<long> GenerateRandomLongs<T1, T2, T>(T1? min, T2 max,
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="long"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{long}"/> containing random long values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<long> GenerateRandomLongs<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -125,28 +59,8 @@ public static IEnumerable<long> GenerateRandomLongs<T1, T2, T>(T1? min, T2 max,
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="long"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="long"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static long GenerateRandomLong<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomLong(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="long"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{long}"/> containing random long values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<long> GenerateRandomLongs<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -155,17 +69,6 @@ public static IEnumerable<long> GenerateRandomLongs<T1, T2, T>(T1 min, T2? max,
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="long"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{long}"/> containing random long values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<long> GenerateRandomLongs<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -174,28 +77,8 @@ public static IEnumerable<long> GenerateRandomLongs<T1, T2, T>(T1 min, T2? max,
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="long"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="long"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static long GenerateRandomLong<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomLong(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="long"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{long}"/> containing random long values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<long> GenerateRandomLongs<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -204,17 +87,6 @@ public static IEnumerable<long> GenerateRandomLongs<T1, T2, T>(T1? min, T2? max,
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="long"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{long}"/> containing random long values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<long> GenerateRandomLongs<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -223,11 +95,5 @@ public static IEnumerable<long> GenerateRandomLongs<T1, T2, T>(T1? min, T2? max,
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="long"/> value between <see cref="long.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="long"/> value between <see cref="long.MinValue"/> and <paramref name="max"/>.</returns>
     public static long GenerateRandomLong<T>(T? max) where T : struct => max.HasValue ? GenerateRandomLong(long.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/YANNum.Long.cs b/lib/YANLib/YANNum.Long.cs
index f96eaa5d..c033ecb7 100644
--- a/lib/YANLib/YANNum.Long.cs
+++ b/lib/YANLib/YANNum.Long.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a long integer.
-    /// Returns the converted <see cref="long"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="long"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static long ToLong<T>(this T num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static long ToLong<T>(this T num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{long}"/> containing the long integer representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{long}"/> containing the long integer representations of the objects.</returns>
     public static IEnumerable<long> ToLong<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,20 +27,8 @@ public static IEnumerable<long> ToLong<T>(this IEnumerable<T> nums) where T : st
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a long using the default format.
-    /// Returns the parsed <see cref="long"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="long"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static long ToLong(this string str) => long.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{long}"/> containing the long integer representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{long}"/> containing the long integer representations of the strings.</returns>
     public static IEnumerable<long> ToLong(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -69,27 +41,8 @@ public static IEnumerable<long> ToLong(this IEnumerable<string> strs)
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a long using the default format.
-    /// Returns the parsed <see cref="long"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="long"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static long ToLong<T>(this string str, T dfltVal) where T : struct => long.TryParse(str, out var num) ? num : dfltVal.ToLong();
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{long}"/> containing the long integer representations of the strings, using a default value for invalid or null strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for invalid or null strings.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <param name="dfltVal">The default value to be used for invalid or null strings.</param>
-    /// <returns>An <see cref="IEnumerable{long}"/> containing the long integer representations of the strings.</returns>
     public static IEnumerable<long> ToLong<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -102,15 +55,6 @@ public static IEnumerable<long> ToLong<T>(this IEnumerable<string> strs, T dfltV
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="long"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="long"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static long GenerateRandomLong<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToLong();
@@ -118,17 +62,6 @@ public static long GenerateRandomLong<T1, T2>(T1 min, T2 max) where T1 : struct
         return minValue > maxValue ? default : new Random().NextInt64(minValue, maxValue);
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="long"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to generate.</param>
-    /// <returns>An <see cref="IEnumerable{long}"/> containing random long values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<long> GenerateRandomLongs<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -137,17 +70,7 @@ public static IEnumerable<long> GenerateRandomLongs<T1, T2, T>(T1 min, T2 max, T
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="long"/> value between <see cref="long.MinValue"/> and <see cref="long.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="long"/> value between <see cref="long.MinValue"/> and <see cref="long.MaxValue"/>.</returns>
     public static long GenerateRandomLong() => GenerateRandomLong(long.MinValue, long.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="long"/> value between <see cref="long.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="long"/> value between <see cref="long.MinValue"/> and <paramref name="max"/>.</returns>
     public static long GenerateRandomLong<T>(T max) where T : struct => GenerateRandomLong(long.MinValue, max);
 }
diff --git a/lib/YANLib/YANNum.Nint.Nullable.cs b/lib/YANLib/YANNum.Nint.Nullable.cs
index 21a0e737..6bd7ae67 100644
--- a/lib/YANLib/YANNum.Nint.Nullable.cs
+++ b/lib/YANLib/YANNum.Nint.Nullable.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a native integer (nint).
-    /// Returns the converted <see cref="nint"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="nint"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static nint ToNint<T>(this T? num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static nint ToNint<T>(this T? num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{nint}"/> containing the nint representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{nint}"/> containing the nint representations of the objects.</returns>
     public static IEnumerable<nint> ToNint<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,30 +27,8 @@ public static IEnumerable<nint> ToNint<T>(this IEnumerable<T?> nums) where T : s
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a pointer-sized signed integer using the default format.
-    /// Returns the parsed <see cref="nint"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="nint"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static nint ToNint<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToNint(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{nint}"/> containing the nint representations of the strings, with an optional default value for conversion.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value for conversion.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <param name="dfltVal">
-    /// The default value for conversion if a string cannot be parsed to nint.
-    /// Used when conversion fails for a particular string.
-    /// </param>
-    /// <returns>An <see cref="IEnumerable{nint}"/> containing the nint representations of the strings.</returns>
     public static IEnumerable<nint> ToNint<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -79,28 +41,8 @@ public static IEnumerable<nint> ToNint<T>(this IEnumerable<string> strs, T? dflt
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="nint"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="nint"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static nint GenerateRandomNint<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomNint(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>, with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable, specifying the number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nint> GenerateRandomNints<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -109,17 +51,6 @@ public static IEnumerable<nint> GenerateRandomNints<T1, T2, T>(T1? min, T2 max,
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>, with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable, specifying the number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nint> GenerateRandomNints<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -128,28 +59,8 @@ public static IEnumerable<nint> GenerateRandomNints<T1, T2, T>(T1? min, T2 max,
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="nint"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="nint"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static nint GenerateRandomNint<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomNint(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>, with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable, specifying the number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nint> GenerateRandomNints<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -158,17 +69,6 @@ public static IEnumerable<nint> GenerateRandomNints<T1, T2, T>(T1 min, T2? max,
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>, with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable, specifying the number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nint> GenerateRandomNints<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -177,28 +77,8 @@ public static IEnumerable<nint> GenerateRandomNints<T1, T2, T>(T1 min, T2? max,
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="nint"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="nint"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static nint GenerateRandomNint<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomNint(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>, with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable, specifying the number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nint> GenerateRandomNints<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -207,17 +87,6 @@ public static IEnumerable<nint> GenerateRandomNints<T1, T2, T>(T1? min, T2? max,
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>, with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable, specifying the number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nint> GenerateRandomNints<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -226,11 +95,5 @@ public static IEnumerable<nint> GenerateRandomNints<T1, T2, T>(T1? min, T2? max,
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="nint"/> value between <see cref="nint.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="nint"/> value between <see cref="nint.MinValue"/> and <paramref name="max"/>.</returns>
     public static nint GenerateRandomNint<T>(T? max) where T : struct => max.HasValue ? GenerateRandomNint(nint.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/YANNum.Nint.cs b/lib/YANLib/YANNum.Nint.cs
index 57e7b73a..027dca88 100644
--- a/lib/YANLib/YANNum.Nint.cs
+++ b/lib/YANLib/YANNum.Nint.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a native integer (nint).
-    /// Returns the converted <see cref="nint"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="nint"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static nint ToNint<T>(this T num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static nint ToNint<T>(this T num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{nint}"/> containing the nint representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{nint}"/> containing the nint representations of the objects.</returns>
     public static IEnumerable<nint> ToNint<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,20 +27,8 @@ public static IEnumerable<nint> ToNint<T>(this IEnumerable<T> nums) where T : st
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a nint using the default format.
-    /// Returns the parsed <see cref="nint"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="nint"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static nint ToNint(this string str) => nint.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{nint}"/> containing the nint representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{nint}"/> containing the nint representations of the strings.</returns>
     public static IEnumerable<nint> ToNint(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -69,30 +41,8 @@ public static IEnumerable<nint> ToNint(this IEnumerable<string> strs)
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a nint using the default format.
-    /// Returns the parsed <see cref="nint"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="nint"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static nint ToNint<T>(this string str, T dfltVal) where T : struct => nint.TryParse(str, out var num) ? num : dfltVal.ToNint();
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{nint}"/> containing the nint representations of the strings, with an optional default value for conversion.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value for conversion.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <param name="dfltVal">
-    /// The default value for conversion if a string cannot be parsed to nint.
-    /// Used when conversion fails for a particular string.
-    /// </param>
-    /// <returns>An <see cref="IEnumerable{nint}"/> containing the nint representations of the strings.</returns>
     public static IEnumerable<nint> ToNint<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -105,15 +55,6 @@ public static IEnumerable<nint> ToNint<T>(this IEnumerable<string> strs, T dfltV
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="IntPtr"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="IntPtr"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static nint GenerateRandomNint<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToNint();
@@ -121,17 +62,6 @@ public static nint GenerateRandomNint<T1, T2>(T1 min, T2 max) where T1 : struct
         return minValue > maxValue ? default : new Random().NextInt64(minValue, maxValue).ToNint();
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>, with a specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable, specifying the number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="IntPtr"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nint> GenerateRandomNints<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -140,17 +70,7 @@ public static IEnumerable<nint> GenerateRandomNints<T1, T2, T>(T1 min, T2 max, T
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="nint"/> value between <see cref="nint.MinValue"/> and <see cref="nint.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="nint"/> value between <see cref="nint.MinValue"/> and <see cref="nint.MaxValue"/>.</returns>
     public static nint GenerateRandomNint() => GenerateRandomNint(nint.MinValue, nint.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="nint"/> value between <see cref="nint.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="nint"/> value between <see cref="nint.MinValue"/> and <paramref name="max"/>.</returns>
     public static nint GenerateRandomNint<T>(T max) where T : struct => GenerateRandomNint(nint.MinValue, max);
 }
diff --git a/lib/YANLib/YANNum.Nuint.Nullable.cs b/lib/YANLib/YANNum.Nuint.Nullable.cs
index 56111dd7..e8f4e12b 100644
--- a/lib/YANLib/YANNum.Nuint.Nullable.cs
+++ b/lib/YANLib/YANNum.Nuint.Nullable.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a <see cref="nuint"/> (an unsigned integer type representing a pointer or a handle).
-    /// Returns the converted <see cref="nuint"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="nuint"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static nuint ToNuint<T>(this T? num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static nuint ToNuint<T>(this T? num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an enumerable of <see cref="nuint"/> values, which represent the unsigned integer equivalent of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An enumerable of <see cref="nuint"/> values representing the unsigned integer equivalent of the objects.</returns>
     public static IEnumerable<nuint> ToNuint<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,27 +27,8 @@ public static IEnumerable<nuint> ToNuint<T>(this IEnumerable<T?> nums) where T :
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a <see cref="nuint"/> using the default format.
-    /// Returns the parsed <see cref="nuint"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="nuint"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static nuint ToNuint<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToNuint(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings <paramref name="strs"/> to an enumerable of <see cref="nuint"/> values, which represent the unsigned integer equivalent of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for conversion.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <param name="dfltVal">The default value to be used for conversion in case of failure.</param>
-    /// <returns>An enumerable of <see cref="nuint"/> values representing the unsigned integer equivalent of the strings.</returns>
     public static IEnumerable<nuint> ToNuint<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -76,28 +41,8 @@ public static IEnumerable<nuint> ToNuint<T>(this IEnumerable<string> strs, T? df
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="nuint"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="nuint"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static nuint GenerateRandomNuint<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomNuint(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nuint> GenerateRandomNuints<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -106,17 +51,6 @@ public static IEnumerable<nuint> GenerateRandomNuints<T1, T2, T>(T1? min, T2 max
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nuint> GenerateRandomNuints<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -125,28 +59,8 @@ public static IEnumerable<nuint> GenerateRandomNuints<T1, T2, T>(T1? min, T2 max
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="nuint"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="nuint"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static nuint GenerateRandomNuint<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomNuint(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nuint> GenerateRandomNuints<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -155,17 +69,6 @@ public static IEnumerable<nuint> GenerateRandomNuints<T1, T2, T>(T1 min, T2? max
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nuint> GenerateRandomNuints<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -174,28 +77,8 @@ public static IEnumerable<nuint> GenerateRandomNuints<T1, T2, T>(T1 min, T2? max
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="nuint"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="nuint"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static nuint GenerateRandomNuint<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomNuint(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nuint> GenerateRandomNuints<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -204,17 +87,6 @@ public static IEnumerable<nuint> GenerateRandomNuints<T1, T2, T>(T1? min, T2? ma
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nuint> GenerateRandomNuints<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -223,11 +95,5 @@ public static IEnumerable<nuint> GenerateRandomNuints<T1, T2, T>(T1? min, T2? ma
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="nuint"/> value between <see cref="nuint.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="nuint"/> value between <see cref="nuint.MinValue"/> and <paramref name="max"/>.</returns>
     public static nuint GenerateRandomNuint<T>(T? max) where T : struct => max.HasValue ? GenerateRandomNuint(nuint.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/YANNum.Nuint.cs b/lib/YANLib/YANNum.Nuint.cs
index c44ec55d..0f7f54a9 100644
--- a/lib/YANLib/YANNum.Nuint.cs
+++ b/lib/YANLib/YANNum.Nuint.cs
@@ -4,13 +4,7 @@ namespace YANLib;
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a <see cref="nuint"/> (an unsigned integer type representing a pointer or a handle).
-    /// Returns the converted <see cref="nuint"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="nuint"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static nuint ToNuint<T>(this T num) where T : struct
     {
         try
@@ -23,16 +17,6 @@ public static nuint ToNuint<T>(this T num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an enumerable of <see cref="nuint"/> values, which represent the unsigned integer equivalent of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An enumerable of <see cref="nuint"/> values representing the unsigned integer equivalent of the objects.</returns>
     public static IEnumerable<nuint> ToNuint<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -45,20 +29,8 @@ public static IEnumerable<nuint> ToNuint<T>(this IEnumerable<T> nums) where T :
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a <see cref="nuint"/> using the default format.
-    /// Returns the parsed <see cref="nuint"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="nuint"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static nuint ToNuint(this string str) => nuint.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings <paramref name="strs"/> to an enumerable of <see cref="nuint"/> values, which represent the unsigned integer equivalent of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An enumerable of <see cref="nuint"/> values representing the unsigned integer equivalent of the strings.</returns>
     public static IEnumerable<nuint> ToNuint(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -71,27 +43,8 @@ public static IEnumerable<nuint> ToNuint(this IEnumerable<string> strs)
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a <see cref="nuint"/> using the default format.
-    /// Returns the parsed <see cref="nuint"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="nuint"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static nuint ToNuint<T>(this string str, T dfltVal) where T : struct => nuint.TryParse(str, out var num) ? num : dfltVal.ToNuint();
 
-    /// <summary>
-    /// Converts an enumerable of strings <paramref name="strs"/> to an enumerable of <see cref="nuint"/> values, which represent the unsigned integer equivalent of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for conversion.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <param name="dfltVal">The default value to be used for conversion in case of failure.</param>
-    /// <returns>An enumerable of <see cref="nuint"/> values representing the unsigned integer equivalent of the strings.</returns>
     public static IEnumerable<nuint> ToNuint<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -104,15 +57,6 @@ public static IEnumerable<nuint> ToNuint<T>(this IEnumerable<string> strs, T dfl
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="nuint"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="nuint"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static nuint GenerateRandomNuint<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToNuint();
@@ -120,17 +64,6 @@ public static nuint GenerateRandomNuint<T1, T2>(T1 min, T2 max) where T1 : struc
         return minValue > maxValue ? default : (new Random().NextInt64(nint.MinValue, (long)(maxValue - (minValue - (BigInteger)nint.MinValue))) - nint.MinValue).ToNuint() + minValue;
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/> with a specified size <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable to be generated.</param>
-    /// <returns>An enumerable of random <see cref="nuint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<nuint> GenerateRandomNuints<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -139,17 +72,7 @@ public static IEnumerable<nuint> GenerateRandomNuints<T1, T2, T>(T1 min, T2 max,
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="nuint"/> value between <see cref="nuint.MinValue"/> and <see cref="nuint.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="nuint"/> value between <see cref="nuint.MinValue"/> and <see cref="nuint.MaxValue"/>.</returns>
     public static nuint GenerateRandomNuint() => GenerateRandomNuint(nuint.MinValue, nuint.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="nuint"/> value between <see cref="nuint.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="nuint"/> value between <see cref="nuint.MinValue"/> and <paramref name="max"/>.</returns>
     public static nuint GenerateRandomNuint<T>(T max) where T : struct => GenerateRandomNuint(nuint.MinValue, max);
 }
diff --git a/lib/YANLib/YANNum.Sbyte.Nullable.cs b/lib/YANLib/YANNum.Sbyte.Nullable.cs
index cd75a61e..fffec63a 100644
--- a/lib/YANLib/YANNum.Sbyte.Nullable.cs
+++ b/lib/YANLib/YANNum.Sbyte.Nullable.cs
@@ -2,13 +2,7 @@
 
 public partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a signed byte (sbyte).
-    /// Returns the converted <see cref="sbyte"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="sbyte"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static sbyte ToSbyte<T>(this T? num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static sbyte ToSbyte<T>(this T? num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{sbyte}"/> containing the signed byte representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{sbyte}"/> containing the signed byte representations of the objects.</returns>
     public static IEnumerable<sbyte> ToSbyte<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,27 +27,8 @@ public static IEnumerable<sbyte> ToSbyte<T>(this IEnumerable<T?> nums) where T :
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of an <see cref="sbyte"/> using the default format.
-    /// Returns the parsed <see cref="sbyte"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="sbyte"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static sbyte ToSbyte<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToSbyte(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{sbyte}"/> containing the signed byte representations of the strings, using the specified default value for invalid string representations.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for invalid string representations.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <param name="dfltVal">The default value to be used for invalid string representations.</param>
-    /// <returns>An <see cref="IEnumerable{sbyte}"/> containing the signed byte representations of the strings.</returns>
     public static IEnumerable<sbyte> ToSbyte<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -76,28 +41,8 @@ public static IEnumerable<sbyte> ToSbyte<T>(this IEnumerable<string> strs, T? df
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="sbyte"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="sbyte"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static sbyte GenerateRandomSbyte<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomSbyte(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate given by <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<sbyte> GenerateRandomSbytes<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -106,17 +51,6 @@ public static IEnumerable<sbyte> GenerateRandomSbytes<T1, T2, T>(T1? min, T2 max
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate given by <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<sbyte> GenerateRandomSbytes<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -125,28 +59,8 @@ public static IEnumerable<sbyte> GenerateRandomSbytes<T1, T2, T>(T1? min, T2 max
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="sbyte"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="sbyte"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static sbyte GenerateRandomSbyte<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomSbyte(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate given by <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<sbyte> GenerateRandomSbytes<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -155,17 +69,6 @@ public static IEnumerable<sbyte> GenerateRandomSbytes<T1, T2, T>(T1 min, T2? max
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate given by <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<sbyte> GenerateRandomSbytes<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -174,28 +77,8 @@ public static IEnumerable<sbyte> GenerateRandomSbytes<T1, T2, T>(T1 min, T2? max
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="sbyte"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="sbyte"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static sbyte GenerateRandomSbyte<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomSbyte(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate given by <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<sbyte> GenerateRandomSbytes<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -204,17 +87,6 @@ public static IEnumerable<sbyte> GenerateRandomSbytes<T1, T2, T>(T1? min, T2? ma
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate given by <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<sbyte> GenerateRandomSbytes<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -223,11 +95,5 @@ public static IEnumerable<sbyte> GenerateRandomSbytes<T1, T2, T>(T1? min, T2? ma
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="sbyte"/> value between <see cref="sbyte.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="sbyte"/> value between <see cref="sbyte.MinValue"/> and <paramref name="max"/>.</returns>
     public static sbyte GenerateRandomSbyte<T>(T? max) where T : struct => max.HasValue ? GenerateRandomSbyte(sbyte.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/YANNum.Sbyte.cs b/lib/YANLib/YANNum.Sbyte.cs
index b13dd7a9..83bd2435 100644
--- a/lib/YANLib/YANNum.Sbyte.cs
+++ b/lib/YANLib/YANNum.Sbyte.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a signed byte (sbyte).
-    /// Returns the converted <see cref="sbyte"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="sbyte"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static sbyte ToSbyte<T>(this T num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static sbyte ToSbyte<T>(this T num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{sbyte}"/> containing the signed byte representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{sbyte}"/> containing the signed byte representations of the objects.</returns>
     public static IEnumerable<sbyte> ToSbyte<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,20 +27,8 @@ public static IEnumerable<sbyte> ToSbyte<T>(this IEnumerable<T> nums) where T :
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a signed byte using the default format.
-    /// Returns the parsed <see cref="sbyte"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="sbyte"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static sbyte ToSbyte(this string str) => sbyte.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{sbyte}"/> containing the signed byte representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{sbyte}"/> containing the signed byte representations of the strings.</returns>
     public static IEnumerable<sbyte> ToSbyte(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -69,27 +41,8 @@ public static IEnumerable<sbyte> ToSbyte(this IEnumerable<string> strs)
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a signed byte using the default format.
-    /// Returns the parsed <see cref="sbyte"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="sbyte"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static sbyte ToSbyte<T>(this string str, T dfltVal) where T : struct => sbyte.TryParse(str, out var num) ? num : dfltVal.ToSbyte();
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{sbyte}"/> containing the signed byte representations of the strings, using the specified default value for invalid string representations.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for invalid string representations.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <param name="dfltVal">The default value to be used for invalid string representations.</param>
-    /// <returns>An <see cref="IEnumerable{sbyte}"/> containing the signed byte representations of the strings.</returns>
     public static IEnumerable<sbyte> ToSbyte<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -102,15 +55,6 @@ public static IEnumerable<sbyte> ToSbyte<T>(this IEnumerable<string> strs, T dfl
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="sbyte"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="sbyte"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static sbyte GenerateRandomSbyte<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToSbyte();
@@ -118,17 +62,6 @@ public static sbyte GenerateRandomSbyte<T1, T2>(T1 min, T2 max) where T1 : struc
         return minValue > maxValue ? default : new Random().Next(minValue, maxValue).ToSbyte();
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate given by <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An enumerable of random <see cref="sbyte"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<sbyte> GenerateRandomSbytes<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -137,17 +70,7 @@ public static IEnumerable<sbyte> GenerateRandomSbytes<T1, T2, T>(T1 min, T2 max,
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="sbyte"/> value between <see cref="sbyte.MinValue"/> and <see cref="sbyte.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="sbyte"/> value between <see cref="sbyte.MinValue"/> and <see cref="sbyte.MaxValue"/>.</returns>
     public static sbyte GenerateRandomSbyte() => GenerateRandomSbyte(sbyte.MinValue, sbyte.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="sbyte"/> value between <see cref="sbyte.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="sbyte"/> value between <see cref="sbyte.MinValue"/> and <paramref name="max"/>.</returns>
     public static sbyte GenerateRandomSbyte<T>(T max) where T : struct => GenerateRandomSbyte(sbyte.MinValue, max);
 }
diff --git a/lib/YANLib/YANNum.Short.Nullable.cs b/lib/YANLib/YANNum.Short.Nullable.cs
index e533805c..742a09f1 100644
--- a/lib/YANLib/YANNum.Short.Nullable.cs
+++ b/lib/YANLib/YANNum.Short.Nullable.cs
@@ -2,13 +2,7 @@
 
 public partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a <see cref="short"/>.
-    /// Returns the converted <see cref="short"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="short"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static short ToShort<T>(this T? num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static short ToShort<T>(this T? num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{short}"/> containing the short integer representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{short}"/> containing the short integer representations of the objects.</returns>
     public static IEnumerable<short> ToShort<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,27 +27,8 @@ public static IEnumerable<short> ToShort<T>(this IEnumerable<T?> nums) where T :
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a short using the default format.
-    /// Returns the parsed <see cref="short"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="short"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static short ToShort<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToShort(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{short}"/> containing the short integer representations of the strings, using the specified default value for invalid or null strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for invalid or null strings.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <param name="dfltVal">The default value to be used for invalid or null strings.</param>
-    /// <returns>An <see cref="IEnumerable{short}"/> containing the short integer representations of the strings.</returns>
     public static IEnumerable<short> ToShort<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -76,28 +41,8 @@ public static IEnumerable<short> ToShort<T>(this IEnumerable<string> strs, T? df
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="short"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="short"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static short GenerateRandomShort<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomShort(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="short"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{short}"/> containing the random short values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<short> GenerateRandomShorts<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -106,17 +51,6 @@ public static IEnumerable<short> GenerateRandomShorts<T1, T2, T>(T1? min, T2 max
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="short"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{short}"/> containing the random short values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<short> GenerateRandomShorts<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -125,28 +59,8 @@ public static IEnumerable<short> GenerateRandomShorts<T1, T2, T>(T1? min, T2 max
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="short"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="short"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static short GenerateRandomShort<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomShort(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="short"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{short}"/> containing the random short values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<short> GenerateRandomShorts<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -155,17 +69,6 @@ public static IEnumerable<short> GenerateRandomShorts<T1, T2, T>(T1 min, T2? max
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="short"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{short}"/> containing the random short values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<short> GenerateRandomShorts<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -174,28 +77,8 @@ public static IEnumerable<short> GenerateRandomShorts<T1, T2, T>(T1 min, T2? max
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="short"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="short"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static short GenerateRandomShort<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomShort(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="short"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{short}"/> containing the random short values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<short> GenerateRandomShorts<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -204,17 +87,6 @@ public static IEnumerable<short> GenerateRandomShorts<T1, T2, T>(T1? min, T2? ma
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="short"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{short}"/> containing the random short values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<short> GenerateRandomShorts<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -223,11 +95,5 @@ public static IEnumerable<short> GenerateRandomShorts<T1, T2, T>(T1? min, T2? ma
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="short"/> value between <see cref="short.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="short"/> value between <see cref="short.MinValue"/> and <paramref name="max"/>.</returns>
     public static short GenerateRandomShort<T>(T? max) where T : struct => max.HasValue ? GenerateRandomShort(short.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/YANNum.Short.cs b/lib/YANLib/YANNum.Short.cs
index 9b734b8d..6db99731 100644
--- a/lib/YANLib/YANNum.Short.cs
+++ b/lib/YANLib/YANNum.Short.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a <see cref="short"/>.
-    /// Returns the converted <see cref="short"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="short"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static short ToShort<T>(this T num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static short ToShort<T>(this T num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{short}"/> containing the short integer representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{short}"/> containing the short integer representations of the objects.</returns>
     public static IEnumerable<short> ToShort<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,20 +27,8 @@ public static IEnumerable<short> ToShort<T>(this IEnumerable<T> nums) where T :
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a short integer using the default format.
-    /// Returns the parsed <see cref="short"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="short"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static short ToShort(this string str) => short.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{short}"/> containing the short integer representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{short}"/> containing the short integer representations of the strings.</returns>
     public static IEnumerable<short> ToShort(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -69,27 +41,8 @@ public static IEnumerable<short> ToShort(this IEnumerable<string> strs)
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a <see cref="short"/> using the default format.
-    /// Returns the parsed <see cref="short"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="short"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static short ToShort<T>(this string str, T dfltVal) where T : struct => short.TryParse(str, out var num) ? num : dfltVal.ToShort();
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{short}"/> containing the short integer representations of the strings, using the specified default value for invalid or null strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used for invalid or null strings.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <param name="dfltVal">The default value to be used for invalid or null strings.</param>
-    /// <returns>An <see cref="IEnumerable{short}"/> containing the short integer representations of the strings.</returns>
     public static IEnumerable<short> ToShort<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -102,15 +55,6 @@ public static IEnumerable<short> ToShort<T>(this IEnumerable<string> strs, T dfl
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="short"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="short"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static short GenerateRandomShort<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToShort();
@@ -118,17 +62,6 @@ public static short GenerateRandomShort<T1, T2>(T1 min, T2 max) where T1 : struc
         return minValue > maxValue ? default : new Random().Next(minValue, maxValue).ToShort();
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="short"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified number of values to generate determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{short}"/> containing the random short values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<short> GenerateRandomShorts<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -137,17 +70,7 @@ public static IEnumerable<short> GenerateRandomShorts<T1, T2, T>(T1 min, T2 max,
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="short"/> value between <see cref="short.MinValue"/> and <see cref="short.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="short"/> value between <see cref="short.MinValue"/> and <see cref="short.MaxValue"/>.</returns>
     public static short GenerateRandomShort() => GenerateRandomShort(short.MinValue, short.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="short"/> value between <see cref="short.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="short"/> value between <see cref="short.MinValue"/> and <paramref name="max"/>.</returns>
     public static short GenerateRandomShort<T>(T max) where T : struct => GenerateRandomShort(short.MinValue, max);
 }
diff --git a/lib/YANLib/YANNum.Uint.Nullable.cs b/lib/YANLib/YANNum.Uint.Nullable.cs
index 33621d90..ee62d8c4 100644
--- a/lib/YANLib/YANNum.Uint.Nullable.cs
+++ b/lib/YANLib/YANNum.Uint.Nullable.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to an unsigned integer.
-    /// Returns the converted <see cref="uint"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="uint"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static uint ToUint<T>(this T? num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static uint ToUint<T>(this T? num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{byte}"/> containing the byte representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the byte representations of the objects.</returns>
     public static IEnumerable<uint> ToUint<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,27 +27,8 @@ public static IEnumerable<uint> ToUint<T>(this IEnumerable<T?> nums) where T : s
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of an unsigned integer using the default format.
-    /// Returns the parsed <see cref="uint"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="uint"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static uint ToUint<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToUint(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{uint}"/> containing the uint representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value for the conversion to uint.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <param name="dfltVal">The default value for the conversion to uint.</param>
-    /// <returns>An <see cref="IEnumerable{uint}"/> containing the uint representations of the strings.</returns>
     public static IEnumerable<uint> ToUint<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -76,29 +41,8 @@ public static IEnumerable<uint> ToUint<T>(this IEnumerable<string> strs, T? dflt
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="uint"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="uint"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static uint GenerateRandomUint<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomUint(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The size of the enumerable is determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty enumerable is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable.</param>
-    /// <returns>An enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<uint> GenerateRandomUints<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -107,18 +51,6 @@ public static IEnumerable<uint> GenerateRandomUints<T1, T2, T>(T1? min, T2 max,
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The size of the enumerable is determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty enumerable is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable.</param>
-    /// <returns>An enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<uint> GenerateRandomUints<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -127,29 +59,8 @@ public static IEnumerable<uint> GenerateRandomUints<T1, T2, T>(T1? min, T2 max,
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="uint"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="uint"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static uint GenerateRandomUint<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomUint(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The size of the enumerable is determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty enumerable is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable.</param>
-    /// <returns>An enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<uint> GenerateRandomUints<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -158,18 +69,6 @@ public static IEnumerable<uint> GenerateRandomUints<T1, T2, T>(T1 min, T2? max,
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The size of the enumerable is determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty enumerable is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable.</param>
-    /// <returns>An enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<uint> GenerateRandomUints<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -178,29 +77,8 @@ public static IEnumerable<uint> GenerateRandomUints<T1, T2, T>(T1 min, T2? max,
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="uint"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="uint"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static uint GenerateRandomUint<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomUint(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The size of the enumerable is determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty enumerable is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable.</param>
-    /// <returns>An enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<uint> GenerateRandomUints<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -209,18 +87,6 @@ public static IEnumerable<uint> GenerateRandomUints<T1, T2, T>(T1? min, T2? max,
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The size of the enumerable is determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty enumerable is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable.</param>
-    /// <returns>An enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<uint> GenerateRandomUints<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -229,11 +95,5 @@ public static IEnumerable<uint> GenerateRandomUints<T1, T2, T>(T1? min, T2? max,
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="uint"/> value between <see cref="uint.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="uint"/> value between <see cref="uint.MinValue"/> and <paramref name="max"/>.</returns>
     public static uint GenerateRandomUint<T>(T? max) where T : struct => max.HasValue ? GenerateRandomUint(uint.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/YANNum.Uint.cs b/lib/YANLib/YANNum.Uint.cs
index e31e4fa6..e5369423 100644
--- a/lib/YANLib/YANNum.Uint.cs
+++ b/lib/YANLib/YANNum.Uint.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to an unsigned integer.
-    /// Returns the converted <see cref="uint"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="uint"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static uint ToUint<T>(this T num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static uint ToUint<T>(this T num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{byte}"/> containing the byte representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{byte}"/> containing the byte representations of the objects.</returns>
     public static IEnumerable<uint> ToUint<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,20 +27,8 @@ public static IEnumerable<uint> ToUint<T>(this IEnumerable<T> nums) where T : st
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of an unsigned integer using the default format.
-    /// Returns the parsed <see cref="uint"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="uint"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static uint ToUint(this string str) => uint.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{uint}"/> containing the uint representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{uint}"/> containing the uint representations of the strings.</returns>
     public static IEnumerable<uint> ToUint(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -69,27 +41,8 @@ public static IEnumerable<uint> ToUint(this IEnumerable<string> strs)
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of an unsigned integer using the default format.
-    /// Returns the parsed <see cref="uint"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="uint"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static uint ToUint<T>(this string str, T dfltVal) where T : struct => uint.TryParse(str, out var num) ? num : dfltVal.ToUint();
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{uint}"/> containing the uint representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value for the conversion to uint.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <param name="dfltVal">The default value for the conversion to uint.</param>
-    /// <returns>An <see cref="IEnumerable{uint}"/> containing the uint representations of the strings.</returns>
     public static IEnumerable<uint> ToUint<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -102,15 +55,6 @@ public static IEnumerable<uint> ToUint<T>(this IEnumerable<string> strs, T dfltV
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="uint"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="uint"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static uint GenerateRandomUint<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToUint();
@@ -118,18 +62,6 @@ public static uint GenerateRandomUint<T1, T2>(T1 min, T2 max) where T1 : struct
         return minValue > maxValue ? default : new Random().NextInt64(minValue, maxValue).ToUint();
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The size of the enumerable is determined by the <paramref name="size"/> parameter.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty enumerable is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size parameter, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable.</param>
-    /// <returns>An enumerable of random <see cref="uint"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<uint> GenerateRandomUints<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -138,17 +70,7 @@ public static IEnumerable<uint> GenerateRandomUints<T1, T2, T>(T1 min, T2 max, T
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="uint"/> value between <see cref="uint.MinValue"/> and <see cref="uint.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="uint"/> value between <see cref="uint.MinValue"/> and <see cref="uint.MaxValue"/>.</returns>
     public static uint GenerateRandomUint() => GenerateRandomUint(uint.MinValue, uint.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="uint"/> value between <see cref="uint.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="uint"/> value between <see cref="uint.MinValue"/> and <paramref name="max"/>.</returns>
     public static uint GenerateRandomUint<T>(T max) where T : struct => GenerateRandomUint(uint.MinValue, max);
 }
diff --git a/lib/YANLib/YANNum.Ulong.Nullable.cs b/lib/YANLib/YANNum.Ulong.Nullable.cs
index 6a972f87..f4d7daf8 100644
--- a/lib/YANLib/YANNum.Ulong.Nullable.cs
+++ b/lib/YANLib/YANNum.Ulong.Nullable.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to an unsigned long integer.
-    /// Returns the converted <see cref="ulong"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="ulong"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static ulong ToUlong<T>(this T? num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static ulong ToUlong<T>(this T? num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{ulong}"/> containing the ulong representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{ulong}"/> containing the ulong representations of the objects.</returns>
     public static IEnumerable<ulong> ToUlong<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,27 +27,8 @@ public static IEnumerable<ulong> ToUlong<T>(this IEnumerable<T?> nums) where T :
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of an unsigned long integer using the default format.
-    /// Returns the parsed <see cref="ulong"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="ulong"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static ulong ToUlong<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToUlong(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings <paramref name="strs"/> to an <see cref="IEnumerable{ulong}"/> containing the ulong representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used when converting strings to ulong.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <param name="dfltVal">The default value to be used when converting strings to ulong.</param>
-    /// <returns>An <see cref="IEnumerable{ulong}"/> containing the ulong representations of the strings.</returns>
     public static IEnumerable<ulong> ToUlong<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -76,29 +41,8 @@ public static IEnumerable<ulong> ToUlong<T>(this IEnumerable<string> strs, T? df
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static ulong GenerateRandomUlong<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomUlong(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="ulong"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{ulong}"/> containing the generated random ulong values.</returns>
     public static IEnumerable<ulong> GenerateRandomUlongs<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -107,18 +51,6 @@ public static IEnumerable<ulong> GenerateRandomUlongs<T1, T2, T>(T1? min, T2 max
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="ulong"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{ulong}"/> containing the generated random ulong values.</returns>
     public static IEnumerable<ulong> GenerateRandomUlongs<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -127,29 +59,8 @@ public static IEnumerable<ulong> GenerateRandomUlongs<T1, T2, T>(T1? min, T2 max
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static ulong GenerateRandomUlong<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomUlong(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="ulong"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{ulong}"/> containing the generated random ulong values.</returns>
     public static IEnumerable<ulong> GenerateRandomUlongs<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -158,18 +69,6 @@ public static IEnumerable<ulong> GenerateRandomUlongs<T1, T2, T>(T1 min, T2? max
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="ulong"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{ulong}"/> containing the generated random ulong values.</returns>
     public static IEnumerable<ulong> GenerateRandomUlongs<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -178,29 +77,8 @@ public static IEnumerable<ulong> GenerateRandomUlongs<T1, T2, T>(T1 min, T2? max
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static ulong GenerateRandomUlong<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomUlong(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="ulong"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{ulong}"/> containing the generated random ulong values.</returns>
     public static IEnumerable<ulong> GenerateRandomUlongs<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -209,18 +87,6 @@ public static IEnumerable<ulong> GenerateRandomUlongs<T1, T2, T>(T1? min, T2? ma
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="ulong"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{ulong}"/> containing the generated random ulong values.</returns>
     public static IEnumerable<ulong> GenerateRandomUlongs<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -229,11 +95,5 @@ public static IEnumerable<ulong> GenerateRandomUlongs<T1, T2, T>(T1? min, T2? ma
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="ulong"/> value between <see cref="ulong.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="ulong"/> value between <see cref="ulong.MinValue"/> and <paramref name="max"/>.</returns>
     public static ulong GenerateRandomUlong<T>(T? max) where T : struct => max.HasValue ? GenerateRandomUlong(ulong.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/YANNum.Ulong.cs b/lib/YANLib/YANNum.Ulong.cs
index 2e1e359a..a9370941 100644
--- a/lib/YANLib/YANNum.Ulong.cs
+++ b/lib/YANLib/YANNum.Ulong.cs
@@ -4,13 +4,7 @@ namespace YANLib;
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to an unsigned long integer.
-    /// Returns the converted <see cref="ulong"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="ulong"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static ulong ToUlong<T>(this T num) where T : struct
     {
         try
@@ -23,16 +17,6 @@ public static ulong ToUlong<T>(this T num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{ulong}"/> containing the ulong representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{ulong}"/> containing the ulong representations of the objects.</returns>
     public static IEnumerable<ulong> ToUlong<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -45,20 +29,8 @@ public static IEnumerable<ulong> ToUlong<T>(this IEnumerable<T> nums) where T :
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of an unsigned long integer using the default format.
-    /// Returns the parsed <see cref="ulong"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="ulong"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static ulong ToUlong(this string str) => ulong.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings <paramref name="strs"/> to an <see cref="IEnumerable{ulong}"/> containing the ulong representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{ulong}"/> containing the ulong representations of the strings.</returns>
     public static IEnumerable<ulong> ToUlong(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -71,27 +43,8 @@ public static IEnumerable<ulong> ToUlong(this IEnumerable<string> strs)
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of an <see cref="ulong"/> using the default format.
-    /// Returns the parsed <see cref="ulong"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="ulong"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static ulong ToUlong<T>(this string str, T dfltVal) where T : struct => ulong.TryParse(str, out var num) ? num : dfltVal.ToUlong();
 
-    /// <summary>
-    /// Converts an enumerable of strings <paramref name="strs"/> to an <see cref="IEnumerable{ulong}"/> containing the ulong representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value to be used when converting strings to ulong.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <param name="dfltVal">The default value to be used when converting strings to ulong.</param>
-    /// <returns>An <see cref="IEnumerable{ulong}"/> containing the ulong representations of the strings.</returns>
     public static IEnumerable<ulong> ToUlong<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -104,15 +57,6 @@ public static IEnumerable<ulong> ToUlong<T>(this IEnumerable<string> strs, T dfl
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static ulong GenerateRandomUlong<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToUlong();
@@ -120,18 +64,6 @@ public static ulong GenerateRandomUlong<T1, T2>(T1 min, T2 max) where T1 : struc
         return minValue > maxValue ? default : (new Random().NextInt64(long.MinValue, (long)(maxValue - (minValue - (BigInteger)long.MinValue))) - long.MinValue).ToUlong() + minValue;
     }
 
-    /// <summary>
-    /// Generates an enumerable of random <see cref="ulong"/> values between <paramref name="min"/> and <paramref name="max"/>.
-    /// The number of values generated is determined by the value of <paramref name="size"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The number of random values to generate.</param>
-    /// <returns>An <see cref="IEnumerable{ulong}"/> containing the generated random ulong values.</returns>
     public static IEnumerable<ulong> GenerateRandomUlongs<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -140,17 +72,7 @@ public static IEnumerable<ulong> GenerateRandomUlongs<T1, T2, T>(T1 min, T2 max,
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="ulong"/> value between <see cref="ulong.MinValue"/> and <see cref="ulong.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="ulong"/> value between <see cref="ulong.MinValue"/> and <see cref="ulong.MaxValue"/>.</returns>
     public static ulong GenerateRandomUlong() => GenerateRandomUlong(ulong.MinValue, ulong.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="ulong"/> value between <see cref="ulong.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="ulong"/> value between <see cref="ulong.MinValue"/> and <paramref name="max"/>.</returns>
     public static ulong GenerateRandomUlong<T>(T max) where T : struct => GenerateRandomUlong(ulong.MinValue, max);
 }
diff --git a/lib/YANLib/YANNum.Ushort.Nullable.cs b/lib/YANLib/YANNum.Ushort.Nullable.cs
index bbcd2add..feb336bb 100644
--- a/lib/YANLib/YANNum.Ushort.Nullable.cs
+++ b/lib/YANLib/YANNum.Ushort.Nullable.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a unsigned short integer.
-    /// Returns the converted <see cref="ushort"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="ushort"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static ushort ToUshort<T>(this T? num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static ushort ToUshort<T>(this T? num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{ushort}"/> containing the ushort representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{ushort}"/> containing the ushort representations of the objects.</returns>
     public static IEnumerable<ushort> ToUshort<T>(this IEnumerable<T?> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,27 +27,8 @@ public static IEnumerable<ushort> ToUshort<T>(this IEnumerable<T?> nums) where T
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of a ushort using the default format.
-    /// Returns the parsed <see cref="ushort"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="ushort"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static ushort ToUshort<T>(this string str, T? dfltVal) where T : struct => dfltVal.HasValue ? str.ToUshort(dfltVal.Value) : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{ushort}"/> containing the ushort representations of the strings, using the specified default value for conversion failure.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value for conversion failure.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <param name="dfltVal">The default value to be used for conversion failure.</param>
-    /// <returns>An <see cref="IEnumerable{ushort}"/> containing the ushort representations of the strings.</returns>
     public static IEnumerable<ushort> ToUshort<T>(this IEnumerable<string> strs, T? dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -76,28 +41,8 @@ public static IEnumerable<ushort> ToUshort<T>(this IEnumerable<string> strs, T?
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static ushort GenerateRandomUshort<T1, T2>(T1? min, T2 max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomUshort(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable sequence.</param>
-    /// <returns>An enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<ulong> GenerateRandomUshorts<T1, T2, T>(T1? min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -106,17 +51,6 @@ public static IEnumerable<ulong> GenerateRandomUshorts<T1, T2, T>(T1? min, T2 ma
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable sequence.</param>
-    /// <returns>An enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<ulong> GenerateRandomUshorts<T1, T2, T>(T1? min, T2 max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -125,28 +59,8 @@ public static IEnumerable<ulong> GenerateRandomUshorts<T1, T2, T>(T1? min, T2 ma
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static ushort GenerateRandomUshort<T1, T2>(T1 min, T2? max) where T1 : struct where T2 : struct => max.HasValue ? GenerateRandomUshort(min, max.Value) : default;
 
-    /// <summary>
-    /// Generates an enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable sequence.</param>
-    /// <returns>An enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<ulong> GenerateRandomUshorts<T1, T2, T>(T1 min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -155,17 +69,6 @@ public static IEnumerable<ulong> GenerateRandomUshorts<T1, T2, T>(T1 min, T2? ma
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable sequence.</param>
-    /// <returns>An enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<ulong> GenerateRandomUshorts<T1, T2, T>(T1 min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -174,28 +77,8 @@ public static IEnumerable<ulong> GenerateRandomUshorts<T1, T2, T>(T1 min, T2? ma
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="ulong"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static ushort GenerateRandomUshort<T1, T2>(T1? min, T2? max) where T1 : struct where T2 : struct => min.HasValue ? GenerateRandomUshort(min.Value, max) : default;
 
-    /// <summary>
-    /// Generates an enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable sequence.</param>
-    /// <returns>An enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<ulong> GenerateRandomUshorts<T1, T2, T>(T1? min, T2? max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -204,17 +87,6 @@ public static IEnumerable<ulong> GenerateRandomUshorts<T1, T2, T>(T1? min, T2? m
         }
     }
 
-    /// <summary>
-    /// Generates an enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable sequence.</param>
-    /// <returns>An enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<ulong> GenerateRandomUshorts<T1, T2, T>(T1? min, T2? max, T? size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -223,11 +95,5 @@ public static IEnumerable<ulong> GenerateRandomUshorts<T1, T2, T>(T1? min, T2? m
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="ushort"/> value between <see cref="ushort.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="ushort"/> value between <see cref="ushort.MinValue"/> and <paramref name="max"/>.</returns>
     public static ushort GenerateRandomUshort<T>(T? max) where T : struct => max.HasValue ? GenerateRandomUshort(ushort.MinValue, max.Value) : default;
 }
diff --git a/lib/YANLib/YANNum.Ushort.cs b/lib/YANLib/YANNum.Ushort.cs
index eddf4310..d4c1e37b 100644
--- a/lib/YANLib/YANNum.Ushort.cs
+++ b/lib/YANLib/YANNum.Ushort.cs
@@ -2,13 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Converts the specified value to a unsigned short integer.
-    /// Returns the converted <see cref="ushort"/> value, or <see langword="default"/> if the conversion fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be converted, which must be a value type.</typeparam>
-    /// <param name="num">The value to be converted.</param>
-    /// <returns>The converted <see cref="ushort"/> value, or <see langword="default"/> if the conversion fails.</returns>
+    
     public static ushort ToUshort<T>(this T num) where T : struct
     {
         try
@@ -21,16 +15,6 @@ public static ushort ToUshort<T>(this T num) where T : struct
         }
     }
 
-    /// <summary>
-    /// Converts an enumerable of value-type objects of type <typeparamref name="T"/> to an <see cref="IEnumerable{ushort}"/> containing the ushort representations of the objects.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> objects.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the value-type objects to be converted.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="nums">The enumerable of value-type objects to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{ushort}"/> containing the ushort representations of the objects.</returns>
     public static IEnumerable<ushort> ToUshort<T>(this IEnumerable<T> nums) where T : struct
     {
         if (nums is null || !nums.Any())
@@ -43,20 +27,8 @@ public static IEnumerable<ushort> ToUshort<T>(this IEnumerable<T> nums) where T
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of an unsigned short integer using the default format.
-    /// Returns the parsed <see cref="ushort"/> value, or <see langword="default"/> if the parsing fails.
-    /// </summary>
-    /// <param name="str">The string to be parsed.</param>
-    /// <returns>The parsed <see cref="ushort"/> value, or <see langword="default"/> if the parsing fails.</returns>
     public static ushort ToUshort(this string str) => ushort.TryParse(str, out var num) ? num : default;
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{ushort}"/> containing the ushort representations of the strings.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <returns>An <see cref="IEnumerable{ushort}"/> containing the ushort representations of the strings.</returns>
     public static IEnumerable<ushort> ToUshort(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -69,27 +41,8 @@ public static IEnumerable<ushort> ToUshort(this IEnumerable<string> strs)
         }
     }
 
-    /// <summary>
-    /// Parses the string representation of an unsigned short using the default format.
-    /// Returns the parsed <see cref="ushort"/> value, or <paramref name="dfltVal"/> if the parsing fails.
-    /// </summary>
-    /// <typeparam name="T">The type of the default value to be returned, which must be a value type.</typeparam>
-    /// <param name="str">The string to be parsed.</param>
-    /// <param name="dfltVal">The default value to be returned if the parsing fails.</param>
-    /// <returns>The parsed <see cref="ushort"/> value, or <paramref name="dfltVal"/> if the parsing fails.</returns>
     public static ushort ToUshort<T>(this string str, T dfltVal) where T : struct => ushort.TryParse(str, out var num) ? num : dfltVal.ToUshort();
 
-    /// <summary>
-    /// Converts an enumerable of strings to an <see cref="IEnumerable{ushort}"/> containing the ushort representations of the strings, using the specified default value for conversion failure.
-    /// Returns an empty sequence if the input enumerable is <see langword="null"/>, empty, or contains only <see langword="null"/> strings.
-    /// </summary>
-    /// <typeparam name="T">
-    /// The type of the default value for conversion failure.
-    /// Must be a value type.
-    /// </typeparam>
-    /// <param name="strs">The enumerable of strings to be converted.</param>
-    /// <param name="dfltVal">The default value to be used for conversion failure.</param>
-    /// <returns>An <see cref="IEnumerable{ushort}"/> containing the ushort representations of the strings.</returns>
     public static IEnumerable<ushort> ToUshort<T>(this IEnumerable<string> strs, T dfltVal) where T : struct
     {
         if (strs is null || !strs.Any())
@@ -102,15 +55,6 @@ public static IEnumerable<ushort> ToUshort<T>(this IEnumerable<string> strs, T d
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="ushort"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, <see langword="default"/> is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="ushort"/> value between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static ushort GenerateRandomUshort<T1, T2>(T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToUshort();
@@ -118,17 +62,6 @@ public static ushort GenerateRandomUshort<T1, T2>(T1 min, T2 max) where T1 : str
         return minValue > maxValue ? default : new Random().Next(minValue, maxValue).ToUshort();
     }
 
-    /// <summary>
-    /// Generates an enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>, with the specified size.
-    /// If <paramref name="min"/> is greater than <paramref name="max"/>, an empty sequence is returned.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <typeparam name="T">The type of the size value, which must be a value type.</typeparam>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <param name="size">The size of the enumerable sequence.</param>
-    /// <returns>An enumerable sequence of random <see cref="ushort"/> values between <paramref name="min"/> and <paramref name="max"/>.</returns>
     public static IEnumerable<ushort> GenerateRandomUshorts<T1, T2, T>(T1 min, T2 max, T size) where T1 : struct where T2 : struct where T : struct
     {
         for (var i = 0ul; i < size.ToUlong(); i++)
@@ -137,17 +70,7 @@ public static IEnumerable<ushort> GenerateRandomUshorts<T1, T2, T>(T1 min, T2 ma
         }
     }
 
-    /// <summary>
-    /// Generates a random <see cref="ushort"/> value between <see cref="ushort.MinValue"/> and <see cref="ushort.MaxValue"/>.
-    /// </summary>
-    /// <returns>A random <see cref="ushort"/> value between <see cref="ushort.MinValue"/> and <see cref="ushort.MaxValue"/>.</returns>
     public static ushort GenerateRandomUshort() => GenerateRandomUshort(ushort.MinValue, ushort.MaxValue);
 
-    /// <summary>
-    /// Generates a random <see cref="ushort"/> value between <see cref="ushort.MinValue"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="ushort"/> value between <see cref="ushort.MinValue"/> and <paramref name="max"/>.</returns>
     public static ushort GenerateRandomUshort<T>(T max) where T : struct => GenerateRandomUshort(ushort.MinValue, max);
 }
diff --git a/lib/YANLib/YANNum.cs b/lib/YANLib/YANNum.cs
index b57eaec6..97f0579e 100644
--- a/lib/YANLib/YANNum.cs
+++ b/lib/YANLib/YANNum.cs
@@ -2,12 +2,7 @@
 
 public static partial class YANNum
 {
-    /// <summary>
-    /// Finds the minimum value in an array of values that implement the <see cref="IComparable{T}"/> interface.
-    /// </summary>
-    /// <typeparam name="T">The type of the values in the array.</typeparam>
-    /// <param name="nums">The array of values to find the minimum value in.</param>
-    /// <returns>The minimum value in the array.</returns>
+    
     public static T? Min<T>(params T[] nums) where T : IComparable<T>
     {
         if (nums is null || nums.Length < 1)
@@ -25,12 +20,6 @@ public static partial class YANNum
         return min;
     }
 
-    /// <summary>
-    /// Finds the maximum value in an array of values that implement the <see cref="IComparable{T}"/> interface.
-    /// </summary>
-    /// <typeparam name="T">The type of the values in the array.</typeparam>
-    /// <param name="nums">The array of values to find the maximum value in.</param>
-    /// <returns>The maximum value in the array.</returns>
     public static T? Max<T>(params T[] nums) where T : IComparable<T>
     {
         if (nums is null || nums.Length < 1)
diff --git a/lib/YANLib/YANPass.cs b/lib/YANLib/YANPass.cs
index d40ce15e..1428d0c7 100644
--- a/lib/YANLib/YANPass.cs
+++ b/lib/YANLib/YANPass.cs
@@ -24,11 +24,7 @@ public class YANPass
     #endregion
 
     #region Methods
-    /// <summary>
-    /// Computes the hash value of the specified password, along with a randomly generated salt and other parameters, and returns the resulting string in a specific format.
-    /// </summary>
-    /// <param name="password">The password to hash.</param>
-    /// <returns>A string in the format "hashValue|salt|iterations|algorithm", where "hashValue" is the computed hash value of the password, "salt" is the randomly generated salt used for hashing, "iterations" is the number of iterations used for the key derivation function, and "algorithm" is the name of the key derivation function used.</returns>
+    
     public string? Hash(string password)
     {
         if (password.IsNotNullAndWhiteSpace() && SaltSize > 0 && Iterations > 0 && KeySize > 0)
@@ -39,12 +35,6 @@ public class YANPass
         return default;
     }
 
-    /// <summary>
-    /// Verifies the provided password against a stored hash and returns a <see cref="bool"/> indicating whether the password is valid.
-    /// </summary>
-    /// <param name="password">The password to verify.</param>
-    /// <param name="strHash">The hash value to verify the password against.</param>
-    /// <returns><see langword="true"/> if the provided password is valid; otherwise, <see langword="false"/>.</returns>
     public bool Verify(string password, string strHash)
     {
         if (strHash.IsNotNullAndWhiteSpace() && SegmentDelimiter.IsNotEmptyAndWhiteSpace())
@@ -59,27 +49,10 @@ public bool Verify(string password, string strHash)
         return false;
     }
 
-    /// <summary>
-    /// Determines whether a password meets the standard requirements for password validation, which are: it contains at least one character, has a length of at least 8, and contains at least one lowercase letter, one uppercase letter, one digit, and one special character.
-    /// </summary>
-    /// <param name="password">The password string to validate.</param>
-    /// <returns><see langword="true"/> if the password meets the standard requirements for password validation; otherwise, <see langword="false"/>.</returns>
     public static bool IsValidPasswordStandard(string password) => password.IsNotNullAndWhiteSpace() && password.Length >= 8 && new Regex(@"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^\da-zA-Z]).+$").IsMatch(password);
 
-    /// <summary>
-    /// Determines whether a password meets the requirements for password validation, which are: it contains at least one character, has a length of at least the specified value, and contains at least one lowercase letter, one uppercase letter, one digit, and one special character.
-    /// </summary>
-    /// <param name="password">The password string to validate.</param>
-    /// <param name="len">The minimum length for the password.</param>
-    /// <returns><see langword="true"/> if the password meets the requirements for password validation; otherwise, <see langword="false"/>.</returns>
     public static bool IsValidPassword<T>(string password, T len) where T : struct => password.IsNotNullAndWhiteSpace() && password.Length >= len.ToByte() && new Regex(@"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^\da-zA-Z]).+$").IsMatch(password);
 
-    /// <summary>
-    /// Determines whether a password meets the standard requirements for password validation, which are: it contains at least one character, has a length of at least 8, and contains at least one lowercase letter, one uppercase letter, one digit, and one special character, in addition to any specified additional special characters.
-    /// </summary>
-    /// <param name="password">The password string to validate.</param>
-    /// <param name="splChars">Additional special characters to require in the password.</param>
-    /// <returns><see langword="true"/> if the password meets the standard requirements for password validation; otherwise, <see langword="false"/>.</returns>
     public bool IsValidPassword(string password, params char[] splChars)
     {
         // has character
@@ -98,12 +71,6 @@ public bool IsValidPassword(string password, params char[] splChars)
         return IsMatch(password, $@"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[{Escape(new string(newPwdSplChar.ToArray()))}]).+$");
     }
 
-    /// <summary>
-    /// Determines whether a password meets the standard requirements for password validation, which are: it contains at least one character, has a length of at least 8, and contains at least one lowercase letter, one uppercase letter, one digit, and one special character, in addition to any specified additional special characters.
-    /// </summary>
-    /// <param name="password">The password string to validate.</param>
-    /// <param name="splChars">Additional special characters to require in the password.</param>
-    /// <returns><see langword="true"/> if the password meets the standard requirements for password validation; otherwise, <see langword="false"/>.</returns>
     public bool IsValidPassword(string password, IEnumerable<char> splChars)
     {
         // has character
@@ -122,13 +89,6 @@ public bool IsValidPassword(string password, IEnumerable<char> splChars)
         return IsMatch(password, $@"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[{Escape(new string(newPwdSplChar.ToArray()))}]).+$");
     }
 
-    /// <summary>
-    /// Determines whether a password meets the requirements for password validation, which are: it contains at least one character, has a length of at least the specified value, and contains at least one lowercase letter, one uppercase letter, one digit, and one special character, in addition to any specified additional special characters.
-    /// </summary>
-    /// <param name="password">The password string to validate.</param>
-    /// <param name="len">The minimum length for the password.</param>
-    /// <param name="splChars">Additional special characters to require in the password.</param>
-    /// <returns><see langword="true"/> if the password meets the requirements for password validation; otherwise, <see langword="false"/>.</returns>
     public bool IsValidPassword<T>(string password, T len, params char[] splChars) where T : struct
     {
         // has character
@@ -147,13 +107,6 @@ public bool IsValidPassword<T>(string password, T len, params char[] splChars) w
         return IsMatch(password, $@"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[{Escape(new string(newPwdSplChar.ToArray()))}]).+$");
     }
 
-    /// <summary>
-    /// Determines whether a password meets the requirements for password validation, which are: it contains at least one character, has a length of at least the specified value, and contains at least one lowercase letter, one uppercase letter, one digit, and one special character, in addition to any specified additional special characters.
-    /// </summary>
-    /// <param name="password">The password string to validate.</param>
-    /// <param name="len">The minimum length for the password.</param>
-    /// <param name="splChars">Additional special characters to require in the password.</param>
-    /// <returns><see langword="true"/> if the password meets the requirements for password validation; otherwise, <see langword="false"/>.</returns>
     public bool IsValidPassword<T>(string password, T len, IEnumerable<char> splChars) where T : struct
     {
         // has character
diff --git a/lib/YANLib/YANProcess.cs b/lib/YANLib/YANProcess.cs
index 50ae7b9f..6a095d35 100644
--- a/lib/YANLib/YANProcess.cs
+++ b/lib/YANLib/YANProcess.cs
@@ -5,12 +5,7 @@ namespace YANLib;
 
 public static partial class YANProcess
 {
-    /// <summary>
-    /// Asynchronously kills all running processes with the specified name by first attempting to close their main window, and if that fails, force-killing them.
-    /// After attempting to close the processes, this method waits for one second before force-killing any remaining processes to give them a chance to exit gracefully.
-    /// </summary>
-    /// <param name="name">The name of the processes to kill.</param>
-    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    
     public static async Task KillAllProcessesByName(this string name)
     {
         if (name.IsNotNullAndWhiteSpace())
@@ -26,12 +21,6 @@ await WhenAll(GetProcessesByName(name).Select(p =>
         }
     }
 
-    /// <summary>
-    /// Asynchronously kills all running processes with any of the specified names by first attempting to close their main window, and if that fails, force-killing them.
-    /// After attempting to close the processes, this method waits for one second before force-killing any remaining processes to give them a chance to exit gracefully.
-    /// </summary>
-    /// <param name="names">The names of the processes to kill.</param>
-    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     public static async Task KillAllProcessesByName(params string[] names)
     {
         if (names.IsNotNullAndWhiteSpace())
diff --git a/lib/YANLib/YANRandom.cs b/lib/YANLib/YANRandom.cs
index 9249d4bd..ced34920 100644
--- a/lib/YANLib/YANRandom.cs
+++ b/lib/YANLib/YANRandom.cs
@@ -2,29 +2,11 @@
 
 public static partial class YANRandom
 {
-    /// <summary>
-    /// Returns a random 32-bit signed integer value.
-    /// </summary>
-    /// <param name="rnd">The <see cref="Random"/> object.</param>
-    /// <returns>A 32-bit signed integer value between 0 and 2,147,483,647 (inclusive).</returns>
+    
     public static int NextInt32(this Random rnd) => rnd.Next(0, 1 << 4) << 28 | rnd.Next(0, 1 << 28);
 
-    /// <summary>
-    /// Returns the next random <see cref="decimal"/> value.
-    /// </summary>
-    /// <param name="rnd">The <see cref="Random"/> object.</param>
-    /// <returns>A random <see cref="decimal"/> value.</returns>
     public static decimal NextDecimal(this Random rnd) => new(rnd.NextInt32(), rnd.NextInt32(), rnd.NextInt32(), rnd.Next(2) is 1, (byte)rnd.Next(29));
 
-    /// <summary>
-    /// Returns a random <see cref="float"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="rnd">The <see cref="Random"/> object.</param>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="float"/> value between <paramref name="minValue"/> and <paramref name="maxValue"/>.</returns>
     public static float NextSingle<T1, T2>(this Random rnd, T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToFloat();
@@ -32,15 +14,6 @@ public static float NextSingle<T1, T2>(this Random rnd, T1 min, T2 max) where T1
         return minValue < maxValue ? rnd.NextSingle() * (maxValue - minValue) + minValue : minValue == maxValue ? minValue : default;
     }
 
-    /// <summary>
-    /// Returns a random <see cref="double"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="rnd">The <see cref="Random"/> object.</param>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="double"/> value between <paramref name="minValue"/> and <paramref name="maxValue"/>.</returns>
     public static double NextDouble<T1, T2>(this Random rnd, T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToDouble();
@@ -48,15 +21,6 @@ public static double NextDouble<T1, T2>(this Random rnd, T1 min, T2 max) where T
         return minValue < maxValue ? rnd.NextDouble() * (maxValue - minValue) + minValue : minValue == maxValue ? minValue : default;
     }
 
-    /// <summary>
-    /// Returns a random <see cref="decimal"/> value between <paramref name="min"/> and <paramref name="max"/>.
-    /// </summary>
-    /// <typeparam name="T1">The type of the minimum value, which must be a value type.</typeparam>
-    /// <typeparam name="T2">The type of the maximum value, which must be a value type.</typeparam>
-    /// <param name="rnd">The <see cref="Random"/> object.</param>
-    /// <param name="min">The minimum value.</param>
-    /// <param name="max">The maximum value.</param>
-    /// <returns>A random <see cref="decimal"/> value between <paramref name="minValue"/> and <paramref name="maxValue"/>.</returns>
     public static decimal NextDecimal<T1, T2>(this Random rnd, T1 min, T2 max) where T1 : struct where T2 : struct
     {
         var minValue = min.ToDecimal();
diff --git a/lib/YANLib/YANTask.cs b/lib/YANLib/YANTask.cs
index 72a19359..42834eba 100644
--- a/lib/YANLib/YANTask.cs
+++ b/lib/YANLib/YANTask.cs
@@ -5,28 +5,9 @@ namespace YANLib;
 
 public static partial class YANTask
 {
-    /// <summary>
-    /// Waits for any of the specified <see cref="ValueTask{TResult}"/> objects in an enumerable of <see cref="ValueTask{T}"/> to complete and returns a nullable <typeparamref name="T"/> result that matches the specified condition.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be returned, which must be a value type.</typeparam>
-    /// <param name="goodRslt">The value that the result of the completed task should match in order to be considered valid.</param>
-    /// <param name="tasks">An enumerable of <see cref="ValueTask{T}"/> objects to wait for.</param>
-    /// <returns>
-    /// A <see cref="ValueTask{TResult}"/> that represents the asynchronous operation.
-    /// The result of the operation is the <typeparamref name="T"/> value of the completed task that matches the specified condition, or <see langword="default"/> if no such task completed successfully.
-    /// </returns>
+    
     public static async ValueTask<T?> WaitAnyWithCondition<T>(T goodRslt, params ValueTask<T>[] tasks) where T : IComparable<T> => await tasks.WaitAnyWithCondition(goodRslt);
 
-    /// <summary>
-    /// Waits for any of the specified <see cref="ValueTask{TResult}"/> objects in an enumerable of <see cref="ValueTask{T}"/> to complete and returns a nullable <typeparamref name="T"/> result that matches the specified condition.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be returned, which must be a value type.</typeparam>
-    /// <param name="tasks">An enumerable of <see cref="ValueTask{T}"/> objects to wait for.</param>
-    /// <param name="goodRslt">The value that the result of the completed task should match in order to be considered valid.</param>
-    /// <returns>
-    /// A <see cref="ValueTask{TResult}"/> that represents the asynchronous operation.
-    /// The result of the operation is the <typeparamref name="T"/> value of the completed task that matches the specified condition, or <see langword="default"/> if no such task completed successfully.
-    /// </returns>
     public static async ValueTask<T?> WaitAnyWithCondition<T>(this IEnumerable<ValueTask<T>> tasks, T goodRslt) where T : IComparable<T>
     {
         if (tasks is not null && tasks.Any())
@@ -40,28 +21,8 @@ public static partial class YANTask
         return default;
     }
 
-    /// <summary>
-    /// Waits for any of the specified <see cref="Task{TResult}"/> objects in an enumerable of <see cref="Task{T}"/> to complete and returns a nullable <typeparamref name="T"/> result that matches the specified condition.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be returned, which must be a value type.</typeparam>
-    /// <param name="goodRslt">The value that the result of the completed task should match in order to be considered valid.</param>
-    /// <param name="tasks">An enumerable of <see cref="Task{T}"/> objects to wait for.</param>
-    /// <returns>
-    /// A <see cref="ValueTask{TResult}"/> that represents the asynchronous operation.
-    /// The result of the operation is the <typeparamref name="T"/> value of the completed task that matches the specified condition, or <see langword="default"/> if no such task completed successfully.
-    /// </returns>
     public static async ValueTask<T?> WaitAnyWithCondition<T>(T goodRslt, params Task<T>[] tasks) where T : IComparable<T> => await tasks.WaitAnyWithCondition(goodRslt);
 
-    /// <summary>
-    /// Waits for any of the specified <see cref="Task{TResult}"/> objects in an enumerable of <see cref="Task{T}"/> to complete and returns a nullable <typeparamref name="T"/> result that matches the specified condition.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be returned, which must be a value type.</typeparam>
-    /// <param name="tasks">An enumerable of <see cref="Task{T}"/> objects to wait for.</param>
-    /// <param name="goodRslt">The value that the result of the completed task should match in order to be considered valid.</param>
-    /// <returns>
-    /// A <see cref="ValueTask{TResult}"/> that represents the asynchronous operation.
-    /// The result of the operation is the <typeparamref name="T"/> value of the completed task that matches the specified condition, or <see langword="default"/> if no such task completed successfully.
-    /// </returns>
     public static async ValueTask<T?> WaitAnyWithCondition<T>(this IEnumerable<Task<T>> tasks, T goodRslt) where T : IComparable<T>
     {
         if (tasks is not null && tasks.Any())
@@ -72,28 +33,8 @@ public static partial class YANTask
         return default;
     }
 
-    /// <summary>
-    /// Waits for any of the specified <see cref="ValueTask{TResult}"/> objects in an enumerable of <see cref="ValueTask{T}"/> to complete and returns a nullable <typeparamref name="T"/> result that matches the specified condition.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be returned, which must be a value type.</typeparam>
-    /// <param name="goodRslt">The value that the result of the completed task should match in order to be considered valid.</param>
-    /// <param name="tasks">An enumerable of <see cref="ValueTask{T}"/> objects to wait for.</param>
-    /// <returns>
-    /// A <see cref="ValueTask{TResult}"/> that represents the asynchronous operation.
-    /// The result of the operation is the <typeparamref name="T"/> value of the completed task that matches the specified condition, or <see langword="default"/> if no such task completed successfully.
-    /// </returns>
     public static async ValueTask<T?> WhenAnyWithCondition<T>(T goodRslt, params ValueTask<T>[] tasks) where T : IComparable<T> => await tasks.WhenAnyWithCondition(goodRslt);
 
-    /// <summary>
-    /// Waits for any of the specified <see cref="ValueTask{TResult}"/> objects in an enumerable of <see cref="ValueTask{T}"/> to complete and returns a nullable <typeparamref name="T"/> result that matches the specified condition.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be returned, which must be a value type.</typeparam>
-    /// <param name="tasks">An enumerable of <see cref="ValueTask{T}"/> objects to wait for.</param>
-    /// <param name="goodRslt">The value that the result of the completed task should match in order to be considered valid.</param>
-    /// <returns>
-    /// A <see cref="ValueTask{TResult}"/> that represents the asynchronous operation.
-    /// The result of the operation is the <typeparamref name="T"/> value of the completed task that matches the specified condition, or <see langword="default"/> if no such task completed successfully.
-    /// </returns>
     public static async ValueTask<T?> WhenAnyWithCondition<T>(this IEnumerable<ValueTask<T>> tasks, T goodRslt) where T : IComparable<T>
     {
         if (tasks is not null && tasks.Any())
@@ -113,28 +54,8 @@ public static partial class YANTask
         return default;
     }
 
-    /// <summary>
-    /// Waits for any of the specified <see cref="Task{TResult}"/> objects in an enumerable of <see cref="Task{T}"/> to complete and returns a nullable <typeparamref name="T"/> result that matches the specified condition.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be returned, which must be a value type.</typeparam>
-    /// <param name="goodRslt">The value that the result of the completed task should match in order to be considered valid.</param>
-    /// <param name="tasks">An enumerable of <see cref="Task{T}"/> objects to wait for.</param>
-    /// <returns>
-    /// A <see cref="ValueTask{TResult}"/> that represents the asynchronous operation.
-    /// The result of the operation is the <typeparamref name="T"/> value of the completed task that matches the specified condition, or <see langword="default"/> if no such task completed successfully.
-    /// </returns>
     public static async ValueTask<T?> WhenAnyWithCondition<T>(T goodRslt, params Task<T>[] tasks) where T : IComparable<T> => await tasks.WhenAnyWithCondition(goodRslt);
 
-    /// <summary>
-    /// Waits for any of the specified <see cref="Task{TResult}"/> objects in an enumerable of <see cref="Task{T}"/> to complete and returns a nullable <typeparamref name="T"/> result that matches the specified condition.
-    /// </summary>
-    /// <typeparam name="T">The type of the value to be returned, which must be a value type.</typeparam>
-    /// <param name="tasks">An enumerable of <see cref="Task{T}"/> objects to wait for.</param>
-    /// <param name="goodRslt">The value that the result of the completed task should match in order to be considered valid.</param>
-    /// <returns>
-    /// A <see cref="ValueTask{TResult}"/> that represents the asynchronous operation.
-    /// The result of the operation is the <typeparamref name="T"/> value of the completed task that matches the specified condition, or <see langword="default"/> if no such task completed successfully.
-    /// </returns>
     public static async ValueTask<T?> WhenAnyWithCondition<T>(this IEnumerable<Task<T>> tasks, T goodRslt) where T : IComparable<T>
     {
         if (tasks is not null && tasks.Any())
diff --git a/lib/YANLib/YANText.Char.cs b/lib/YANLib/YANText.Char.cs
index a26fc893..ae7d2479 100644
--- a/lib/YANLib/YANText.Char.cs
+++ b/lib/YANLib/YANText.Char.cs
@@ -4,315 +4,93 @@ namespace YANLib;
 
 public static partial class YANText
 {
-    /// <summary>
-    /// Determines whether the specified character is the null character (<see cref="char.MinValue"/>).
-    /// </summary>
-    /// <param name="c">The character to check.</param>
-    /// <returns><see langword="true"/> if the character is the null character (<see cref="char.MinValue"/>); otherwise, <see langword="false"/>.</returns>
+    
     public static bool IsEmpty(this char c) => c is char.MinValue;
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable is <see langword="null"/> or <see cref="char.MinValue"/>.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable is <see langword="null"/> or <see cref="char.MinValue"/>; otherwise, <see langword="false"/>.</returns>
     public static bool IsEmpty(params char[] cs) => cs is not null && !cs.Any(c => c.IsNotEmpty());
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable is <see langword="null"/> or <see cref="char.MinValue"/>.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable is <see langword="null"/> or <see cref="char.MinValue"/>; otherwise, <see langword="false"/>.</returns>
     public static bool IsEmpty(this IEnumerable<char> cs) => cs is not null && !cs.Any(c => c.IsNotEmpty());
 
-    /// <summary>
-    /// Determines whether the specified character is a white space character, including space, tab, and line break characters.
-    /// </summary>
-    /// <param name="c">The character to check.</param>
-    /// <returns><see langword="true"/> if the character is a white space character; otherwise, <see langword="false"/>.</returns>
     public static bool IsWhiteSpace(this char c) => char.IsWhiteSpace(c);
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable is a white space character, including space, tab, and line break characters.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable is a white space character; otherwise, <see langword="false"/>.</returns>
     public static bool IsWhiteSpace(params char[] cs) => cs is not null && !cs.Any(c => c.IsNotWhiteSpace());
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable is a white space character, including space, tab, and line break characters.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable is a white space character; otherwise, <see langword="false"/>.</returns>
     public static bool IsWhiteSpace(this IEnumerable<char> cs) => cs is not null && !cs.Any(c => c.IsNotWhiteSpace());
 
-    /// <summary>
-    /// Determines whether the specified character is the null character (<see cref="char.MinValue"/>) or white space.
-    /// </summary>
-    /// <param name="c">The character to check.</param>
-    /// <returns><see langword="true"/> if the character is the null character (<see cref="char.MinValue"/>) or white space; otherwise, <see langword="false"/>.</returns>
     public static bool IsNullOrWhiteSpace(this char c) => c.IsEmpty() || c.IsWhiteSpace();
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable is <see langword="null"/> or <see cref="char.MinValue"/> or whitespace.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable is <see langword="null"/> or <see cref="char.MinValue"/> or whitespace; otherwise, <see langword="false"/>.</returns>
     public static bool IsNullOrWhiteSpace(params char[] cs) => cs is not null && !cs.Any(c => c.IsNotEmptyAndWhiteSpace());
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable is <see langword="null"/> or <see cref="char.MinValue"/> or whitespace.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable is <see langword="null"/> or <see cref="char.MinValue"/> or whitespace; otherwise, <see langword="false"/>.</returns>
     public static bool IsNullOrWhiteSpace(this IEnumerable<char> cs) => cs is not null && !cs.Any(c => c.IsNotEmptyAndWhiteSpace());
 
-    /// <summary>
-    /// Determines whether the specified character is an alphabetic character, which includes letters from any language, or is the null character (<see cref="char.MinValue"/>) or a white space character.
-    /// </summary>
-    /// <param name="c">The character to check.</param>
-    /// <returns><see langword="true"/> if the character is an alphabetic character, or is the null character (<see cref="char.MinValue"/>) or a white space character; otherwise, <see langword="false"/>.</returns>
     public static bool IsAlphabetic(this char c) => char.IsLetter(c);
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable is an alphabetic character, which includes letters from any language, or is <see langword="null"/>, or is the null character (<see cref="char.MinValue"/>), or is a white space character.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable is an alphabetic character, or is <see langword="null"/>, or is the null character (<see cref="char.MinValue"/>), or is a white space character; otherwise, <see langword="false"/>.</returns>
     public static bool IsAlphabetic(params char[] cs) => cs is not null && !cs.Any(c => c.IsNotAlphabetic());
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable is an alphabetic character, which includes letters from any language, or is <see langword="null"/>, or is the null character (<see cref="char.MinValue"/>), or is a white space character.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable is an alphabetic character, or is <see langword="null"/>, or is the null character (<see cref="char.MinValue"/>), or is a white space character; otherwise, <see langword="false"/>.</returns>
     public static bool IsAlphabetic(this IEnumerable<char> cs) => cs is not null && !cs.Any(c => c.IsNotAlphabetic());
 
-    /// <summary>
-    /// Determines whether the specified character is a punctuation character, such as period, comma, exclamation mark, etc., or is the null character (<see cref="char.MinValue"/>) or a white space character.
-    /// </summary>
-    /// <param name="c">The character to check.</param>
-    /// <returns><see langword="true"/> if the character is a punctuation character, or is the null character (<see cref="char.MinValue"/>) or a white space character; otherwise, <see langword="false"/>.</returns>
     public static bool IsPunctuation(this char c) => char.IsPunctuation(c);
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable is a punctuation character, such as period, comma, exclamation mark, etc., or is <see langword="null"/> or <see cref="char.MinValue"/> or whitespace.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable is a punctuation character, or is <see langword="null"/> or <see cref="char.MinValue"/> or whitespace; otherwise, <see langword="false"/>.</returns>
     public static bool IsPunctuation(params char[] cs) => cs is not null && !cs.Any(c => c.IsNotPunctuation());
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable is a punctuation character, such as period, comma, exclamation mark, etc., or is <see langword="null"/> or <see cref="char.MinValue"/> or whitespace.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable is a punctuation character, or is <see langword="null"/> or <see cref="char.MinValue"/> or whitespace; otherwise, <see langword="false"/>.</returns>
     public static bool IsPunctuation(this IEnumerable<char> cs) => cs is not null && !cs.Any(c => c.IsNotPunctuation());
 
-    /// <summary>
-    /// Determines whether the specified character is a numeric character, such as 0-9, or is the null character (<see cref="char.MinValue"/>) or a punctuation character, such as period, comma, exclamation mark, etc.
-    /// </summary>
-    /// <param name="c">The character to check.</param>
-    /// <returns><see langword="true"/> if the character is a numeric character, or is the null character (<see cref="char.MinValue"/>) or a punctuation character; otherwise, <see langword="false"/>.</returns>
     public static bool IsNumber(this char c) => char.IsDigit(c);
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable is a numeric character, such as 0-9, or is <see langword="null"/> or <see cref="char.MinValue"/> or whitespace, or is a punctuation character, such as period, comma, exclamation mark, etc.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable is a numeric character, or is <see langword="null"/> or <see cref="char.MinValue"/> or whitespace, or is a punctuation character; otherwise, <see langword="false"/>.</returns>
     public static bool IsNumber(params char[] cs) => cs is not null && !cs.Any(c => c.IsNotNumber());
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable is a numeric character, such as 0-9, or is <see langword="null"/> or <see cref="char.MinValue"/> or whitespace, or is a punctuation character, such as period, comma, exclamation mark, etc.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable is a numeric character, or is <see langword="null"/> or <see cref="char.MinValue"/> or whitespace, or is a punctuation character; otherwise, <see langword="false"/>.</returns>
     public static bool IsNumber(this IEnumerable<char> cs) => cs is not null && !cs.Any(c => c.IsNotNumber());
 
-    /// <summary>
-    /// Determines whether the specified characters are equal, comparing their Unicode values.
-    /// </summary>
-    /// <param name="c1">The first character to compare.</param>
-    /// <param name="c2">The second character to compare.</param>
-    /// <returns><see langword="true"/> if the characters are equal, comparing their Unicode values; otherwise, <see langword="false"/>.</returns>
     public static bool Equals(this char c1, char c2) => c1 == c2;
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable are equal to the first character in the enumerable, comparing their Unicode values.
-    /// </summary>
-    /// <param name="cs">The characters to compare.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable are equal to the first character in the enumerable, comparing their Unicode values; otherwise, <see langword="false"/>.</returns>
     public static bool Equals(params char[] cs) => cs is not null && !cs.Any(s => s.NotEquals(cs[0]));
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable are equal to the first character in the enumerable, comparing their Unicode values.
-    /// </summary>
-    /// <param name="cs">The characters to compare.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable are equal to the first character in the enumerable, comparing their Unicode values; otherwise, <see langword="false"/>.</returns>
     public static bool Equals(this IEnumerable<char> cs) => cs is not null && !cs.Any(s => s.NotEquals(cs.First()));
 
-    /// <summary>
-    /// Determines whether the specified characters are equal, ignoring their casing, and comparing their Unicode values.
-    /// </summary>
-    /// <param name="c1">The first character to compare.</param>
-    /// <param name="c2">The second character to compare.</param>
-    /// <returns><see langword="true"/> if the characters are equal, ignoring their casing, and comparing their Unicode values; otherwise, <see langword="false"/>.</returns>
     public static bool EqualsIgnoreCase(this char c1, char c2) => c1.ToLowerInvariant() == c2.ToLowerInvariant();
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable are equal to the first character in the enumerable, ignoring their casing, and comparing their Unicode values.
-    /// </summary>
-    /// <param name="cs">The characters to compare.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable are equal to the first character in the enumerable, ignoring their casing, and comparing their Unicode values; otherwise, <see langword="false"/>.</returns>
     public static bool EqualsIgnoreCase(params char[] cs) => cs is not null && !cs.Any(s => s.NotEqualsIgnoreCase(cs[0]));
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable are equal to the first character in the enumerable, ignoring their casing, and comparing their Unicode values.
-    /// </summary>
-    /// <param name="cs">The characters to compare.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable are equal to the first character in the enumerable, ignoring their casing, and comparing their Unicode values; otherwise, <see langword="false"/>.</returns>
     public static bool EqualsIgnoreCase(this IEnumerable<char> cs) => cs is not null && !cs.Any(s => s.NotEqualsIgnoreCase(cs.First()));
 
-    /// <summary>
-    /// Determines whether the specified character is not the null character (<see cref="char.MinValue"/>).
-    /// </summary>
-    /// <param name="c">The character to check.</param>
-    /// <returns><see langword="true"/> if the character is not the null character (<see cref="char.MinValue"/>); otherwise, <see langword="false"/>.</returns>
     public static bool IsNotEmpty(this char c) => c is not char.MinValue;
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable is not <see langword="null"/> and not <see cref="char.MinValue"/>.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable is not <see langword="null"/> and not <see cref="char.MinValue"/>; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotEmpty(params char[] cs) => cs is not null && !cs.Any(c => c.IsEmpty());
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable is not <see langword="null"/> and not <see cref="char.MinValue"/>.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable is not <see langword="null"/> and not <see cref="char.MinValue"/>; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotEmpty(this IEnumerable<char> cs) => cs is not null && !cs.Any(c => c.IsEmpty());
 
-    /// <summary>
-    /// Determines whether the specified character is not a whitespace character, including space, tab, newline, carriage return, form feed, or vertical tab.
-    /// </summary>
-    /// <param name="c">The character to check.</param>
-    /// <returns><see langword="true"/> if the character is not a whitespace character; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotWhiteSpace(this char c) => !char.IsWhiteSpace(c);
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable is not a whitespace character, including space, tab, newline, carriage return, form feed, or vertical tab.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable is not a whitespace character; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotWhiteSpace(params char[] cs) => cs is not null && !cs.Any(c => c.IsWhiteSpace());
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable is not a whitespace character, including space, tab, newline, carriage return, form feed, or vertical tab.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable is not a whitespace character; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotWhiteSpace(this IEnumerable<char> cs) => cs is not null && !cs.Any(c => c.IsWhiteSpace());
 
-    /// <summary>
-    /// Determines whether the specified character is not the null character (<see cref="char.MinValue"/>) and is not a whitespace character.
-    /// </summary>
-    /// <param name="c">The character to check.</param>
-    /// <returns><see langword="true"/> if the character is not the null character (<see cref="char.MinValue"/>) and is not a whitespace character; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotEmptyAndWhiteSpace(this char c) => c.IsNotEmpty() && c.IsNotWhiteSpace();
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable is not a white-space character or <see cref="char.MinValue"/>.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable is not a white-space character or <see cref="char.MinValue"/>; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotEmptyAndWhiteSpace(params char[] cs) => cs is not null && !cs.Any(c => c.IsNullOrWhiteSpace());
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable is not a white-space character or <see cref="char.MinValue"/>.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable is not a white-space character or <see cref="char.MinValue"/>; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotEmptyAndWhiteSpace(this IEnumerable<char> cs) => cs is not null && !cs.Any(c => c.IsNullOrWhiteSpace());
 
-    /// <summary>
-    /// Determines whether the specified character is not an alphabetic character and is not the null character (<see cref="char.MinValue"/>) and is not a whitespace character.
-    /// </summary>
-    /// <param name="c">The character to check.</param>
-    /// <returns><see langword="true"/> if the character is not an alphabetic character and is not the null character (<see cref="char.MinValue"/>) and is not a whitespace character; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotAlphabetic(this char c) => !char.IsLetter(c);
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable is not an alphabetic character, not a white-space character, or not <see cref="char.MinValue"/>.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable is not an alphabetic character, not a white-space character, or not <see cref="char.MinValue"/>; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotAlphabetic(params char[] cs) => cs is not null && !cs.Any(c => c.IsAlphabetic());
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable is not an alphabetic character, not a white-space character, or not <see cref="char.MinValue"/>.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable is not an alphabetic character, not a white-space character, or not <see cref="char.MinValue"/>; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotAlphabetic(this IEnumerable<char> cs) => cs is not null && !cs.Any(c => c.IsAlphabetic());
 
-    /// <summary>
-    /// Determines whether the specified character is not a punctuation character, not an alphabetic character, not the null character (<see cref="char.MinValue"/>), and not a whitespace character.
-    /// </summary>
-    /// <param name="c">The character to check.</param>
-    /// <returns><see langword="true"/> if the character is not a punctuation character, not an alphabetic character, not the null character (<see cref="char.MinValue"/>), and not a whitespace character; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotPunctuation(this char c) => !char.IsPunctuation(c);
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable is not a punctuation character, not an alphabetic character, not a white-space character, or not <see cref="char.MinValue"/>.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable is not a punctuation character, not an alphabetic character, not a white-space character, or not <see cref="char.MinValue"/>; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotPunctuation(params char[] cs) => cs is not null && !cs.Any(c => c.IsPunctuation());
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable is not a punctuation character, not an alphabetic character, not a white-space character, or not <see cref="char.MinValue"/>.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable is not a punctuation character, not an alphabetic character, not a white-space character, or not <see cref="char.MinValue"/>; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotPunctuation(this IEnumerable<char> cs) => cs is not null && !cs.Any(c => c.IsPunctuation());
 
-    /// <summary>
-    /// Determines whether the specified character is not a numeric character, not a punctuation character, not an alphabetic character, not the null character (<see cref="char.MinValue"/>), and not a whitespace character.
-    /// </summary>
-    /// <param name="c">The character to check.</param>
-    /// <returns><see langword="true"/> if the character is not a numeric character, not a punctuation character, not an alphabetic character, not the null character (<see cref="char.MinValue"/>), and not a whitespace character; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotNumber(this char c) => !char.IsDigit(c);
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable is not a numeric character, not a punctuation character, not an alphabetic character, not a white-space character, or not <see cref="char.MinValue"/>.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable is not a numeric character, not a punctuation character, not an alphabetic character, not a white-space character, or not <see cref="char.MinValue"/>; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotNumber(params char[] cs) => cs is not null && !cs.Any(c => c.IsNumber());
 
-    /// <summary>
-    /// Determines whether any of the specified characters in the enumerable is not a numeric character, not a punctuation character, not an alphabetic character, not a white-space character, or not <see cref="char.MinValue"/>.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if any of the characters in the enumerable is not a numeric character, not a punctuation character, not an alphabetic character, not a white-space character, or not <see cref="char.MinValue"/>; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotNumber(this IEnumerable<char> cs) => cs is not null && !cs.Any(c => c.IsNumber());
 
-    /// <summary>
-    /// Determines whether two specified characters are not equal, based on their Unicode values.
-    /// </summary>
-    /// <param name="c1">The first character to compare.</param>
-    /// <param name="c2">The second character to compare.</param>
-    /// <returns><see langword="true"/> if the two characters are not equal, based on their Unicode values; otherwise, <see langword="false"/>.</returns>
     public static bool NotEquals(this char c1, char c2) => c1 != c2;
 
-    /// <summary>
-    /// Determines whether all the characters in the specified enumerable are distinct, based on their Unicode values.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if all the characters in the specified enumerable are distinct, based on their Unicode values; otherwise, <see langword="false"/>.</returns>
     public static bool NotEquals(params char[] cs)
     {
         if (cs is null || cs.Length < 2)
@@ -330,11 +108,6 @@ public static bool NotEquals(params char[] cs)
         return true;
     }
 
-    /// <summary>
-    /// Determines whether all the characters in the specified enumerable are distinct, based on their Unicode values.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if all the characters in the specified enumerable are distinct, based on their Unicode values; otherwise, <see langword="false"/>.</returns>
     public static bool NotEquals(this IEnumerable<char> cs)
     {
         if (cs is null || cs.Count() < 2)
@@ -352,19 +125,8 @@ public static bool NotEquals(this IEnumerable<char> cs)
         return true;
     }
 
-    /// <summary>
-    /// Determines whether two specified characters are not equal, ignoring their casing, based on their Unicode values.
-    /// </summary>
-    /// <param name="c1">The first character to compare.</param>
-    /// <param name="c2">The second character to compare.</param>
-    /// <returns><see langword="true"/> if the two characters are not equal, ignoring their casing, based on their Unicode values; otherwise, <see langword="false"/>.</returns>
     public static bool NotEqualsIgnoreCase(this char c1, char c2) => c1.ToLowerInvariant() != c2.ToLowerInvariant();
 
-    /// <summary>
-    /// Determines whether all the characters in the specified enumerable are distinct, ignoring their casing, based on their Unicode values.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if all the characters in the specified enumerable are distinct, ignoring their casing, based on their Unicode values; otherwise, <see langword="false"/>.</returns>
     public static bool NotEqualsIgnoreCase(params char[] cs)
     {
         if (cs is null || cs.Length < 2)
@@ -382,11 +144,6 @@ public static bool NotEqualsIgnoreCase(params char[] cs)
         return true;
     }
 
-    /// <summary>
-    /// Determines whether all the characters in the specified enumerable are distinct, ignoring their casing, based on their Unicode values.
-    /// </summary>
-    /// <param name="cs">The characters to check.</param>
-    /// <returns><see langword="true"/> if all the characters in the specified enumerable are distinct, ignoring their casing, based on their Unicode values; otherwise, <see langword="false"/>.</returns>
     public static bool NotEqualsIgnoreCase(this IEnumerable<char> cs)
     {
         if (cs is null || cs.Count() < 2)
@@ -404,43 +161,18 @@ public static bool NotEqualsIgnoreCase(this IEnumerable<char> cs)
         return true;
     }
 
-    /// <summary>
-    /// Returns the non-null character value or <see cref="char.MinValue"/> if it is <see langword="null"/> or empty.
-    /// </summary>
-    /// <param name="c">The character to retrieve the value from.</param>
-    /// <returns>The non-null character value or <see cref="char.MinValue"/> if it is <see langword="null"/> or empty.</returns>
     public static char GetValue(this char c) => c.IsEmpty() ? char.MinValue : c;
 
-    /// <summary>
-    /// Returns the non-null character value or the default value if it is <see langword="null"/>.
-    /// </summary>
-    /// <param name="c">The character to retrieve the value from.</param>
-    /// <param name="dfltVal">The default value to return if the character is <see langword="null"/>.</param>
-    /// <returns>The non-null character value or the default value if it is <see langword="null"/>.</returns>
     public static char GetValue(this char c, char dfltVal) => c.IsEmpty() ? dfltVal : c;
 
-    /// <summary>
-    /// Generates a random lowercase character from the English alphabet.
-    /// </summary>
-    /// <returns>A randomly generated lowercase character from the English alphabet.</returns>
     public static char GenerateRandomCharacter()
     {
         var chars = "abcdefghijklmnopqrstuvwxyz";
         return chars[GenerateRandomByte(chars.Length)];
     }
 
-    /// <summary>
-    /// Converts the character to lowercase if it is not empty or whitespace; otherwise, returns the original character.
-    /// </summary>
-    /// <param name="c">The character to convert to lowercase.</param>
-    /// <returns>The lowercase version of the character if it is not empty or whitespace; otherwise, the original character.</returns>
     public static char ToLower(this char c) => c.IsNotEmptyAndWhiteSpace() ? char.ToLower(c) : c;
 
-    /// <summary>
-    /// Enumerates through an enumerable of characters and returns a new enumerable of characters converted to lowercase, ignoring their casing, based on their Unicode values.
-    /// </summary>
-    /// <param name="cs">The characters to convert to lowercase.</param>
-    /// <returns>An enumerable of characters converted to lowercase, ignoring their casing, based on their Unicode values.</returns>
     public static IEnumerable<char> ToLower(this IEnumerable<char> cs)
     {
         if (cs is null || !cs.Any())
@@ -453,10 +185,6 @@ public static IEnumerable<char> ToLower(this IEnumerable<char> cs)
         }
     }
 
-    /// <summary>
-    /// Converts the characters in the specified list to lowercase, ignoring their casing, based on their Unicode values.
-    /// </summary>
-    /// <param name="cs">The list of characters to convert to lowercase.</param>
     public static void ToLower(this IList<char> cs)
     {
         if (cs is not null && cs.Count > 0)
@@ -468,18 +196,8 @@ public static void ToLower(this IList<char> cs)
         }
     }
 
-    /// <summary>
-    /// Converts the character to lowercase using the invariant culture, if it is not empty or whitespace; otherwise, returns the original character.
-    /// </summary>
-    /// <param name="c">The character to convert to lowercase.</param>
-    /// <returns>The lowercase version of the character using the invariant culture if it is not empty or whitespace; otherwise, the original character.</returns>
     public static char ToLowerInvariant(this char c) => c.IsNotEmptyAndWhiteSpace() ? char.ToLowerInvariant(c) : c;
 
-    /// <summary>
-    /// Enumerates through an enumerable of characters and returns a new enumerable of characters converted to lowercase, ignoring their casing, based on their Unicode values using the invariant culture.
-    /// </summary>
-    /// <param name="cs">The characters to convert to lowercase.</param>
-    /// <returns>An enumerable of characters converted to lowercase, ignoring their casing, based on their Unicode values using the invariant culture.</returns>
     public static IEnumerable<char> ToLowerInvariant(this IEnumerable<char> cs)
     {
         if (cs is null || !cs.Any())
@@ -492,10 +210,6 @@ public static IEnumerable<char> ToLowerInvariant(this IEnumerable<char> cs)
         }
     }
 
-    /// <summary>
-    /// Converts all characters in the specified character list to lowercase using the invariant culture, by modifying the list in-place.
-    /// </summary>
-    /// <param name="cs">The character list to convert to lowercase.</param>
     public static void ToLowerInvariant(this IList<char> cs)
     {
         if (cs is not null && cs.Count > 0)
@@ -507,18 +221,8 @@ public static void ToLowerInvariant(this IList<char> cs)
         }
     }
 
-    /// <summary>
-    /// Converts the character to uppercase using the invariant culture, if it is not empty or whitespace; otherwise, returns the original character.
-    /// </summary>
-    /// <param name="c">The character to convert to uppercase.</param>
-    /// <returns>The uppercase version of the character using the invariant culture if it is not empty or whitespace; otherwise, the original character.</returns>
     public static char ToUpper(this char c) => c.IsNotEmptyAndWhiteSpace() ? char.ToUpper(c) : c;
 
-    /// <summary>
-    /// Enumerates through an enumerable of characters and returns a new enumerable of characters converted to uppercase, ignoring their casing, based on their Unicode values using the invariant culture.
-    /// </summary>
-    /// <param name="cs">The characters to convert to uppercase.</param>
-    /// <returns>An enumerable of characters converted to uppercase, ignoring their casing, based on their Unicode values using the invariant culture.</returns>
     public static IEnumerable<char> ToUpper(this IEnumerable<char> cs)
     {
         if (cs is null || !cs.Any())
@@ -531,10 +235,6 @@ public static IEnumerable<char> ToUpper(this IEnumerable<char> cs)
         }
     }
 
-    /// <summary>
-    /// Converts all characters in the specified character list to uppercase, by modifying the list in-place.
-    /// </summary>
-    /// <param name="cs">The character list to convert to uppercase.</param>
     public static void ToUpper(this IList<char> cs)
     {
         if (cs is not null && cs.Count > 0)
@@ -546,18 +246,8 @@ public static void ToUpper(this IList<char> cs)
         }
     }
 
-    /// <summary>
-    /// Converts the character to uppercase using the invariant culture, if it is not empty or whitespace; otherwise, returns the original character.
-    /// </summary>
-    /// <param name="c">The character to convert to uppercase.</param>
-    /// <returns>The uppercase version of the character using the invariant culture if it is not empty or whitespace; otherwise, the original character.</returns>
     public static char ToUpperInvariant(this char c) => c.IsNotEmptyAndWhiteSpace() ? char.ToUpperInvariant(c) : c;
 
-    /// <summary>
-    /// Enumerates through an enumerable of characters and returns a new enumerable of characters converted to uppercase, ignoring their casing, based on their Unicode values using the invariant culture.
-    /// </summary>
-    /// <param name="cs">The characters to convert to uppercase.</param>
-    /// <returns>An enumerable of characters converted to uppercase, ignoring their casing, based on their Unicode values using the invariant culture.</returns>
     public static IEnumerable<char> ToUpperInvariant(this IEnumerable<char> cs)
     {
         if (cs is null || !cs.Any())
@@ -570,10 +260,6 @@ public static IEnumerable<char> ToUpperInvariant(this IEnumerable<char> cs)
         }
     }
 
-    /// <summary>
-    /// Converts all characters in the specified character list to uppercase using the invariant culture, by modifying the list in-place.
-    /// </summary>
-    /// <param name="cs">The character list to convert to uppercase.</param>
     public static void ToUpperInvariant(this IList<char> cs)
     {
         if (cs is not null && cs.Count > 0)
diff --git a/lib/YANLib/YANText.String.cs b/lib/YANLib/YANText.String.cs
index 962ce4c9..ad3b952b 100644
--- a/lib/YANLib/YANText.String.cs
+++ b/lib/YANLib/YANText.String.cs
@@ -1,193 +1,62 @@
 using System.Globalization;
 using static System.StringComparison;
+using static System.Globalization.CultureInfo;
 
 namespace YANLib;
 
 public static partial class YANText
 {
-    /// <summary>
-    /// Determines whether the specified string is <see langword="null"/>.
-    /// </summary>
-    /// <param name="str">The string to check.</param>
-    /// <returns><see langword="true"/> if the string is <see langword="null"/>; otherwise, <see langword="false"/>.</returns>
+    
     public static bool IsNull(this string str) => str is null;
 
-    /// <summary>
-    /// Determines whether any of the specified strings in the enumerable is <see langword="null"/>.
-    /// </summary>
-    /// <param name="strs">The strings to check.</param>
-    /// <returns><see langword="true"/> if any of the strings in the enumerable is <see langword="null"/>; otherwise, <see langword="false"/>.</returns>
     public static bool IsNull(params string[] strs) => strs is not null && !strs.Any(s => s.IsNotNull());
 
-    /// <summary>
-    /// Determines whether any of the specified strings in the enumerable is <see langword="null"/>.
-    /// </summary>
-    /// <param name="strs">The strings to check.</param>
-    /// <returns><see langword="true"/> if any of the strings in the enumerable is <see langword="null"/>; otherwise, <see langword="false"/>.</returns>
     public static bool IsNull(this IEnumerable<string> strs) => strs is not null && !strs.Any(s => s.IsNotNull());
 
-    /// <summary>
-    /// Determines whether the specified string is <see langword="null"/> or <see cref="string.Empty"/>.
-    /// </summary>
-    /// <param name="str">The string to check.</param>
-    /// <returns><see langword="true"/> if the string is <see langword="null"/> or <see cref="string.Empty"/>; otherwise, <see langword="false"/>.</returns>
     public static bool IsNullOrEmpty(this string str) => string.IsNullOrEmpty(str);
 
-    /// <summary>
-    /// Determines whether any of the specified strings in the enumerable is <see langword="null"/> or <see cref="string.Empty"/>.
-    /// </summary>
-    /// <param name="strs">The strings to check.</param>
-    /// <returns><see langword="true"/> if any of the strings in the enumerable is <see langword="null"/> or <see cref="string.Empty"/>; otherwise, <see langword="false"/>.</returns>
     public static bool IsNullOrEmpty(params string[] strs) => strs is not null && !strs.Any(s => s.IsNotNullAndEmpty());
 
-    /// <summary>
-    /// Determines whether any of the specified strings in the enumerable is <see langword="null"/> or <see cref="string.Empty"/>.
-    /// </summary>
-    /// <param name="strs">The strings to check.</param>
-    /// <returns><see langword="true"/> if any of the strings in the enumerable is <see langword="null"/> or <see cref="string.Empty"/>; otherwise, <see langword="false"/>.</returns>
     public static bool IsNullOrEmpty(this IEnumerable<string> strs) => strs is not null && !strs.Any(s => s.IsNotNullAndEmpty());
 
-    /// <summary>
-    /// Determines whether the specified string is <see langword="null"/>, <see cref="string.Empty"/>, or consists only of white-space characters.
-    /// </summary>
-    /// <param name="str">The string to check.</param>
-    /// <returns><see langword="true"/> if the string is <see langword="null"/>, <see cref="string.Empty"/>, or consists only of white-space characters; otherwise, <see langword="false"/>.</returns>
     public static bool IsNullOrWhiteSpace(this string str) => string.IsNullOrWhiteSpace(str);
 
-    /// <summary>
-    /// Determines whether any of the specified strings in the enumerable is <see langword="null"/>, <see cref="string.Empty"/>, or consists only of white-space characters.
-    /// </summary>
-    /// <param name="strs">The strings to check.</param>
-    /// <returns><see langword="true"/> if any of the strings in the enumerable is <see langword="null"/>, <see cref="string.Empty"/>, or consists only of white-space characters; otherwise, <see langword="false"/>.</returns>
     public static bool IsNullOrWhiteSpace(params string[] strs) => strs is not null && !strs.Any(s => s.IsNotNullAndWhiteSpace());
 
-    /// <summary>
-    /// Determines whether any of the specified strings in the enumerable is <see langword="null"/>, <see cref="string.Empty"/>, or consists only of white-space characters.
-    /// </summary>
-    /// <param name="strs">The strings to check.</param>
-    /// <returns><see langword="true"/> if any of the strings in the enumerable is <see langword="null"/>, <see cref="string.Empty"/>, or consists only of white-space characters; otherwise, <see langword="false"/>.</returns>
     public static bool IsNullOrWhiteSpace(this IEnumerable<string> strs) => strs is not null && !strs.Any(s => s.IsNotNullAndWhiteSpace());
 
-    /// <summary>
-    /// Determines whether the specified strings are equal, comparing their values.
-    /// </summary>
-    /// <param name="str1">The first string to compare.</param>
-    /// <param name="str2">The second string to compare.</param>
-    /// <returns><see langword="true"/> if the strings are equal, comparing their values; otherwise, <see langword="false"/>.</returns>
     public static bool Equals(this string str1, string str2) => str1 == str2;
 
-    /// <summary>
-    /// Determines whether any of the specified strings in the enumerable are equal to the first string in the enumerable, comparing their values.
-    /// </summary>
-    /// <param name="strs">The strings to compare.</param>
-    /// <returns><see langword="true"/> if any of the strings in the enumerable are equal to the first string in the enumerable, comparing their values; otherwise, <see langword="false"/>.</returns>
     public static bool Equals(params string[] strs) => strs is not null && !strs.Any(s => s.NotEquals(strs[0]));
 
-    /// <summary>
-    /// Determines whether any of the specified strings in the enumerable are equal to the first string in the enumerable, comparing their values.
-    /// </summary>
-    /// <param name="strs">The strings to compare.</param>
-    /// <returns><see langword="true"/> if any of the strings in the enumerable are equal to the first string in the enumerable, comparing their values; otherwise, <see langword="false"/>.</returns>
     public static bool Equals(this IEnumerable<string> strs) => strs is not null && !strs.Any(s => s.NotEquals(strs.First()));
 
-    /// <summary>
-    /// Determines whether the specified strings are equal, ignoring their casing, and comparing their values using ordinal comparison.
-    /// </summary>
-    /// <param name="str1">The first string to compare.</param>
-    /// <param name="str2">The second string to compare.</param>
-    /// <returns><see langword="true"/> if the strings are equal, ignoring their casing, and comparing their values using ordinal comparison; otherwise, <see langword="false"/>.</returns>
     public static bool EqualsIgnoreCase(this string str1, string str2) => IsNull(str1, str2) || str1.IsNotNull() && str1.IsNotNull() && string.Equals(str1, str2, OrdinalIgnoreCase);
 
-    /// <summary>
-    /// Determines whether the specified strings are equal, ignoring their casing, and comparing their values using ordinal comparison.
-    /// </summary>
-    /// <param name="strs">The strings to compare.</param>
-    /// <returns><see langword="true"/> if any of the strings in the enumerable are equal to the first string in the enumerable, ignoring their casing, and comparing their values using ordinal comparison; otherwise, <see langword="false"/>.</returns>
     public static bool EqualsIgnoreCase(params string[] strs) => strs is not null && !strs.Any(s => s.NotEqualsIgnoreCase(strs[0]));
 
-    /// <summary>
-    /// Determines whether the specified strings are equal, ignoring their casing, and comparing their values using ordinal comparison.
-    /// </summary>
-    /// <param name="strs">The strings to compare.</param>
-    /// <returns><see langword="true"/> if any of the strings in the enumerable are equal to the first string in the enumerable, ignoring their casing, and comparing their values using ordinal comparison; otherwise, <see langword="false"/>.</returns>
     public static bool EqualsIgnoreCase(this IEnumerable<string> strs) => strs is not null && !strs.Any(s => s.NotEqualsIgnoreCase(strs.First()));
 
-    /// <summary>
-    /// Determines whether the specified string is not <see langword="null"/>.
-    /// </summary>
-    /// <param name="str">The string to check.</param>
-    /// <returns><see langword="true"/> if the string is not <see langword="null"/>; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotNull(this string str) => str is not null;
 
-    /// <summary>
-    /// Determines whether the specified strings are not <see langword="null"/>.
-    /// </summary>
-    /// <param name="strs">The strings to check.</param>
-    /// <returns><see langword="true"/> if all the strings in the enumerable are not <see langword="null"/>; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotNull(params string[] strs) => strs is not null && !strs.Any(s => s.IsNull());
 
-    /// <summary>
-    /// Determines whether the specified strings are not <see langword="null"/>.
-    /// </summary>
-    /// <param name="strs">The strings to check.</param>
-    /// <returns><see langword="true"/> if all the strings in the enumerable are not <see langword="null"/>; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotNull(this IEnumerable<string> strs) => strs is not null && !strs.Any(s => s.IsNull());
 
-    /// <summary>
-    /// Determines whether the specified string is not <see langword="null"/> or <see cref="string.Empty"/>.
-    /// </summary>
-    /// <param name="str">The string to check.</param>
-    /// <returns><see langword="true"/> if the string is not <see langword="null"/> or <see cref="string.Empty"/>; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotNullAndEmpty(this string str) => !string.IsNullOrEmpty(str);
 
-    /// <summary>
-    /// Determines whether any of the specified strings is not <see langword="null"/> or <see cref="string.Empty"/>.
-    /// </summary>
-    /// <param name="strs">The strings to check.</param>
-    /// <returns><see langword="true"/> if any of the strings is not <see langword="null"/> or <see cref="string.Empty"/>; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotNullAndEmpty(params string[] strs) => strs is not null && !strs.Any(s => s.IsNullOrEmpty());
 
-    /// <summary>
-    /// Determines whether any of the specified strings in the enumerable is not <see langword="null"/> or <see cref="string.Empty"/>.
-    /// </summary>
-    /// <param name="strs">The strings to check.</param>
-    /// <returns><see langword="true"/> if any of the strings in the enumerable is not <see langword="null"/> or <see cref="string.Empty"/>; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotNullAndEmpty(this IEnumerable<string> strs) => strs is not null && !strs.Any(s => s.IsNullOrEmpty());
 
-    /// <summary>
-    /// Determines whether the specified string is not <see langword="null"/>, <see cref="string.Empty"/>, or consists only of whitespace characters.
-    /// </summary>
-    /// <param name="str">The string to check.</param>
-    /// <returns><see langword="true"/> if the string is not <see langword="null"/>, <see cref="string.Empty"/>, or consists only of whitespace characters; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotNullAndWhiteSpace(this string str) => !string.IsNullOrWhiteSpace(str);
 
-    /// <summary>
-    /// Determines whether all the specified strings are not <see langword="null"/>, <see cref="string.Empty"/>, or consist only of whitespace characters.
-    /// </summary>
-    /// <param name="strs">The strings to check.</param>
-    /// <returns><see langword="true"/> if all the strings are not <see langword="null"/>, <see cref="string.Empty"/>, or consist only of whitespace characters; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotNullAndWhiteSpace(params string[] strs) => strs is not null && !strs.Any(s => s.IsNullOrWhiteSpace());
 
-    /// <summary>
-    /// Determines whether all the specified strings in the enumerable are not <see langword="null"/>, <see cref="string.Empty"/>, or consist only of whitespace characters.
-    /// </summary>
-    /// <param name="strs">The strings to check.</param>
-    /// <returns><see langword="true"/> if all the strings in the enumerable are not <see langword="null"/>, <see cref="string.Empty"/>, or consist only of whitespace characters; otherwise, <see langword="false"/>.</returns>
     public static bool IsNotNullAndWhiteSpace(this IEnumerable<string> strs) => strs is not null && !strs.Any(s => s.IsNullOrWhiteSpace());
 
-    /// <summary>
-    /// Determines whether two specified strings are not equal, based on their values.
-    /// </summary>
-    /// <param name="str1">The first string to compare.</param>
-    /// <param name="str2">The second string to compare.</param>
-    /// <returns><see langword="true"/> if the two strings are not equal, based on their values; otherwise, <see langword="false"/>.</returns>
     public static bool NotEquals(this string str1, string str2) => str1 != str2;
 
-    /// <summary>
-    /// Determines whether all the strings in the specified enumerable are distinct, based on their values.
-    /// </summary>
-    /// <param name="strs">The strings to check.</param>
-    /// <returns><see langword="true"/> if all the strings in the specified enumerable are distinct, based on their values; otherwise, <see langword="false"/>.</returns>
     public static bool NotEquals(params string[] strs)
     {
         if (strs is null || strs.Length < 2)
@@ -205,11 +74,6 @@ public static bool NotEquals(params string[] strs)
         return true;
     }
 
-    /// <summary>
-    /// Determines whether all the strings in the specified enumerable are distinct, based on their values.
-    /// </summary>
-    /// <param name="strs">The strings to check.</param>
-    /// <returns><see langword="true"/> if all the strings in the specified enumerable are distinct, based on their values; otherwise, <see langword="false"/>.</returns>
     public static bool NotEquals(this IEnumerable<string> strs)
     {
         if (strs is null || strs.Count() < 2)
@@ -227,19 +91,8 @@ public static bool NotEquals(this IEnumerable<string> strs)
         return true;
     }
 
-    /// <summary>
-    /// Determines whether two specified strings are not equal, ignoring their casing, based on their values using ordinal comparison.
-    /// </summary>
-    /// <param name="str1">The first string to compare.</param>
-    /// <param name="str2">The second string to compare.</param>
-    /// <returns><see langword="true"/> if the two strings are not equal, ignoring their casing, based on their values using ordinal comparison; otherwise, <see langword="false"/>.</returns>
     public static bool NotEqualsIgnoreCase(this string str1, string str2) => IsNotNull(str1, str2) && !string.Equals(str1, str2, OrdinalIgnoreCase);
 
-    /// <summary>
-    /// Determines whether all the strings in the specified enumerable are distinct, ignoring their casing, based on their values using ordinal comparison.
-    /// </summary>
-    /// <param name="strs">The strings to check.</param>
-    /// <returns><see langword="true"/> if all the strings in the specified enumerable are distinct, ignoring their casing, based on their values using ordinal comparison; otherwise, <see langword="false"/>.</returns>
     public static bool NotEqualsIgnoreCase(params string[] strs)
     {
         if (strs is null || strs.Length < 1)
@@ -257,11 +110,6 @@ public static bool NotEqualsIgnoreCase(params string[] strs)
         return true;
     }
 
-    /// <summary>
-    /// Determines whether all the strings in the specified enumerable are distinct, ignoring their casing, based on their values using ordinal comparison.
-    /// </summary>
-    /// <param name="strs">The strings to check.</param>
-    /// <returns><see langword="true"/> if all the strings in the specified enumerable are distinct, ignoring their casing, based on their values using ordinal comparison; otherwise, <see langword="false"/>.</returns>
     public static bool NotEqualsIgnoreCase(this IEnumerable<string> strs)
     {
         if (strs is null || strs.Count() < 2)
@@ -279,44 +127,14 @@ public static bool NotEqualsIgnoreCase(this IEnumerable<string> strs)
         return true;
     }
 
-    /// <summary>
-    /// Returns the non-null string value or <see cref="string.Empty"/> if it is <see langword="null"/>.
-    /// </summary>
-    /// <param name="str">The string to retrieve the value from.</param>
-    /// <returns>The non-null string value or <see cref="string.Empty"/> if it is <see langword="null"/>.</returns>
     public static string GetValue(this string str) => str ?? string.Empty;
 
-    /// <summary>
-    /// Returns the non-null string value or the default value if it is <see langword="null"/>.
-    /// </summary>
-    /// <param name="str">The string to retrieve the value from.</param>
-    /// <param name="dfltVal">The default value to return if the string is <see langword="null"/>.</param>
-    /// <returns>The non-null string value or the default value if it is <see langword="null"/>.</returns>
     public static string GetValue(this string str, string dfltVal) => str ?? dfltVal;
 
-    /// <summary>
-    /// Returns the non-null string value or the default value if it is <see langword="null"/>.
-    /// </summary>
-    /// <param name="str">The string to retrieve the value from.</param>
-    /// <param name="dfltVal">The default character value to return if the string is <see langword="null"/>.</param>
-    /// <returns>
-    /// The non-null string value or the default value if it is <see langword="null"/>.
-    /// If the default character value is not a valid character, an empty string is returned.
-    /// </returns>
     public static string GetValue(this string str, char dfltVal) => str ?? (dfltVal.IsNotEmpty() ? dfltVal.ToString() : string.Empty);
 
-    /// <summary>
-    /// Converts the string to lowercase if it is not empty or whitespace; otherwise, returns the original string.
-    /// </summary>
-    /// <param name="str">The string to convert to lowercase.</param>
-    /// <returns>The lowercase version of the string if it is not empty or whitespace; otherwise, the original string.</returns>
     public static string ToLower(this string str) => str.IsNotNullAndWhiteSpace() ? str.ToLower() : str;
 
-    /// <summary>
-    /// Enumerates through an enumerable of strings and returns a new enumerable of strings converted to lowercase, ignoring their casing, based on their Unicode values.
-    /// </summary>
-    /// <param name="strs">The strings to convert to lowercase.</param>
-    /// <returns>An enumerable of strings converted to lowercase, ignoring their casing, based on their Unicode values.</returns>
     public static IEnumerable<string> ToLower(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -329,10 +147,6 @@ public static IEnumerable<string> ToLower(this IEnumerable<string> strs)
         }
     }
 
-    /// <summary>
-    /// Converts the strings in the specified list to lowercase, ignoring their casing, based on their Unicode values.
-    /// </summary>
-    /// <param name="strs">The list of strings to convert to lowercase.</param>
     public static void ToLower(this IList<string> strs)
     {
         if (strs is not null && strs.Count > 0)
@@ -344,18 +158,8 @@ public static void ToLower(this IList<string> strs)
         }
     }
 
-    /// <summary>
-    /// Converts the string to lowercase using the invariant culture, if it is not empty or whitespace; otherwise, returns the original string.
-    /// </summary>
-    /// <param name="str">The string to convert to lowercase.</param>
-    /// <returns>The lowercase version of the string using the invariant culture if it is not empty or whitespace; otherwise, the original string.</returns>
     public static string ToLowerInvariant(this string str) => str.IsNotNullAndWhiteSpace() ? str.ToLower(CultureInfo.InvariantCulture) : str;
 
-    /// <summary>
-    /// Enumerates through an enumerable of strings and returns a new enumerable of strings converted to lowercase, ignoring their casing, based on their Unicode values using the invariant culture.
-    /// </summary>
-    /// <param name="strs">The strings to convert to lowercase.</param>
-    /// <returns>An enumerable of strings converted to lowercase, ignoring their casing, based on their Unicode values using the invariant culture.</returns>
     public static IEnumerable<string> ToLowerInvariant(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -368,10 +172,6 @@ public static IEnumerable<string> ToLowerInvariant(this IEnumerable<string> strs
         }
     }
 
-    /// <summary>
-    /// Converts all strings in the specified string list to lowercase using the invariant culture, by modifying the list in-place.
-    /// </summary>
-    /// <param name="strs">The string list to convert to lowercase.</param>
     public static void ToLowerInvariant(this IList<string> strs)
     {
         if (strs is not null && strs.Count > 0)
@@ -383,18 +183,8 @@ public static void ToLowerInvariant(this IList<string> strs)
         }
     }
 
-    /// <summary>
-    /// Converts the string to uppercase using the invariant culture, if it is not empty or whitespace; otherwise, returns the original string.
-    /// </summary>
-    /// <param name="str">The string to convert to uppercase.</param>
-    /// <returns>The uppercase version of the string using the invariant culture if it is not empty or whitespace; otherwise, the original string.</returns>
     public static string ToUpper(this string str) => str.IsNotNullAndWhiteSpace() ? str.ToUpper() : str;
 
-    /// <summary>
-    /// Enumerates through an enumerable of strings and returns a new enumerable of strings converted to uppercase, ignoring their casing, using the invariant culture.
-    /// </summary>
-    /// <param name="strs">The strings to convert to uppercase.</param>
-    /// <returns>An enumerable of strings converted to uppercase, ignoring their casing, using the invariant culture.</returns>
     public static IEnumerable<string> ToUpper(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -407,10 +197,6 @@ public static IEnumerable<string> ToUpper(this IEnumerable<string> strs)
         }
     }
 
-    /// <summary>
-    /// Converts all strings in the specified list of strings to uppercase, by modifying the list in-place.
-    /// </summary>
-    /// <param name="strs">The list of strings to convert to uppercase.</param>
     public static void ToUpper(this IList<string> strs)
     {
         if (strs is not null && strs.Count > 0)
@@ -422,18 +208,8 @@ public static void ToUpper(this IList<string> strs)
         }
     }
 
-    /// <summary>
-    /// Converts the input string to uppercase using the invariant culture, if it is not empty or whitespace; otherwise, returns the original string.
-    /// </summary>
-    /// <param name="str">The string to convert to uppercase.</param>
-    /// <returns>The uppercase version of the input string using the invariant culture if it is not empty or whitespace; otherwise, the original string.</returns>
     public static string ToUpperInvariant(this string str) => str.IsNotNullAndWhiteSpace() ? str.ToUpper(CultureInfo.InvariantCulture) : str;
 
-    /// <summary>
-    /// Enumerates through an enumerable of strings and returns a new enumerable of strings converted to uppercase, ignoring their casing, based on their Unicode values using the invariant culture.
-    /// </summary>
-    /// <param name="strs">The strings to convert to uppercase.</param>
-    /// <returns>An enumerable of strings converted to uppercase, ignoring their casing, based on their Unicode values using the invariant culture.</returns>
     public static IEnumerable<string> ToUpperInvariant(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -446,10 +222,6 @@ public static IEnumerable<string> ToUpperInvariant(this IEnumerable<string> strs
         }
     }
 
-    /// <summary>
-    /// Converts all strings in the specified string list to uppercase using the invariant culture, by modifying the list in-place.
-    /// </summary>
-    /// <param name="strs">The string list to convert to uppercase.</param>
     public static void ToUpperInvariant(this IList<string> strs)
     {
         if (strs is not null && strs.Count > 0)
diff --git a/lib/YANLib/YANText.cs b/lib/YANLib/YANText.cs
index a79021b7..cc36189d 100644
--- a/lib/YANLib/YANText.cs
+++ b/lib/YANLib/YANText.cs
@@ -1,22 +1,13 @@
-using System.Globalization;
-using System.Text;
+using System.Text;
+using static System.Globalization.CultureInfo;
 
 namespace YANLib;
 
 public static partial class YANText
 {
-    /// <summary>
-    /// Converts the string to title case using the current culture's text info, if it is not empty or whitespace; otherwise, returns the original string.
-    /// </summary>
-    /// <param name="str">The string to convert to title case.</param>
-    /// <returns>The title case version of the string using the current culture's text info if it is not empty or whitespace; otherwise, the original string.</returns>
-    public static string ToTitle(this string str) => str.IsNullOrWhiteSpace() ? str : CultureInfo.CurrentCulture.TextInfo.ToTitleCase(str);
 
-    /// <summary>
-    /// Enumerates through an enumerable of strings and returns a new enumerable of strings converted to title case using the current culture's text info.
-    /// </summary>
-    /// <param name="strs">The strings to convert to title case.</param>
-    /// <returns>An enumerable of strings converted to title case using the current culture's text info.</returns>
+    public static string ToTitle(this string str) => str.IsNullOrWhiteSpace() ? str : CurrentCulture.TextInfo.ToTitleCase(str);
+
     public static IEnumerable<string> ToTitle(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -29,10 +20,6 @@ public static IEnumerable<string> ToTitle(this IEnumerable<string> strs)
         }
     }
 
-    /// <summary>
-    /// Converts all strings in the specified list to title case using the current culture's text info, by modifying the list in-place.
-    /// </summary>
-    /// <param name="strs">The list of strings to convert to title case.</param>
     public static void ToTitle(this IList<string> strs)
     {
         if (strs is not null && strs.Count > 0)
@@ -44,11 +31,6 @@ public static void ToTitle(this IList<string> strs)
         }
     }
 
-    /// <summary>
-    /// Converts the first character of each word in the input string to uppercase, and the remaining characters to lowercase, using the current culture's text info.
-    /// </summary>
-    /// <param name="str">The string to capitalize.</param>
-    /// <returns>The capitalized version of the input string.</returns>
     public static string ToCapitalize(this string str)
     {
         if (str.IsNullOrWhiteSpace())
@@ -72,11 +54,6 @@ public static string ToCapitalize(this string str)
         return sb.ToString();
     }
 
-    /// <summary>
-    /// Enumerates through an enumerable of strings and returns a new enumerable of strings with the first character of each word capitalized and the remaining characters in lowercase, based on the current culture's text info.
-    /// </summary>
-    /// <param name="strs">The strings to capitalize.</param>
-    /// <returns>An enumerable of strings with the first character of each word capitalized and the remaining characters in lowercase, based on the current culture's text info.</returns>
     public static IEnumerable<string> ToCapitalize(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -89,11 +66,6 @@ public static IEnumerable<string> ToCapitalize(this IEnumerable<string> strs)
         }
     }
 
-    /// <summary>
-    /// Converts all strings in the specified string list to capitalize form, by modifying the list in-place.
-    /// The first character of each word is capitalized and the remaining characters are converted to lowercase, based on the current culture's text info.
-    /// </summary>
-    /// <param name="strs">The string list to convert to capitalize form.</param>
     public static void ToCapitalize(this IList<string> strs)
     {
         if (strs is not null && strs.Count > 0)
@@ -105,13 +77,6 @@ public static void ToCapitalize(this IList<string> strs)
         }
     }
 
-    /// <summary>
-    /// Removes excess whitespace characters from the beginning, end, and within the specified string.
-    /// Consecutive whitespace characters are reduced to a single space character.
-    /// If the input string is null or empty, it is returned unchanged.
-    /// </summary>
-    /// <param name="str">The string to clean up.</param>
-    /// <returns>A string with excess whitespace characters removed and consecutive whitespace characters reduced to a single space character.</returns>
     public static string CleanSpace(this string str)
     {
         if (str.IsNullOrEmpty())
@@ -140,12 +105,6 @@ public static string CleanSpace(this string str)
         return sb.ToString();
     }
 
-    /// <summary>
-    /// Enumerates through an enumerable of strings and returns a new enumerable of strings with excess whitespace characters removed from the beginning, end, and within each string.
-    /// Consecutive whitespace characters are reduced to a single space character.
-    /// </summary>
-    /// <param name="strs">The strings to clean up.</param>
-    /// <returns>An enumerable of strings with excess whitespace characters removed.</returns>
     public static IEnumerable<string> CleanSpace(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -158,11 +117,6 @@ public static IEnumerable<string> CleanSpace(this IEnumerable<string> strs)
         }
     }
 
-    /// <summary>
-    /// Removes excess whitespace characters from the beginning, end, and within each string in the specified list of strings, by modifying the list in-place.
-    /// Consecutive whitespace characters are reduced to a single space character.
-    /// </summary>
-    /// <param name="strs">The list of strings to clean up.</param>
     public static void CleanSpace(this IList<string> strs)
     {
         if (strs is not null && strs.Count > 0)
@@ -174,12 +128,6 @@ public static void CleanSpace(this IList<string> strs)
         }
     }
 
-    /// <summary>
-    /// Formats the input string as a name by capitalizing the first letter of each word and converting the rest to lowercase, while ignoring punctuation, numbers, and consecutive whitespace characters.
-    /// If the input string is empty or consists of only whitespace, it is returned unchanged.
-    /// </summary>
-    /// <param name="str">The string to format as a name.</param>
-    /// <returns>The formatted name string.</returns>
     public static string FormatName(this string str)
     {
         if (str.IsNullOrEmpty())
@@ -201,11 +149,6 @@ public static string FormatName(this string str)
         return sb.ToString();
     }
 
-    /// <summary>
-    /// Enumerates through an enumerable of strings and returns a new enumerable of strings with each string formatted by filtering out non-alphabetic characters and converting the remaining characters to uppercase, ignoring their casing, based on their Unicode values using the invariant culture.
-    /// </summary>
-    /// <param name="strs">The strings to format by filtering out non-alphabetic characters and converting the remaining characters to uppercase.</param>
-    /// <returns>An enumerable of strings with each string formatted by filtering out non-alphabetic characters and converting the remaining characters to uppercase, ignoring their casing, based on their Unicode values using the invariant culture.</returns>
     public static IEnumerable<string> FormatName(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -218,10 +161,6 @@ public static IEnumerable<string> FormatName(this IEnumerable<string> strs)
         }
     }
 
-    /// <summary>
-    /// Formats a list of strings in place by filtering out non-alphabetic characters and converting the remaining characters to uppercase, ignoring their casing, based on their Unicode values using the invariant culture.
-    /// </summary>
-    /// <param name="strs">The list of strings to format by filtering out non-alphabetic characters and converting the remaining characters to uppercase.</param>
     public static void FormatName(this IList<string> strs)
     {
         if (strs is not null && strs.Count > 0)
@@ -233,12 +172,6 @@ public static void FormatName(this IList<string> strs)
         }
     }
 
-    /// <summary>
-    /// Filters out non-alphabetic characters from a string by creating a new string containing only the alphabetic characters, and returns the result.
-    /// Empty or null strings are returned as is.
-    /// </summary>
-    /// <param name="str">The string to filter out non-alphabetic characters from.</param>
-    /// <returns>A new string containing only the alphabetic characters from the input string, or the original string if it is empty or null.</returns>
     public static string FilterAlphabetic(this string str)
     {
         if (str.IsNullOrEmpty())
@@ -257,12 +190,6 @@ public static string FilterAlphabetic(this string str)
         return sb.ToString();
     }
 
-    /// <summary>
-    /// Enumerates through an enumerable of strings and returns a new enumerable of strings with all non-alphabetic characters filtered out, based on their Unicode values.
-    /// Empty or null strings are returned as is.
-    /// </summary>
-    /// <param name="strs">The strings to filter out non-alphabetic characters from.</param>
-    /// <returns>An enumerable of strings with all non-alphabetic characters filtered out, based on their Unicode values.</returns>
     public static IEnumerable<string> FilterAlphabetic(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -275,10 +202,6 @@ public static IEnumerable<string> FilterAlphabetic(this IEnumerable<string> strs
         }
     }
 
-    /// <summary>
-    /// Filters out all non-alphabetic characters from the strings in the specified list based on their Unicode values.
-    /// </summary>
-    /// <param name="strs">The list of strings to filter out non-alphabetic characters from.</param>
     public static void FilterAlphabetic(this IList<string> strs)
     {
         if (strs is not null && strs.Count > 0)
@@ -290,11 +213,6 @@ public static void FilterAlphabetic(this IList<string> strs)
         }
     }
 
-    /// <summary>
-    /// Filters out all numeric characters from the string and returns a new string containing only non-numeric characters.
-    /// </summary>
-    /// <param name="str">The string to filter out numeric characters from.</param>
-    /// <returns>A new string containing only non-numeric characters from the original string.</returns>
     public static string FilterNumber(this string str)
     {
         if (str.IsNullOrEmpty())
@@ -313,12 +231,6 @@ public static string FilterNumber(this string str)
         return sb.ToString();
     }
 
-    /// <summary>
-    /// Enumerates through an enumerable of strings and returns a new enumerable of strings with all numeric characters filtered out, based on their Unicode values.
-    /// If a string is empty or whitespace, it is returned as-is.
-    /// </summary>
-    /// <param name="strs">The strings to filter out numeric characters from.</param>
-    /// <returns>An enumerable of strings with all numeric characters filtered out, based on their Unicode values.</returns>
     public static IEnumerable<string> FilterNumber(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -331,11 +243,6 @@ public static IEnumerable<string> FilterNumber(this IEnumerable<string> strs)
         }
     }
 
-    /// <summary>
-    /// Filters out all numeric characters from the strings in the specified list, based on their Unicode values.
-    /// If a string in the list is empty or whitespace, it is left unchanged.
-    /// </summary>
-    /// <param name="strs">The list of strings to filter out numeric characters from.</param>
     public static void FilterNumber(this IList<string> strs)
     {
         if (strs is not null && strs.Count > 0)
@@ -347,11 +254,6 @@ public static void FilterNumber(this IList<string> strs)
         }
     }
 
-    /// <summary>
-    /// Filters out all non-alphanumeric characters (i.e., characters that are not numbers or letters) from the string, and returns the filtered string.
-    /// </summary>
-    /// <param name="str">The string to filter out non-alphanumeric characters from.</param>
-    /// <returns>The filtered string with only alphanumeric characters.</returns>
     public static string FilterAlphanumeric(this string str)
     {
         if (str.IsNullOrEmpty())
@@ -370,11 +272,6 @@ public static string FilterAlphanumeric(this string str)
         return sb.ToString();
     }
 
-    /// <summary>
-    /// Enumerates through an enumerable of strings and returns a new enumerable of strings with all non-alphanumeric characters (i.e., characters that are not numbers or letters) filtered out.
-    /// </summary>
-    /// <param name="strs">The strings to filter out non-alphanumeric characters from.</param>
-    /// <returns>An enumerable of strings with all non-alphanumeric characters filtered out.</returns>
     public static IEnumerable<string> FilterAlphanumeric(this IEnumerable<string> strs)
     {
         if (strs is null || !strs.Any())
@@ -387,10 +284,6 @@ public static IEnumerable<string> FilterAlphanumeric(this IEnumerable<string> st
         }
     }
 
-    /// <summary>
-    /// Modifies the strings in the specified list by filtering out all non-alphanumeric characters (i.e., characters that are not numbers or letters).
-    /// </summary>
-    /// <param name="strs">The list of strings to filter out non-alphanumeric characters from.</param>
     public static void FilterAlphanumeric(this IList<string> strs)
     {
         if (strs is not null && strs.Count > 0)