// <auto-generated/>
#r "nuget: CommunityToolkit.Common"
#r "nuget: CommunityToolkit.Diagnostics"
#r "nuget: CommunityToolkit.HighPerformance"
#r "nuget: FastGenericNew"
#r "nuget: JetBrains.Annotations"
#r "nuget: TextCopy"
#pragma warning disable CS0208
#define NET8_0
#define NET80
#define NET8_0_OR_GREATER
#define NET80_OR_GREATER
#define NET7_0_OR_GREATER
#define NET70_OR_GREATER
#define NET6_0_OR_GREATER
#define NET60_OR_GREATER
#define NET5_0_OR_GREATER
#define NET50_OR_GREATER
#define NETCOREAPP
#define NETSTANDARD2_1_OR_GREATER
#define NETSTANDARD2_0_OR_GREATER
#define NETSTANDARD1_6_OR_GREATER
#define NETSTANDARD1_5_OR_GREATER
#define NETSTANDARD1_4_OR_GREATER
#define NETSTANDARD1_3_OR_GREATER
#define NETSTANDARD1_2_OR_GREATER
#define NETSTANDARD1_1_OR_GREATER
#define NETSTANDARD1_0_OR_GREATER
#define NETSTANDARD
#define NO_ALLOWS_REF_STRUCT
#define CSHARPREPL
#define DEBUG
global using System;
global using System.Buffers;
global using System.Buffers.Binary;
global using System.Buffers.Text;
global using System.CodeDom.Compiler;
global using System.Collections;
global using System.Collections.Concurrent;
global using System.Collections.Frozen;
global using System.Collections.Generic;
global using System.Collections.Immutable;
global using System.Collections.ObjectModel;
global using System.Collections.Specialized;
global using System.ComponentModel;
global using System.ComponentModel.Design;
global using System.ComponentModel.Design.Serialization;
global using System.Configuration.Assemblies;
global using System.Data;
global using System.Data.Common;
global using System.Data.SqlTypes;
global using System.Diagnostics;
global using System.Diagnostics.CodeAnalysis;
global using System.Diagnostics.Contracts;
global using System.Diagnostics.Eventing;
global using System.Diagnostics.Eventing.Reader;
global using System.Diagnostics.Metrics;
global using System.Diagnostics.SymbolStore;
global using System.Diagnostics.Tracing;
global using System.Drawing;
global using System.Drawing.Configuration;
global using System.Dynamic;
global using System.Formats;
global using System.Formats.Asn1;
global using System.Globalization;
global using System.IO;
global using System.IO.Compression;
global using System.IO.Enumeration;
global using System.IO.IsolatedStorage;
global using System.IO.MemoryMappedFiles;
global using System.IO.Pipes;
global using System.Linq;
global using System.Linq.Expressions;
global using System.Linq.Expressions.Interpreter;
global using System.Net;
global using System.Net.Cache;
global using System.Net.Http;
global using System.Net.Http.Headers;
global using System.Net.Http.Metrics;
global using System.Net.Mail;
global using System.Net.Mime;
global using System.Net.NetworkInformation;
global using System.Net.Security;
global using System.Net.Sockets;
global using System.Net.WebSockets;
global using System.Numerics;
global using System.Reflection;
global using System.Reflection.Emit;
global using System.Reflection.Metadata;
global using System.Reflection.Metadata.Ecma335;
global using System.Reflection.PortableExecutable;
global using System.Resources;
global using System.Runtime;
global using System.Runtime.CompilerServices;
global using System.Runtime.ConstrainedExecution;
global using System.Runtime.ExceptionServices;
global using System.Runtime.InteropServices;
global using System.Runtime.InteropServices.ComTypes;
global using System.Runtime.InteropServices.Marshalling;
global using System.Runtime.InteropServices.ObjectiveC;
global using System.Runtime.Intrinsics;
global using System.Runtime.Intrinsics.Arm;
global using System.Runtime.Intrinsics.Wasm;
global using System.Runtime.Intrinsics.X86;
global using System.Runtime.Loader;
global using System.Runtime.Remoting;
global using System.Runtime.Serialization;
global using System.Runtime.Serialization.Formatters;
global using System.Runtime.Serialization.Formatters.Binary;
global using System.Runtime.Serialization.Json;
global using System.Runtime.Versioning;
global using System.Security;
global using System.Security.Authentication;
global using System.Security.Authentication.ExtendedProtection;
global using System.Security.Claims;
global using System.Security.Cryptography;
global using System.Security.Cryptography.Pkcs;
global using System.Security.Cryptography.X509Certificates;
global using System.Security.Permissions;
global using System.Security.Principal;
global using System.Text;
global using System.Text.Encodings;
global using System.Text.Encodings.Web;
global using System.Text.Json;
global using System.Text.Json.Nodes;
global using System.Text.Json.Serialization;
global using System.Text.Json.Serialization.Metadata;
global using System.Text.RegularExpressions;
global using System.Text.Unicode;
global using System.Threading;
global using System.Threading.Channels;
global using System.Threading.Tasks;
global using System.Threading.Tasks.Sources;
global using System.Timers;
global using System.Transactions;
global using System.Web;
global using System.Windows;
global using System.Windows.Input;
global using System.Windows.Markup;
global using System.Xml;
global using System.Xml.Linq;
global using System.Xml.Resolvers;
global using System.Xml.Schema;
global using System.Xml.Serialization;
global using System.Xml.XPath;
global using System.Xml.Xsl;
global using System.Xml.Xsl.Runtime;
global using CommunityToolkit.Common;
global using CommunityToolkit.Common.Collections;
global using CommunityToolkit.Common.Deferred;
global using CommunityToolkit.Common.Extensions;
global using CommunityToolkit.Common.Helpers;
global using CommunityToolkit.Diagnostics;
global using CommunityToolkit.Helpers;
global using CommunityToolkit.HighPerformance;
global using CommunityToolkit.HighPerformance.Buffers;
global using CommunityToolkit.HighPerformance.Buffers.Views;
global using CommunityToolkit.HighPerformance.Enumerables;
global using CommunityToolkit.HighPerformance.Helpers;
global using CommunityToolkit.HighPerformance.Memory;
global using CommunityToolkit.HighPerformance.Memory.Views;
global using CommunityToolkit.HighPerformance.Streams;
global using FastGenericNew;
global using JetBrains.Annotations;
global using TextCopy;
global using static FastGenericNew.FastNew;
global using static TextCopy.ClipboardService;
global using ComptimeString = System.Buffers.SearchValues<char>;
global using DisallowNullAttribute = System.Diagnostics.CodeAnalysis.DisallowNullAttribute;
global using Expression = System.Linq.Expressions.Expression;
global using PureAttribute = System.Diagnostics.Contracts.PureAttribute;
global using GeneratedSource = (string HintName, string Source);
using static System.Runtime.CompilerServices.RuntimeHelpers;
using static JetBrains.Annotations.CollectionAccessType;
using static JetBrains.Annotations.CollectionAccessType;
using static JetBrains.Annotations.CollectionAccessType;
using static JetBrains.Annotations.CollectionAccessType;
using static JetBrains.Annotations.CollectionAccessType;
using static JetBrains.Annotations.CollectionAccessType;
using SecurityAction = System.Security.Permissions.SecurityAction;
using static System.Security.Permissions.SecurityAction;
using static System.Security.Permissions.SecurityPermissionFlag;
using Buffer = System.Buffer;
using static JetBrains.Annotations.CollectionAccessType;
using static JetBrains.Annotations.CollectionAccessType;
using Substring = System.ReadOnlyMemory<char>;
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable once CheckNamespace
/// <summary>Provides extension methods to convert representations of text into destination types.</summary>
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Parse<T>(this string? s) => Parse<T>(s, out _);
    /// <summary>Parses the <see cref="string"/> into a <typeparamref name="T"/>.</summary>
    /// <typeparam name="T">The type to parse into.</typeparam>
    /// <param name="s">The buffer source.</param>
    /// <param name="success">Whether the parsing was successful.</param>
    /// <returns>The parsed value.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Parse<T>(this string? s, out bool success) =>
        typeof(string) == typeof(T) && (success = true)
            ? (T?)(object?)s
            : FindTryParseFor<T>.WithString(s, out success);
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Parse<T>(this scoped ReadOnlySpan<byte> s) => Parse<T>(s, out _);
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Parse<T>(this scoped ReadOnlySpan<byte> s, out bool success) =>
        typeof(string) == typeof(T) && (success = true)
#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
            ? (T)(object)Encoding.UTF8.GetString(s)
#else
            ? (T)(object)Encoding.UTF8.GetString(s.ToArray())
#endif
            : FindTryParseFor<T>.WithByteSpan(s, out success);
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Parse<T>(this scoped ReadOnlySpan<char> s) => Parse<T>(s, out _);
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Parse<T>(this scoped ReadOnlySpan<char> s, out bool success) =>
        typeof(string) == typeof(T) && (success = true)
            ? (T)(object)s.ToString()
            : FindTryParseFor<T>.WithCharSpan(s, out success);
#if NET7_0_OR_GREATER
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Into<T>(this string? s)
        where T : IParsable<T> =>
        Into<T>(s, out _);
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Into<T>(this string? s, IFormatProvider? provider)
        where T : IParsable<T> =>
        Into<T>(s, provider, out _);
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Into<T>(this string? s, out bool success)
        where T : IParsable<T> =>
        (success = T.TryParse(s, CultureInfo.InvariantCulture, out var result)) ? result : default;
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Into<T>(this string? s, IFormatProvider? provider, out bool success)
        where T : IParsable<T> =>
        (success = T.TryParse(s, provider, out var result)) ? result : default;
#if NET8_0_OR_GREATER
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Into<T>(this scoped ReadOnlySpan<byte> s)
        where T : IUtf8SpanParsable<T> =>
        Into<T>(s, out _);
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Into<T>(this scoped ReadOnlySpan<byte> s, IFormatProvider? provider)
        where T : IUtf8SpanParsable<T> =>
        Into<T>(s, provider, out _);
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Into<T>(this scoped ReadOnlySpan<byte> s, out bool success)
        where T : IUtf8SpanParsable<T> =>
        (success = T.TryParse(s, CultureInfo.InvariantCulture, out var result)) ? result : default;
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Into<T>(this scoped ReadOnlySpan<byte> s, IFormatProvider? provider, out bool success)
        where T : IUtf8SpanParsable<T> =>
        (success = T.TryParse(s, provider, out var result)) ? result : default;
#endif
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Into<T>(this scoped ReadOnlySpan<char> s)
        where T : ISpanParsable<T> =>
        Into<T>(s, out _);
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Into<T>(this scoped ReadOnlySpan<char> s, IFormatProvider? provider)
        where T : ISpanParsable<T> =>
        Into<T>(s, provider, out _);
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Into<T>(this scoped ReadOnlySpan<char> s, out bool success)
        where T : ISpanParsable<T> =>
        (success = T.TryParse(s, CultureInfo.InvariantCulture, out var result)) ? result : default;
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Into<T>(this scoped ReadOnlySpan<char> s, IFormatProvider? provider, out bool success)
        where T : ISpanParsable<T> =>
        (success = T.TryParse(s, provider, out var result)) ? result : default;
#endif
#if NET40_OR_GREATER || NETSTANDARD || NETCOREAPP
    /// <summary>Parses the <see cref="string"/> into the <typeparamref name="T"/>.</summary>
    /// <typeparam name="T">The type to parse into.</typeparam>
    /// <param name="s">The buffer source.</param>
    /// <param name="ignoreCase">Whether to ignore case.</param>
    /// <returns>The parsed value.</returns>
    public static T IntoEnum<T>(this string? s, bool ignoreCase = true)
        where T : struct =>
        Enum.TryParse(s, ignoreCase, out T result) ? result : default;
    /// <summary>Parses the <see cref="string"/> into the <typeparamref name="T"/>.</summary>
    /// <typeparam name="T">The type to parse into.</typeparam>
    /// <param name="s">The buffer source.</param>
    /// <param name="ignoreCase">Whether to ignore case.</param>
    /// <returns>The parsed value.</returns>
    public static T? TryIntoEnum<T>(this string? s, bool ignoreCase = true)
        where T : struct =>
        Enum.TryParse(s, ignoreCase, out T result) ? result : null;
#endif
#if NET6_0_OR_GREATER
    /// <summary>Parses the <see cref="string"/> into the <typeparamref name="T"/>.</summary>
    /// <typeparam name="T">The type to parse into.</typeparam>
    /// <param name="s">The buffer source.</param>
    /// <param name="ignoreCase">Whether to ignore case.</param>
    /// <returns>The parsed value.</returns>
    public static T IntoEnum<T>(this scoped ReadOnlySpan<char> s, bool ignoreCase = true)
        where T : struct =>
        Enum.TryParse(s, ignoreCase, out T result) ? result : default;
    /// <summary>Parses the <see cref="string"/> into the <typeparamref name="T"/>.</summary>
    /// <typeparam name="T">The type to parse into.</typeparam>
    /// <param name="s">The buffer source.</param>
    /// <param name="ignoreCase">Whether to ignore case.</param>
    /// <returns>The parsed value.</returns>
    public static T? TryIntoEnum<T>(this scoped ReadOnlySpan<char> s, bool ignoreCase = true)
        where T : struct =>
        Enum.TryParse(s, ignoreCase, out T result) ? result : null;
#endif
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? TryParse<T>(this string? s)
        where T : struct =>
        Parse<T>(s, out var success) is var value && success ? value : null;
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? TryParse<T>(this scoped ReadOnlySpan<byte> s)
        where T : struct =>
        Parse<T>(s, out var success) is var value && success ? value : null;
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? TryParse<T>(this scoped ReadOnlySpan<char> s)
        where T : struct =>
        Parse<T>(s, out var success) is var value && success ? value : null;
#if NET7_0_OR_GREATER
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? TryInto<T>(this string? s)
        where T : struct, IParsable<T> =>
        T.TryParse(s, CultureInfo.InvariantCulture, out var result) ? result : null;
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? TryInto<T>(this string? s, IFormatProvider? provider)
        where T : struct, IParsable<T> =>
        T.TryParse(s, provider, out var result) ? result : null;
#if NET8_0_OR_GREATER
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? TryInto<T>(this scoped ReadOnlySpan<byte> s)
        where T : struct, IUtf8SpanParsable<T> =>
        T.TryParse(s, CultureInfo.InvariantCulture, out var result) ? result : null;
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? TryInto<T>(this scoped ReadOnlySpan<byte> s, IFormatProvider? provider)
        where T : struct, IUtf8SpanParsable<T> =>
        T.TryParse(s, provider, out var result) ? result : null;
#endif
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? TryInto<T>(this scoped ReadOnlySpan<char> s)
        where T : struct, ISpanParsable<T> =>
        T.TryParse(s, CultureInfo.InvariantCulture, out var result) ? result : null;
    /// <inheritdoc cref="Parse{T}(string, out bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? TryInto<T>(this scoped ReadOnlySpan<char> s, IFormatProvider? provider)
        where T : struct, ISpanParsable<T> =>
        T.TryParse(s, provider, out var result) ? result : null;
#endif
    static class FindTryParseFor<T>
    {
        [Pure]
        public delegate T? ByteParser(in ReadOnlySpan<byte> s, out bool success);
        [Pure]
        public delegate T? CharParser(in ReadOnlySpan<char> s, out bool success);
        [Pure]
        public delegate T? Parser(in string? s, out bool success);
        [Pure]
        delegate bool InByteParser(ReadOnlySpan<byte> s, CultureInfo info, out T? result);
        [Pure]
        delegate bool InCharParser(ReadOnlySpan<char> s, CultureInfo info, out T? result);
        [Pure]
        delegate bool InEnumByteParser(ReadOnlySpan<byte> s, bool ignoreCase, out T? result);
        [Pure]
        delegate bool InEnumCharParser(ReadOnlySpan<char> s, bool ignoreCase, out T? result);
        [Pure]
        delegate bool InEnumParser(string? s, bool ignoreCase, out T? result);
        [Pure]
        delegate bool InNumberByteParser(ReadOnlySpan<byte> s, NumberStyles style, CultureInfo info, out T? result);
        [Pure]
        delegate bool InNumberCharParser(ReadOnlySpan<char> s, NumberStyles style, CultureInfo info, out T? result);
        [Pure]
        delegate bool InNumberParser(string? s, NumberStyles style, CultureInfo info, out T? result);
        [Pure]
        delegate bool InParser(string? s, CultureInfo info, out T? result);
        const BindingFlags Flags = BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy;
        static readonly InByteParser? s_byteParse = Make<InByteParser>();
        static readonly InCharParser? s_charParse = Make<InCharParser>();
        static readonly InEnumByteParser? s_byteParseEnum = Make<InEnumByteParser>();
        static readonly InEnumCharParser? s_charParseEnum = Make<InEnumCharParser>();
        static readonly InEnumParser? s_parseEnum = Make<InEnumParser>();
        static readonly InNumberByteParser? s_byteParseNumber = Make<InNumberByteParser>();
        static readonly InNumberCharParser? s_charParseNumber = Make<InNumberCharParser>();
        static readonly InNumberParser? s_parseNumber = Make<InNumberParser>();
        static readonly InParser? s_parse = Make<InParser>();
        public static Parser WithString { [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get; } =
            s_parseNumber is not null ? ParseNumberInvoker :
            s_parseEnum is not null ? ParseEnumInvoker :
            s_parse is not null ? ParseInvoker : FailedParseInvoker;
        public static ByteParser WithByteSpan { [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get; } =
            s_byteParseNumber is not null ? ByteParseNumberInvoker :
            s_byteParseEnum is not null ? ByteParseEnumInvoker :
            s_byteParse is not null ? ByteParseInvoker : ByteFailedParseInvoker;
        public static CharParser WithCharSpan { [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get; } =
            s_charParseNumber is not null ? CharParseNumberInvoker :
            s_charParseEnum is not null ? CharParseEnumInvoker :
            s_charParse is not null ? CharParseInvoker : CharFailedParseInvoker;
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        static T? ByteFailedParseInvoker(in ReadOnlySpan<byte> _, out bool b)
        {
            b = false;
            return default;
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        static T? ByteParseInvoker(in ReadOnlySpan<byte> s, out bool b)
        {
            b = s_byteParse!(s, CultureInfo.InvariantCulture, out var result);
            return result;
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        static T? ByteParseEnumInvoker(in ReadOnlySpan<byte> s, out bool b)
        {
            b = s_byteParseEnum!(s, true, out var result);
            return result;
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        static T? ByteParseNumberInvoker(in ReadOnlySpan<byte> s, out bool b)
        {
            b = s_byteParseNumber!(s, NumberStyles.Any, CultureInfo.InvariantCulture, out var result);
            return result;
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        static T? CharFailedParseInvoker(in ReadOnlySpan<char> _, out bool b)
        {
            b = false;
            return default;
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        static T? CharParseInvoker(in ReadOnlySpan<char> s, out bool b)
        {
            b = s_charParse!(s, CultureInfo.InvariantCulture, out var result);
            return result;
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        static T? CharParseEnumInvoker(in ReadOnlySpan<char> s, out bool b)
        {
            b = s_charParseEnum!(s, true, out var result);
            return result;
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        static T? CharParseNumberInvoker(in ReadOnlySpan<char> s, out bool b)
        {
            b = s_charParseNumber!(s, NumberStyles.Any, CultureInfo.InvariantCulture, out var result);
            return result;
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        static T? FailedParseInvoker(in string? _, out bool b)
        {
            b = false;
            return default;
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        static T? ParseInvoker(in string? s, out bool b)
        {
            b = s_parse!(s, CultureInfo.InvariantCulture, out var result);
            return result;
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        static T? ParseEnumInvoker(in string? s, out bool b)
        {
            b = s_parseEnum!(s, true, out var result);
            return result;
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        static T? ParseNumberInvoker(in string? s, out bool b)
        {
            b = s_parseNumber!(s, NumberStyles.Any, CultureInfo.InvariantCulture, out var result);
            return result;
        }
        [Pure]
        static TDelegate? Make<TDelegate>()
            where TDelegate : Delegate =>
            typeof(T)
               .GetMethods(Flags)
               .Where(x => x.Name is nameof(int.TryParse))
               .Select(x => x.IsGenericMethodDefinition && x.GetGenericArguments() is { Length: 1 } ? TryCoerce(x) : x)
               .Select(x => Delegate.CreateDelegate(typeof(TDelegate), x, false))
               .OfType<TDelegate>()
               .FirstOrDefault();
        [MustUseReturnValue]
        static System.Reflection.MethodInfo TryCoerce(System.Reflection.MethodInfo x)
        {
            try
            {
                return x.MakeGenericMethod(typeof(T));
            }
            catch (ArgumentException)
            {
                return x;
            }
        }
    }
// SPDX-License-Identifier: MPL-2.0
#pragma warning disable SA1003, SA1114
// ReSharper disable BadParensLineBreaks BadPreprocessorIndent
// ReSharper disable once CheckNamespace
/// <summary>Provides prime numbers.</summary>
#if CSHARPREPL
public
#endif
    static class Primes
{
    /// <summary>The smallest prime number.</summary>
    public const short Min = 2;
    /// <summary>The largest prime number for signed 16-bit numbers.</summary>
    public const short MaxInt16 = 32749;
    /// <summary>Gets all <see langword="short"/> prime numbers.</summary>
    public static
#if NETCOREAPP || ROSLYN
        ImmutableArray
#else
        System.Collections.ObjectModel.ReadOnlyCollection
#endif
        <short> Int16 { [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get; } =
#if NETCOREAPP || ROSLYN
        ImmutableCollectionsMarshal.AsImmutableArray<short>(
#else
        Array.AsReadOnly<short>(
#endif
            [
                2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101,
                103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211,
                223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337,
                347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461,
                463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601,
                607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739,
                743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881,
                883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021,
                1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129,
                1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277,
                1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409,
                1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511,
                1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621,
                1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759,
                1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901,
                1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029,
                2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153,
                2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297,
                2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417,
                2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579,
                2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699,
                2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819,
                2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939, 2953, 2957, 2963,
                2969, 2971, 2999, 3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079, 3083, 3089, 3109, 3119,
                3121, 3137, 3163, 3167, 3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 3259,
                3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391,
                3407, 3413, 3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533, 3539,
                3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643, 3659, 3671,
                3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727, 3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797, 3803,
                3821, 3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907, 3911, 3917, 3919, 3923, 3929, 3931,
                3943, 3947, 3967, 3989, 4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049, 4051, 4057, 4073, 4079, 4091,
                4093, 4099, 4111, 4127, 4129, 4133, 4139, 4153, 4157, 4159, 4177, 4201, 4211, 4217, 4219, 4229, 4231,
                4241, 4243, 4253, 4259, 4261, 4271, 4273, 4283, 4289, 4297, 4327, 4337, 4339, 4349, 4357, 4363, 4373,
                4391, 4397, 4409, 4421, 4423, 4441, 4447, 4451, 4457, 4463, 4481, 4483, 4493, 4507, 4513, 4517, 4519,
                4523, 4547, 4549, 4561, 4567, 4583, 4591, 4597, 4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657, 4663,
                4673, 4679, 4691, 4703, 4721, 4723, 4729, 4733, 4751, 4759, 4783, 4787, 4789, 4793, 4799, 4801, 4813,
                4817, 4831, 4861, 4871, 4877, 4889, 4903, 4909, 4919, 4931, 4933, 4937, 4943, 4951, 4957, 4967, 4969,
                4973, 4987, 4993, 4999, 5003, 5009, 5011, 5021, 5023, 5039, 5051, 5059, 5077, 5081, 5087, 5099, 5101,
                5107, 5113, 5119, 5147, 5153, 5167, 5171, 5179, 5189, 5197, 5209, 5227, 5231, 5233, 5237, 5261, 5273,
                5279, 5281, 5297, 5303, 5309, 5323, 5333, 5347, 5351, 5381, 5387, 5393, 5399, 5407, 5413, 5417, 5419,
                5431, 5437, 5441, 5443, 5449, 5471, 5477, 5479, 5483, 5501, 5503, 5507, 5519, 5521, 5527, 5531, 5557,
                5563, 5569, 5573, 5581, 5591, 5623, 5639, 5641, 5647, 5651, 5653, 5657, 5659, 5669, 5683, 5689, 5693,
                5701, 5711, 5717, 5737, 5741, 5743, 5749, 5779, 5783, 5791, 5801, 5807, 5813, 5821, 5827, 5839, 5843,
                5849, 5851, 5857, 5861, 5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, 5953, 5981, 5987, 6007,
                6011, 6029, 6037, 6043, 6047, 6053, 6067, 6073, 6079, 6089, 6091, 6101, 6113, 6121, 6131, 6133, 6143,
                6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, 6229, 6247, 6257, 6263, 6269, 6271, 6277, 6287,
                6299, 6301, 6311, 6317, 6323, 6329, 6337, 6343, 6353, 6359, 6361, 6367, 6373, 6379, 6389, 6397, 6421,
                6427, 6449, 6451, 6469, 6473, 6481, 6491, 6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571, 6577, 6581,
                6599, 6607, 6619, 6637, 6653, 6659, 6661, 6673, 6679, 6689, 6691, 6701, 6703, 6709, 6719, 6733, 6737,
                6761, 6763, 6779, 6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, 6841, 6857, 6863, 6869, 6871, 6883,
                6899, 6907, 6911, 6917, 6947, 6949, 6959, 6961, 6967, 6971, 6977, 6983, 6991, 6997, 7001, 7013, 7019,
                7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7121, 7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207,
                7211, 7213, 7219, 7229, 7237, 7243, 7247, 7253, 7283, 7297, 7307, 7309, 7321, 7331, 7333, 7349, 7351,
                7369, 7393, 7411, 7417, 7433, 7451, 7457, 7459, 7477, 7481, 7487, 7489, 7499, 7507, 7517, 7523, 7529,
                7537, 7541, 7547, 7549, 7559, 7561, 7573, 7577, 7583, 7589, 7591, 7603, 7607, 7621, 7639, 7643, 7649,
                7669, 7673, 7681, 7687, 7691, 7699, 7703, 7717, 7723, 7727, 7741, 7753, 7757, 7759, 7789, 7793, 7817,
                7823, 7829, 7841, 7853, 7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919, 7927, 7933, 7937, 7949, 7951,
                7963, 7993, 8009, 8011, 8017, 8039, 8053, 8059, 8069, 8081, 8087, 8089, 8093, 8101, 8111, 8117, 8123,
                8147, 8161, 8167, 8171, 8179, 8191, 8209, 8219, 8221, 8231, 8233, 8237, 8243, 8263, 8269, 8273, 8287,
                8291, 8293, 8297, 8311, 8317, 8329, 8353, 8363, 8369, 8377, 8387, 8389, 8419, 8423, 8429, 8431, 8443,
                8447, 8461, 8467, 8501, 8513, 8521, 8527, 8537, 8539, 8543, 8563, 8573, 8581, 8597, 8599, 8609, 8623,
                8627, 8629, 8641, 8647, 8663, 8669, 8677, 8681, 8689, 8693, 8699, 8707, 8713, 8719, 8731, 8737, 8741,
                8747, 8753, 8761, 8779, 8783, 8803, 8807, 8819, 8821, 8831, 8837, 8839, 8849, 8861, 8863, 8867, 8887,
                8893, 8923, 8929, 8933, 8941, 8951, 8963, 8969, 8971, 8999, 9001, 9007, 9011, 9013, 9029, 9041, 9043,
                9049, 9059, 9067, 9091, 9103, 9109, 9127, 9133, 9137, 9151, 9157, 9161, 9173, 9181, 9187, 9199, 9203,
                9209, 9221, 9227, 9239, 9241, 9257, 9277, 9281, 9283, 9293, 9311, 9319, 9323, 9337, 9341, 9343, 9349,
                9371, 9377, 9391, 9397, 9403, 9413, 9419, 9421, 9431, 9433, 9437, 9439, 9461, 9463, 9467, 9473, 9479,
                9491, 9497, 9511, 9521, 9533, 9539, 9547, 9551, 9587, 9601, 9613, 9619, 9623, 9629, 9631, 9643, 9649,
                9661, 9677, 9679, 9689, 9697, 9719, 9721, 9733, 9739, 9743, 9749, 9767, 9769, 9781, 9787, 9791, 9803,
                9811, 9817, 9829, 9833, 9839, 9851, 9857, 9859, 9871, 9883, 9887, 9901, 9907, 9923, 9929, 9931, 9941,
                9949, 9967, 9973, 10007, 10009, 10037, 10039, 10061, 10067, 10069, 10079, 10091, 10093, 10099, 10103,
                10111, 10133, 10139, 10141, 10151, 10159, 10163, 10169, 10177, 10181, 10193, 10211, 10223, 10243, 10247,
                10253, 10259, 10267, 10271, 10273, 10289, 10301, 10303, 10313, 10321, 10331, 10333, 10337, 10343, 10357,
                10369, 10391, 10399, 10427, 10429, 10433, 10453, 10457, 10459, 10463, 10477, 10487, 10499, 10501, 10513,
                10529, 10531, 10559, 10567, 10589, 10597, 10601, 10607, 10613, 10627, 10631, 10639, 10651, 10657, 10663,
                10667, 10687, 10691, 10709, 10711, 10723, 10729, 10733, 10739, 10753, 10771, 10781, 10789, 10799, 10831,
                10837, 10847, 10853, 10859, 10861, 10867, 10883, 10889, 10891, 10903, 10909, 10937, 10939, 10949, 10957,
                10973, 10979, 10987, 10993, 11003, 11027, 11047, 11057, 11059, 11069, 11071, 11083, 11087, 11093, 11113,
                11117, 11119, 11131, 11149, 11159, 11161, 11171, 11173, 11177, 11197, 11213, 11239, 11243, 11251, 11257,
                11261, 11273, 11279, 11287, 11299, 11311, 11317, 11321, 11329, 11351, 11353, 11369, 11383, 11393, 11399,
                11411, 11423, 11437, 11443, 11447, 11467, 11471, 11483, 11489, 11491, 11497, 11503, 11519, 11527, 11549,
                11551, 11579, 11587, 11593, 11597, 11617, 11621, 11633, 11657, 11677, 11681, 11689, 11699, 11701, 11717,
                11719, 11731, 11743, 11777, 11779, 11783, 11789, 11801, 11807, 11813, 11821, 11827, 11831, 11833, 11839,
                11863, 11867, 11887, 11897, 11903, 11909, 11923, 11927, 11933, 11939, 11941, 11953, 11959, 11969, 11971,
                11981, 11987, 12007, 12011, 12037, 12041, 12043, 12049, 12071, 12073, 12097, 12101, 12107, 12109, 12113,
                12119, 12143, 12149, 12157, 12161, 12163, 12197, 12203, 12211, 12227, 12239, 12241, 12251, 12253, 12263,
                12269, 12277, 12281, 12289, 12301, 12323, 12329, 12343, 12347, 12373, 12377, 12379, 12391, 12401, 12409,
                12413, 12421, 12433, 12437, 12451, 12457, 12473, 12479, 12487, 12491, 12497, 12503, 12511, 12517, 12527,
                12539, 12541, 12547, 12553, 12569, 12577, 12583, 12589, 12601, 12611, 12613, 12619, 12637, 12641, 12647,
                12653, 12659, 12671, 12689, 12697, 12703, 12713, 12721, 12739, 12743, 12757, 12763, 12781, 12791, 12799,
                12809, 12821, 12823, 12829, 12841, 12853, 12889, 12893, 12899, 12907, 12911, 12917, 12919, 12923, 12941,
                12953, 12959, 12967, 12973, 12979, 12983, 13001, 13003, 13007, 13009, 13033, 13037, 13043, 13049, 13063,
                13093, 13099, 13103, 13109, 13121, 13127, 13147, 13151, 13159, 13163, 13171, 13177, 13183, 13187, 13217,
                13219, 13229, 13241, 13249, 13259, 13267, 13291, 13297, 13309, 13313, 13327, 13331, 13337, 13339, 13367,
                13381, 13397, 13399, 13411, 13417, 13421, 13441, 13451, 13457, 13463, 13469, 13477, 13487, 13499, 13513,
                13523, 13537, 13553, 13567, 13577, 13591, 13597, 13613, 13619, 13627, 13633, 13649, 13669, 13679, 13681,
                13687, 13691, 13693, 13697, 13709, 13711, 13721, 13723, 13729, 13751, 13757, 13759, 13763, 13781, 13789,
                13799, 13807, 13829, 13831, 13841, 13859, 13873, 13877, 13879, 13883, 13901, 13903, 13907, 13913, 13921,
                13931, 13933, 13963, 13967, 13997, 13999, 14009, 14011, 14029, 14033, 14051, 14057, 14071, 14081, 14083,
                14087, 14107, 14143, 14149, 14153, 14159, 14173, 14177, 14197, 14207, 14221, 14243, 14249, 14251, 14281,
                14293, 14303, 14321, 14323, 14327, 14341, 14347, 14369, 14387, 14389, 14401, 14407, 14411, 14419, 14423,
                14431, 14437, 14447, 14449, 14461, 14479, 14489, 14503, 14519, 14533, 14537, 14543, 14549, 14551, 14557,
                14561, 14563, 14591, 14593, 14621, 14627, 14629, 14633, 14639, 14653, 14657, 14669, 14683, 14699, 14713,
                14717, 14723, 14731, 14737, 14741, 14747, 14753, 14759, 14767, 14771, 14779, 14783, 14797, 14813, 14821,
                14827, 14831, 14843, 14851, 14867, 14869, 14879, 14887, 14891, 14897, 14923, 14929, 14939, 14947, 14951,
                14957, 14969, 14983, 15013, 15017, 15031, 15053, 15061, 15073, 15077, 15083, 15091, 15101, 15107, 15121,
                15131, 15137, 15139, 15149, 15161, 15173, 15187, 15193, 15199, 15217, 15227, 15233, 15241, 15259, 15263,
                15269, 15271, 15277, 15287, 15289, 15299, 15307, 15313, 15319, 15329, 15331, 15349, 15359, 15361, 15373,
                15377, 15383, 15391, 15401, 15413, 15427, 15439, 15443, 15451, 15461, 15467, 15473, 15493, 15497, 15511,
                15527, 15541, 15551, 15559, 15569, 15581, 15583, 15601, 15607, 15619, 15629, 15641, 15643, 15647, 15649,
                15661, 15667, 15671, 15679, 15683, 15727, 15731, 15733, 15737, 15739, 15749, 15761, 15767, 15773, 15787,
                15791, 15797, 15803, 15809, 15817, 15823, 15859, 15877, 15881, 15887, 15889, 15901, 15907, 15913, 15919,
                15923, 15937, 15959, 15971, 15973, 15991, 16001, 16007, 16033, 16057, 16061, 16063, 16067, 16069, 16073,
                16087, 16091, 16097, 16103, 16111, 16127, 16139, 16141, 16183, 16187, 16189, 16193, 16217, 16223, 16229,
                16231, 16249, 16253, 16267, 16273, 16301, 16319, 16333, 16339, 16349, 16361, 16363, 16369, 16381, 16411,
                16417, 16421, 16427, 16433, 16447, 16451, 16453, 16477, 16481, 16487, 16493, 16519, 16529, 16547, 16553,
                16561, 16567, 16573, 16603, 16607, 16619, 16631, 16633, 16649, 16651, 16657, 16661, 16673, 16691, 16693,
                16699, 16703, 16729, 16741, 16747, 16759, 16763, 16787, 16811, 16823, 16829, 16831, 16843, 16871, 16879,
                16883, 16889, 16901, 16903, 16921, 16927, 16931, 16937, 16943, 16963, 16979, 16981, 16987, 16993, 17011,
                17021, 17027, 17029, 17033, 17041, 17047, 17053, 17077, 17093, 17099, 17107, 17117, 17123, 17137, 17159,
                17167, 17183, 17189, 17191, 17203, 17207, 17209, 17231, 17239, 17257, 17291, 17293, 17299, 17317, 17321,
                17327, 17333, 17341, 17351, 17359, 17377, 17383, 17387, 17389, 17393, 17401, 17417, 17419, 17431, 17443,
                17449, 17467, 17471, 17477, 17483, 17489, 17491, 17497, 17509, 17519, 17539, 17551, 17569, 17573, 17579,
                17581, 17597, 17599, 17609, 17623, 17627, 17657, 17659, 17669, 17681, 17683, 17707, 17713, 17729, 17737,
                17747, 17749, 17761, 17783, 17789, 17791, 17807, 17827, 17837, 17839, 17851, 17863, 17881, 17891, 17903,
                17909, 17911, 17921, 17923, 17929, 17939, 17957, 17959, 17971, 17977, 17981, 17987, 17989, 18013, 18041,
                18043, 18047, 18049, 18059, 18061, 18077, 18089, 18097, 18119, 18121, 18127, 18131, 18133, 18143, 18149,
                18169, 18181, 18191, 18199, 18211, 18217, 18223, 18229, 18233, 18251, 18253, 18257, 18269, 18287, 18289,
                18301, 18307, 18311, 18313, 18329, 18341, 18353, 18367, 18371, 18379, 18397, 18401, 18413, 18427, 18433,
                18439, 18443, 18451, 18457, 18461, 18481, 18493, 18503, 18517, 18521, 18523, 18539, 18541, 18553, 18583,
                18587, 18593, 18617, 18637, 18661, 18671, 18679, 18691, 18701, 18713, 18719, 18731, 18743, 18749, 18757,
                18773, 18787, 18793, 18797, 18803, 18839, 18859, 18869, 18899, 18911, 18913, 18917, 18919, 18947, 18959,
                18973, 18979, 19001, 19009, 19013, 19031, 19037, 19051, 19069, 19073, 19079, 19081, 19087, 19121, 19139,
                19141, 19157, 19163, 19181, 19183, 19207, 19211, 19213, 19219, 19231, 19237, 19249, 19259, 19267, 19273,
                19289, 19301, 19309, 19319, 19333, 19373, 19379, 19381, 19387, 19391, 19403, 19417, 19421, 19423, 19427,
                19429, 19433, 19441, 19447, 19457, 19463, 19469, 19471, 19477, 19483, 19489, 19501, 19507, 19531, 19541,
                19543, 19553, 19559, 19571, 19577, 19583, 19597, 19603, 19609, 19661, 19681, 19687, 19697, 19699, 19709,
                19717, 19727, 19739, 19751, 19753, 19759, 19763, 19777, 19793, 19801, 19813, 19819, 19841, 19843, 19853,
                19861, 19867, 19889, 19891, 19913, 19919, 19927, 19937, 19949, 19961, 19963, 19973, 19979, 19991, 19993,
                19997, 20011, 20021, 20023, 20029, 20047, 20051, 20063, 20071, 20089, 20101, 20107, 20113, 20117, 20123,
                20129, 20143, 20147, 20149, 20161, 20173, 20177, 20183, 20201, 20219, 20231, 20233, 20249, 20261, 20269,
                20287, 20297, 20323, 20327, 20333, 20341, 20347, 20353, 20357, 20359, 20369, 20389, 20393, 20399, 20407,
                20411, 20431, 20441, 20443, 20477, 20479, 20483, 20507, 20509, 20521, 20533, 20543, 20549, 20551, 20563,
                20593, 20599, 20611, 20627, 20639, 20641, 20663, 20681, 20693, 20707, 20717, 20719, 20731, 20743, 20747,
                20749, 20753, 20759, 20771, 20773, 20789, 20807, 20809, 20849, 20857, 20873, 20879, 20887, 20897, 20899,
                20903, 20921, 20929, 20939, 20947, 20959, 20963, 20981, 20983, 21001, 21011, 21013, 21017, 21019, 21023,
                21031, 21059, 21061, 21067, 21089, 21101, 21107, 21121, 21139, 21143, 21149, 21157, 21163, 21169, 21179,
                21187, 21191, 21193, 21211, 21221, 21227, 21247, 21269, 21277, 21283, 21313, 21317, 21319, 21323, 21341,
                21347, 21377, 21379, 21383, 21391, 21397, 21401, 21407, 21419, 21433, 21467, 21481, 21487, 21491, 21493,
                21499, 21503, 21517, 21521, 21523, 21529, 21557, 21559, 21563, 21569, 21577, 21587, 21589, 21599, 21601,
                21611, 21613, 21617, 21647, 21649, 21661, 21673, 21683, 21701, 21713, 21727, 21737, 21739, 21751, 21757,
                21767, 21773, 21787, 21799, 21803, 21817, 21821, 21839, 21841, 21851, 21859, 21863, 21871, 21881, 21893,
                21911, 21929, 21937, 21943, 21961, 21977, 21991, 21997, 22003, 22013, 22027, 22031, 22037, 22039, 22051,
                22063, 22067, 22073, 22079, 22091, 22093, 22109, 22111, 22123, 22129, 22133, 22147, 22153, 22157, 22159,
                22171, 22189, 22193, 22229, 22247, 22259, 22271, 22273, 22277, 22279, 22283, 22291, 22303, 22307, 22343,
                22349, 22367, 22369, 22381, 22391, 22397, 22409, 22433, 22441, 22447, 22453, 22469, 22481, 22483, 22501,
                22511, 22531, 22541, 22543, 22549, 22567, 22571, 22573, 22613, 22619, 22621, 22637, 22639, 22643, 22651,
                22669, 22679, 22691, 22697, 22699, 22709, 22717, 22721, 22727, 22739, 22741, 22751, 22769, 22777, 22783,
                22787, 22807, 22811, 22817, 22853, 22859, 22861, 22871, 22877, 22901, 22907, 22921, 22937, 22943, 22961,
                22963, 22973, 22993, 23003, 23011, 23017, 23021, 23027, 23029, 23039, 23041, 23053, 23057, 23059, 23063,
                23071, 23081, 23087, 23099, 23117, 23131, 23143, 23159, 23167, 23173, 23189, 23197, 23201, 23203, 23209,
                23227, 23251, 23269, 23279, 23291, 23293, 23297, 23311, 23321, 23327, 23333, 23339, 23357, 23369, 23371,
                23399, 23417, 23431, 23447, 23459, 23473, 23497, 23509, 23531, 23537, 23539, 23549, 23557, 23561, 23563,
                23567, 23581, 23593, 23599, 23603, 23609, 23623, 23627, 23629, 23633, 23663, 23669, 23671, 23677, 23687,
                23689, 23719, 23741, 23743, 23747, 23753, 23761, 23767, 23773, 23789, 23801, 23813, 23819, 23827, 23831,
                23833, 23857, 23869, 23873, 23879, 23887, 23893, 23899, 23909, 23911, 23917, 23929, 23957, 23971, 23977,
                23981, 23993, 24001, 24007, 24019, 24023, 24029, 24043, 24049, 24061, 24071, 24077, 24083, 24091, 24097,
                24103, 24107, 24109, 24113, 24121, 24133, 24137, 24151, 24169, 24179, 24181, 24197, 24203, 24223, 24229,
                24239, 24247, 24251, 24281, 24317, 24329, 24337, 24359, 24371, 24373, 24379, 24391, 24407, 24413, 24419,
                24421, 24439, 24443, 24469, 24473, 24481, 24499, 24509, 24517, 24527, 24533, 24547, 24551, 24571, 24593,
                24611, 24623, 24631, 24659, 24671, 24677, 24683, 24691, 24697, 24709, 24733, 24749, 24763, 24767, 24781,
                24793, 24799, 24809, 24821, 24841, 24847, 24851, 24859, 24877, 24889, 24907, 24917, 24919, 24923, 24943,
                24953, 24967, 24971, 24977, 24979, 24989, 25013, 25031, 25033, 25037, 25057, 25073, 25087, 25097, 25111,
                25117, 25121, 25127, 25147, 25153, 25163, 25169, 25171, 25183, 25189, 25219, 25229, 25237, 25243, 25247,
                25253, 25261, 25301, 25303, 25307, 25309, 25321, 25339, 25343, 25349, 25357, 25367, 25373, 25391, 25409,
                25411, 25423, 25439, 25447, 25453, 25457, 25463, 25469, 25471, 25523, 25537, 25541, 25561, 25577, 25579,
                25583, 25589, 25601, 25603, 25609, 25621, 25633, 25639, 25643, 25657, 25667, 25673, 25679, 25693, 25703,
                25717, 25733, 25741, 25747, 25759, 25763, 25771, 25793, 25799, 25801, 25819, 25841, 25847, 25849, 25867,
                25873, 25889, 25903, 25913, 25919, 25931, 25933, 25939, 25943, 25951, 25969, 25981, 25997, 25999, 26003,
                26017, 26021, 26029, 26041, 26053, 26083, 26099, 26107, 26111, 26113, 26119, 26141, 26153, 26161, 26171,
                26177, 26183, 26189, 26203, 26209, 26227, 26237, 26249, 26251, 26261, 26263, 26267, 26293, 26297, 26309,
                26317, 26321, 26339, 26347, 26357, 26371, 26387, 26393, 26399, 26407, 26417, 26423, 26431, 26437, 26449,
                26459, 26479, 26489, 26497, 26501, 26513, 26539, 26557, 26561, 26573, 26591, 26597, 26627, 26633, 26641,
                26647, 26669, 26681, 26683, 26687, 26693, 26699, 26701, 26711, 26713, 26717, 26723, 26729, 26731, 26737,
                26759, 26777, 26783, 26801, 26813, 26821, 26833, 26839, 26849, 26861, 26863, 26879, 26881, 26891, 26893,
                26903, 26921, 26927, 26947, 26951, 26953, 26959, 26981, 26987, 26993, 27011, 27017, 27031, 27043, 27059,
                27061, 27067, 27073, 27077, 27091, 27103, 27107, 27109, 27127, 27143, 27179, 27191, 27197, 27211, 27239,
                27241, 27253, 27259, 27271, 27277, 27281, 27283, 27299, 27329, 27337, 27361, 27367, 27397, 27407, 27409,
                27427, 27431, 27437, 27449, 27457, 27479, 27481, 27487, 27509, 27527, 27529, 27539, 27541, 27551, 27581,
                27583, 27611, 27617, 27631, 27647, 27653, 27673, 27689, 27691, 27697, 27701, 27733, 27737, 27739, 27743,
                27749, 27751, 27763, 27767, 27773, 27779, 27791, 27793, 27799, 27803, 27809, 27817, 27823, 27827, 27847,
                27851, 27883, 27893, 27901, 27917, 27919, 27941, 27943, 27947, 27953, 27961, 27967, 27983, 27997, 28001,
                28019, 28027, 28031, 28051, 28057, 28069, 28081, 28087, 28097, 28099, 28109, 28111, 28123, 28151, 28163,
                28181, 28183, 28201, 28211, 28219, 28229, 28277, 28279, 28283, 28289, 28297, 28307, 28309, 28319, 28349,
                28351, 28387, 28393, 28403, 28409, 28411, 28429, 28433, 28439, 28447, 28463, 28477, 28493, 28499, 28513,
                28517, 28537, 28541, 28547, 28549, 28559, 28571, 28573, 28579, 28591, 28597, 28603, 28607, 28619, 28621,
                28627, 28631, 28643, 28649, 28657, 28661, 28663, 28669, 28687, 28697, 28703, 28711, 28723, 28729, 28751,
                28753, 28759, 28771, 28789, 28793, 28807, 28813, 28817, 28837, 28843, 28859, 28867, 28871, 28879, 28901,
                28909, 28921, 28927, 28933, 28949, 28961, 28979, 29009, 29017, 29021, 29023, 29027, 29033, 29059, 29063,
                29077, 29101, 29123, 29129, 29131, 29137, 29147, 29153, 29167, 29173, 29179, 29191, 29201, 29207, 29209,
                29221, 29231, 29243, 29251, 29269, 29287, 29297, 29303, 29311, 29327, 29333, 29339, 29347, 29363, 29383,
                29387, 29389, 29399, 29401, 29411, 29423, 29429, 29437, 29443, 29453, 29473, 29483, 29501, 29527, 29531,
                29537, 29567, 29569, 29573, 29581, 29587, 29599, 29611, 29629, 29633, 29641, 29663, 29669, 29671, 29683,
                29717, 29723, 29741, 29753, 29759, 29761, 29789, 29803, 29819, 29833, 29837, 29851, 29863, 29867, 29873,
                29879, 29881, 29917, 29921, 29927, 29947, 29959, 29983, 29989, 30011, 30013, 30029, 30047, 30059, 30071,
                30089, 30091, 30097, 30103, 30109, 30113, 30119, 30133, 30137, 30139, 30161, 30169, 30181, 30187, 30197,
                30203, 30211, 30223, 30241, 30253, 30259, 30269, 30271, 30293, 30307, 30313, 30319, 30323, 30341, 30347,
                30367, 30389, 30391, 30403, 30427, 30431, 30449, 30467, 30469, 30491, 30493, 30497, 30509, 30517, 30529,
                30539, 30553, 30557, 30559, 30577, 30593, 30631, 30637, 30643, 30649, 30661, 30671, 30677, 30689, 30697,
                30703, 30707, 30713, 30727, 30757, 30763, 30773, 30781, 30803, 30809, 30817, 30829, 30839, 30841, 30851,
                30853, 30859, 30869, 30871, 30881, 30893, 30911, 30931, 30937, 30941, 30949, 30971, 30977, 30983, 31013,
                31019, 31033, 31039, 31051, 31063, 31069, 31079, 31081, 31091, 31121, 31123, 31139, 31147, 31151, 31153,
                31159, 31177, 31181, 31183, 31189, 31193, 31219, 31223, 31231, 31237, 31247, 31249, 31253, 31259, 31267,
                31271, 31277, 31307, 31319, 31321, 31327, 31333, 31337, 31357, 31379, 31387, 31391, 31393, 31397, 31469,
                31477, 31481, 31489, 31511, 31513, 31517, 31531, 31541, 31543, 31547, 31567, 31573, 31583, 31601, 31607,
                31627, 31643, 31649, 31657, 31663, 31667, 31687, 31699, 31721, 31723, 31727, 31729, 31741, 31751, 31769,
                31771, 31793, 31799, 31817, 31847, 31849, 31859, 31873, 31883, 31891, 31907, 31957, 31963, 31973, 31981,
                31991, 32003, 32009, 32027, 32029, 32051, 32057, 32059, 32063, 32069, 32077, 32083, 32089, 32099, 32117,
                32119, 32141, 32143, 32159, 32173, 32183, 32189, 32191, 32203, 32213, 32233, 32237, 32251, 32257, 32261,
                32297, 32299, 32303, 32309, 32321, 32323, 32327, 32341, 32353, 32359, 32363, 32369, 32371, 32377, 32381,
                32401, 32411, 32413, 32423, 32429, 32441, 32443, 32467, 32479, 32491, 32497, 32503, 32507, 32531, 32533,
                32537, 32561, 32563, 32569, 32573, 32579, 32587, 32603, 32609, 32611, 32621, 32633, 32647, 32653, 32687,
                32693, 32707, 32713, 32717, 32719, 32749,
            ]
        );
    /// <summary>Performs the index operation.</summary>
    /// <param name="index">The index.</param>
    /// <returns>The prime at the specified index.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure, ValueRange(Min, MaxInt16)]
    public static short Index(int index) =>
#if NETCOREAPP || ROSLYN
        Int16[index.Mod(Int16.Length)];
#else
        Int16[index.Mod(Int16.Count)];
#endif
    /// <inheritdoc cref="Index(int)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure, ValueRange(Min, MaxInt16)]
    internal static short Index(Index index) => Index(index.IsFromEnd ? -index.Value - 1 : index.Value);
}
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable once CheckNamespace
/// <summary>Extension methods for iterating over a set of elements, or for generating new ones.</summary>
    /// <summary>
    /// Defines an <see cref="IEnumerable{T}"/> with a <see cref="Delegate"/> that is invoked on iteration.
    /// </summary>
    /// <typeparam name="T">The type of item in the <see cref="IEnumerable{T}"/>.</typeparam>
    /// <typeparam name="TExternal">The context element to pass into the <see cref="Delegate"/>.</typeparam>
    sealed partial class Enumerable<T, TExternal> : IEnumerable<T>
    {
        readonly Delegate _action;
        readonly IEnumerable<T> _enumerable;
        readonly TExternal _external;
        /// <inheritdoc />
        public Enumerable([ProvidesContext] IEnumerable<T> enumerable, TExternal external, Action<T> action)
            : this(enumerable, external, (Delegate)action) { }
        /// <inheritdoc />
        public Enumerable([ProvidesContext] IEnumerable<T> enumerable, TExternal external, Action<T, int> action)
            : this(enumerable, external, (Delegate)action) { }
        /// <inheritdoc />
        public Enumerable([ProvidesContext] IEnumerable<T> enumerable, TExternal external, Action<T, TExternal> action)
            : this(enumerable, external, (Delegate)action) { }
        /// <inheritdoc />
        public Enumerable(
            [ProvidesContext] IEnumerable<T> enumerable,
            TExternal external,
            Action<T, int, TExternal> action
        )
            : this(enumerable, external, (Delegate)action) { }
        /// <summary>Initializes a new instance of the <see cref="Enumerable{T, TExternal}"/> class.</summary>
        /// <param name="enumerable">
        /// The <see cref="IEnumerable{T}"/> to create an <see cref="IEnumerator{T}"/> from.
        /// </param>
        /// <param name="external">The context element.</param>
        /// <param name="action">The <see cref="Delegate"/> to invoke on iteration.</param>
        Enumerable([ProvidesContext] IEnumerable<T> enumerable, TExternal external, Delegate action)
        {
            _enumerable = enumerable;
            _external = external;
            _action = action;
        }
        /// <summary>
        /// Implicitly converts the parameter by creating the new instance of <see cref="Enumerable{T, TExternal}"/>
        /// by using the constructor <see cref="Enumerable{T, TExternal}(IEnumerable{T}, TExternal, Action{T})"/>.
        /// </summary>
        /// <param name="tuple">The parameter to pass onto the constructor.</param>
        /// <returns>
        /// The new instance of <see cref="Enumerable{T, TExternal}"/> by passing the parameter <paramref name="tuple"/>
        /// to the constructor <see cref="Enumerable{T, TExternal}(IEnumerable{T}, TExternal, Action{T})"/>.
        /// </returns>
        [Pure]
        public static implicit operator Enumerable<T, TExternal>(
            (IEnumerable<T> Enumerable, TExternal External, Action<T> Action) tuple
        ) =>
            new(tuple.Enumerable, tuple.External, tuple.Action);
        /// <summary>
        /// Implicitly converts the parameter by creating the new instance of <see cref="Enumerable{T, TExternal}"/>
        /// by using the constructor <see cref="Enumerable{T, TExternal}(IEnumerable{T}, TExternal, Action{T, int})"/>.
        /// </summary>
        /// <param name="tuple">The parameter to pass onto the constructor.</param>
        /// <returns>
        /// The new instance of Enumerable{T, TExternal} by passing the parameter <paramref name="tuple"/> to
        /// the constructor <see cref="Enumerable{T, TExternal}(IEnumerable{T}, TExternal, Action{T, int})"/>.
        /// </returns>
        [Pure]
        public static implicit operator Enumerable<T, TExternal>(
            (IEnumerable<T> Enumerable, TExternal External, Action<T, int> Action) tuple
        ) =>
            new(tuple.Enumerable, tuple.External, tuple.Action);
        /// <summary>
        /// Implicitly converts the parameter by creating the new instance of <see cref="Enumerable{T, TExternal}"/>
        /// by using the constructor <see cref="Enumerable{T, TExternal}(IEnumerable{T}, TExternal, Action{T, TExternal})"/>.
        /// </summary>
        /// <param name="tuple">The parameter to pass onto the constructor.</param>
        /// <returns>
        /// The new instance of <see cref="Enumerable{T, TExternal}"/> by passing the parameter <paramref name="tuple"/>
        /// to the constructor <see cref="Enumerable{T, TExternal}(IEnumerable{T}, TExternal, Action{T, TExternal})"/>.
        /// </returns>
        [Pure]
        public static implicit operator Enumerable<T, TExternal>(
            (IEnumerable<T> Enumerable, TExternal External, Action<T, TExternal> Action) tuple
        ) =>
            new(tuple.Enumerable, tuple.External, tuple.Action);
        /// <summary>
        /// Implicitly converts the parameter by creating the new instance of Enumerable{T, TExternal} by using the
        /// constructor <see cref="Enumerable{T, TExternal}(IEnumerable{T}, TExternal, Action{T, int, TExternal})"/>.
        /// </summary>
        /// <param name="tuple">The parameter to pass onto the constructor.</param>
        /// <returns>
        /// The new instance of <see cref="Enumerable{T, TExternal}"/> by passing the parameter <paramref name="tuple"/>
        /// to the constructor <see cref="Enumerable{T, TExternal}(IEnumerable{T}, TExternal, Action{T, int, TExternal})"/>.
        /// </returns>
        [Pure]
        public static implicit operator Enumerable<T, TExternal>(
            (IEnumerable<T> Enumerable, TExternal External, Action<T, int, TExternal> Action) tuple
        ) =>
            new(tuple.Enumerable, tuple.External, tuple.Action);
        /// <inheritdoc />
        [CollectionAccess(CollectionAccessType.Read), MustDisposeResource, Pure]
        public IEnumerator<T> GetEnumerator() => new Enumerator(_enumerable.GetEnumerator(), _external, _action);
        /// <inheritdoc />
        [CollectionAccess(CollectionAccessType.Read), MustDisposeResource, Pure]
        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
        sealed class Enumerator(
            [HandlesResourceDisposal, ProvidesContext] IEnumerator<T> enumerator,
            TExternal external,
            Delegate action
        ) : IEnumerator<T>
        {
            int _index;
            /// <inheritdoc />
            public T Current => enumerator.Current;
            /// <inheritdoc />
            object? IEnumerator.Current => ((IEnumerator)enumerator).Current;
            /// <inheritdoc />
            public void Reset()
            {
                enumerator.Reset();
                _index = 0;
            }
            /// <inheritdoc />
            public void Dispose() => enumerator.Dispose();
            /// <inheritdoc />
            public bool MoveNext()
            {
                if (!enumerator.MoveNext())
                    return false;
                var current = Current;
                switch (action)
                {
                    case Action<T> a:
                        a(current);
                        break;
                    case Action<T, int> a:
                        a(current, _index);
                        break;
                    case Action<T, TExternal> a:
                        a(current, external);
                        break;
                    case Action<T, int, TExternal> a:
                        a(current, _index, external);
                        break;
                }
                _index++;
                return true;
            }
        }
    }
    /// <summary>
    /// The <see langword="foreach"/> statement executes a statement or a block of statements for each element in an
    /// instance of the type that implements the <see cref="IEnumerable{T}"/> interface.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-foreach-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <typeparam name="T">The type of iterator.</typeparam>
    /// <param name="iterable">The collection of items to go through one-by-one.</param>
    /// <param name="action">The action to do on each item in <paramref name="iterable"/>.</param>
    /// <returns>The parameter <paramref name="iterable"/>.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<T> Lazily<T>([NoEnumeration] this IEnumerable<T> iterable, Action<T> action) =>
        new Enumerable<T, object?>(iterable, null, action);
    /// <summary>
    /// The <see langword="foreach"/> statement executes a statement or a block of statements for each element in an
    /// instance of the type that implements the <see cref="IEnumerable{T}"/> interface.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-foreach-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <typeparam name="T">The type of iterator.</typeparam>
    /// <typeparam name="TExternal">The type of external parameter to pass into the callback.</typeparam>
    /// <param name="iterable">The collection of items to go through one-by-one.</param>
    /// <param name="external">Any external parameter to be passed repeatedly into the callback.</param>
    /// <param name="action">The action to do on each item in <paramref name="iterable"/>.</param>
    /// <returns>The parameter <paramref name="iterable"/>.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<T> Lazily<T, TExternal>(
        [NoEnumeration] this IEnumerable<T> iterable,
        TExternal external,
        Action<T, TExternal> action
    ) =>
        new Enumerable<T, TExternal>(iterable, external, action);
    /// <summary>
    /// The <see langword="foreach"/> statement executes a statement or a block of statements for each element in an
    /// instance of the type that implements the <see cref="IEnumerable{T}"/> interface.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-foreach-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <typeparam name="T">The type of iterator.</typeparam>
    /// <param name="iterable">The collection of items to go through one-by-one.</param>
    /// <param name="action">The action to do on each item in <paramref name="iterable"/>.</param>
    /// <returns>The parameter <paramref name="iterable"/>.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<T> Lazily<T>([NoEnumeration] this IEnumerable<T> iterable, Action<T, int> action) =>
        new Enumerable<T, object?>(iterable, null, action);
    /// <summary>
    /// The <see langword="foreach"/> statement executes a statement or a block of statements for each element in an
    /// instance of the type that implements the <see cref="IEnumerable{T}"/> interface.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-foreach-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <typeparam name="T">The type of iterator.</typeparam>
    /// <typeparam name="TExternal">The type of external parameter to pass into the callback.</typeparam>
    /// <param name="iterable">The collection of items to go through one-by-one.</param>
    /// <param name="external">Any external parameter to be passed repeatedly into the callback.</param>
    /// <param name="action">The action to do on each item in <paramref name="iterable"/>.</param>
    /// <returns>The parameter <paramref name="iterable"/>.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<T> Lazily<T, TExternal>(
        [NoEnumeration] this IEnumerable<T> iterable,
        TExternal external,
        Action<T, int, TExternal> action
    ) =>
        new Enumerable<T, TExternal>(iterable, external, action);
// SPDX-License-Identifier: MPL-2.0
#if (NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) && !NO_SYSTEM_MEMORY
// ReSharper disable once CheckNamespace RedundantUsingDirective
/// <summary>Contains extension methods for fast SIMD operations.</summary>
// ReSharper disable NullableWarningSuppressionIsUsed RedundantSuppressNullableWarningExpression
    /// <summary>Determines whether the type is a numeric primitive.</summary>
    /// <typeparam name="T">The type to test.</typeparam>
    /// <returns>Whether the type parameter <typeparamref name="T"/> is a primitive representing a number.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool IsNumericPrimitive<T>()
#if !NO_ALLOWS_REF_STRUCT
        where T : allows ref struct
#endif
        =>
            typeof(T) == typeof(byte) ||
            typeof(T) == typeof(double) ||
            typeof(T) == typeof(float) ||
            typeof(T) == typeof(int) ||
            typeof(T) == typeof(long) ||
            typeof(T) == typeof(nint) ||
            typeof(T) == typeof(nuint) ||
            typeof(T) == typeof(sbyte) ||
            typeof(T) == typeof(short) ||
            typeof(T) == typeof(uint) ||
            typeof(T) == typeof(ulong) ||
            typeof(T) == typeof(ushort);
    /// <inheritdoc cref="Range{T}(Span{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Span<T> Range<T>(this IMemoryOwner<T> source) => Range(source.Memory.Span);
    /// <inheritdoc cref="Range{T}(Span{T}, int)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Span<T> Range<T>(this IMemoryOwner<T> source, int index) => Range(source.Memory.Span, index);
    /// <inheritdoc cref="Range{T}(Span{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Span<T> Range<T>(this Memory<T> source) => Range(source.Span);
    /// <inheritdoc cref="Range{T}(Span{T}, int)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Span<T> Range<T>(this Memory<T> source, int index) => Range(source.Span, index);
    /// <summary>Creates the range.</summary>
    /// <typeparam name="T">The type of number.</typeparam>
    /// <param name="source">The <see cref="Span{T}"/> to mutate.</param>
    /// <exception cref="MissingMethodException">The type <typeparamref name="T"/> is unsupported.</exception>
    /// <returns>The parameter <paramref name="source"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Span<T> Range<T>(this Span<T> source)
    {
        switch (source.Length)
        {
            case 0: return source;
            case 1:
                MemoryMarshal.GetReference(source) = default!;
                return source;
            case var length:
                if (!IsNumericPrimitive<T>() && !IsSupported<T>())
                    _ = Fail<T>();
                SpanRange<T>(length).CopyTo(source);
                return source;
        }
    }
    /// <summary>Creates the range.</summary>
    /// <typeparam name="T">The type of number.</typeparam>
    /// <param name="source">The <see cref="Span{T}"/> to mutate.</param>
    /// <param name="index">The starting index.</param>
    /// <exception cref="MissingMethodException">The type <typeparamref name="T"/> is unsupported.</exception>
    /// <returns>The parameter <paramref name="source"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Span<T> Range<T>(this Span<T> source, int index)
    {
        if (source.Length is 0)
            return source;
        if (!IsNumericPrimitive<T>() && !IsSupported<T>())
            _ = Fail<T>();
        SpanRange<T>(index + source.Length).UnsafelySkip(index).CopyTo(source);
        return source;
    }
    /// <inheritdoc cref="InAscendingOrder{T}.Memory"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ReadOnlyMemory<byte> AsMemory(this byte length) => MemoryRange<byte>(length + 1)[length..];
    /// <inheritdoc cref="InAscendingOrder{T}.Memory"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ReadOnlyMemory<char> AsMemory(this char length) => MemoryRange<char>(length + 1)[length..];
    /// <inheritdoc cref="InAscendingOrder{T}.Memory"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ReadOnlyMemory<sbyte> AsMemory(this sbyte length) => MemoryRange<sbyte>(length + 1)[length..];
    /// <inheritdoc cref="InAscendingOrder{T}.Memory"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ReadOnlyMemory<short> AsMemory(this short length) => MemoryRange<short>(length + 1)[length..];
    /// <inheritdoc cref="InAscendingOrder{T}.Memory"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ReadOnlyMemory<ushort> AsMemory(this ushort length) => MemoryRange<ushort>(length + 1)[length..];
    /// <inheritdoc cref="InAscendingOrder{T}.Span"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ReadOnlySpan<byte> AsSpan(this byte length) => SpanRange<byte>(length + 1).UnsafelySkip(length);
    /// <inheritdoc cref="InAscendingOrder{T}.Span"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ReadOnlySpan<char> AsSpan(this char length) => SpanRange<char>(length + 1).UnsafelySkip(length);
    /// <inheritdoc cref="InAscendingOrder{T}.Span"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ReadOnlySpan<sbyte> AsSpan(this sbyte length) => SpanRange<sbyte>(length + 1).UnsafelySkip(length);
    /// <inheritdoc cref="InAscendingOrder{T}.Span"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ReadOnlySpan<short> AsSpan(this short length) => SpanRange<short>(length + 1).UnsafelySkip(length);
    /// <inheritdoc cref="InAscendingOrder{T}.Span"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ReadOnlySpan<ushort> AsSpan(this ushort length) => SpanRange<ushort>(length + 1).UnsafelySkip(length);
#if NET5_0_OR_GREATER
    /// <inheritdoc cref="InAscendingOrder{T}.Span"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ReadOnlySpan<Half> AsSpan(this Half length)
    {
        var i = (int)length;
        return SpanRange<Half>(i).UnsafelySkip(i);
    }
#endif
    /// <inheritdoc cref="InAscendingOrder{T}.Memory"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ReadOnlyMemory<T> MemoryRange<T>(this int length) => InAscendingOrder<T>.Memory(length);
    /// <inheritdoc cref="InAscendingOrder{T}.Span"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ReadOnlySpan<T> SpanRange<T>(this int length) => InAscendingOrder<T>.Span(length);
    static class InAscendingOrder<T>
    {
        const int InitialCapacity = 512;
        static T[] s_values = [];
        /// <summary>Gets the read-only span containing the set of values up to the specified parameter.</summary>
        /// <param name="length">The amount of items required.</param>
        /// <exception cref="MissingMethodException">The type <typeparamref name="T"/> is unsupported.</exception>
        /// <returns>
        /// The <see cref="ReadOnlySpan{T}"/> containing a range from 0 to <paramref name="length"/> - 1.
        /// </returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ReadOnlySpan<T> Span(int length)
        {
            if (typeof(T) == typeof(char))
                return To<T>.From(length.SpanRange<ushort>());
            ReadOnlySpan<T> original = s_values;
            if (length <= original.Length)
                return original.UnsafelyTake(length);
            var replacement = new T[System.Math.Max(length.RoundUpToPowerOf2(), InitialCapacity / Unsafe.SizeOf<T>())];
            Span<T> span = replacement;
            original.CopyTo(span);
            Populate(span.UnsafelySkip(original.Length - (!original.IsEmpty).ToByte()));
            s_values = replacement;
            return span.UnsafelyTake(length);
        }
        /// <summary>Gets the read-only span containing the set of values up to the specified parameter.</summary>
        /// <param name="length">The amount of items required.</param>
        /// <exception cref="MissingMethodException">The type <typeparamref name="T"/> is unsupported.</exception>
        /// <returns>
        /// The <see cref="ReadOnlySpan{T}"/> containing a range from 0 to <paramref name="length"/> - 1.
        /// </returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ReadOnlyMemory<T> Memory(int length)
        {
            if (typeof(T) == typeof(char))
                return Unsafe.As<ReadOnlyMemory<ushort>, ReadOnlyMemory<T>>(ref AsRef(length.MemoryRange<ushort>()));
            _ = Span(length);
            return new(s_values, 0, length);
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        static void Populate(scoped Span<T> span)
        {
            ref var start = ref MemoryMarshal.GetReference(span);
            ref var last = ref Unsafe.Add(ref start, span.Length);
            start = ref Unsafe.Add(ref start, 1)!;
            while (Unsafe.IsAddressLessThan(ref start, ref last))
            {
                start = Unsafe.Subtract(ref start, 1);
                Increment(ref start);
                start = ref Unsafe.Add(ref start, 1)!;
            }
        }
    }
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable once CheckNamespace
/// <summary>Extension methods to count digits in numbers.</summary>
    /// <summary>Gets the amount of digits of the number.</summary>
    /// <param name="number">The number to count.</param>
    /// <returns>The amount of digits in the parameter <paramref name="number"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure, ValueRange(1, 3)]
    public static byte DigitCount(this byte number) =>
        number switch
        {
            < 10 => 1,
            < 100 => 2,
            _ => 3,
        };
    /// <inheritdoc cref="DigitCount(byte)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure, ValueRange(1, 3)]
    public static byte DigitCount(this sbyte number) =>
        number switch
        {
            < 10 and > -10 => 1,
            < 100 and > -100 => 2,
            _ => 3,
        };
    /// <inheritdoc cref="DigitCount(byte)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure, ValueRange(1, 5)]
    public static byte DigitCount(this ushort number) =>
        number switch
        {
            < 10 => 1,
            < 100 => 2,
            < 1000 => 3,
            < 10000 => 4,
            _ => 5,
        };
    /// <inheritdoc cref="DigitCount(byte)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure, ValueRange(1, 5)]
    public static byte DigitCount(this short number) =>
        number switch
        {
            < 10 and > -10 => 1,
            < 100 and > -100 => 2,
            < 1000 and > -1000 => 3,
            < 10000 and > -10000 => 4,
            _ => 5,
        };
    /// <inheritdoc cref="DigitCount(byte)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure, ValueRange(1, 10)]
    public static byte DigitCount(this uint number) =>
        number switch
        {
            < 10 => 1,
            < 100 => 2,
            < 1000 => 3,
            < 10000 => 4,
            < 100000 => 5,
            < 1000000 => 6,
            < 10000000 => 7,
            < 100000000 => 8,
            < 1000000000 => 9,
            _ => 10,
        };
    /// <inheritdoc cref="DigitCount(byte)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure, ValueRange(1, 10)]
    public static byte DigitCount(this int number) =>
        number switch
        {
            < 10 and > -10 => 1,
            < 100 and > -100 => 2,
            < 1000 and > -1000 => 3,
            < 10000 and > -10000 => 4,
            < 100000 and > -100000 => 5,
            < 1000000 and > -1000000 => 6,
            < 10000000 and > -10000000 => 7,
            < 100000000 and > -100000000 => 8,
            < 1000000000 and > -1000000000 => 9,
            _ => 10,
        };
// SPDX-License-Identifier: MPL-2.0
#if !NET20 && !NET30
// ReSharper disable once CheckNamespace
#pragma warning disable IDE0180
/// <summary>Extension methods for randomized getters.</summary>
    static readonly Func<int, int, int> s_rng =
#if KTANE
        UnityEngine.Random.Range;
#elif NET6_0_OR_GREATER
        System.Random.Shared.Next;
#else
        new Random().Next;
#endif
    /// <summary>Shuffles a collection.</summary>
    /// <typeparam name="T">The item in the collection.</typeparam>
    /// <param name="iterable">The <see cref="IEnumerable{T}"/> to shuffle.</param>
    /// <param name="selector">The indices to swap with.</param>
    /// <returns>A randomized list of items in the parameter <paramref name="selector"/>.</returns>
    public static IList<T> Shuffle<T>(
        [InstantHandle] this IEnumerable<T> iterable,
        [InstantHandle] Func<int, int, int>? selector = null
    )
    {
        selector ??= s_rng;
        var list = iterable.ToIList();
        for (var j = list.Count; j >= 1; j--)
        {
            var item = selector(0, j);
            if (item >= j - 1)
                continue;
            var t = list[item];
            list[item] = list[j - 1];
            list[j - 1] = t;
        }
        return list;
    }
    /// <inheritdoc cref="Shuffle{T}(IEnumerable{T}, Func{int, int, int})" />
    public static Span<T> Shuffle<T>(this Span<T> iterable, [InstantHandle] Func<int, int, int>? selector = null)
    {
        selector ??= s_rng;
        for (var j = iterable.Length; j >= 1; j--)
        {
            var item = selector(0, j);
            if (item >= j - 1)
                continue;
            var t = iterable[item];
            iterable[item] = iterable[j - 1];
            iterable[j - 1] = t;
        }
        return iterable;
    }
    /// <summary>Shuffles a collection.</summary>
    /// <typeparam name="T">The item in the collection.</typeparam>
    /// <param name="iterable">The <see cref="IEnumerable{T}"/> to shuffle.</param>
    /// <param name="selector">The indices to swap with.</param>
    /// <returns>A randomized list of items in the parameter <paramref name="selector"/>.</returns>
    [MustUseReturnValue]
    public static T PickRandom<T>(
        [InstantHandle] this IEnumerable<T> iterable,
        [InstantHandle] Func<int, int, int>? selector = null
    )
    {
        static T Fallback(IEnumerable<T> iterable, Func<int, int, int> selector)
        {
            IReadOnlyList<T> list = [..iterable];
            return list[selector(0, list.Count)];
        }
        selector ??= s_rng;
        return iterable switch
        {
            IList<T> list => list[selector(0, list.Count)],
            IReadOnlyList<T> list => list[selector(0, list.Count)],
            _ when iterable.TryCount() is { } count => iterable.ElementAt(selector(0, count)),
            _ => Fallback(iterable, selector),
        };
    }
    /// <inheritdoc cref="PickRandom{T}(IEnumerable{T}, Func{int, int, int})" />
    [MustUseReturnValue]
    public static T PickRandom<T>([InstantHandle] this scoped Span<T> iterable, Func<int, int, int>? selector = null) =>
        iterable.ReadOnly().PickRandom(selector);
    /// <inheritdoc cref="PickRandom{T}(IEnumerable{T}, Func{int, int, int})" />
    [MustUseReturnValue]
    public static T PickRandom<T>(
        [InstantHandle] this scoped ReadOnlySpan<T> iterable,
        Func<int, int, int>? selector = null
    ) =>
        iterable[(selector ?? s_rng)(0, iterable.Length)];
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable BadPreprocessorIndent RedundantUnsafeContext UseSymbolAlias
// ReSharper disable once CheckNamespace
#pragma warning disable CS8500, CS8631, RCS1175
// ReSharper disable RedundantNameQualifier RedundantUsingDirective
/// <summary>Defines methods for spans.</summary>
/// <remarks><para>See <see cref="MaxStackalloc"/> for details about stack- and heap-allocation.</para></remarks>
    /// <summary>Provides reinterpret span methods.</summary>
    /// <typeparam name="TTo">The type to convert to.</typeparam>
    public static class To<TTo>
    {
        /// <summary>
        /// Encapsulates the functionality to determine if a conversion is supported between two types.
        /// </summary>
        /// <typeparam name="TFrom">The type to convert from.</typeparam>
        public static class Is<TFrom>
#if !NO_ALLOWS_REF_STRUCT
            where TFrom : allows ref struct
#endif
        {
            /// <summary>
            /// Gets a value indicating whether the conversion between types
            /// <typeparamref name="TFrom"/> and <see name="TTo"/> in <see cref="To{TTo}"/> is defined.
            /// </summary>
            public static bool Supported { [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get; } =
#if NETSTANDARD && !NETSTANDARD2_0_OR_GREATER
                typeof(TFrom) == typeof(TTo);
#else
#pragma warning disable MA0169
                typeof(TFrom) == typeof(TTo) ||
                Unsafe.SizeOf<TFrom>() >= Unsafe.SizeOf<TTo>() &&
                (IsReinterpretable(typeof(TFrom), typeof(TTo)) ||
                    !IsReferenceOrContainsReferences<TFrom>() && !IsReferenceOrContainsReferences<TTo>());
            [Pure]
            static bool IsReinterpretable(Type first, Type second)
            {
                while (first.IsValueType && first.GetFields() is [{ FieldType: var next }])
                    first = next;
                while (second.IsValueType && second.GetFields() is [{ FieldType: var next }])
                    second = next;
                return first == second;
#pragma warning restore MA0169
            }
#endif
        }
        /// <summary>
        /// Converts a <see cref="ReadOnlySpan{T}"/> of type <typeparamref name="TFrom"/>
        /// to a <see cref="ReadOnlySpan{T}"/> of type <see name="TTo"/> in <see cref="To{TTo}"/>.
        /// </summary>
        /// <typeparam name="TFrom">The type to convert from.</typeparam>
        /// <param name="source">The <see cref="ReadOnlySpan{T}"/> to convert from.</param>
        /// <exception cref="NotSupportedException">
        /// Thrown when <see cref="Is{TFrom}.Supported"/> is <see langword="false"/>.
        /// </exception>
        /// <returns>
        /// The reinterpretation of the parameter <paramref name="source"/> from its original type
        /// <typeparamref name="TFrom"/> to the destination type <see name="TTo"/> in <see cref="To{TTo}"/>.
        /// </returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        public static unsafe ReadOnlySpan<TTo> From<TFrom>(ReadOnlySpan<TFrom> source)
        {
            System.Diagnostics.Debug.Assert(Is<TFrom>.Supported, "No out-of-bounds access.");
#if (NET452_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP) && !CSHARPREPL
            InlineIL.IL.Emit.Ldarg_0();
            InlineIL.IL.Emit.Ret();
            throw InlineIL.IL.Unreachable();
#else
            return *(ReadOnlySpan<TTo>*)&source;
#endif
        }
        /// <summary>
        /// Converts a <see cref="Span{T}"/> of type <typeparamref name="TFrom"/>
        /// to a <see cref="Span{T}"/> of type <see name="TTo"/> in <see cref="To{TTo}"/>.
        /// </summary>
        /// <typeparam name="TFrom">The type to convert from.</typeparam>
        /// <param name="source">The <see cref="Span{T}"/> to convert from.</param>
        /// <exception cref="NotSupportedException">
        /// Thrown when <see cref="Is{TFrom}.Supported"/> is <see langword="false"/>.
        /// </exception>
        /// <returns>
        /// The reinterpretation of the parameter <paramref name="source"/> from its original
        /// type <typeparamref name="TFrom"/> to the destination type <see name="TTo"/> in <see cref="To{TTo}"/>.
        /// </returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        public static unsafe Span<TTo> From<TFrom>(Span<TFrom> source)
        {
            System.Diagnostics.Debug.Assert(Is<TFrom>.Supported, "No out-of-bounds access.");
#if (NET452_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP) && !CSHARPREPL
            InlineIL.IL.Emit.Ldarg_0();
            InlineIL.IL.Emit.Ret();
            throw InlineIL.IL.Unreachable();
#else
            return *(Span<TTo>*)&source;
#endif
        }
    }
    /// <summary>The maximum size for stack allocations in bytes.</summary>
    /// <remarks><para>
    /// Stack allocating arrays is an incredibly powerful tool that gets rid of a lot of the overhead that comes
    /// from instantiating arrays normally. Notably, that all classes (such as <see cref="List{T}"/>) are heap
    /// allocated, and moreover are garbage collected. This can cause strain in methods that are called often.
    /// </para><para>
    /// However, there isn't as much stack memory available as there is heap, which can cause a DoS (Denial of Service)
    /// vulnerability if you aren't careful. Use this constant to determine if you should use a heap allocation.
    /// </para></remarks>
    public const int MaxStackalloc = 1 << 11;
    /// <summary>Sets the reference to the address within the null range.</summary>
    /// <remarks><para>
    /// This is a highly unsafe function. The runtime reserves the first 2kiB for null-behaving values, which means a
    /// valid reference will never be within this range. This allows reference types to be a disjoint union of a valid
    /// reference, and an 11-bit number. Be careful with the values returned by this function: <see langword="null"/>
    /// comparisons can <see langword="return"/> <see langword="false"/>, but will behave as such.
    /// </para></remarks>
    /// <typeparam name="T">The type of the nullable reference type.</typeparam>
    /// <param name="reference">
    /// The resulting reference that contains the address of the parameter <paramref name="address"/>.
    /// </param>
    /// <param name="address">The number to set.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static unsafe void UnsafelySetNullishTo<T>(out T? reference, byte address)
        where T : class
    {
#if !(NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) || NO_SYSTEM_MEMORY
        fixed (T* ptr = &reference)
            *(nuint*)ptr = address;
#else
        Unsafe.SkipInit(out reference);
        Unsafe.As<T?, nuint>(ref reference) = address;
#endif
    }
    /// <inheritdoc cref="System.MemoryExtensions.Equals(ReadOnlySpan{char}, ReadOnlySpan{char}, StringComparison)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool EqualsIgnoreCase(this string left, scoped ReadOnlySpan<char> right) =>
        left.AsSpan().Equals(right, StringComparison.OrdinalIgnoreCase);
    /// <inheritdoc cref="System.MemoryExtensions.Equals(ReadOnlySpan{char}, ReadOnlySpan{char}, StringComparison)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool EqualsIgnoreCase(this IMemoryOwner<char> left, scoped ReadOnlySpan<char> right) =>
        left.Memory.Span.ReadOnly().Equals(right, StringComparison.OrdinalIgnoreCase);
    /// <inheritdoc cref="System.MemoryExtensions.Equals(ReadOnlySpan{char}, ReadOnlySpan{char}, StringComparison)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool EqualsIgnoreCase(this Memory<char> left, scoped ReadOnlySpan<char> right) =>
        left.Span.ReadOnly().Equals(right, StringComparison.OrdinalIgnoreCase);
    /// <inheritdoc cref="System.MemoryExtensions.Equals(ReadOnlySpan{char}, ReadOnlySpan{char}, StringComparison)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool EqualsIgnoreCase(this scoped Span<char> left, scoped ReadOnlySpan<char> right) =>
        left.ReadOnly().Equals(right, StringComparison.OrdinalIgnoreCase);
    /// <inheritdoc cref="System.MemoryExtensions.Equals(ReadOnlySpan{char}, ReadOnlySpan{char}, StringComparison)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool EqualsIgnoreCase(this ReadOnlyMemory<char> left, scoped ReadOnlySpan<char> right) =>
        left.Span.Equals(right, StringComparison.OrdinalIgnoreCase);
    /// <inheritdoc cref="System.MemoryExtensions.Equals(ReadOnlySpan{char}, ReadOnlySpan{char}, StringComparison)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool EqualsIgnoreCase(this scoped ReadOnlySpan<char> left, scoped ReadOnlySpan<char> right) =>
        left.Equals(right, StringComparison.OrdinalIgnoreCase);
#if NET6_0_OR_GREATER
    /// <inheritdoc cref="System.MemoryExtensions.SequenceEqual{T}(Span{T}, ReadOnlySpan{T}, IEqualityComparer{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool SequenceEqual<T>(
        this Memory<T> span,
        ReadOnlyMemory<T> other,
        IEqualityComparer<T>? comparer
    ) =>
        span.Span.SequenceEqual(other.Span, comparer);
    /// <inheritdoc cref="System.MemoryExtensions.SequenceEqual{T}(Span{T}, ReadOnlySpan{T}, IEqualityComparer{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool SequenceEqual<T>(
        this ReadOnlyMemory<T> span,
        ReadOnlyMemory<T> other,
        IEqualityComparer<T>? comparer
    ) =>
        span.Span.SequenceEqual(other.Span, comparer);
#endif
    /// <inheritdoc cref="System.MemoryExtensions.SequenceEqual{T}(Span{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool SequenceEqual<T>(this Memory<T> span, ReadOnlyMemory<T> other)
        where T : IEquatable<T>? =>
        span.Span.SequenceEqual(other.Span);
    /// <inheritdoc cref="System.MemoryExtensions.SequenceEqual{T}(Span{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool SequenceEqual<T>(this ReadOnlyMemory<T> span, ReadOnlyMemory<T> other)
        where T : IEquatable<T>? =>
        span.Span.SequenceEqual(other.Span);
    /// <summary>Reads the raw memory of the object.</summary>
    /// <typeparam name="T">The type of value to read.</typeparam>
    /// <param name="value">The value to read.</param>
    /// <returns>The raw memory of the parameter <paramref name="value"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static unsafe byte[] Raw<T>(T value)
#if !NO_ALLOWS_REF_STRUCT
        where T : allows ref struct
#endif
        =>
#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
            [.. MemoryMarshal.CreateReadOnlySpan(ref Unsafe.As<T, byte>(ref AsRef(value)), Unsafe.SizeOf<T>())];
#else
            new Span<byte>(&value, Unsafe.SizeOf<T>()).ToArray();
#endif
    /// <summary>Returns the memory address of a given reference object.</summary>
    /// <remarks><para>The value is not pinned; do not read values from this location.</para></remarks>
    /// <param name="_">The reference <see cref="object"/> for which to get the address.</param>
    /// <returns>The memory address of the reference object.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static nuint ToAddress<T>(this T? _)
        where T : class
    {
#if CSHARPREPL
        return Unsafe.As<T?, nuint>(ref _);
#elif NET452_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP
        InlineIL.IL.Emit.Ldarg_0();
        return InlineIL.IL.Return<nuint>();
#else
        unsafe
        {
            return *(nuint*)&_;
        }
#endif
    }
    /// <summary>Creates a new <see cref="ReadOnlySpan{T}"/> of length 1 around the specified reference.</summary>
    /// <typeparam name="T">The type of <paramref name="reference"/>.</typeparam>
    /// <param name="reference">A reference to data.</param>
    /// <returns>The created span over the parameter <paramref name="reference"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ReadOnlySpan<T> In<T>(in T reference) =>
#if NET8_0_OR_GREATER || CSHARPREPL
        new(ref AsRef(reference));
#elif NET7_0_OR_GREATER
        new(AsRef(reference));
#elif NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
        MemoryMarshal.CreateReadOnlySpan(ref AsRef(reference), 1);
#else
        new([reference]);
#endif
    /// <summary>Creates a new reinterpreted <see cref="ReadOnlySpan{T}"/> over the specified reference.</summary>
    /// <typeparam name="TFrom">The source type.</typeparam>
    /// <typeparam name="TTo">The destination type.</typeparam>
    /// <param name="reference">A reference to data.</param>
    /// <returns>The created span over the parameter <paramref name="reference"/>.</returns>
    public static ReadOnlySpan<TTo> In<TFrom, TTo>(in TFrom reference)
        where TFrom : struct
        where TTo : struct =>
        MemoryMarshal.Cast<TFrom, TTo>(In(reference));
    /// <summary>Converts the <see cref="Memory{T}"/> to the <see cref="ReadOnlyMemory{T}"/>.</summary>
    /// <typeparam name="T">The type of memory.</typeparam>
    /// <param name="memory">The memory to convert.</param>
    /// <returns>The <see cref="ReadOnlyMemory{T}"/> of the parameter <paramref name="memory"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ReadOnlyMemory<T> ReadOnly<T>(this Memory<T> memory) => memory;
    /// <summary>Converts the <see cref="Span{T}"/> to the <see cref="ReadOnlySpan{T}"/>.</summary>
    /// <typeparam name="T">The type of span.</typeparam>
    /// <param name="span">The span to convert.</param>
    /// <returns>The <see cref="ReadOnlySpan{T}"/> of the parameter <paramref name="span"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ReadOnlySpan<T> ReadOnly<T>(this Span<T> span) => span;
    /// <summary>Creates a new <see cref="Span{T}"/> of length 1 around the specified reference.</summary>
    /// <typeparam name="T">The type of <paramref name="reference"/>.</typeparam>
    /// <param name="reference">A reference to data.</param>
    /// <returns>The created span over the parameter <paramref name="reference"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static Span<T> Ref<T>(ref T reference) =>
#if NET7_0_OR_GREATER
        new(ref reference);
#elif NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
        MemoryMarshal.CreateSpan(ref reference, 1);
#else
        new([reference]);
#endif
    /// <summary>Creates a new reinterpreted <see cref="Span{T}"/> over the specified reference.</summary>
    /// <typeparam name="TFrom">The source type.</typeparam>
    /// <typeparam name="TTo">The destination type.</typeparam>
    /// <param name="reference">A reference to data.</param>
    /// <returns>The created span over the parameter <paramref name="reference"/>.</returns>
    public static Span<TTo> Ref<TFrom, TTo>(ref TFrom reference)
        where TFrom : struct
        where TTo : struct =>
        MemoryMarshal.Cast<TFrom, TTo>(Ref(ref reference));
#if (NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) && !NO_SYSTEM_MEMORY
    /// <summary>Reinterprets the given read-only reference as a mutable reference.</summary>
    /// <typeparam name="T">The underlying type of the reference.</typeparam>
    /// <param name="source">The read-only reference to reinterpret.</param>
    /// <returns>A mutable reference to a value of type <typeparamref name="T"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ref T AsRef<T>(in T source)
#if !NO_ALLOWS_REF_STRUCT
        where T : allows ref struct
#endif
        =>
            ref Unsafe.AsRef(source);
#endif
    /// <summary>Separates the head from the tail of a <see cref="Memory{T}"/>.</summary>
    /// <typeparam name="T">The item in the collection.</typeparam>
    /// <param name="memory">The memory to split.</param>
    /// <param name="head">The first element of the parameter <paramref name="memory"/>.</param>
    /// <param name="tail">The rest of the parameter <paramref name="memory"/>.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void Deconstruct<T>(this Memory<T> memory, out T? head, out Memory<T> tail)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
    {
        if (memory.IsEmpty)
        {
            head = default;
            tail = default;
            return;
        }
        head = memory.Span.UnsafelyIndex(0);
        tail = memory[1..];
    }
    /// <summary>Separates the head from the tail of a <see cref="Memory{T}"/>.</summary>
    /// <typeparam name="T">The item in the collection.</typeparam>
    /// <param name="memory">The memory to split.</param>
    /// <param name="head">The first element of the parameter <paramref name="memory"/>.</param>
    /// <param name="tail">The rest of the parameter <paramref name="memory"/>.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void Deconstruct<T>(this ReadOnlyMemory<T> memory, out T? head, out ReadOnlyMemory<T> tail)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
    {
        if (memory.IsEmpty)
        {
            head = default;
            tail = default;
            return;
        }
        head = memory.Span.UnsafelyIndex(0);
        tail = memory[1..];
    }
    /// <summary>Separates the head from the tail of a <see cref="Span{T}"/>.</summary>
    /// <typeparam name="T">The item in the collection.</typeparam>
    /// <param name="span">The span to split.</param>
    /// <param name="head">The first element of the parameter <paramref name="span"/>.</param>
    /// <param name="tail">The rest of the parameter <paramref name="span"/>.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void Deconstruct<T>(this Span<T> span, out T? head, out Span<T> tail)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
    {
        if (span.IsEmpty)
        {
            head = default;
            tail = default;
            return;
        }
        head = span.UnsafelyIndex(0);
        tail = span.UnsafelySkip(1);
    }
    /// <summary>Separates the head from the tail of a <see cref="ReadOnlySpan{T}"/>.</summary>
    /// <typeparam name="T">The item in the collection.</typeparam>
    /// <param name="span">The span to split.</param>
    /// <param name="head">The first element of the parameter <paramref name="span"/>.</param>
    /// <param name="tail">The rest of the parameter <paramref name="span"/>.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void Deconstruct<T>(this ReadOnlySpan<T> span, out T? head, out ReadOnlySpan<T> tail)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
    {
        if (span.IsEmpty)
        {
            head = default;
            tail = default;
            return;
        }
        head = span.UnsafelyIndex(0);
        tail = span.UnsafelySkip(1);
    }
#if (NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) && !NO_SYSTEM_MEMORY
    /// <summary>
    /// Gets the index of an element of a given <see cref="Memory{T}"/> from its <see cref="Span{T}"/>.
    /// </summary>
    /// <typeparam name="T">The type if items in the input <see cref="Memory{T}"/>.</typeparam>
    /// <param name="memory">The input <see cref="Memory{T}"/> to calculate the index for.</param>
    /// <param name="span">The reference to the target item to get the index for.</param>
    /// <returns>The index of <paramref name="memory"/> within <paramref name="span"/>, or <c>-1</c>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int IndexOf<T>(ReadOnlyMemory<T> memory, scoped ReadOnlySpan<T> span) =>
        memory.Span.IndexOf(ref MemoryMarshal.GetReference(span));
#endif
    /// <summary>Gets the index of an element of a given <see cref="Span{T}"/> from its reference.</summary>
    /// <typeparam name="T">The type if items in the input <see cref="Span{T}"/>.</typeparam>
    /// <param name="span">The input <see cref="Span{T}"/> to calculate the index for.</param>
    /// <param name="value">The reference to the target item to get the index for.</param>
    /// <returns>The index of <paramref name="value"/> within <paramref name="span"/>, or <c>-1</c>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static unsafe int IndexOf<T>(this scoped ReadOnlySpan<T> span, scoped ref T value)
#if (NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) && !NO_SYSTEM_MEMORY
        =>
            Unsafe.ByteOffset(ref MemoryMarshal.GetReference(span), ref value) is var byteOffset &&
            byteOffset / (nint)(uint)Unsafe.SizeOf<T>() is var elementOffset &&
            (nuint)elementOffset < (uint)span.Length
                ? (int)elementOffset
                : -1;
#else
    {
        fixed (T* ptr = &value)
        fixed (T* s = span)
            return (nint)(span.Align(s) - ptr) is var elementOffset && (nuint)elementOffset < (uint)span.Length
                ? (int)elementOffset
                : -1;
    }
#endif
    /// <inheritdoc cref="IndexOf{T}(ReadOnlySpan{T}, ref T)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static int IndexOf<T>(this scoped Span<T> origin, scoped ref T target) =>
        origin.ReadOnly().IndexOf(ref target);
#if !NET7_0_OR_GREATER
    /// <inheritdoc cref="IndexOfAny{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int IndexOfAny<T>(this scoped Span<T> span, scoped ReadOnlySpan<T> values)
#if UNMANAGED_SPAN
        where T : unmanaged, IEquatable<T>?
#else
        where T : IEquatable<T>?
#endif
        =>
            span.ReadOnly().IndexOfAny(values);
    /// <summary>
    /// Searches for the first index of the specified values similar
    /// to calling IndexOf several times with the logical OR operator.
    /// </summary>
    /// <typeparam name="T">The type of the span and values.</typeparam>
    /// <param name="span">The span to search.</param>
    /// <param name="values">The set of values to search for.</param>
    /// <returns>The first index of the occurrence of the values in the span. If not found, returns -1.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static unsafe int IndexOfAny<T>(this scoped ReadOnlySpan<T> span, scoped ReadOnlySpan<T> values)
#if UNMANAGED_SPAN
        where T : unmanaged, IEquatable<T>?
#else
        where T : IEquatable<T>?
#endif
    {
        fixed (T* searchSpace = span)
        fixed (T* value = values)
            return SpanHelpers.IndexOfAny(span.Align(searchSpace), span.Length, values.Align(value), values.Length);
    }
#endif
    /// <inheritdoc cref="IndexOf{T}(ReadOnlySpan{T}, ref T)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static unsafe int OffsetOf<T>(this scoped ReadOnlySpan<T> origin, scoped ReadOnlySpan<T> target)
#if (NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) && !NO_SYSTEM_MEMORY
        =>
            origin.IndexOf(ref MemoryMarshal.GetReference(target));
#else
    {
        fixed (T* value = target)
            return origin.IndexOf(ref *target.Align(value));
    }
#endif
    /// <inheritdoc cref="IndexOf{T}(ReadOnlySpan{T}, ref T)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static int OffsetOf<T>(this scoped Span<T> origin, scoped ReadOnlySpan<T> target) =>
        origin.ReadOnly().OffsetOf(target);
    /// <summary>Converts the provided <see cref="Span{T}"/> to the <see cref="Memory{T}"/>.</summary>
    /// <typeparam name="T">The type if items in the input <see cref="Span{T}"/>.</typeparam>
    /// <param name="span">The <see cref="Span{T}"/> to convert.</param>
    /// <param name="memory">The bounds.</param>
    /// <returns>The parameter <paramref name="span"/> as <see cref="ReadOnlyMemory{T}"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static unsafe ReadOnlyMemory<T> AsMemory<T>(this scoped ReadOnlySpan<T> span, ReadOnlyMemory<T> memory)
    {
#if (NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) && !NO_SYSTEM_MEMORY
        return memory.Span.IndexOf(ref MemoryMarshal.GetReference(span)) is not -1 and var i
            ? memory.Slice(i, span.Length)
            : default;
#else
        var other = memory.Span;
        fixed (T* s = span)
        fixed (T* o = other)
            return ((nint)(span.Align(s) - other.Align(o)) is var elementOffset &&
                (nuint)elementOffset < (uint)span.Length
                    ? (int)elementOffset
                    : -1) is not -1 and var i
                ? memory.Slice(i, span.Length)
                : default;
#endif
    }
    /// <summary>Gets the specific slice from the memory.</summary>
    /// <typeparam name="T">The type of item in the memory.</typeparam>
    /// <param name="owner">The <see cref="IMemoryOwner{T}"/> to get an item from.</param>
    /// <param name="range">The index to get.</param>
    /// <returns>A slice from the parameter <paramref name="owner"/>, or <see langword="default"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ReadOnlyMemory<T> Nth<T>(this IMemoryOwner<T> owner, Range range)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            owner.Memory.Nth(range);
    /// <summary>Gets the specific slice from the memory.</summary>
    /// <typeparam name="T">The type of item in the memory.</typeparam>
    /// <param name="span">The <see cref="ReadOnlyMemory{T}"/> to get an item from.</param>
    /// <param name="range">The index to get.</param>
    /// <returns>A slice from the parameter <paramref name="span"/>, or <see langword="default"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ReadOnlyMemory<T> Nth<T>(this ReadOnlyMemory<T> span, Range range)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            range.TryGetOffsetAndLength(span.Length, out var off, out var len) ? span.Slice(off, len) : default;
    /// <summary>Gets the specific slice from the memory.</summary>
    /// <typeparam name="T">The type of item in the memory.</typeparam>
    /// <param name="span">The <see cref="Memory{T}"/> to get an item from.</param>
    /// <param name="range">The index to get.</param>
    /// <returns>A slice from the parameter <paramref name="span"/>, or <see langword="default"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static Memory<T> Nth<T>(this Memory<T> span, Range range)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            range.TryGetOffsetAndLength(span.Length, out var off, out var len) ? span.Slice(off, len) : default;
    /// <summary>Gets a specific item from the memory.</summary>
    /// <typeparam name="T">The type of item in the memory.</typeparam>
    /// <param name="owner">The <see cref="IMemoryOwner{T}"/> to get an item from.</param>
    /// <param name="index">The index to get.</param>
    /// <returns>An element from the parameter <paramref name="owner"/>, or <see langword="default"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Nth<T>(this IMemoryOwner<T> owner, [NonNegativeValue] int index)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            owner.Memory.Nth(index);
    /// <summary>Gets a specific item from the memory.</summary>
    /// <typeparam name="T">The type of item in the memory.</typeparam>
    /// <param name="memory">The <see cref="ReadOnlyMemory{T}"/> to get an item from.</param>
    /// <param name="index">The index to get.</param>
    /// <returns>An element from the parameter <paramref name="memory"/>, or <see langword="default"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Nth<T>(this ReadOnlyMemory<T> memory, [NonNegativeValue] int index)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            (uint)index < (uint)memory.Length ? memory.Span[index] : default;
    /// <summary>Gets a specific item from the memory.</summary>
    /// <typeparam name="T">The type of item in the memory.</typeparam>
    /// <param name="owner">The <see cref="IMemoryOwner{T}"/> to get an item from.</param>
    /// <param name="index">The index to get.</param>
    /// <returns>An element from the parameter <paramref name="owner"/>, or <see langword="default"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Nth<T>(this IMemoryOwner<T> owner, Index index)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            owner.Memory.Nth(index);
    /// <summary>Gets a specific item from the memory.</summary>
    /// <typeparam name="T">The type of item in the memory.</typeparam>
    /// <param name="memory">The <see cref="ReadOnlyMemory{T}"/> to get an item from.</param>
    /// <param name="index">The index to get.</param>
    /// <returns>An element from the parameter <paramref name="memory"/>, or <see langword="default"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Nth<T>(this ReadOnlyMemory<T> memory, Index index)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            index.GetOffset(memory.Length) is var o && (uint)o < (uint)memory.Length
                ? memory.Span.UnsafelyIndex(o)
                : default;
    /// <summary>Gets a specific item from the memory.</summary>
    /// <typeparam name="T">The type of item in the memory.</typeparam>
    /// <param name="owner">The <see cref="IMemoryOwner{T}"/> to get an item from.</param>
    /// <param name="index">The index to get.</param>
    /// <returns>An element from the parameter <paramref name="owner"/>, or <see langword="default"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? NthLast<T>(this IMemoryOwner<T> owner, int index)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            owner.Memory.NthLast(index);
    /// <summary>Gets a specific item from the memory.</summary>
    /// <typeparam name="T">The type of item in the memory.</typeparam>
    /// <param name="memory">The <see cref="ReadOnlyMemory{T}"/> to get an item from.</param>
    /// <param name="index">The index to get.</param>
    /// <returns>An element from the parameter <paramref name="memory"/>, or <see langword="default"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? NthLast<T>(this ReadOnlyMemory<T> memory, [NonNegativeValue] int index)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            (uint)(index - 1) < (uint)memory.Length ? memory.Span[memory.Length - index] : default;
    /// <summary>Gets a specific item from the memory.</summary>
    /// <typeparam name="T">The type of item in the memory.</typeparam>
    /// <param name="memory">The <see cref="Memory{T}"/> to get an item from.</param>
    /// <param name="index">The index to get.</param>
    /// <returns>An element from the parameter <paramref name="memory"/>, or <see langword="default"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Nth<T>(this Memory<T> memory, [NonNegativeValue] int index)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            (uint)index < (uint)memory.Length ? memory.Span.UnsafelyIndex(index) : default;
    /// <summary>Gets a specific item from the memory.</summary>
    /// <typeparam name="T">The type of item in the memory.</typeparam>
    /// <param name="memory">The <see cref="Memory{T}"/> to get an item from.</param>
    /// <param name="index">The index to get.</param>
    /// <returns>An element from the parameter <paramref name="memory"/>, or <see langword="default"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Nth<T>(this Memory<T> memory, Index index)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            index.GetOffset(memory.Length) is var off && (uint)off < (uint)memory.Length
                ? memory.Span.UnsafelyIndex(off)
                : default;
    /// <summary>Gets a specific item from the memory.</summary>
    /// <typeparam name="T">The type of item in the memory.</typeparam>
    /// <param name="memory">The <see cref="Memory{T}"/> to get an item from.</param>
    /// <param name="index">The index to get.</param>
    /// <returns>An element from the parameter <paramref name="memory"/>, or <see langword="default"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? NthLast<T>(this Memory<T> memory, [NonNegativeValue] int index)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            (uint)(index - 1) < (uint)memory.Length ? memory.Span.UnsafelyIndex(memory.Length - index) : default;
    /// <summary>Gets the specific slice from the span.</summary>
    /// <typeparam name="T">The type of item in the span.</typeparam>
    /// <param name="span">The <see cref="ReadOnlySpan{T}"/> to get an item from.</param>
    /// <param name="range">The index to get.</param>
    /// <returns>A slice from the parameter <paramref name="span"/>, or <see langword="default"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ReadOnlySpan<T> Nth<T>(this ReadOnlySpan<T> span, Range range)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            range.TryGetOffsetAndLength(span.Length, out var off, out var len) ? span.UnsafelySlice(off, len) : default;
    /// <summary>Gets the specific slice from the span.</summary>
    /// <typeparam name="T">The type of item in the span.</typeparam>
    /// <param name="span">The <see cref="Span{T}"/> to get an item from.</param>
    /// <param name="range">The index to get.</param>
    /// <returns>A slice from the parameter <paramref name="span"/>, or <see langword="default"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static Span<T> Nth<T>(this Span<T> span, Range range)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            range.TryGetOffsetAndLength(span.Length, out var off, out var len) ? span.UnsafelySlice(off, len) : default;
    /// <summary>Gets a specific item from the span.</summary>
    /// <typeparam name="T">The type of item in the span.</typeparam>
    /// <param name="span">The <see cref="ReadOnlySpan{T}"/> to get an item from.</param>
    /// <param name="index">The index to get.</param>
    /// <returns>An element from the parameter <paramref name="span"/>, or <see langword="default"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Nth<T>(this scoped ReadOnlySpan<T> span, [NonNegativeValue] int index)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            (uint)index < (uint)span.Length ? span.UnsafelyIndex(index) : default;
    /// <summary>Gets a specific item from the span.</summary>
    /// <typeparam name="T">The type of item in the span.</typeparam>
    /// <param name="span">The <see cref="ReadOnlySpan{T}"/> to get an item from.</param>
    /// <param name="index">The index to get.</param>
    /// <returns>An element from the parameter <paramref name="span"/>, or <see langword="default"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Nth<T>(this scoped ReadOnlySpan<T> span, Index index)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            index.GetOffset(span.Length) is var o && (uint)o < (uint)span.Length ? span.UnsafelyIndex(o) : default;
    /// <summary>Gets a specific item from the span.</summary>
    /// <typeparam name="T">The type of item in the span.</typeparam>
    /// <param name="span">The <see cref="ReadOnlySpan{T}"/> to get an item from.</param>
    /// <param name="index">The index to get.</param>
    /// <returns>An element from the parameter <paramref name="span"/>, or <see langword="default"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? NthLast<T>(this scoped ReadOnlySpan<T> span, [NonNegativeValue] int index)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            (uint)(index - 1) < (uint)span.Length ? span.UnsafelyIndex(span.Length - index) : default;
    /// <summary>Gets a specific item from the span.</summary>
    /// <typeparam name="T">The type of item in the span.</typeparam>
    /// <param name="span">The <see cref="Span{T}"/> to get an item from.</param>
    /// <param name="index">The index to get.</param>
    /// <returns>An element from the parameter <paramref name="span"/>, or <see langword="default"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Nth<T>(this scoped Span<T> span, [NonNegativeValue] int index)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            (uint)index < (uint)span.Length ? span.UnsafelyIndex(index) : default;
    /// <summary>Gets a specific item from the span.</summary>
    /// <typeparam name="T">The type of item in the span.</typeparam>
    /// <param name="span">The <see cref="Span{T}"/> to get an item from.</param>
    /// <param name="index">The index to get.</param>
    /// <returns>An element from the parameter <paramref name="span"/>, or <see langword="default"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? Nth<T>(this scoped Span<T> span, Index index)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            index.GetOffset(span.Length) is var o && (uint)o < (uint)span.Length ? span.UnsafelyIndex(o) : default;
    /// <summary>Gets a specific item from the span.</summary>
    /// <typeparam name="T">The type of item in the span.</typeparam>
    /// <param name="span">The <see cref="Span{T}"/> to get an item from.</param>
    /// <param name="index">The index to get.</param>
    /// <returns>An element from the parameter <paramref name="span"/>, or <see langword="default"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T? NthLast<T>(this scoped Span<T> span, [NonNegativeValue] int index)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            (uint)(index - 1) < (uint)span.Length ? span.UnsafelyIndex(span.Length - index) : default;
    /// <inheritdoc cref="Span{T}.this"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T UnsafelyIndex<T>(this scoped ReadOnlySpan<T> body, [NonNegativeValue] int index)
    {
        System.Diagnostics.Debug.Assert((uint)index < (uint)body.Length, "index is in range");
#if (NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) && !NO_SYSTEM_MEMORY
        return Unsafe.Add(ref MemoryMarshal.GetReference(body), index);
#else
        return body[index];
#endif
    }
    /// <inheritdoc cref="Enumerable.Skip{T}"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ReadOnlySpan<T> UnsafelySkip<T>(this ReadOnlySpan<T> body, [NonNegativeValue] int start)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
    {
        System.Diagnostics.Debug.Assert((uint)start <= (uint)body.Length, "start is in range");
        return UnsafelySlice(body, start, body.Length - start);
    }
    /// <inheritdoc cref="Span{T}.Slice(int, int)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ReadOnlySpan<T> UnsafelySlice<T>(
        this ReadOnlySpan<T> body,
        [NonNegativeValue] int start,
        [NonNegativeValue] int length
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
    {
        System.Diagnostics.Debug.Assert((uint)(start + length) <= (uint)body.Length, "start and length is in range");
#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
        return MemoryMarshal.CreateReadOnlySpan(ref Unsafe.Add(ref MemoryMarshal.GetReference(body), start), length);
#else
        return body.Slice(start, length);
#endif
    }
    /// <inheritdoc cref="Enumerable.Take{T}(IEnumerable{T}, int)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ReadOnlySpan<T> UnsafelyTake<T>(this ReadOnlySpan<T> body, [NonNegativeValue] int end)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
    {
        System.Diagnostics.Debug.Assert((uint)end <= (uint)body.Length, "end is in range");
        return UnsafelySlice(body, 0, end);
    }
    /// <inheritdoc cref="Span{T}.this"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T UnsafelyIndex<T>(this scoped Span<T> body, [NonNegativeValue] int index)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
    {
        System.Diagnostics.Debug.Assert((uint)index < (uint)body.Length, "index is in range");
#if (NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) && !NO_SYSTEM_MEMORY
        return Unsafe.Add(ref MemoryMarshal.GetReference(body), index);
#else
        return body[index];
#endif
    }
    /// <inheritdoc cref="Enumerable.Skip{T}"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static Span<T> UnsafelySkip<T>(this Span<T> body, [NonNegativeValue] int start)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
    {
        System.Diagnostics.Debug.Assert((uint)start <= (uint)body.Length, "start is in range");
        return UnsafelySlice(body, start, body.Length - start);
    }
    /// <inheritdoc cref="Span{T}.Slice(int, int)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static Span<T> UnsafelySlice<T>(
        this Span<T> body,
        [NonNegativeValue] int start,
        [NonNegativeValue] int length
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
    {
        System.Diagnostics.Debug.Assert((uint)(start + length) <= (uint)body.Length, "start and length is in range");
#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
        return MemoryMarshal.CreateSpan(ref Unsafe.Add(ref MemoryMarshal.GetReference(body), start), length);
#else
        return body.Slice(start, length);
#endif
    }
    /// <inheritdoc cref="Enumerable.Take{T}(IEnumerable{T}, int)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static Span<T> UnsafelyTake<T>(this Span<T> body, [NonNegativeValue] int end)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
    {
        System.Diagnostics.Debug.Assert((uint)end <= (uint)body.Length, "end is in range");
        return UnsafelySlice(body, 0, end);
    }
    /// <summary>Aligns the pointer obtained from a fixed expression to the first element of the pointer.</summary>
    /// <typeparam name="T">The type of <see cref="Span{T}"/>.</typeparam>
    /// <param name="span">The span to obtain the pointer of.</param>
    /// <param name="pinned">The pointed obtained from pinning the parameter <paramref name="span"/>.</param>
    /// <returns>
    /// The pointer to the first element of the buffer, or <see langword="null"/>
    /// if the parameter <paramref name="span"/> is empty.
    /// </returns>
    [Inline]
    internal static unsafe T* Align<T>([UsedImplicitly] this ReadOnlySpan<T> span, T* pinned)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
#if !(NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) || NO_SYSTEM_MEMORY
            span.Length is 0 ? null :
            span.Pinnable is null ? (T*)span.ByteOffset :
            (T*)((byte*)Unsafe.AsPointer(ref span.Pinnable.Data) + span.ByteOffset);
#else
            pinned;
#endif
    /// <summary>Aligns the pointer obtained from a fixed expression to the first element of the pointer.</summary>
    /// <typeparam name="T">The type of <see cref="Span{T}"/>.</typeparam>
    /// <param name="span">The span to obtain the pointer of.</param>
    /// <param name="pinned">The pointed obtained from pinning the parameter <paramref name="span"/>.</param>
    /// <returns>
    /// The pointer to the first element of the buffer, or <see langword="null"/>
    /// if the parameter <paramref name="span"/> is empty.
    /// </returns>
    [Inline]
    internal static unsafe T* Align<T>([UsedImplicitly] this Span<T> span, T* pinned)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
#if !(NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) || NO_SYSTEM_MEMORY
            span.Length is 0 ? null :
            span.Pinnable is null ? (T*)span.ByteOffset :
            (T*)((byte*)pinned + span.ByteOffset);
#else
            pinned;
#endif
// SPDX-License-Identifier: MPL-2.0
#if ROSLYN
// ReSharper disable once CheckNamespace
/// <summary>Contains syntactic operations and registrations.</summary>
    /// <summary>Gets the fully qualified name for a given symbol.</summary>
    /// <param name="symbol">The input <see cref="ISymbol"/> instance.</param>
    /// <returns>The fully qualified name for <paramref name="symbol"/>.</returns>
    public static string GetFullyQualifiedName(this ISymbol symbol) =>
        symbol.ToDisplayString(
            SymbolDisplayFormat.FullyQualifiedFormat.AddMiscellaneousOptions(
                SymbolDisplayMiscellaneousOptions.EscapeKeywordIdentifiers
            )
        );
    /// <summary>Gets the fully qualified name for a given symbol, including nullability annotations.</summary>
    /// <param name="symbol">The input <see cref="ISymbol"/> instance.</param>
    /// <returns>The fully qualified name for <paramref name="symbol"/>.</returns>
    public static string GetFullyQualifiedNameWithNullabilityAnnotations(this ISymbol symbol) =>
        symbol.ToDisplayString(
            SymbolDisplayFormat.FullyQualifiedFormat.AddMiscellaneousOptions(
                SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier |
                SymbolDisplayMiscellaneousOptions.EscapeKeywordIdentifiers
            )
        );
    /// <summary>Gets the minimally qualified name for a given symbol.</summary>
    /// <param name="symbol">The input <see cref="ISymbol"/> instance.</param>
    /// <returns>The minimally qualified name for <paramref name="symbol"/>.</returns>
    public static string GetMinimallyQualifiedName(this ISymbol symbol) =>
        symbol.ToDisplayString(
            SymbolDisplayFormat.MinimallyQualifiedFormat.AddMiscellaneousOptions(
                SymbolDisplayMiscellaneousOptions.EscapeKeywordIdentifiers
            )
        );
    /// <summary>Checks whether or not a given type symbol has a specified full name.</summary>
    /// <param name="symbol">The input <see cref="ISymbol"/> instance to check.</param>
    /// <param name="name">The full name to check.</param>
    /// <returns>Whether <paramref name="symbol"/> has a full name equals to <paramref name="name"/>.</returns>
    public static bool HasFullyQualifiedName(this ISymbol symbol, string name) =>
        symbol.GetFullyQualifiedName() == name;
    /// <summary>
    /// Checks whether or not a given symbol has an attribute with the specified fully qualified metadata name.
    /// </summary>
    /// <param name="symbol">The input <see cref="ISymbol"/> instance to check.</param>
    /// <param name="name">The attribute name to look for.</param>
    /// <returns>Whether or not <paramref name="symbol"/> has an attribute with the specified name.</returns>
    public static bool HasAttributeWithFullyQualifiedMetadataName(this ISymbol symbol, string name)
    {
        foreach (var attribute in symbol.GetAttributes())
            if (attribute.AttributeClass is { } named && named.HasFullyQualifiedMetadataName(name))
                return true;
        return false;
    }
    /// <summary>Checks whether or not a given symbol has an attribute with the specified type.</summary>
    /// <param name="symbol">The input <see cref="ISymbol"/> instance to check.</param>
    /// <param name="typeSymbol">The <see cref="ITypeSymbol"/> instance for the attribute type to look for.</param>
    /// <returns>Whether or not <paramref name="symbol"/> has an attribute with the specified type.</returns>
    public static bool HasAttributeWithType(this ISymbol symbol, ITypeSymbol typeSymbol) =>
        TryGetAttributeWithType(symbol, typeSymbol, out _);
    /// <summary>Tries to get an attribute with the specified type.</summary>
    /// <param name="symbol">The input <see cref="ISymbol"/> instance to check.</param>
    /// <param name="typeSymbol">The <see cref="ITypeSymbol"/> instance for the attribute type to look for.</param>
    /// <param name="attributeData">The resulting attribute, if it was found.</param>
    /// <returns>Whether or not <paramref name="symbol"/> has an attribute with the specified type.</returns>
    [Pure]
    public static bool TryGetAttributeWithType(
        this ISymbol symbol,
        ITypeSymbol typeSymbol,
        [NotNullWhen(true)] out AttributeData? attributeData
    )
    {
        foreach (var attribute in symbol.GetAttributes())
            if (SymbolEqualityComparer.Default.Equals(attribute.AttributeClass, typeSymbol))
            {
                attributeData = attribute;
                return true;
            }
        attributeData = null;
        return false;
    }
    /// <summary>Checks whether or not a given type symbol has a specified fully qualified metadata name.</summary>
    /// <param name="symbol">The input <see cref="ITypeSymbol"/> instance to check.</param>
    /// <param name="name">The full name to check.</param>
    /// <returns>Whether <paramref name="symbol"/> has a full name equals to <paramref name="name"/>.</returns>
    public static bool HasFullyQualifiedMetadataName(this ITypeSymbol symbol, string name)
    {
        var builder = ImmutableArrayBuilder<char>.Rent();
        try
        {
            symbol.AppendFullyQualifiedMetadataName(builder);
            return builder.WrittenSpan.SequenceEqual(name.AsSpan());
        }
        finally
        {
            builder.Dispose();
        }
    }
    /// <summary>Gets the fully qualified metadata name for a given <see cref="ITypeSymbol"/> instance.</summary>
    /// <param name="symbol">The input <see cref="ITypeSymbol"/> instance.</param>
    /// <returns>The fully qualified metadata name for <paramref name="symbol"/>.</returns>
    [Pure]
    public static string GetFullyQualifiedMetadataName(this ITypeSymbol symbol)
    {
        var builder = ImmutableArrayBuilder<char>.Rent();
        try
        {
            symbol.AppendFullyQualifiedMetadataName(builder);
            return builder.ToString();
        }
        finally
        {
            builder.Dispose();
        }
    }
    /// <summary>Tries to get an attribute with the specified fully qualified metadata name.</summary>
    /// <param name="symbol">The input <see cref="ISymbol"/> instance to check.</param>
    /// <param name="name">The attribute name to look for.</param>
    /// <param name="attributeData">The resulting attribute, if it was found.</param>
    /// <returns>Whether or not <paramref name="symbol"/> has an attribute with the specified name.</returns>
    [Pure]
    public static bool TryGetAttributeWithFullyQualifiedMetadataName(
        this ISymbol symbol,
        string name,
        [NotNullWhen(true)] out AttributeData? attributeData
    )
    {
        foreach (var attribute in symbol.GetAttributes())
            if (attribute.AttributeClass is { } named && named.HasFullyQualifiedMetadataName(name))
            {
                attributeData = attribute;
                return true;
            }
        attributeData = null;
        return false;
    }
    /// <summary>Calculates the effective accessibility for a given symbol.</summary>
    /// <param name="s">The <see cref="ISymbol"/> instance to check.</param>
    /// <returns>The effective accessibility for <paramref name="s"/>.</returns>
    [Pure]
    public static Accessibility GetEffectiveAccessibility(this ISymbol s)
    {
        for (; s.Kind is SymbolKind.Parameter; s = s.ContainingSymbol) { }
        if (s.Kind is SymbolKind.Alias or SymbolKind.TypeParameter)
            return Accessibility.Private;
        var ret = Accessibility.Public;
        for (; s is { DeclaredAccessibility: var next } and not { Kind: SymbolKind.Namespace }; s = s.ContainingSymbol)
        {
            if (next is Accessibility.NotApplicable or Accessibility.Private)
                return Accessibility.Private;
            ret = next switch
            {
                Accessibility.ProtectedAndInternal => Accessibility.ProtectedAndInternal,
                Accessibility.Protected =>
                    ret is Accessibility.Public ? Accessibility.Protected : Accessibility.ProtectedAndInternal,
                Accessibility.Internal =>
                    ret is Accessibility.Public ? Accessibility.Internal : Accessibility.ProtectedAndInternal,
                Accessibility.ProtectedOrInternal when ret is Accessibility.Public => Accessibility.ProtectedOrInternal,
                _ => ret,
            };
        }
        return ret;
    }
    /// <summary>Checks whether or not a given symbol can be accessed from a specified assembly.</summary>
    /// <param name="symbol">The input <see cref="ISymbol"/> instance to check.</param>
    /// <param name="assembly">The assembly to check the accessibility of <paramref name="symbol"/> for.</param>
    /// <returns>Whether <paramref name="assembly"/> can access <paramref name="symbol"/>.</returns>
    [Pure]
    public static bool CanBeAccessedFrom(this ISymbol symbol, IAssemblySymbol assembly) =>
        symbol.GetEffectiveAccessibility() is var accessibility &&
        accessibility is Accessibility.Public ||
        accessibility is Accessibility.Internal && symbol.ContainingAssembly.GivesAccessTo(assembly);
    /// <summary>Negated <see cref="SyntaxValueProvider.ForAttributeWithMetadataName"/>.</summary>
    /// <inheritdoc cref="SyntaxValueProvider.ForAttributeWithMetadataName"/>
    [Pure]
    public static IncrementalValuesProvider<T> AgainstAttributeWithMetadataName<T>(
        this SyntaxValueProvider syntaxValueProvider,
        string fullyQualifiedMetadataName,
        [InstantHandle] Func<SyntaxNode, CancellationToken, bool> predicate,
        [InstantHandle] Func<SyntaxNode, ISymbol, SemanticModel, CancellationToken, T> transform
    )
    {
        (bool HasValue, T Value) Extract(GeneratorSyntaxContext context, CancellationToken token) =>
            context.SemanticModel.GetDeclaredSymbol(context.Node, token) is { } symbol &&
            !symbol.TryGetAttributeWithFullyQualifiedMetadataName(fullyQualifiedMetadataName, out _)
                ? (true, transform(context.Node, symbol, context.SemanticModel, token))
                : default;
        return syntaxValueProvider
           .CreateSyntaxProvider(predicate, Extract)
           .Where(static x => x.HasValue)
           .Select(static (item, _) => item.Value);
    }
    /// <summary>Filters an <see cref="IncrementalValuesProvider{T}"/> to only non-null values.</summary>
    /// <typeparam name="T">The type of value to filter.</typeparam>
    /// <param name="provider">The <see cref="IncrementalValuesProvider{T}"/> to filter.</param>
    /// <returns>A filtered <see cref="IncrementalValuesProvider{T}"/> with strictly non-null values.</returns>
    [Pure]
    public static IncrementalValuesProvider<T> Filter<T>(this IncrementalValuesProvider<T?> provider) =>
#pragma warning disable 8619
        provider.Where(x => x is not null);
#pragma warning restore 8619
    /// <summary>Filters an <see cref="IncrementalValuesProvider{T}"/> to only non-null values.</summary>
    /// <typeparam name="T">The type of value to filter.</typeparam>
    /// <param name="provider">The <see cref="IncrementalValuesProvider{T}"/> to filter.</param>
    /// <returns>A filtered <see cref="IncrementalValuesProvider{T}"/> with strictly non-null values.</returns>
    [Pure]
    public static IncrementalValuesProvider<T> Filter<T>(this IncrementalValuesProvider<T?> provider)
        where T : struct =>
#pragma warning disable 8629
        provider.Where(x => x.HasValue).Select((x, _) => x.Value);
#pragma warning restore 8629
    /// <summary>Filters an <see cref="IncrementalValuesProvider{T}"/> to the specified destination type.</summary>
    /// <typeparam name="TFrom">The initial type.</typeparam>
    /// <typeparam name="TTo">The target type.</typeparam>
    /// <param name="provider">The <see cref="IncrementalValuesProvider{T}"/> to filter.</param>
    /// <returns>A filtered <see cref="IncrementalValuesProvider{T}"/> with <typeparamref name="TTo"/> values.</returns>
    [Pure]
    public static IncrementalValuesProvider<TTo> OfType<TFrom, TTo>(this IncrementalValuesProvider<TFrom?> provider)
        where TTo : TFrom =>
        provider.Where(static x => x is TTo).Select(static (x, _) => (TTo)x!);
    /// <summary>Appends the fully qualified metadata name for a given symbol to a target builder.</summary>
    /// <param name="symbol">The input <see cref="ITypeSymbol"/> instance.</param>
    /// <param name="builder">The target <see cref="ImmutableArrayBuilder{T}"/> instance.</param>
    static void AppendFullyQualifiedMetadataName(this ISymbol symbol, in ImmutableArrayBuilder<char> builder)
    {
        static void BuildFrom(ISymbol? symbol, in ImmutableArrayBuilder<char> builder)
        {
            switch (symbol)
            {
                case INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: false }:
                    BuildFrom(symbol.ContainingNamespace, builder);
                    builder.Add('.');
                    builder.AddRange(symbol.MetadataName.AsSpan());
                    break;
                case INamespaceSymbol { IsGlobalNamespace: false }:
                case ITypeSymbol { ContainingSymbol: INamespaceSymbol { IsGlobalNamespace: true } }:
                    builder.AddRange(symbol.MetadataName.AsSpan());
                    break;
                case ITypeSymbol { ContainingSymbol: INamespaceSymbol namespaceSymbol }:
                    BuildFrom(namespaceSymbol, builder);
                    builder.Add('.');
                    builder.AddRange(symbol.MetadataName.AsSpan());
                    break;
                case ITypeSymbol { ContainingSymbol: ITypeSymbol typeSymbol }:
                    BuildFrom(typeSymbol, builder);
                    builder.Add('+');
                    builder.AddRange(symbol.MetadataName.AsSpan());
                    break;
            }
        }
        BuildFrom(symbol, builder);
    }
#endif
// SPDX-License-Identifier: MPL-2.0
#if ROSLYN
#pragma warning disable GlobalUsingsAnalyzer, SA1216
// ReSharper disable once RedundantUsingDirective.Global
#pragma warning restore GlobalUsingsAnalyzer, RCS1175
// ReSharper disable once CheckNamespace
/// <summary>Contains syntactic operations and registrations.</summary>
    /// <summary>Adds the deconstruction of the tuples onto the <see cref="SourceProductionContext"/>.</summary>
    /// <param name="context">The context to use for source generation.</param>
    /// <param name="generated">The tuple containing the hint name and source.</param>
    public static void AddSource(SourceProductionContext context, GeneratedSource generated) =>
        context.AddSource(generated.HintName, generated.Source);
    /// <summary>
    /// Returns the <c>TypeDeclarationSyntax</c> annotated with the provided <c>AttributeSyntax</c>.
    /// </summary>
    /// <param name="syntax">The <c>AttributeSyntax</c> to extract from.</param>
    /// <returns>
    /// The <c>TypeDeclarationSyntax</c>, or <see langword="null"/> if the parameter <paramref name="syntax"/>
    /// is <see langword="null"/>, or annotated to something other than a <c>TypeDeclarationSyntax</c>.
    /// </returns>
    [Pure]
    public static TypeDeclarationSyntax? TypeDeclaration(this AttributeSyntax? syntax)
    {
        if (syntax is not { Parent: var parent })
            return null;
        while (parent is { Parent: var grandparent } and
            not BaseParameterSyntax and
            not MemberDeclarationSyntax and
            not TypeParameterSyntax)
            parent = grandparent;
        return parent as TypeDeclarationSyntax;
    }
    /// <summary>Returns whether the provided <see cref="SyntaxNode"/> is of type <typeparamref name="T"/>.</summary>
    /// <typeparam name="T">The type of <see cref="SyntaxNode"/> to test the instance for.</typeparam>
    /// <param name="node">The passed in node to test.</param>
    /// <param name="_">The discarded token, existing purely for convenience.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="node"/> is
    /// an instance of <typeparamref name="T"/>, otherwise; <see langword="false"/>.
    /// </returns>
    [Pure]
    public static bool AnnotatedAndIs<T>([NotNullWhen(true)] SyntaxNode? node, CancellationToken _ = default)
        where T : MemberDeclarationSyntax =>
        node is T { AttributeLists.Count: >= 1 };
    /// <summary>Determines whether the symbol can be passed in as a generic.</summary>
    /// <param name="symbol">The symbol to check.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="symbol"/>
    /// can be placed as a generic parameter, otherwise; <see langword="false"/>.
    /// </returns>
    [Pure]
    public static bool CanBeGeneric([NotNullWhen(true)] this ITypeSymbol? symbol) =>
        symbol is
            not null and
            not IDynamicTypeSymbol and
            not IPointerTypeSymbol and
            not { IsRefLikeType: true } and
            not { SpecialType: System_Void };
    /// <summary>Determines whether the symbol is declared with the attribute of the specific name.</summary>
    /// <param name="symbol">The symbol to check.</param>
    /// <param name="name">The name to get.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="symbol"/>
    /// has the attribute <paramref name="name"/>, otherwise; <see langword="false"/>.
    /// </returns>
    [Pure]
    public static bool HasAttribute([NotNullWhen(true)] this ISymbol? symbol, string? name)
    {
        [Pure]
        static ReadOnlySpan<char> WithoutAttributeSuffix(string name) =>
            name.AsSpan() is var span && span is [.. var x, 'A', 't', 't', 'r', 'i', 'b', 'u', 't', 'e'] ? x : span;
        if (symbol is null)
            return false;
        if (name is null)
            return symbol.GetAttributes() is not [];
        var against = WithoutAttributeSuffix(name);
        foreach (var attribute in symbol.GetAttributes())
            if (attribute.AttributeClass?.Name is { } match && WithoutAttributeSuffix(match).SequenceEqual(against))
                return true;
        return false;
    }
    /// <summary>Determines whether the symbol has a default implementation.</summary>
    /// <param name="symbol">The symbol to check.</param>
    /// <returns>The value <see langword="true"/> if the symbol has a default implementation.</returns>
    [Pure]
    public static bool HasDefaultImplementation([NotNullWhen(true)] this ISymbol? symbol) =>
        symbol is IMethodSymbol { IsAbstract: false, IsVirtual: true };
    /// <summary>Determines whether the symbol has a parameterless constructor.</summary>
    /// <param name="symbol">The symbol to check.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="symbol"/>
    /// has a parameterless constructor, otherwise; <see langword="false"/>.
    /// </returns>
    [Pure]
    public static bool HasParameterlessConstructor([NotNullWhen(true)] this ITypeSymbol? symbol) =>
        symbol is INamedTypeSymbol { InstanceConstructors: var x } && x.Any(x => x.Parameters is []);
    /// <summary>Determines whether the symbols have matching nullable annotations.</summary>
    /// <param name="x">The left-hand side.</param>
    /// <param name="y">The right-hand side.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="x"/>
    /// has the equivalent <see cref="ITypeSymbol.NullableAnnotation"/> as the
    /// parameter <paramref name="y"/>, otherwise; <see langword="false"/>.
    /// </returns>
    [Pure]
    public static bool MatchesNullableAnnotation(this ITypeSymbol x, ITypeSymbol y) =>
        !(x.NullableAnnotation is not NullableAnnotation.None and var a &&
            y.NullableAnnotation is not NullableAnnotation.None and var b &&
            a != b);
    /// <summary>Gets the hint name of the <see cref="INamedTypeSymbol"/>.</summary>
    /// <param name="symbol">The symbol to use.</param>
    /// <param name="prefix">If specified, the prefix to contain within the hint name.</param>
    /// <returns>The hint name of the parameter <paramref name="symbol"/>.</returns>
    [Pure]
    [return: NotNullIfNotNull(nameof(symbol))]
    public static string? HintName(this INamedTypeSymbol? symbol, string? prefix = nameof(Emik))
    {
        if (symbol is null)
            return null;
        StringBuilder sb = new(symbol.Name);
        ISymbol? containing = symbol;
        if (symbol.TypeParameters.Length is not 0 and var length)
            sb.Append('`').Append(length);
        while ((containing = containing.ContainingWithoutGlobal()) is not null)
        {
            sb.Insert(0, '.').Insert(0, containing.Name);
            if (containing is INamedTypeSymbol { TypeParameters.Length: not 0 and var i })
                sb.Append('`').Append(i);
        }
        if (prefix is not null)
            sb.Insert(0, '.').Insert(0, prefix);
        return sb.Append(".g.cs").ToString();
    }
    /// <summary>Returns whether the provided <see cref="SyntaxNode"/> is of type <typeparamref name="T"/>.</summary>
    /// <typeparam name="T">The type of <see cref="SyntaxNode"/> to test the instance for.</typeparam>
    /// <param name="node">The passed in node to test.</param>
    /// <param name="_">The discarded token, existing purely for convenience.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="node"/> is
    /// an instance of <typeparamref name="T"/>, otherwise; <see langword="false"/>.
    /// </returns>
    [Pure]
    public static bool Is<T>([NotNullWhen(true)] SyntaxNode? node, CancellationToken _ = default)
        where T : SyntaxNode =>
        node is T;
    /// <summary>Determines whether the symbol is accessible from an external assembly.</summary>
    /// <param name="accessibility">The symbol to check.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="accessibility"/> is accessible externally.
    /// </returns>
    [Pure]
    public static bool IsAccessible(this Accessibility accessibility) =>
        accessibility is Accessibility.Protected or Accessibility.ProtectedOrInternal or Accessibility.Public;
    /// <summary>Determines whether the symbol is accessible from an external assembly.</summary>
    /// <param name="symbol">The symbol to check.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="symbol"/> is accessible externally.
    /// </returns>
    [Pure]
    public static bool IsAccessible([NotNullWhen(true)] this ISymbol? symbol) =>
        symbol?.DeclaredAccessibility.IsAccessible() is true;
    /// <summary>
    /// Determines whether the symbol and all subsequent parent types
    /// are declared with the <see langword="partial"/> keyword.
    /// </summary>
    /// <param name="symbol">The symbol to check.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="symbol"/> and all its subsequent
    /// parent types are <see langword="partial"/>, otherwise; <see langword="false"/>.
    /// </returns>
    [Pure]
    public static bool IsCompletelyPartial([NotNullWhen(true)] this ISymbol? symbol) =>
        symbol?.FindPathToNull(x => x.ContainingType).All(IsPartial) is true;
    /// <summary>Returns whether the provided <see cref="SyntaxNode"/> is the first declaration.</summary>
    /// <param name="node">The passed in node to test.</param>
    /// <param name="symbol">The symbol to retrieve the declaring syntax references from.</param>
    /// <param name="token">The cancellation token.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="node"/> is the first
    /// to declare the parameter <paramref name="symbol"/>, otherwise; <see langword="false"/>.
    /// </returns>
    [Pure]
    public static bool IsFirst(
        this SyntaxNode? node,
        [NotNullWhen(true)] ISymbol? symbol,
        CancellationToken token = default
    ) =>
        symbol is { DeclaringSyntaxReferences: var x } && (x is not [var first, ..] || first.GetSyntax(token) == node);
    /// <summary>Determines whether the symbol is from metadata.</summary>
    /// <param name="symbol">The symbol to check.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="symbol"/>
    /// is in metadata, otherwise; <see langword="false"/>.
    /// </returns>
    [Pure]
    public static bool IsInMetadata([NotNullWhen(true)] this ISymbol? symbol) =>
        symbol is { Locations: [{ IsInMetadata: true }, ..] };
    /// <summary>Determines whether the symbol is from source code.</summary>
    /// <param name="symbol">The symbol to check.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="symbol"/>
    /// is from source code, otherwise; <see langword="false"/>.
    /// </returns>
    [Pure]
    public static bool IsInSource([NotNullWhen(true)] this ISymbol? symbol) =>
        symbol is { Locations: [{ IsInSource: true }, ..] };
    /// <summary>Determines whether the symbol is an <see langword="interface"/>.</summary>
    /// <param name="symbol">The symbol to check.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="symbol"/>
    /// is an <see langword="interface"/>, otherwise; <see langword="false"/>.
    /// </returns>
    [Pure]
    public static bool IsInterface([NotNullWhen(true)] this ITypeSymbol? symbol) =>
        symbol is { BaseType: null, SpecialType: not System_Object };
    /// <summary>Returns whether the provided <see cref="ISymbol"/> is an interface implementation.</summary>
    /// <param name="symbol">The passed in symbol to test.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="symbol"/>
    /// is an explicit interface implementation, otherwise; <see langword="false"/>.
    /// </returns>
    [Pure]
    public static bool IsInterfaceDeclaration([NotNullWhen(true)] this ISymbol? symbol) =>
        symbol?.Name.Contains('.') ?? false;
    /// <summary>Determines whether the symbol is declared with the <see cref="ObsoleteAttribute"/> attribute.</summary>
    /// <param name="symbol">The symbol to check.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="symbol"/>
    /// is obsolete, otherwise; <see langword="false"/>.
    /// </returns>
    [Pure]
    public static bool IsObsolete([NotNullWhen(true)] this ISymbol? symbol) =>
        symbol.HasAttribute(nameof(ObsoleteAttribute));
    /// <summary>Determines whether the symbol is declared with the <see langword="partial"/> keyword.</summary>
    /// <param name="symbol">The symbol to check.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="symbol"/>
    /// is <see langword="partial"/>, otherwise; <see langword="false"/>.
    /// </returns>
    [Pure]
    public static bool IsPartial([NotNullWhen(true)] this ISymbol? symbol) =>
        symbol
          ?.DeclaringSyntaxReferences
           .Select(x => x.GetSyntax())
           .OfType<TypeDeclarationSyntax>()
           .Any(x => x.Modifiers.Any(x => x.ValueText is "partial")) is true;
    /// <summary>Determines whether the symbol is an <see langword="unmanaged"/> primitive type.</summary>
    /// <param name="symbol">The symbol to check.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="symbol"/> is
    /// an <see langword="unmanaged"/> primitive, otherwise; <see langword="false"/>.
    /// </returns>
    [Pure]
    public static bool IsUnmanagedPrimitive([NotNullWhen(true)] this ITypeSymbol? symbol) =>
        symbol is
        {
            SpecialType: System_Char or
            System_SByte or
            System_Byte or
            System_Int16 or
            System_UInt16 or
            System_Int32 or
            System_UInt32 or
            System_Int64 or
            System_UInt64 or
            System_Decimal or
            System_Single or
            System_Double or
            System_IntPtr or
            System_UIntPtr,
        };
    /// <summary>Determines whether the symbol represents an unsafe type.</summary>
    /// <param name="symbol">The symbol to check.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="symbol"/>
    /// represents an unsafe type, otherwise; <see langword="false"/>.
    /// </returns>
    [Pure]
    public static bool IsUnsafe([NotNullWhen(true)] this ITypeSymbol? symbol) =>
        symbol is IFunctionPointerTypeSymbol or IPointerTypeSymbol ||
        symbol is IArrayTypeSymbol { ElementType: var e } && IsUnsafe(e);
    /// <summary>Gets the keyword associated with the declaration of the <see cref="ITypeSymbol"/>.</summary>
    /// <param name="symbol">The symbol to get its keyword.</param>
    /// <returns>The keyword used to declare the parameter <paramref name="symbol"/>.</returns>
    [Pure]
    public static string Keyword(this ITypeSymbol symbol) =>
        symbol switch
        {
            { TypeKind: TypeKind.Enum } => "enum",
            { TypeKind: TypeKind.Delegate } => "delegate",
            { TypeKind: TypeKind.Interface } => "interface",
            { IsValueType: true, IsRecord: true } => "record struct",
            { IsRecord: true } => "record",
            { IsValueType: true } => "struct",
            { IsReferenceType: true } => "class",
            _ => "",
        };
    /// <summary>Gets the keyword associated with the declaration of the <see cref="RefKind"/>.</summary>
    /// <param name="kind">The symbol to get its keyword.</param>
    /// <returns>The keyword used to declare the parameter <paramref name="kind"/>.</returns>
    [Pure]
    public static string KeywordInParameter(this RefKind kind) =>
        kind switch
        {
            RefKind.In => "in ",
            RefKind.Out => "out ",
            RefKind.Ref => "ref ",
            _ => "",
        };
    /// <summary>Gets the keyword associated with the declaration of the <see cref="RefKind"/>.</summary>
    /// <param name="kind">The symbol to get its keyword.</param>
    /// <returns>The keyword used to declare the parameter <paramref name="kind"/>.</returns>
    [Pure]
    public static string KeywordInReturn(this RefKind kind) =>
        kind switch
        {
            RefKind.Ref => "ref ",
            RefKind.RefReadOnly => "ref readonly ",
            _ => "",
        };
    /// <summary>Gets the constraint syntax for the <see cref="ITypeParameterSymbol"/>.</summary>
    /// <param name="symbol">The symbol containing constraints.</param>
    /// <returns>The constraint declaration of the parameter <paramref name="symbol"/>.</returns>
    [Pure]
    public static string? Constraints(this ITypeParameterSymbol symbol)
    {
        var reference = symbol.HasReferenceTypeConstraint;
        var value = symbol.HasValueTypeConstraint;
        var unmanaged = symbol.HasUnmanagedTypeConstraint;
        var notnull = symbol.HasNotNullConstraint;
        var types = symbol.ConstraintTypes.Any();
        var constructor = symbol.HasConstructorConstraint;
        if (!reference && !value && !unmanaged && !notnull && !types && !constructor)
            return null;
        List<string> list = 0 switch
        {
            _ when unmanaged => ["unmanaged"],
            _ when value => ["struct"],
            _ when reference => ["class"],
            _ when notnull => ["notnull"],
            _ => [],
        };
        if (types)
            list.AddRange(symbol.ConstraintTypes.Select(x => x.GetFullyQualifiedName()));
        if (constructor)
            list.Add("new()");
        return $"where {symbol.GetFullyQualifiedName()} : {list.Conjoin()}";
    }
    /// <inheritdoc cref="MemberPath.TryGetMemberName(ExpressionSyntax, out string)"/>
    [Pure]
    public static string? MemberName(this ExpressionSyntax syntax)
    {
        syntax.TryGetMemberName(out var result);
        return result;
    }
    /// <inheritdoc cref="AttributeArgumentSyntaxExt.TryGetStringValue(AttributeArgumentSyntax, SemanticModel, CancellationToken, out string)"/>
    [Pure]
    public static string? StringValue(this SyntaxNodeAnalysisContext context, AttributeArgumentSyntax syntax)
    {
        syntax.TryGetStringValue(context.SemanticModel, context.CancellationToken, out var result);
        return result;
    }
    /// <inheritdoc cref="AnalysisContext.RegisterSyntaxNodeAction{TLanguageKindEnum}(Action{SyntaxNodeAnalysisContext}, TLanguageKindEnum[])"/>
    public static AnalysisContext RegisterSyntaxNodeAction<TSyntaxNode>(
        this AnalysisContext context,
        Action<SyntaxNodeAnalysisContext, TSyntaxNode> action,
        params SyntaxKind[] syntaxKinds
    )
        where TSyntaxNode : SyntaxNode =>
        context.RegisterSyntaxNodeAction(action, ImmutableArray.Create(syntaxKinds));
    /// <inheritdoc cref="AnalysisContext.RegisterSyntaxNodeAction{TLanguageKindEnum}(Action{SyntaxNodeAnalysisContext}, ImmutableArray{TLanguageKindEnum})"/>
    public static AnalysisContext RegisterSyntaxNodeAction<TSyntaxNode>(
        this AnalysisContext context,
        Action<SyntaxNodeAnalysisContext, TSyntaxNode> action,
        ImmutableArray<SyntaxKind> syntaxKinds
    )
        where TSyntaxNode : SyntaxNode
    {
        context.RegisterSyntaxNodeAction(Filter(action), syntaxKinds);
        return context;
    }
    /// <summary>Adds information to a diagnostic.</summary>
    /// <typeparam name="T">The type of <paramref name="message"/>.</typeparam>
    /// <param name="diagnostic">The diagnostic to append.</param>
    /// <param name="message">The string to append.</param>
    /// <returns>The diagnostic with added information.</returns>
    [MustUseReturnValue]
    public static Diagnostic And<T>(this Diagnostic diagnostic, T message) =>
        Diagnostic.Create(
            new(
                diagnostic.Descriptor.Id,
                diagnostic.Descriptor.Title,
                $"{diagnostic.Descriptor.MessageFormat} {message.ToDeconstructed()}",
                diagnostic.Descriptor.Category,
                diagnostic.Descriptor.DefaultSeverity,
                diagnostic.Descriptor.IsEnabledByDefault,
                $"{diagnostic.Descriptor.Description} {message.ToDeconstructed()}",
                diagnostic.Descriptor.HelpLinkUri,
                diagnostic.Descriptor.CustomTags.ToArrayLazily()
            ),
            diagnostic.Location,
            diagnostic.Severity,
            diagnostic.AdditionalLocations,
            diagnostic.Properties
        );
    /// <summary>Gets all the members, including its base type members.</summary>
    /// <param name="symbol">The symbol to get all of the members of.</param>
    /// <returns>
    /// All of the symbols of the parameter <paramref name="symbol"/>, including the members that come from its
    /// interfaces and base types, and any subsequent interfaces and base types from those.
    /// </returns>
    [Pure]
    public static IEnumerable<ISymbol> GetAllMembers(this INamedTypeSymbol symbol) =>
        symbol
           .BaseType
           .FindPathToNull(x => x.BaseType)
           .SelectMany(GetAllMembers)
           .Concat(symbol.GetMembers());
    /// <summary>Gets the symbol from a lookup.</summary>
    /// <param name="context">The context to use.</param>
    /// <param name="syntax">The syntax to lookup.</param>
    /// <returns>The symbols that likely define it.</returns>
    [Pure]
    public static IEnumerable<ISymbol> Symbols(this in SyntaxNodeAnalysisContext context, ExpressionSyntax syntax) =>
        (syntax.MemberName() ?? $"{syntax}") is var name && syntax is PredefinedTypeSyntax
            ? context.Compilation.GetSymbolsWithName(
                x => x.Contains(name),
                cancellationToken: context.CancellationToken
            )
            : context.SemanticModel.LookupSymbols(syntax.SpanStart, name: name);
    /// <summary>Gets the containing <see cref="INamespaceOrTypeSymbol"/>.</summary>
    /// <param name="syntax">The syntax to lookup.</param>
    /// <returns>The containing type or namespace of the parameter <paramref name="syntax"/>.</returns>
    [Pure]
    public static INamespaceOrTypeSymbol ContainingSymbol(this ISymbol syntax) =>
        syntax.ContainingType ?? (INamespaceOrTypeSymbol)syntax.ContainingNamespace;
    /// <summary>Gets the containing symbol so long as it isn't the global namespace.</summary>
    /// <param name="symbol">The symbol to use.</param>
    /// <returns>The containing symbol, or <see langword="null"/> if it is the global namespace.</returns>
    [Pure]
    public static ISymbol? ContainingWithoutGlobal(this ISymbol? symbol) =>
        symbol?.ContainingSymbol is var x && x is INamespaceSymbol { IsGlobalNamespace: true } ? null : x;
    /// <inheritdoc cref="GetAllMembers(INamespaceSymbol)" />
    [Pure]
    public static IEnumerable<INamespaceOrTypeSymbol> GetAllMembers(this Compilation symbol) =>
        symbol.GlobalNamespace.GetAllMembers();
    /// <inheritdoc cref="GetAllMembers(INamespaceSymbol)" />
    [Pure]
    public static IEnumerable<INamespaceOrTypeSymbol> GetAllMembers(this IAssemblySymbol symbol) =>
        symbol.GlobalNamespace.GetAllMembers();
    /// <summary>Gets all of the types declared by this symbol.</summary>
    /// <param name="symbol">The symbol to get all of the type symbols of.</param>
    /// <returns>
    /// The <see cref="IEnumerable{T}"/> of all types defined in the parameter <paramref name="symbol"/>.
    /// </returns>
    [Pure]
    public static IEnumerable<INamespaceOrTypeSymbol> GetAllMembers(this INamespaceSymbol symbol) =>
        symbol.GetMembers().SelectMany(GetAllNamespaceOrTypeSymbolMembers).Prepend(symbol);
    /// <summary>Gets the interface members explicitly implemented by this <see cref="ISymbol"/>.</summary>
    /// <param name="symbol">The symbol to get the interface members from.</param>
    /// <returns>The explicitly implemented interface members of the parameter <paramref name="symbol"/>.</returns>
    [Pure]
    public static ImmutableArray<ISymbol> ExplicitInterfaceSymbols(this ISymbol? symbol) =>
        symbol switch
        {
            IEventSymbol x => x.ExplicitInterfaceImplementations.As<ISymbol>(),
            IMethodSymbol x => x.ExplicitInterfaceImplementations.As<ISymbol>(),
            IPropertySymbol x => x.ExplicitInterfaceImplementations.As<ISymbol>(),
            _ => [],
        };
    /// <summary>Gets the underlying type symbol of another symbol.</summary>
    /// <param name="symbol">The symbol to get the underlying type from.</param>
    /// <returns>The underlying type symbol from <paramref name="symbol"/>, if applicable.</returns>
    [Pure]
    public static ITypeSymbol? ToUnderlying(this ISymbol? symbol) =>
        symbol switch
        {
            IEventSymbol x => x.Type,
            IFieldSymbol x => x.Type,
            ILocalSymbol x => x.Type,
            IDiscardSymbol x => x.Type,
            IPropertySymbol x => x.Type,
            IParameterSymbol x => x.Type,
            IMethodSymbol x => x.ReturnType,
            IArrayTypeSymbol x => x.ElementType,
            IPointerTypeSymbol x => x.PointedAtType,
            IFunctionPointerTypeSymbol x => x.Signature.ReturnType,
            _ => null,
        };
    /// <summary>Gets the underlying symbol if the provided parameter is the nullable type.</summary>
    /// <param name="symbol">The symbol to get the underlying type from.</param>
    /// <returns>The underlying type of <paramref name="symbol"/>, if it exists.</returns>
    [Pure]
    public static ITypeSymbol? UnderlyingNullable(this ISymbol? symbol) =>
        symbol is INamedTypeSymbol
        {
            ContainingNamespace: { ContainingNamespace.IsGlobalNamespace: true, Name: nameof(System) },
            Name: nameof(Nullable),
            IsValueType: true,
            TypeArguments:
            [
                { } underlying and not { Name: nameof(Nullable) },
            ],
        }
            ? underlying
            : null;
    /// <summary>Gets the <see cref="RefKind"/> of the parameter.</summary>
    /// <param name="argument">The argument to get the <see cref="RefKind"/> of.</param>
    /// <returns>The <see cref="RefKind"/> of the parameter <paramref name="argument"/>.</returns>
    public static RefKind GetRefKind(this ArgumentSyntax? argument) =>
        argument?.RefKindKeyword.Kind() switch
        {
            SyntaxKind.RefKeyword => RefKind.Ref,
            SyntaxKind.OutKeyword => RefKind.Out,
            SyntaxKind.InKeyword => RefKind.In,
            _ => RefKind.None,
        };
    /// <summary>Gets the specified symbol.</summary>
    /// <typeparam name="T">The type of symbol to get.</typeparam>
    /// <param name="context">The context.</param>
    /// <param name="token">The cancellation token.</param>
    /// <returns>The context node as <typeparamref name="T"/>.</returns>
    [Pure]
    public static T? Get<T>(this in GeneratorSyntaxContext context, CancellationToken token = default)
        where T : ISymbol =>
        context.SemanticModel.GetDeclaredSymbol(context.Node, token) is T symbol ? symbol : default;
    [Pure]
    static Action<SyntaxNodeAnalysisContext> Filter<TSyntaxNode>(Action<SyntaxNodeAnalysisContext, TSyntaxNode> action)
        where TSyntaxNode : SyntaxNode =>
        context =>
        {
            if (context.Node is TSyntaxNode node && !context.IsExcludedFromAnalysis())
                action(context, node);
        };
    [Pure]
    static IEnumerable<INamespaceOrTypeSymbol> GetAllNamespaceOrTypeSymbolMembers(INamespaceOrTypeSymbol x) =>
        ((x as INamespaceSymbol)?.GetAllMembers() ?? []).Prepend(x);
#endif
// SPDX-License-Identifier: MPL-2.0
#if !NET20 && !NET30
// ReSharper disable once CheckNamespace
/// <summary>Extension methods to create power sets.</summary>
    /// <inheritdoc cref="PowerSet{T}(ICollection{T})"/>
    [LinqTunnel, Pure]
    public static IEnumerable<IEnumerable<object>> PowerSet(this ICollection collection) =>
        collection.Cast<object>().PowerSetInner(collection.Count);
    /// <summary>Creates a power set from a collection.</summary>
    /// <remarks><para>
    /// The power set is defined as the set of all subsets, including the empty set and the set itself.
    /// </para></remarks>
    /// <typeparam name="T">The type of item in the set.</typeparam>
    /// <exception cref="ArgumentOutOfRangeException">
    /// The argument <paramref name="collection"/> has 32 or more elements.
    /// </exception>
    /// <param name="collection">The set to create a power set.</param>
    /// <returns>The power set of the parameter <paramref name="collection"/>.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<IEnumerable<T>> PowerSet<T>(this ICollection<T> collection) =>
        collection.PowerSetInner(collection.Count);
    /// <inheritdoc cref="PowerSet{T}(ICollection{T})"/>
    [LinqTunnel, Pure]
    public static IEnumerable<IEnumerable<T>> PowerSet<T>(this IReadOnlyCollection<T> collection) =>
        collection.PowerSetInner(collection.Count);
    /// <inheritdoc cref="PowerSet{T}(ICollection{T})"/>
    [LinqTunnel, Pure]
    public static IEnumerable<IEnumerable<T>> PowerSet<T>(this T[] collection) =>
        ((ICollection<T>)collection).PowerSet();
    [LinqTunnel, Pure]
    static IEnumerable<IEnumerable<T>> PowerSetInner<T>(this IEnumerable<T> iterable, [ValueRange(0, 31)] int count) =>
        count < 32
            ? Enumerable.Range(0, 1 << count).Select(mask => iterable.Where((_, j) => (1 << j & mask) is not 0))
            : throw new ArgumentOutOfRangeException(nameof(count), count, $"Cannot exceed bits in {nameof(Int32)}.");
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable once CheckNamespace
/// <summary>Extension methods for iterating over a set of elements, or for generating new ones.</summary>
#if !NETFRAMEWORK || NET35_OR_GREATER
    /// <summary>Upcasts or creates an <see cref="IList{T}"/>.</summary>
    /// <typeparam name="T">The item in the collection.</typeparam>
    /// <param name="iterable">The <see cref="IEnumerable{T}"/> to upcast or encapsulate.</param>
    /// <returns>Itself as <see cref="IList{T}"/>, or collected.</returns>
    [Pure]
    [return: NotNullIfNotNull(nameof(iterable))]
    public static T[]? ToArrayLazily<T>([InstantHandle] this IEnumerable<T>? iterable) =>
        iterable is null ? null : iterable as T[] ?? [..iterable];
#endif
    /// <summary>Wraps the <see cref="IEnumerable{T}"/> in a known-size collection type.</summary>
    /// <remarks><para>The parameter <paramref name="count"/> is assumed to be correct.</para></remarks>
    /// <typeparam name="T">The item in the collection.</typeparam>
    /// <param name="iterable">The <see cref="IEnumerable{T}"/> to encapsulate.</param>
    /// <param name="count">The number of elements in the parameter <paramref name="iterable"/>.</param>
    /// <returns>The parameter <paramref name="iterable"/> as a <see cref="Collection{T}"/>.</returns>
    [Pure]
    [return: NotNullIfNotNull(nameof(iterable))]
    public static Collection<T>? WithCount<T>(this IEnumerable<T>? iterable, [NonNegativeValue] int count) =>
        iterable is null ? null : new(iterable, count);
    /// <summary>Upcasts or creates an <see cref="ICollection{T}"/>.</summary>
    /// <typeparam name="T">The item in the collection.</typeparam>
    /// <param name="iterable">The <see cref="IEnumerable{T}"/> to upcast or encapsulate.</param>
    /// <returns>Itself as <see cref="ICollection{T}"/>, or collected.</returns>
    [Pure]
    [return: NotNullIfNotNull(nameof(iterable))]
    public static ICollection<T>? ToICollection<T>([InstantHandle] this IEnumerable<T>? iterable) =>
        iterable is null
            ? null
            : iterable as ICollection<T> ??
            (iterable.TryCount() is { } count
                ? new Collection<T>(iterable, count)
#if NETFRAMEWORK && NET40_OR_GREATER
                : new List<T>(iterable));
#else
                : iterable.ToIList());
#endif
    /// <summary>Returns a fallback enumeration if the collection given is null or empty.</summary>
    /// <typeparam name="T">The type of item within the enumeration.</typeparam>
    /// <param name="iterable">The potentially empty collection.</param>
    /// <param name="fallback">The fallback value.</param>
    /// <returns>
    /// The parameter <paramref name="iterable"/> when non-empty, otherwise; <paramref name="fallback"/>.
    /// </returns>
    [Pure]
    public static IEnumerable<T> DefaultIfEmpty<T>(this IEnumerable<T>? iterable, IEnumerable<T> fallback)
    {
        using var a = iterable?.GetEnumerator();
        if (a?.MoveNext() ?? false)
            do
                yield return a.Current;
            while (a.MoveNext());
        else
            foreach (var b in fallback)
                yield return b;
    }
    /// <summary>Appends one element and returns the list.</summary>
    /// <typeparam name="T">The type of the list and element.</typeparam>
    /// <param name="list">The list to append to.</param>
    /// <param name="item">The item to append with.</param>
    /// <returns>The parameter <paramref name="list"/>.</returns>
    public static List<T> AndAdd<T>(this List<T> list, [CanBeNull] T item)
    {
        list.Add(item);
        return list;
    }
    /// <summary>Upcasts or creates an <see cref="IList{T}"/>.</summary>
    /// <typeparam name="T">The item in the collection.</typeparam>
    /// <param name="iterable">The <see cref="IEnumerable{T}"/> to upcast or encapsulate.</param>
    /// <returns>Itself as <see cref="IList{T}"/>, or collected.</returns>
    [Pure]
    [return: NotNullIfNotNull(nameof(iterable))]
    public static IList<T>? ToIList<T>([InstantHandle] this IEnumerable<T>? iterable) =>
#if !NET40_OR_GREATER && NETFRAMEWORK
        iterable is null ? null : iterable as IList<T> ?? new List<T>(iterable);
#else
        iterable is null ? null : iterable as IList<T> ?? [..iterable];
#endif
#if !NETFRAMEWORK || NET40_OR_GREATER
    /// <summary>Creates a <see cref="HashSet{T}"/>.</summary>
    /// <typeparam name="T">The item in the collection.</typeparam>
    /// <param name="iterable">The <see cref="IEnumerable{T}"/> to encapsulate.</param>
    /// <param name="comparer">The comparer to use.</param>
    /// <returns>Itself as <see cref="ISet{T}"/>.</returns>
    [Pure]
    [return: NotNullIfNotNull(nameof(iterable))]
    public static HashSet<T>? ToSet<T>(
        [InstantHandle] this IEnumerable<T>? iterable,
        IEqualityComparer<T>? comparer = null
    ) =>
        iterable is null ? null : new HashSet<T>(iterable, comparer);
    /// <summary>Upcasts or creates an <see cref="ISet{T}"/>.</summary>
    /// <typeparam name="T">The item in the collection.</typeparam>
    /// <param name="iterable">The <see cref="IEnumerable{T}"/> to upcast or encapsulate.</param>
    /// <returns>Itself as <see cref="IList{T}"/>, or collected.</returns>
    [Pure]
    [return: NotNullIfNotNull(nameof(iterable))]
    public static ISet<T>? ToSetLazily<T>([InstantHandle] this IEnumerable<T>? iterable) =>
        iterable is null ? null : iterable as ISet<T> ?? new HashSet<T>(iterable);
    /// <summary>Upcasts or creates an <see cref="ISet{T}"/>.</summary>
    /// <typeparam name="T">The item in the collection.</typeparam>
    /// <param name="iterable">The <see cref="IEnumerable{T}"/> to upcast or encapsulate.</param>
    /// <param name="comparer">The comparer to use if one needs to be generated.</param>
    /// <returns>Itself as <see cref="ISet{T}"/>, or collected.</returns>
    [Pure]
    [return: NotNullIfNotNull(nameof(iterable))]
    public static ISet<T>? ToSetLazily<T>(
        [InstantHandle] this IEnumerable<T>? iterable,
        IEqualityComparer<T> comparer
    ) =>
        iterable is null ? null : iterable as ISet<T> ?? new HashSet<T>(iterable, comparer);
#endif
    /// <summary>Provides a wrapper to an <see cref="IEnumerable{T}"/> with a known count.</summary>
    /// <param name="enumerable">The enumerable to encapsulate.</param>
    /// <param name="count">The pre-computed count.</param>
    /// <typeparam name="T">The type of element in the <see cref="IEnumerable{T}"/>.</typeparam>
    internal sealed class Collection<T>([ProvidesContext] IEnumerable<T> enumerable, [NonNegativeValue] int count) :
        ICollection,
        ICollection<T>,
        IReadOnlyCollection<T>
    {
        /// <inheritdoc />
        [Pure]
        bool ICollection.IsSynchronized => true;
        /// <inheritdoc />
        [Pure]
        bool ICollection<T>.IsReadOnly => true;
        /// <inheritdoc cref="ICollection{T}.Count" />
        [NonNegativeValue, Pure]
        public int Count => count;
        /// <inheritdoc />
        [Pure]
        public object SyncRoot => enumerable;
        /// <inheritdoc />
        public void CopyTo(Array array, [NonNegativeValue] int index)
        {
            var i = index;
            foreach (var next in enumerable)
            {
                array.SetValue(next, i);
                _ = checked(i++);
            }
        }
        /// <inheritdoc />
        public void CopyTo(T[] array, [NonNegativeValue] int arrayIndex)
        {
            var i = arrayIndex;
            foreach (var next in enumerable)
            {
                array[i] = next;
                _ = checked(i++);
            }
        }
        /// <inheritdoc />
        void ICollection<T>.Add(T? item) { }
        /// <inheritdoc />
        void ICollection<T>.Clear() { }
        /// <inheritdoc />
        [Pure]
        public bool Contains(T item) => enumerable.Contains(item);
        /// <inheritdoc />
        [Pure]
        bool ICollection<T>.Remove(T? item) => false;
        /// <inheritdoc />
        [Pure]
        IEnumerator IEnumerable.GetEnumerator() => enumerable.GetEnumerator();
        /// <inheritdoc />
        [Pure]
        public IEnumerator<T> GetEnumerator() => enumerable.GetEnumerator();
    }
// SPDX-License-Identifier: MPL-2.0
#if (NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) && !NO_SYSTEM_MEMORY
// ReSharper disable BadPreprocessorIndent CheckNamespace StructCanBeMadeReadOnly RedundantReadonlyModifier
#pragma warning disable CS8500, IDE0251, MA0102
/// <summary>Extension methods that act as factories for <see cref="Bits{T}"/>.</summary>
    /// <summary>Creates the <see cref="Bits{T}"/> from the item.</summary>
    /// <typeparam name="T">The type of item.</typeparam>
    /// <param name="source">The item.</param>
    /// <returns>The <see cref="Bits{T}"/> instance with the parameter <paramref name="source"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static Bits<T> AsBits<T>(this T source)
        where T : unmanaged =>
        source;
    /// <summary>Computes the Bitwise-AND of the <see cref="IEnumerable{T}"/>.</summary>
    /// <typeparam name="T">The type of item.</typeparam>
    /// <param name="source">The item.</param>
    /// <returns>The value <typeparamref name="T"/> containing the Bitwise-OR of <paramref name="source"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T BitwiseAnd<T>(this IEnumerable<T> source)
        where T : unmanaged
    {
        T t = default;
        foreach (var next in source)
            Bits<T>.And(next, ref t);
        return t;
    }
    /// <summary>Computes the Bitwise-AND-NOT of the <see cref="IEnumerable{T}"/>.</summary>
    /// <typeparam name="T">The type of item.</typeparam>
    /// <param name="source">The item.</param>
    /// <returns>The value <typeparamref name="T"/> containing the Bitwise-OR of <paramref name="source"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T BitwiseAndNot<T>(this IEnumerable<T> source)
        where T : unmanaged
    {
        T t = default;
        foreach (var next in source)
            Bits<T>.AndNot(next, ref t);
        return t;
    }
    /// <summary>Returns the reference that contains the most bits.</summary>
    /// <typeparam name="T">The type of item.</typeparam>
    /// <param name="source">The item.</param>
    /// <returns>The value <typeparamref name="T"/> containing the most bits of <paramref name="source"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T BitwiseMax<T>(this IEnumerable<T> source)
        where T : unmanaged =>
        source.Aggregate(default(T), (acc, next) => Bits<T>.Max(acc, next));
    /// <summary>Returns the reference that contains the least bits.</summary>
    /// <typeparam name="T">The type of item.</typeparam>
    /// <param name="source">The item.</param>
    /// <returns>The value <typeparamref name="T"/> containing the least bits of <paramref name="source"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T BitwiseMin<T>(this IEnumerable<T> source)
        where T : unmanaged =>
        source.Aggregate(default(T), (acc, next) => Bits<T>.Min(acc, next));
    /// <summary>Computes the Bitwise-OR of the <see cref="IEnumerable{T}"/>.</summary>
    /// <typeparam name="T">The type of item.</typeparam>
    /// <param name="source">The item.</param>
    /// <returns>The value <typeparamref name="T"/> containing the Bitwise-OR of <paramref name="source"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T BitwiseOr<T>(this IEnumerable<T> source)
        where T : unmanaged
    {
        T t = default;
        foreach (var next in source)
            Bits<T>.Or(next, ref t);
        return t;
    }
    /// <summary>Computes the Bitwise-XOR of the <see cref="IEnumerable{T}"/>.</summary>
    /// <typeparam name="T">The type of item.</typeparam>
    /// <param name="source">The item.</param>
    /// <returns>The value <typeparamref name="T"/> containing the Bitwise-OR of <paramref name="source"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T BitwiseXor<T>(this IEnumerable<T> source)
        where T : unmanaged
    {
        T t = default;
        foreach (var next in source)
            Bits<T>.Xor(next, ref t);
        return t;
    }
/// <summary>Provides the enumeration of individual bits from the given <typeparamref name="T"/>.</summary>
/// <typeparam name="T">The type of the item to yield.</typeparam>
/// <param name="bits">The item to use.</param>
[StructLayout(LayoutKind.Auto)]
#if CSHARPREPL
public
#endif
#if !NO_READONLY_STRUCTS
readonly
#endif
    partial struct Bits<T>([ProvidesContext] T bits) :
#if NET7_0_OR_GREATER
    IBitwiseOperators<Bits<T>, Bits<T>, Bits<T>>,
    IEqualityOperators<Bits<T>, Bits<T>, bool>,
#endif
    IEquatable<Bits<T>>,
    IReadOnlyList<T>,
    IReadOnlySet<T>,
    ISet<T>,
    IList<T>
    where T : unmanaged
{
    /// <inheritdoc cref="ICollection{T}.IsReadOnly"/>
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)]
    bool ICollection<T>.IsReadOnly
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => true;
    }
    /// <summary>Gets the item to use.</summary>
    [CollectionAccess(Read), ProvidesContext]
    public readonly T Current
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => bits;
    }
    /// <summary>Determines whether both bits of <typeparamref name="T"/> do not contain the same bits.</summary>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameters <paramref name="left"/> and <paramref name="right"/>
    /// do not have the same bits as each other; otherwise, <see langword="false"/>.
    /// </returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool operator !=(Bits<T> left, Bits<T> right) =>
        !Eq(Unsafe.As<Bits<T>, T>(ref Unsafe.AsRef(left)), Unsafe.As<Bits<T>, T>(ref Unsafe.AsRef(right)));
    /// <summary>Determines whether both bits of <typeparamref name="T"/> contain the same bits.</summary>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameters <paramref name="left"/> and <paramref name="right"/>
    /// have the same bits as each other; otherwise, <see langword="false"/>.
    /// </returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool operator ==(Bits<T> left, Bits<T> right) =>
        Eq(Unsafe.As<Bits<T>, T>(ref Unsafe.AsRef(left)), Unsafe.As<Bits<T>, T>(ref Unsafe.AsRef(right)));
    /// <summary>Computes the Bitwise-NOT computation.</summary>
    /// <param name="value">The set of bits.</param>
    /// <returns>The result of the computation.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static Bits<T> operator ~(Bits<T> value)
    {
        Not(ref Unsafe.As<Bits<T>, T>(ref value));
        return value;
    }
    /// <summary>Computes the Bitwise-AND computation.</summary>
    /// <param name="left">The first set of bits.</param>
    /// <param name="right">The second set of bits.</param>
    /// <returns>The result of the computation.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static Bits<T> operator &(Bits<T> left, Bits<T> right)
    {
        And(Unsafe.As<Bits<T>, T>(ref Unsafe.AsRef(left)), ref Unsafe.As<Bits<T>, T>(ref right));
        return right;
    }
    /// <summary>Computes the Bitwise-OR computation.</summary>
    /// <param name="left">The first set of bits.</param>
    /// <param name="right">The second set of bits.</param>
    /// <returns>The result of the computation.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static Bits<T> operator |(Bits<T> left, Bits<T> right)
    {
        Or(Unsafe.As<Bits<T>, T>(ref Unsafe.AsRef(left)), ref Unsafe.As<Bits<T>, T>(ref right));
        return right;
    }
    /// <summary>Computes the Bitwise-XOR computation.</summary>
    /// <param name="left">The first set of bits.</param>
    /// <param name="right">The second set of bits.</param>
    /// <returns>The result of the computation.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static Bits<T> operator ^(Bits<T> left, Bits<T> right)
    {
        Xor(Unsafe.As<Bits<T>, T>(ref Unsafe.AsRef(left)), ref Unsafe.As<Bits<T>, T>(ref right));
        return right;
    }
    /// <summary>Implicitly calls the constructor.</summary>
    /// <param name="value">The value to pass into the constructor.</param>
    /// <returns>A new instance of <see cref="Bits{T}"/> with <paramref name="value"/> passed in.</returns>
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static implicit operator Bits<T>([ProvidesContext] Enumerator value) => value.Current;
    /// <summary>Implicitly calls the constructor.</summary>
    /// <param name="value">The value to pass into the constructor.</param>
    /// <returns>A new instance of <see cref="Bits{T}"/> with <paramref name="value"/> passed in.</returns>
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static implicit operator Bits<T>([ProvidesContext] T value) => new(value);
    /// <summary>Implicitly calls <see cref="Current"/>.</summary>
    /// <param name="value">The value to call <see cref="Current"/>.</param>
    /// <returns>The value that was passed in to this instance.</returns>
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static implicit operator Enumerator([ProvidesContext] Bits<T> value) => value.Current;
    /// <summary>Implicitly calls <see cref="Current"/>.</summary>
    /// <param name="value">The value to call <see cref="Current"/>.</param>
    /// <returns>The value that was passed in to this instance.</returns>
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static implicit operator T(Bits<T> value) => value.Current;
    /// <inheritdoc />
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining)]
    public readonly void CopyTo(T[] array, int arrayIndex)
    {
        foreach (var next in this)
            array[arrayIndex++] = next;
    }
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining)]
    readonly void ICollection<T>.Add(T item) { }
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining)]
    readonly void ICollection<T>.Clear() { }
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining)]
    readonly void IList<T>.Insert(int index, T item) { }
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining)]
    readonly void IList<T>.RemoveAt(int index) { }
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining)]
    readonly void ISet<T>.ExceptWith(IEnumerable<T>? other) { }
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining)]
    readonly void ISet<T>.IntersectWith(IEnumerable<T>? other) { }
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining)]
    readonly void ISet<T>.SymmetricExceptWith(IEnumerable<T>? other) { }
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining)]
    readonly void ISet<T>.UnionWith(IEnumerable<T>? other) { }
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    readonly bool ICollection<T>.Remove(T item) => false;
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    readonly bool ISet<T>.Add(T item) => false;
    /// <summary>Determines whether the reference of <typeparamref name="T"/> contains all zeros.</summary>
    /// <returns>
    /// The value <see langword="true"/> if this instance is all zeros; otherwise, <see langword="false"/>.
    /// </returns>
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly bool Eq0() => Eq0(Unsafe.As<Bits<T>, T>(ref Unsafe.AsRef(this)));
    /// <inheritdoc />
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly override bool Equals(object? other) => other is Bits<T> bit && this == bit;
    /// <inheritdoc />
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly bool Equals(Bits<T> other) => this == other;
    /// <inheritdoc />
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly override int GetHashCode() => Coerce<int>();
    /// <inheritdoc />
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly int IndexOf(T item)
    {
        if ((Enumerator)item is var e && !e.MoveNext() ||
            e.Mask is var mask && e.Index is var index && e.MoveNext())
            return -1;
        var that = (Enumerator)this;
        for (var i = 0; that.MoveNext(); i++)
            if (that.Mask == mask && that.Index == index)
                return i;
            else if (that.Mask > mask || that.Index > index)
                return -1;
        return -1;
    }
    /// <inheritdoc />
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly override string ToString() => ((Enumerator)this).ToRemainingString();
    /// <summary>Computes the Bitwise-AND-NOT computation.</summary>
    /// <param name="other">The other set of bits.</param>
    /// <returns>The result of the computation.</returns>
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly Bits<T> AndNot(Bits<T> other)
    {
        AndNot(Unsafe.As<Bits<T>, T>(ref Unsafe.AsRef(this)), ref Unsafe.As<Bits<T>, T>(ref other));
        return other;
    }
    /// <summary>Returns the greater bits.</summary>
    /// <returns>
    /// This instance if its bits are greater or equal to the parameter
    /// <paramref name="other"/>; otherwise, <paramref name="other"/>.
    /// </returns>
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly Bits<T> Max(Bits<T> other) =>
        Max(Unsafe.As<Bits<T>, T>(ref Unsafe.AsRef(this)), Unsafe.As<Bits<T>, T>(ref other));
    /// <summary>Returns the lesser bits.</summary>
    /// <returns>
    /// This instance if its bits are lesser or equal to the parameter
    /// <paramref name="other"/>; otherwise, <paramref name="other"/>.
    /// </returns>
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly Bits<T> Min(Bits<T> other) =>
        Min(Unsafe.As<Bits<T>, T>(ref Unsafe.AsRef(this)), Unsafe.As<Bits<T>, T>(ref other));
    /// <summary>
    /// Returns itself. Used to tell the compiler that it can be used in a <see langword="foreach"/> loop.
    /// </summary>
    /// <returns>Itself.</returns>
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), MustDisposeResource(false), Pure]
    public readonly Enumerator GetEnumerator() => bits;
    /// <inheritdoc />
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), MustDisposeResource(false), Pure]
    readonly IEnumerator<T> IEnumerable<T>.GetEnumerator() => GetEnumerator();
    /// <inheritdoc />
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), MustDisposeResource(false), Pure]
    readonly IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
#pragma warning disable DOC100
    /// <summary>Reinterprets the bits in <see cref="Current"/> as <typeparamref name="TResult"/>.</summary>
    /// <remarks><para>
    /// If the type <typeparamref name="TResult"/> is smaller than <typeparamref name="T"/>,
    /// the result is truncated to the left. Otherwise, if the type <typeparamref name="TResult"/>
    /// is larger than <typeparamref name="T"/>, the result is zero-padded to the left.
    /// </para>
    /// <example>
    /// <para>Visual description of how the coercion works:</para>
    /// <code lang="C#"><![CDATA[
    /// var bits = ((ushort)0b0101_0110).AsBits();
    /// var padding = bits.Coerce<int>();
    /// var truncation = bits.Coerce<byte>();
    /// ]]></code></example></remarks>
    /// <typeparam name="TResult">The type to reinterpret the bits as.</typeparam>
    /// <returns>The result of reinterpreting <see cref="Current"/> as <typeparamref name="TResult"/>.</returns>
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly TResult Coerce<TResult>()
        where TResult : unmanaged
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        static TResult Copy(T value)
        {
            TResult ret = default;
            Unsafe.As<TResult, T>(ref ret) = value;
            return ret;
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        static TResult Read(T value) => Unsafe.As<T, TResult>(ref value);
        return Unsafe.SizeOf<T>() >= Unsafe.SizeOf<TResult>() ? Read(bits) : Copy(bits);
    }
    /// <summary>Reinterprets the bits in <see cref="Current"/> as <typeparamref name="TResult"/>.</summary>
    /// <remarks><para>
    /// If the type <typeparamref name="TResult"/> is smaller than <typeparamref name="T"/>,
    /// the result is truncated to the right. Otherwise, if the type <typeparamref name="TResult"/>
    /// is larger than <typeparamref name="T"/>, the result is zero-padded to the right.
    /// </para>
    /// <example>
    /// <para>Visual description of how the coercion works:</para>
    /// <code lang="C#"><![CDATA[
    /// var bits = ((ushort)0b0101_0110).AsBits();
    /// var padding = bits.Coerce<int>();
    /// var truncation = bits.Coerce<byte>();
    /// ]]></code></example></remarks>
    /// <typeparam name="TResult">The type to reinterpret the bits as.</typeparam>
    /// <returns>The result of reinterpreting <see cref="Current"/> as <typeparamref name="TResult"/>.</returns>
#pragma warning restore DOC100
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly TResult CoerceLeft<TResult>()
        where TResult : unmanaged
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        static TResult Copy(T value)
        {
            TResult ret = default;
            Unsafe.Subtract(ref Unsafe.As<TResult, T>(ref Unsafe.Add(ref ret, 1)), 1) = value;
            return ret;
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        static TResult Read(T value) => Unsafe.Subtract(ref Unsafe.As<T, TResult>(ref Unsafe.Add(ref value, 1)), 1);
        return Unsafe.SizeOf<T>() == Unsafe.SizeOf<TResult>() ? Coerce<TResult>() :
            Unsafe.SizeOf<T>() > Unsafe.SizeOf<TResult>() ? Read(bits) : Copy(bits);
    }
    /// <summary>Converts the value to a hex <see cref="string"/>.</summary>
    /// <returns>The hex <see cref="string"/>.</returns>
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly string ToHexString()
    {
        Span<char> span = stackalloc char[Unsafe.SizeOf<T>() * 2 + 2];
        ref var first = ref MemoryMarshal.GetReference(span);
        const string Hex = "0123456789abcdef";
        first = '0';
        Unsafe.Add(ref first, 1) = 'x';
        for (int i = 0, j = Unsafe.SizeOf<T>() * 2; i < Unsafe.SizeOf<T>(); i++, j -= 2)
        {
            var b = Unsafe.Add(ref Unsafe.As<T, byte>(ref AsRef(bits)), i);
            Unsafe.Add(ref first, j) = Unsafe.Add(ref AsRef(MemoryMarshal.GetReference(Hex.AsSpan())), (b & 0xf0) >> 4);
            Unsafe.Add(ref first, j + 1) = Unsafe.Add(ref AsRef(MemoryMarshal.GetReference(Hex.AsSpan())), b & 0x0f);
        }
        return span.ToString();
    }
}
#endif
// SPDX-License-Identifier: MPL-2.0
#if !NET20 && !NET30
// ReSharper disable CheckNamespace RedundantNameQualifier
/// <summary>Extension methods for iterating over a set of elements, or for generating new ones.</summary>
    /// <summary>
    /// The <see langword="for"/> statement executes a statement or a block of statements while a specified
    /// Boolean expression evaluates to <see langword="true"/>.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-for-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <param name="index">The range of numbers to iterate over in the <see langword="for"/> loop.</param>
    /// <returns>An enumeration from a range's start to end.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<int> For(this Index index) => (index.IsFromEnd ? -index.Value : index.Value).For();
    /// <summary>
    /// The <see langword="for"/> statement executes a statement or a block of statements while a specified
    /// Boolean expression evaluates to <see langword="true"/>.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-for-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <param name="range">The range of numbers to iterate over in the <see langword="for"/> loop.</param>
    /// <returns>An enumeration from a range's start to end.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<int> For(this Range range) =>
        (range.Start.IsFromEnd ? -range.Start.Value : range.Start.Value) is var start &&
        (range.End.IsFromEnd ? -range.End.Value : range.End.Value) is var end &&
        start == end ? [] :
        start < end ? Enumerable.Range(start - (!range.Start.IsFromEnd && range.End.IsFromEnd ? 1 : 0), end - start) :
        Enumerable.Repeat(start, start - end).Select((x, i) => x - i - 1);
    /// <summary>Separates the head from the tail of an <see cref="IEnumerable{T}"/>.</summary>
    /// <remarks><para>
    /// The tail is not guaranteed to be able to be enumerated over multiple times.
    /// As such, use a method like <see cref="Collected.ToICollection{T}"/> if multiple enumerations are needed.
    /// </para></remarks>
    /// <typeparam name="T">The item in the collection.</typeparam>
    /// <param name="enumerable">The enumerable to split.</param>
    /// <param name="head">The first element of the parameter <paramref name="enumerable"/>.</param>
    /// <param name="tail">The rest of the parameter <paramref name="enumerable"/>.</param>
    public static void Deconstruct<T>(
        this IEnumerable<T>? enumerable,
        out T? head,
        [MustDisposeResource] out IEnumerable<T> tail
    )
    {
        using var e = enumerable?.GetEnumerator();
        if (e is null)
        {
            head = default;
            tail = [];
            return;
        }
        head = e.MoveNext() ? e.Current : default;
        tail = e.AsEnumerable();
    }
    /// <summary>Gets a specific item from a collection.</summary>
    /// <param name="str">The <see cref="IEnumerable{T}"/> to get an item from.</param>
    /// <param name="index">The index to get.</param>
    /// <returns>An element from the parameter <paramref name="str"/>, or <see langword="default"/>.</returns>
    [Pure]
    public static char? Nth(this string str, Index index) =>
        index.IsFromEnd ? str.NthLast(index.Value - 1) : str.Nth(index.Value);
    /// <summary>Gets a specific item from a collection.</summary>
    /// <typeparam name="T">The item in the collection.</typeparam>
    /// <param name="iterable">The <see cref="IEnumerable{T}"/> to get an item from.</param>
    /// <param name="index">The index to get.</param>
    /// <returns>An element from the parameter <paramref name="iterable"/>, or <see langword="default"/>.</returns>
    [MustUseReturnValue]
    public static T? Nth<T>([InstantHandle] this IEnumerable<T> iterable, Index index) =>
        index.IsFromEnd ? iterable.NthLast(index.Value - 1) : iterable.Nth(index.Value);
    /// <summary>Gets a specific item from a collection.</summary>
    /// <param name="str">The <see cref="IEnumerable{T}"/> to get an item from.</param>
    /// <param name="range">The index to get.</param>
    /// <returns>An element from the parameter <paramref name="str"/>, or <see langword="default"/>.</returns>
    [Pure]
    public static string? Nth(this string str, Range range) =>
        range.TryGetOffsetAndLength(str.Length, out var offset, out var length) ? str.Substring(offset, length) : null;
    /// <summary>Gets a range of items from a collection.</summary>
    /// <typeparam name="T">The item in the collection.</typeparam>
    /// <param name="iterable">The <see cref="IEnumerable{T}"/> to get a range of items from.</param>
    /// <param name="range">The ranges to get.</param>
    /// <returns>A slice from the parameter <paramref name="iterable"/>.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<T> Nth<T>([InstantHandle] this IEnumerable<T> iterable, Range range)
    {
        [LinqTunnel, Pure]
        static IEnumerable<TT> Sub<TT>([InstantHandle] IEnumerable<TT> iterable, Range range) =>
            iterable.Skip(range.Start.Value).Take(range.End.Value - range.Start.Value);
        if (!range.Start.IsFromEnd && !range.End.IsFromEnd)
            return Sub(iterable, range);
        if (iterable.TryGetNonEnumeratedCount(out var count) && RangeStart(range, count) is var startRange)
            return Sub(iterable, startRange);
        var arr = iterable.ToIList();
        var arrRange = RangeStart(range, arr.Count);
        return Sub(arr, arrRange);
    }
    /// <summary>Gets an enumeration of an index.</summary>
    /// <param name="index">The index to count up or down to.</param>
    /// <returns>An enumeration from 0 to the index's value, or vice versa.</returns>
    [MustDisposeResource, Pure]
    public static IEnumerator<int> GetEnumerator(this Index index) => index.For().GetEnumerator();
    /// <summary>Gets an enumeration of a range.</summary>
    /// <param name="range">The range to iterate over.</param>
    /// <returns>An enumeration from the range's start to end.</returns>
    [MustDisposeResource, Pure]
    public static IEnumerator<int> GetEnumerator(this Range range) => range.For().GetEnumerator();
    [Pure]
    static Index IndexStart(Index index, int length) => index.IsFromEnd ? length - index.Value - 1 : index;
    [Pure]
    static Range RangeStart(Range range, int length) =>
        new(IndexStart(range.Start, length), IndexStart(range.End, length));
#endif
// SPDX-License-Identifier: MPL-2.0
#if XNA
/// <summary>Contains mouse buttons.</summary>
[Flags]
public enum MouseButtons : byte
{
    /// <summary>No mouse button.</summary>
    None,
    /// <summary>Left mouse button.</summary>
    Left,
    /// <summary>Right mouse button.</summary>
    Right,
    /// <summary>Middle mouse button.</summary>
    Middle = 1 << 2,
    /// <summary>X1 mouse button.</summary>
    X1 = 1 << 3,
    /// <summary>X2 mouse button.</summary>
    X2 = 1 << 4,
}
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable once CheckNamespace
/// <summary>Encapsulates a single value to be exposed as a <see cref="Memory{T}"/> of size 1.</summary>
/// <typeparam name="T">The type of value.</typeparam>
/// <param name="value">The value to encapsulate.</param>
public sealed partial class OnceMemoryManager<T>(T value) : MemoryManager<T>
{
    GCHandle _handle;
    T _value = value;
    /// <summary>Wraps the <typeparamref name="T"/> instance into the <see cref="OnceMemoryManager{T}"/>.</summary>
    /// <param name="value">The value to wrap.</param>
    /// <returns>The wrapped value.</returns>
    public static explicit operator OnceMemoryManager<T>(T value) => new(value);
    /// <inheritdoc />
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
#pragma warning disable IDISP010
    protected override void Dispose(bool disposing)
#pragma warning restore IDISP010
    {
        if (_handle.IsAllocated)
            _handle.Free();
    }
    /// <inheritdoc />
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public override void Unpin() => Dispose(true);
    /// <inheritdoc />
    [MethodImpl(MethodImplOptions.AggressiveInlining), MustUseReturnValue]
    public override unsafe MemoryHandle Pin(int elementIndex = 0) =>
        typeof(T).IsValueType
            ? default
            : new(
                (void*)(_handle.IsAllocated ? _handle : _handle = GCHandle.Alloc(_value, GCHandleType.Pinned))
               .AddrOfPinnedObject()
            );
    /// <inheritdoc />
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public override Span<T> GetSpan() => Ref(ref _value);
}
// SPDX-License-Identifier: MPL-2.0
#if !NET20 && !NET30
// ReSharper disable once CheckNamespace
/// <summary>Methods that creates enumerations from individual items.</summary>
#if !NETSTANDARD || NETSTANDARD1_5_OR_GREATER
    /// <summary>Gets the types from an assembly even if type loads occur.</summary>
    /// <param name="assembly">The assembly to get the types from.</param>
    /// <returns>
    /// The enumeration of all successfully loaded types from the parameter <paramref name="assembly"/>.
    /// </returns>
    [MustUseReturnValue]
    public static IEnumerable<Type> TryGetTypes(this Assembly? assembly)
    {
        try
        {
            return assembly?.GetTypes() ?? [];
        }
        catch (ReflectionTypeLoadException ex)
        {
            return ex.Types.Filter();
        }
    }
#endif
    /// <summary>Uses the callback if the parameter is non-<see langword="null"/>.</summary>
    /// <typeparam name="T">The source of the item.</typeparam>
    /// <typeparam name="TResult">The resulting type.</typeparam>
    /// <param name="item">The item to check.</param>
    /// <param name="map">The callback to use when <paramref name="item"/> is non-<see langword="null"/>.</param>
    /// <returns>The result of the parameter <paramref name="map"/>, or <see cref="Enumerable.Empty{T}"/>.</returns>
    [LinqTunnel, MustUseReturnValue]
    public static IEnumerable<TResult> ManyOrEmpty<T, TResult>(
        this T? item,
        [InstantHandle] Converter<T, IEnumerable<TResult>?> map
    ) =>
        item is not null && map(item) is { } iterable ? iterable : [];
    /// <summary>Uses the callback if the parameter is non-<see langword="null"/>.</summary>
    /// <typeparam name="T">The source of the item.</typeparam>
    /// <typeparam name="TResult">The resulting type.</typeparam>
    /// <param name="item">The item to check.</param>
    /// <param name="map">The callback to use when <paramref name="item"/> is non-<see langword="null"/>.</param>
    /// <returns>The result of the parameter <paramref name="map"/>, or <see cref="Enumerable.Empty{T}"/>.</returns>
    [LinqTunnel, MustUseReturnValue]
    public static IEnumerable<TResult> ManyOrEmpty<T, TResult>(
        this T? item,
        [InstantHandle] Converter<T, IEnumerable<TResult>?> map
    )
        where T : struct =>
        item.HasValue && map(item.Value) is { } iterable ? iterable : [];
    /// <summary>
    /// <see cref="Enumerable.SelectMany{TSource, TResult}(IEnumerable{TSource}, Func{TSource, IEnumerable{TResult}})"/>
    /// but with exhaustive null guards that fall back to empty enumerables.
    /// </summary>
    /// <typeparam name="T">The source of the item.</typeparam>
    /// <typeparam name="TResult">The resulting type.</typeparam>
    /// <param name="iterator">The item to check.</param>
    /// <param name="map">The callback to use when <paramref name="iterator"/> is non-<see langword="null"/>.</param>
    /// <returns>The result of the parameter <paramref name="map"/>, or <see cref="Enumerable.Empty{T}"/>.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<TResult> ManyOrEmpty<T, TResult>(
        [NoEnumeration] this IEnumerable<T?>? iterator,
        Func<T, IEnumerable<TResult?>?> map
    ) =>
        iterator?.Filter().Select(map).SelectMany(x => x ?? []).Filter() ?? [];
    /// <summary>
    /// <see cref="Enumerable.SelectMany{TSource, TResult}(IEnumerable{TSource}, Func{TSource, IEnumerable{TResult}})"/>
    /// but with exhaustive null guards that fall back to empty enumerables.
    /// </summary>
    /// <typeparam name="T">The source of the item.</typeparam>
    /// <typeparam name="TResult">The resulting type.</typeparam>
    /// <param name="iterator">The item to check.</param>
    /// <param name="map">The callback to use when <paramref name="iterator"/> is non-<see langword="null"/>.</param>
    /// <returns>The result of the parameter <paramref name="map"/>, or <see cref="Enumerable.Empty{T}"/>.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<TResult> ManyOrEmpty<T, TResult>(
        [NoEnumeration] this IEnumerable<T?>? iterator,
        Func<T, IEnumerable<TResult?>?> map
    )
        where T : struct =>
        iterator?.Filter().Select(map).SelectMany(x => x ?? []).Filter() ?? [];
    /// <summary>
    /// <see cref="Enumerable.SelectMany{TSource, TResult}(IEnumerable{TSource}, Func{TSource, IEnumerable{TResult}})"/>
    /// but with exhaustive null guards that fall back to empty enumerables.
    /// </summary>
    /// <typeparam name="T">The source of the item.</typeparam>
    /// <typeparam name="TResult">The resulting type.</typeparam>
    /// <param name="iterator">The item to check.</param>
    /// <param name="map">The callback to use when <paramref name="iterator"/> is non-<see langword="null"/>.</param>
    /// <returns>The result of the parameter <paramref name="map"/>, or <see cref="Enumerable.Empty{T}"/>.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<TResult> ManyOrEmpty<T, TResult>(
        [NoEnumeration] this IEnumerable<T?>? iterator,
        Func<T, IEnumerable<TResult?>?> map
    )
        where TResult : struct =>
        iterator?.Filter().Select(map).SelectMany(x => x ?? []).Filter() ?? [];
    /// <summary>
    /// <see cref="Enumerable.SelectMany{TSource, TResult}(IEnumerable{TSource}, Func{TSource, IEnumerable{TResult}})"/>
    /// but with exhaustive null guards that fall back to empty enumerables.
    /// </summary>
    /// <typeparam name="T">The source of the item.</typeparam>
    /// <typeparam name="TResult">The resulting type.</typeparam>
    /// <param name="iterator">The item to check.</param>
    /// <param name="map">The callback to use when <paramref name="iterator"/> is non-<see langword="null"/>.</param>
    /// <returns>The result of the parameter <paramref name="map"/>, or <see cref="Enumerable.Empty{T}"/>.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<TResult> ManyOrEmpty<T, TResult>(
        [NoEnumeration] this IEnumerable<T?>? iterator,
        Func<T, IEnumerable<TResult?>?> map
    )
        where T : struct
        where TResult : struct =>
        iterator?.Filter().Select(map).SelectMany(x => x ?? []).Filter() ?? [];
    /// <summary>
    /// <see cref="Enumerable.SelectMany{TSource, TResult}(IEnumerable{TSource}, Func{TSource, IEnumerable{TResult}})"/>
    /// but with exhaustive null guards that fall back to empty enumerables.
    /// </summary>
    /// <typeparam name="T">The source of the item.</typeparam>
    /// <typeparam name="TResult">The resulting type.</typeparam>
    /// <param name="iterator">The item to check.</param>
    /// <param name="map">The callback to use when <paramref name="iterator"/> is non-<see langword="null"/>.</param>
    /// <returns>The result of the parameter <paramref name="map"/>, or <see cref="Enumerable.Empty{T}"/>.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<TResult> ManyOrEmpty<T, TResult>(
        [NoEnumeration] this IEnumerable<T?>? iterator,
        Func<T, int, IEnumerable<TResult?>?> map
    ) =>
        iterator?.Filter().Select(map).SelectMany(x => x ?? []).Filter() ?? [];
    /// <summary>
    /// <see cref="Enumerable.SelectMany{TSource, TResult}(IEnumerable{TSource}, Func{TSource, IEnumerable{TResult}})"/>
    /// but with exhaustive null guards that fall back to empty enumerables.
    /// </summary>
    /// <typeparam name="T">The source of the item.</typeparam>
    /// <typeparam name="TResult">The resulting type.</typeparam>
    /// <param name="iterator">The item to check.</param>
    /// <param name="map">The callback to use when <paramref name="iterator"/> is non-<see langword="null"/>.</param>
    /// <returns>The result of the parameter <paramref name="map"/>, or <see cref="Enumerable.Empty{T}"/>.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<TResult> ManyOrEmpty<T, TResult>(
        [NoEnumeration] this IEnumerable<T?>? iterator,
        Func<T, int, IEnumerable<TResult?>?> map
    )
        where T : struct =>
        iterator?.Filter().Select(map).SelectMany(x => x ?? []).Filter() ?? [];
    /// <summary>
    /// <see cref="Enumerable.SelectMany{TSource, TResult}(IEnumerable{TSource}, Func{TSource, IEnumerable{TResult}})"/>
    /// but with exhaustive null guards that fall back to empty enumerables.
    /// </summary>
    /// <typeparam name="T">The source of the item.</typeparam>
    /// <typeparam name="TResult">The resulting type.</typeparam>
    /// <param name="iterator">The item to check.</param>
    /// <param name="map">The callback to use when <paramref name="iterator"/> is non-<see langword="null"/>.</param>
    /// <returns>The result of the parameter <paramref name="map"/>, or <see cref="Enumerable.Empty{T}"/>.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<TResult> ManyOrEmpty<T, TResult>(
        [NoEnumeration] this IEnumerable<T?>? iterator,
        Func<T, int, IEnumerable<TResult?>?> map
    )
        where TResult : struct =>
        iterator?.Filter().Select(map).SelectMany(x => x ?? []).Filter() ?? [];
    /// <summary>
    /// <see cref="Enumerable.SelectMany{TSource, TResult}(IEnumerable{TSource}, Func{TSource, IEnumerable{TResult}})"/>
    /// but with exhaustive null guards that fall back to empty enumerables.
    /// </summary>
    /// <typeparam name="T">The source of the item.</typeparam>
    /// <typeparam name="TResult">The resulting type.</typeparam>
    /// <param name="iterator">The item to check.</param>
    /// <param name="map">The callback to use when <paramref name="iterator"/> is non-<see langword="null"/>.</param>
    /// <returns>The result of the parameter <paramref name="map"/>, or <see cref="Enumerable.Empty{T}"/>.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<TResult> ManyOrEmpty<T, TResult>(
        [NoEnumeration] this IEnumerable<T?>? iterator,
        Func<T, int, IEnumerable<TResult?>?> map
    )
        where T : struct
        where TResult : struct =>
        iterator?.Filter().Select(map).SelectMany(x => x ?? []).Filter() ?? [];
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable CheckNamespace ConditionIsAlwaysTrueOrFalse RedundantNameQualifier ReturnTypeCanBeEnumerable.Global UseIndexFromEndExpression
/// <summary>Extension methods to attempt to grab ranges from enumerables.</summary>
    /// <summary>Takes the last item lazily, or a fallback value.</summary>
    /// <typeparam name="T">The type of iterator.</typeparam>
    /// <param name="iterable">The collection of items to go through one-by-one.</param>
    /// <param name="fallback">The fallback item.</param>
    /// <returns>The last item, or the parameter <paramref name="fallback"/>.</returns>
    [Pure]
    public static T EnumerateOr<T>([InstantHandle] this IEnumerable<T> iterable, T fallback)
    {
#if NETCOREAPP || ROSLYN
        if (iterable is ImmutableArray<T> { IsDefaultOrEmpty: true })
            return fallback;
#endif
        using var iterator = iterable.GetEnumerator();
        if (!iterator.MoveNext())
            return fallback;
        var last = iterator.Current;
        while (iterator.MoveNext())
            last = iterator.Current;
        return last;
    }
#if !(NET20 || NET30)
    /// <summary>Takes the first item, or a fallback value.</summary>
    /// <typeparam name="T">The type of iterator.</typeparam>
    /// <param name="iterable">The collection of items to go through one-by-one.</param>
    /// <param name="fallback">The fallback item.</param>
    /// <returns>The first item, or the parameter <paramref name="fallback"/>.</returns>
    [MustUseReturnValue]
    public static T FirstOr<T>([InstantHandle] this IEnumerable<T> iterable, T fallback)
    {
        switch (iterable)
        {
            case string str:
                return str.Length is 0 ? fallback : (T)(object)str[0];
#if NETCOREAPP || ROSLYN
            case ImmutableArray<T> array:
                return array.IsDefaultOrEmpty ? fallback : array[0];
#endif
            case IList<T> list:
                return list.Count is 0 ? fallback : list[0];
            case IReadOnlyList<T> list:
                return list.Count is 0 ? fallback : list[0];
            case var _ when iterable.TryGetNonEnumeratedCount(out var count):
                return count is 0 ? fallback : iterable.First();
            default:
            {
                using var iterator = iterable.GetEnumerator();
                return iterator.MoveNext() ? iterator.Current : fallback;
            }
        }
    }
    /// <summary>Takes the last item, or a fallback value.</summary>
    /// <typeparam name="T">The type of iterator.</typeparam>
    /// <param name="iterable">The collection of items to go through one-by-one.</param>
    /// <param name="fallback">The fallback item.</param>
    /// <returns>The last item, or the parameter <paramref name="fallback"/>.</returns>
    [MustUseReturnValue]
    public static T LastOr<T>([InstantHandle] this IEnumerable<T> iterable, T fallback) =>
        iterable switch
        {
            string str => str is [.., var last] ? (T)(object)last : fallback,
#if NETCOREAPP || ROSLYN
            ImmutableArray<T> array => array is [.., var last] ? last : fallback,
#endif
            IReadOnlyList<T> list => list is [.., var last] ? last : fallback,
            IList<T> list => list is [.., var last] ? last : fallback,
            _ when iterable.TryCount() is { } count => count is 0 ? fallback : iterable.Last(),
            _ => iterable.EnumerateOr(fallback),
        };
#endif
    /// <summary>Gets a specific item from a collection.</summary>
    /// <typeparam name="TKey">The key item in the collection.</typeparam>
    /// <typeparam name="TValue">The value item in the collection.</typeparam>
    /// <param name="dictionary">The <see cref="IEnumerable{T}"/> to get an item from.</param>
    /// <param name="key">The key to use to get the value.</param>
    /// <returns>An element from the parameter <paramref name="dictionary"/>, or <see langword="default"/>.</returns>
    [MustUseReturnValue]
    public static TValue? Nth<TKey, TValue>([InstantHandle] this IDictionary<TKey, TValue> dictionary, TKey key)
        where TKey : notnull =>
        dictionary.TryGetValue(key, out var value) ? value : default;
#if !NET20 && !NET30
    /// <summary>Returns the item, or a fallback.</summary>
    /// <typeparam name="T">The type of item.</typeparam>
    /// <param name="self">The item to potentially return.</param>
    /// <param name="fallback">The fallback item.</param>
    /// <returns>The parameter <paramref name="self"/>, or <paramref name="fallback"/>.</returns>
    [Pure]
    public static T Or<T>(this T? self, T fallback)
        where T : class =>
        self ?? fallback;
    /// <summary>Returns the item, or a fallback.</summary>
    /// <typeparam name="T">The type of item.</typeparam>
    /// <param name="self">The item to potentially return.</param>
    /// <param name="fallback">The fallback item.</param>
    /// <returns>The parameter <paramref name="self"/>, or <paramref name="fallback"/>.</returns>
    [Pure]
    public static T Or<T>(this T? self, T fallback)
        where T : struct =>
        self ?? fallback;
    /// <summary>Returns the item, or a fallback.</summary>
    /// <typeparam name="T">The type of item.</typeparam>
    /// <param name="self">The item to potentially return.</param>
    /// <returns>The parameter <paramref name="self"/>, or a new instance.</returns>
    [Pure]
    public static T OrNew<T>(this T? self)
        where T : class, new() =>
        self ?? new();
    /// <summary>Returns the string, or an empty string.</summary>
    /// <param name="str">The string to potentially return.</param>
    /// <returns>The parameter <paramref name="str"/>, or <see cref="string.Empty"/>.</returns>
    [Pure]
    public static string OrEmpty(this string? str) => str ?? "";
    /// <summary>Returns the enumeration, or an empty enumeration.</summary>
    /// <typeparam name="T">The type of iterator.</typeparam>
    /// <param name="iterable">The enumeration to potentially return.</param>
    /// <returns>The parameter <paramref name="iterable"/>, or <see cref="Enumerable.Empty{T}"/>.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<T> OrEmpty<T>([NoEnumeration] this IEnumerable<T>? iterable) => iterable ?? [];
#if NETCOREAPP || ROSLYN
    /// <summary>Returns the array, or an empty array.</summary>
    /// <typeparam name="T">The type of array.</typeparam>
    /// <param name="array">The array to potentially return.</param>
    /// <returns>The parameter <paramref name="array"/>, or <see cref="ImmutableArray{T}.Empty"/>.</returns>
    [Pure]
    public static ImmutableArray<T> OrEmpty<T>(this ImmutableArray<T> array) => array.IsDefault ? [] : array;
#endif
    /// <summary>Gets a specific character from a string.</summary>
    /// <param name="str">The string to get the character from.</param>
    /// <param name="index">The index to use.</param>
    /// <returns>The character based on the parameters <paramref name="str"/> and <paramref name="index"/>.</returns>
    [Pure]
    public static char? Nth(this string str, [NonNegativeValue] int index) =>
        index >= 0 && index < str.Length ? str[index] : null;
    /// <summary>Gets a specific item from a collection.</summary>
    /// <typeparam name="T">The item in the collection.</typeparam>
    /// <param name="iterable">The <see cref="IEnumerable{T}"/> to get an item from.</param>
    /// <param name="index">The index to get.</param>
    /// <returns>An element from the parameter <paramref name="iterable"/>, or <see langword="default"/>.</returns>
    [MustUseReturnValue]
    public static T? Nth<T>([InstantHandle] this IEnumerable<T> iterable, [NonNegativeValue] int index)
    {
        if (index < 0)
            return default;
        return iterable switch
        {
            string str => index < str.Length ? (T)(object)str[index] : default,
#if NETCOREAPP || ROSLYN
            ImmutableArray<T> array => !array.IsDefault && index < array.Length ? array[index] : default,
#endif
            IReadOnlyList<T> list => index < list.Count ? list[index] : default,
            IList<T> list => index < list.Count ? list[index] : default,
            _ => iterable.Skip(index).FirstOrDefault(),
        };
    }
    /// <summary>Gets a specific character from a string.</summary>
    /// <param name="str">The string to get the character from.</param>
    /// <param name="index">The index to use.</param>
    /// <returns>The character based on the parameters <paramref name="str"/> and <paramref name="index"/>.</returns>
    [Pure]
    public static char? NthLast(this string str, [NonNegativeValue] int index) =>
        index >= 0 && index < str.Length ? str[str.Length - index - 1] : null;
    /// <summary>Gets a specific item from a collection.</summary>
    /// <typeparam name="T">The item in the collection.</typeparam>
    /// <param name="iterable">The <see cref="IEnumerable{T}"/> to get an item from.</param>
    /// <param name="index">The index to get.</param>
    /// <returns>An element from the parameter <paramref name="iterable"/>, or <see langword="default"/>.</returns>
    [MustUseReturnValue]
    public static T? NthLast<T>([InstantHandle] this IEnumerable<T> iterable, [NonNegativeValue] int index)
    {
        if (index < 0)
            return default;
        return iterable switch
        {
            string str => index < str.Length ? (T)(object)str[str.Length - index - 1] : default,
#if NETCOREAPP || ROSLYN
            ImmutableArray<T> array =>
                !array.IsDefault && index < array.Length ? array[array.Length - index - 1] : default,
#endif
            IReadOnlyList<T> list => index < list.Count ? list[list.Count - index - 1] : default,
            IList<T> list => index < list.Count ? list[list.Count - index - 1] : default,
            _ when iterable.TryGetNonEnumeratedCount(out var count) =>
                index < count ? iterable.Skip(count - index - 1).FirstOrDefault() : default,
            _ => iterable.Reverse().Skip(index).FirstOrDefault(),
        };
    }
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable NullableWarningSuppressionIsUsed
// ReSharper disable once CheckNamespace
/// <summary>Inlines 3 elements before falling back on the heap with an expandable <see cref="IList{T}"/>.</summary>
/// <typeparam name="T">The element type.</typeparam>
[StructLayout(LayoutKind.Sequential)]
public partial struct SmallList<T> :
#if !NETSTANDARD || NETSTANDARD1_3_OR_GREATER
    IConvertible,
#endif
    IEquatable<SmallList<T>>,
    IList<T>,
    IReadOnlyList<T>
{
    /// <summary>Number of items to keep inline for <see cref="SmallList{T}"/>.</summary>
    /// <remarks><para>
    /// And Saint Attila raised the <see cref="SmallList{T}"/> up on high, saying, "O Lord, bless this Thy
    /// <see cref="SmallList{T}"/> that, with it, Thou mayest blow Thine allocation costs to tiny bits in Thy mercy.".
    /// </para><para>
    /// And the Lord did grin, and the people did feast upon the lambs and sloths and carp and anchovies and orangutans
    /// and breakfast cereals and fruit bats and large chu...
    /// </para><para>
    /// And the Lord spake, saying, "First shalt thou recreate the
    /// <a href="https://crates.io/crates/smallvec"><c>smallvec</c></a> crate. Then, shalt thou keep three inline. No
    /// more. No less. Three shalt be the number thou shalt keep inline, and the number to keep inline shalt be three.
    /// Four shalt thou not keep inline, nor either keep inline thou two, excepting that thou then proceed to three.
    /// Five is right out. Once the number three,  being the third number, be reached, then, lobbest thou thy
    /// <see cref="SmallList{T}"/> towards thy heap, who, being slow and cache-naughty in My sight, shall snuff it.".
    /// </para><para>
    /// <a href="https://github.com/rhaiscript/rhai/blob/ca18cdd7f47f8ae8bd6e2b7a950ad4815d62f026/src/lib.rs#L373">
    /// (Adapted from Rhai)
    /// </a></para></remarks>
#pragma warning disable RCS1158
    public const int InlinedLength = 3;
#pragma warning restore RCS1158
    //
    [ProvidesContext]
    IList<T>? _rest;
    T? _first, _second, _third;
    /// <summary>Initializes a new instance of the <see cref="SmallList{T}"/> struct with no elements.</summary>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public SmallList() { }
    /// <summary>
    /// Initializes a new instance of the <see cref="SmallList{T}"/> struct.
    /// Collects the enumerable; allocating the heaped list lazily.
    /// </summary>
    /// <param name="enumerable">The enumerable to collect.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public SmallList([InstantHandle] IEnumerable<T>? enumerable)
        : this(enumerable?.GetEnumerator()) { }
    /// <summary>
    /// Initializes a new instance of the <see cref="SmallList{T}"/> struct.
    /// Mutates the enumerator; allocating the heaped list lazily.
    /// </summary>
    /// <param name="enumerator">The enumerator to mutate.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public SmallList(IEnumerator<T>? enumerator)
    {
        if (enumerator?.MoveNext() is not true)
            return;
        _first = enumerator.Current;
        if (!enumerator.MoveNext())
        {
            UnsafelySetNullishTo(out _rest, 1);
            return;
        }
        _second = enumerator.Current;
        if (!enumerator.MoveNext())
        {
            UnsafelySetNullishTo(out _rest, 2);
            return;
        }
        _third = enumerator.Current;
        if (!enumerator.MoveNext())
        {
            _rest = [];
            return;
        }
        List<T> list = [];
        do
            list.Add(enumerator.Current);
        while (enumerator.MoveNext());
        _rest = list;
    }
    /// <summary>Initializes a new instance of the <see cref="SmallList{T}"/> struct with 1 element.</summary>
    /// <param name="first">The first element.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public SmallList(T first)
    {
        _first = first;
        UnsafelySetNullishTo(out _rest, 1);
    }
    /// <summary>Initializes a new instance of the <see cref="SmallList{T}"/> struct with 2 elements.</summary>
    /// <param name="first">The first element.</param>
    /// <param name="second">The second element.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public SmallList(T first, T second)
    {
        _first = first;
        _second = second;
        UnsafelySetNullishTo(out _rest, 2);
    }
    /// <summary>Initializes a new instance of the <see cref="SmallList{T}"/> struct with 3 elements.</summary>
    /// <param name="first">The first element.</param>
    /// <param name="second">The second element.</param>
    /// <param name="third">The third element.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public SmallList(T first, T second, T third)
        : this(first, second, third, []) { }
    /// <summary>Initializes a new instance of the <see cref="SmallList{T}"/> struct with arbitrary elements.</summary>
    /// <param name="first">The first element.</param>
    /// <param name="second">The second element.</param>
    /// <param name="third">The third element.</param>
    /// <param name="rest">The rest of the elements.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public SmallList(T first, T second, T third, IList<T> rest)
    {
        _first = first;
        _second = second;
        _third = third;
        _rest = rest;
    }
    /// <summary>Initializes a new instance of the <see cref="SmallList{T}"/> struct with arbitrary elements.</summary>
    /// <param name="first">The first element.</param>
    /// <param name="second">The second element.</param>
    /// <param name="third">The third element.</param>
    /// <param name="rest">The rest of the elements.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public SmallList(T first, T second, T third, params T[] rest)
        : this(first, second, third, (IList<T>)rest) { }
    /// <summary>Gets the empty list.</summary>
    public static SmallList<T> Empty
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)] get => default;
    }
    /// <summary>Gets a value indicating whether determines whether the collection is empty.</summary>
    public readonly bool IsEmpty
    {
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => _rest is null;
    }
    /// <inheritdoc />
    public readonly bool IsReadOnly
    {
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => false;
    }
    /// <inheritdoc cref="ICollection{T}.Count" />
    public readonly int Count
    {
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        get => _rest.ToAddress() < InlinedLength ? (int)_rest.ToAddress() : _rest!.Count + InlinedLength;
    }
    /// <summary>Gets the number of head elements used.</summary>
    public readonly int HeadCount
    {
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get =>
            System.Math.Min(Count, 3);
    }
    /// <summary>Gets the deep clone of this instance.</summary>
    public readonly SmallList<T> Cloned
    {
        [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        get
        {
            var clone = Uninit(Count);
            CopyTo(ref clone);
            return clone;
        }
    }
    /// <inheritdoc cref="IList{T}.this" />
    public T this[int index]
    {
        [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        readonly get
        {
            BoundsCheck(index, out _);
            return index switch
            {
                0 => _first!,
                1 => _second!,
                2 => _third!,
                _ => _rest![index - InlinedLength],
            };
        }
        [CollectionAccess(ModifyExistingContent), MethodImpl(MethodImplOptions.AggressiveInlining)]
        set
        {
            BoundsCheck(index, out _);
            _ = index switch
            {
                0 => _first = value,
                1 => _second = value,
                2 => _third = value,
                _ => _rest![index - InlinedLength] = value,
            };
        }
    }
    /// <summary>Gets or sets the first element.</summary>
    public T First
    {
        [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure] readonly get => this[0];
        [CollectionAccess(ModifyExistingContent), MethodImpl(MethodImplOptions.AggressiveInlining)]
#pragma warning disable MA0102
        set => this[0] = value;
    }
    /// <summary>Gets or sets the second element.</summary>
    [CollectionAccess(Read), Pure]
    public T Second
    {
        [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure] readonly get => this[1];
        [CollectionAccess(ModifyExistingContent), MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => this[1] = value;
    }
    /// <summary>Gets or sets the third element.</summary>
    [CollectionAccess(Read), Pure]
    public T Third
    {
        [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure] readonly get => this[2];
        [CollectionAccess(ModifyExistingContent), MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => this[2] = value;
#pragma warning restore MA0102
    }
    /// <summary>Gets the rest of the elements.</summary>
    public readonly IList<T>? Rest
    {
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), ProvidesContext, Pure]
        get => _rest.ToAddress() < InlinedLength ? null : _rest;
    }
    /// <summary>Determines whether both sequence are equal.</summary>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>Whether both sequences are equal.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool operator ==(SmallList<T> left, SmallList<T> right) => left.Equals(right);
    /// <summary>Determines whether both sequence are not equal.</summary>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>Whether both sequences are not equal.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool operator !=(SmallList<T> left, SmallList<T> right) => !left.Equals(right);
    /// <summary>Creates the collection with 1 item in it.</summary>
    /// <param name="value">The single item to use.</param>
    /// <returns>The collection with 1 item.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static implicit operator SmallList<T>(T value) => new(value);
    /// <summary>Creates the collection with 2 items in it.</summary>
    /// <param name="tuple">The tuple containing 2 items to destructure and use.</param>
    /// <returns>The collection with 2 items.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static implicit operator SmallList<T>((T First, T Second) tuple) => new(tuple.First, tuple.Second);
    /// <summary>Creates the collection with 3 items in it.</summary>
    /// <param name="tuple">The tuple containing 3 items to destructure and use.</param>
    /// <returns>The collection with 3 items.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static implicit operator SmallList<T>((T First, T Second, T Third) tuple) =>
        new(tuple.First, tuple.Second, tuple.Third);
    /// <summary>Creates the collection with 3 or more items in it.</summary>
    /// <param name="tuple">The tuple containing 3 or more items to destructure and use.</param>
    /// <returns>The collection with 3 or more items.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static implicit operator SmallList<T>((T First, T Second, T Third, IList<T> List) tuple) =>
        new(tuple.First, tuple.Second, tuple.Third, tuple.List);
    /// <summary>
    /// Implicitly converts the parameter by creating the new instance of <see cref="SmallList{T}"/>
    /// by using the constructor <see cref="SmallList{T}(T, T, T, T[])"/>.
    /// </summary>
    /// <param name="tuple">The parameter to pass onto the constructor.</param>
    /// <returns>
    /// The new instance of <see cref="SmallList{T}"/> by passing the parameter <paramref name="tuple"/>
    /// to the constructor <see cref="SmallList{T}(T, T, T, T[])"/>.
    /// </returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static implicit operator SmallList<T>((T First, T Second, T Third, T[] TheRest) tuple) =>
        new(tuple.First, tuple.Second, tuple.Third, tuple.TheRest);
    /// <summary>Skips initialization of inlined elements.</summary>
    /// <param name="length">The length of the <see cref="SmallList{T}"/>.</param>
    /// <returns>The <see cref="SmallList{T}"/> of length <paramref name="length"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SmallList<T> Uninit(int length)
    {
        Unsafe.SkipInit(out SmallList<T> output);
        RestFromLength(length, out output._rest);
        return output;
    }
    /// <summary>Skips initialization of unreachable inlined elements.</summary>
    /// <param name="length">The length of the <see cref="SmallList{T}"/>.</param>
    /// <returns>The <see cref="SmallList{T}"/> of length <paramref name="length"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SmallList<T> Zeroed(int length)
    {
        var output = Uninit(length);
        switch (length)
        {
            case >= 3:
                output._third = default;
                goto case 2;
            case 2:
                output._second = default;
                goto case 1;
            case 1:
                output._first = default;
                break;
        }
        return output;
    }
    /// <inheritdoc />
    [CollectionAccess(UpdatedContent), MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void Add(T item)
    {
        switch (Count)
        {
            case 0:
                _first = item;
                UnsafelySetNullishTo(out _rest, 1);
                break;
            case 1:
                _second = item;
                UnsafelySetNullishTo(out _rest, 2);
                break;
            case 2:
                (_third, _rest) = (item, []);
                break;
            default:
                EnsureMutability().Add(item);
                break;
        }
    }
    /// <summary>Adds the elements of the specified collection to the end of the <see cref="SmallList{T}"/>.</summary>
    /// <param name="collection">
    /// The collection whose elements should be added to the end of the <see cref="SmallList{T}"/>.
    /// </param>
    [CollectionAccess(UpdatedContent), MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void AddRange(IEnumerable<T>? collection)
    {
        if (collection?.ToICollection() is not { Count: var count and not 0 } c)
            return;
        if (InlinedLength - HeadCount is var stackExpand && stackExpand is not 0)
        {
            using var e = c.GetEnumerator();
            for (var i = 0; i < stackExpand; i++)
                if (e.MoveNext())
                    Add(e.Current);
                else
                    return;
        }
        if (count <= stackExpand)
            return;
        var rest = _rest as List<T> ?? [.. _rest!];
#pragma warning disable IDE0305
        rest.AddRange(stackExpand is 0 ? c : c.Skip(stackExpand).ToICollection());
#pragma warning restore IDE0305
        _rest = rest;
    }
    /// <inheritdoc />
    [CollectionAccess(ModifyExistingContent), MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void Clear() => _rest = null;
    /// <summary>Copies all values onto the destination.</summary>
    /// <param name="list">The destination.</param>
    /// <exception cref="ArgumentOutOfRangeException">
    /// The parameter <paramref name="list"/> has fewer elements than itself.
    /// </exception>
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining)]
    public readonly void CopyTo(ref SmallList<T> list)
    {
        if (Count is var count && count is 0)
            return;
        list.BoundsCheck(count - 1, out _);
        switch (count)
        {
            case > InlinedLength:
                IList<T>
                    from = _rest!,
                    to = list._rest!;
                for (var i = 0; i < from.Count; i++)
                    to[i] = from[i];
                goto case 3;
            case 3:
                list._third = _third;
                goto case 2;
            case 2:
                list._second = _second;
                goto case 1;
            case 1:
                list._first = _first;
                break;
        }
    }
    /// <inheritdoc />
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining)]
    public readonly void CopyTo(T[] array, [NonNegativeValue] int arrayIndex)
    {
        switch (Count)
        {
            case > InlinedLength:
                _rest!.CopyTo(array, arrayIndex + InlinedLength);
                goto case 3;
            case 3:
                array[arrayIndex + 2] = _third!;
                goto case 2;
            case 2:
                array[arrayIndex + 1] = _second!;
                goto case 1;
            case 1:
                array[arrayIndex] = _first!;
                break;
        }
    }
    /// <summary>Deconstructs this instance with its properties.</summary>
    /// <param name="head">The first three elements.</param>
    /// <param name="tail">The remaining elements.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public readonly void Deconstruct(out (T? First, T? Second, T? Third) head, out IList<T> tail) =>
        (head, tail) = ((_first, _second, _third), Rest ?? []);
    /// <summary>Deconstructs this instance with the 3 first elements.</summary>
    /// <param name="first">The first element.</param>
    /// <param name="second">The second element.</param>
    /// <param name="third">The third element.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public readonly void Deconstruct(out T? first, out T? second, out T? third) =>
        (first, second, third) = (_first, _second, _third);
    /// <summary>Deconstructs this instance with its properties.</summary>
    /// <param name="first">The first element.</param>
    /// <param name="second">The second element.</param>
    /// <param name="third">The third element.</param>
    /// <param name="rest">The remaining elements.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public readonly void Deconstruct(out T? first, out T? second, out T? third, out IList<T> rest) =>
        (first, second, third, rest) = (_first, _second, _third, Rest ?? []);
    /// <inheritdoc />
    [CollectionAccess(UpdatedContent), MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void Insert(int index, T item)
    {
        BoundsCheck(index, out var count);
        switch (count)
        {
            case 0:
                UnsafelySetNullishTo(out _rest, 1);
                break;
            case 1:
                UnsafelySetNullishTo(out _rest, 2);
                break;
            case 2:
                _rest = [];
                break;
            case >= InlinedLength:
                EnsureMutability().Insert(0, _third!);
                break;
        }
        switch (index)
        {
            case 0:
                _third = _second;
                _second = _first;
                _first = item;
                break;
            case 1:
                _third = _second;
                _second = item;
                break;
            case 2:
                _third = item;
                break;
        }
    }
    /// <inheritdoc />
    [CollectionAccess(ModifyExistingContent), MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void RemoveAt(int index)
    {
        BoundsCheck(index, out var count);
        if (index is 0)
            _first = _second;
        if (index is 0 or 1)
            _second = _third;
        if (index < InlinedLength && _rest is [var head, ..])
            _third = head;
        if (count > InlinedLength)
            EnsureMutability().RemoveAt(System.Math.Max(index - InlinedLength, 0));
        else
            UnsafelySetNullishTo(out _rest, (byte)count);
    }
    [CollectionAccess(ModifyExistingContent), MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void Reverse()
    {
#pragma warning disable IDE0180
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        static void SwapByRef(ref T left, ref T right)
        {
            var temp = left;
            left = right;
            right = temp;
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        static void Swap(ref T left, in IList<T> right, int index)
        {
            var temp = left;
            left = right[index];
            right[index] = temp;
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        static void SwapItself(in IList<T> list, int index, int count)
        {
            var temp = list[index];
            list[count - index - 4] = list[index];
            list[count - index - 4] = temp;
        }
#pragma warning restore IDE0180
        switch (Count)
        {
            case 2:
                SwapByRef(ref _first!, ref _second!);
                break;
            case 3:
                SwapByRef(ref _first!, ref _third!);
                break;
            case 4:
                Swap(ref _first!, EnsureMutability(), 0);
                SwapByRef(ref _second!, ref _third!);
                break;
            case 5:
                Swap(ref _first!, EnsureMutability(), 1);
                Swap(ref _second!, _rest!, 0);
                break;
            case >= 6 and var count:
                Swap(ref _first!, EnsureMutability(), count - 4);
                Swap(ref _second!, _rest!, count - 5);
                Swap(ref _third!, _rest!, count - 6);
                if (_rest is List<T> rest)
                    rest.Reverse(0, count - 6);
                else
                    for (var i = 0; i < count / 2 - 3; i++)
                        SwapItself(_rest!, i, count);
                break;
        }
    }
    /// <inheritdoc />
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly bool Contains(T item) =>
        Count switch
        {
            0 => Eq(_first, item),
            1 => Eq(_first, item) || Eq(_second, item),
            2 => Eq(_first, item) || Eq(_second, item) || Eq(_third, item),
            _ => Eq(_first, item) || Eq(_second, item) || Eq(_third, item) || _rest!.Contains(item),
        };
    /// <summary>Determines whether the item exists in the collection.</summary>
    /// <param name="item">The item to check.</param>
    /// <param name="comparer">The comparer to use.</param>
    /// <returns>The value determining whether the parameter <paramref name="item"/> exists in the collection.</returns>
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly bool Contains(T item, IEqualityComparer<T> comparer) =>
        Count switch
        {
            0 => comparer.Equals(_first!, item),
            1 => comparer.Equals(_first!, item) || comparer.Equals(_second!, item),
            2 => comparer.Equals(_first!, item) || comparer.Equals(_second!, item) || comparer.Equals(_third!, item),
            _ => comparer.Equals(_first!, item) ||
                comparer.Equals(_second!, item) ||
                comparer.Equals(_third!, item) ||
                _rest!.Contains(item, comparer),
        };
    /// <inheritdoc cref="object.Equals(object)"/>
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly override bool Equals([NotNullWhen(true)] object? obj) => obj is SmallList<T> other && Equals(other);
    /// <inheritdoc />
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly bool Equals(SmallList<T> other) =>
        Count == other.Count &&
        Eq(_first, other._first) &&
        Eq(_second, other._second) &&
        Eq(_third, other._third) &&
        (other.Rest is [_, ..] rest ? Rest?.SequenceEqual(rest) ?? false : other.Rest is null);
    /// <inheritdoc />
    [CollectionAccess(ModifyExistingContent), MethodImpl(MethodImplOptions.AggressiveInlining)]
    public bool Remove(T item)
    {
        switch (Count)
        {
            case 0: return false;
            case 1: return Eq(_first, item) && (_rest = null) is var _;
            case 2:
                if (Eq(_first, item))
                {
                    UnsafelySetNullishTo(out _rest, 1);
                    return (_first = _second) is var _;
                }
                if (!Eq(_second, item))
                    return false;
                UnsafelySetNullishTo(out _rest, 1);
                return true;
            default:
                return Eq(_first, item) ? RemoveHead(_first = _second) :
                    Eq(_second, item) ? RemoveHead(_second = _third) :
                    Eq(_third, item) ? RemoveHead() : EnsureMutability().Remove(item);
        }
    }
    /// <inheritdoc />
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly override int GetHashCode()
    {
        unchecked
        {
            const int Prime = 397;
            var hashCode = Prime;
            switch (Count)
            {
                case > InlinedLength:
                    hashCode = _rest!.GetHashCode();
                    goto case 3;
                case 3:
                    hashCode = hashCode * Prime ^ EqualityComparer<T?>.Default.GetHashCode(_third!);
                    goto case 2;
                case 2:
                    hashCode = hashCode * Prime ^ EqualityComparer<T?>.Default.GetHashCode(_second!);
                    goto case 1;
                case 1:
                    hashCode = hashCode * Prime ^ EqualityComparer<T?>.Default.GetHashCode(_first!);
                    break;
            }
            return hashCode;
        }
    }
    /// <inheritdoc />
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly int IndexOf(T item) =>
        Count switch
        {
            0 => Eq(_first, item) ? 0 : -1,
            1 => Eq(_first, item) ? 0 :
                Eq(_second, item) ? 1 : -1,
            2 => Eq(_first, item) ? 0 :
                Eq(_second, item) ? 1 :
                Eq(_third, item) ? 2 : -1,
            _ => Eq(_first, item) ? 0 :
                Eq(_second, item) ? 1 :
                Eq(_third, item) ? 2 :
                _rest!.IndexOf(item) is var i && i is -1 ? i : i + 3,
        };
    /// <inheritdoc />
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly override string ToString() =>
        Count switch
        {
            0 => "[]",
            1 => $"[{_first}]",
            2 => $"[{_first}, {_second}]",
            3 => $"[{_first}, {_second}, {_third}]",
#if NETFRAMEWORK || NETSTANDARD2_0_OR_GREATER || NETCOREAPP2_0_OR_GREATER
            _ => $"[{_first}, {_second}, {_third}, {_rest!.Conjoin()}]",
#else
            _ => $"[{_first}, {_second}, {_third}, {_rest}]",
#endif
        };
    /// <inheritdoc cref="IEnumerable{T}.GetEnumerator" />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), MustDisposeResource(false), Pure]
    public readonly Enumerator GetEnumerator() => new(this);
    /// <summary>Gets the enumeration object that returns the values in reversed order.</summary>
    /// <returns>The backwards enumerator.</returns>
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), MustDisposeResource(false), Pure]
    public readonly Enumerator GetReversedEnumerator() => new(this, true);
    /// <summary>Forms a slice out of the current list that begins at a specified index.</summary>
    /// <param name="start">The index at which to begin the slice.</param>
    /// <returns>
    /// A list that consists of all elements of the current list from <paramref name="start"/> to the end of the span.
    /// </returns>
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
#pragma warning disable IDE0057
    public readonly SmallList<T> Slice(int start) => Slice(start, Count - start);
#pragma warning restore IDE0057
    /// <summary>Forms a slice out of the current list starting at a specified index for a specified length.</summary>
    /// <param name="start">The index at which to begin this slice.</param>
    /// <param name="length">The desired length for the slice.</param>
    /// <returns>
    /// A span that consists of <paramref name="length"/> elements from
    /// the current span starting at <paramref name="start"/>.
    /// </returns>
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly SmallList<T> Slice(int start, int length)
    {
        var count = Count;
        start = System.Math.Max(start, 0);
        length = System.Math.Min(length, count - start);
        if (length <= 0)
            return default;
        if (start is 0 && length == count)
            return Cloned;
        Unsafe.SkipInit(out SmallList<T> output);
        if (length >= InlinedLength && _rest?.Skip(start).Take(length - InlinedLength).ToList() is { } list)
            output._rest = list;
        else
            RestFromLength(length, out output._rest);
        switch (length)
        {
            case >= 3:
                output._third = start is 0 ? _third : _rest![start - 1];
                goto case 2;
            case 2:
                output._second = start switch
                {
                    0 => _second,
                    1 => _third,
                    _ => _rest![start - 2],
                };
                goto case 1;
            case 1:
                output._first = start switch
                {
                    0 => _first,
                    1 => _second,
                    2 => _third,
                    _ => _rest![start - 3],
                };
                break;
        }
        return output;
    }
    /// <summary>Gets the first element of the list that optionally matches the <see cref="Predicate{T}"/>.</summary>
    /// <param name="predicate">The predicate to use as a filter.</param>
    /// <returns>The first element of the list that matches the parameter <paramref name="predicate"/>.</returns>
    public readonly T? FirstOrDefault(Predicate<T>? predicate)
    {
        if (predicate is null)
            return IsEmpty ? default : First;
        foreach (var next in this)
            if (predicate(next))
                return next;
        return default;
    }
    /// <summary>Gets the last element of the list that optionally matches the <see cref="Predicate{T}"/>.</summary>
    /// <param name="predicate">The predicate to use as a filter.</param>
    /// <returns>The last element of the list that matches the parameter <paramref name="predicate"/>.</returns>
    public readonly T? LastOrDefault(Predicate<T>? predicate = null)
    {
        if (predicate is null)
            return Count switch
            {
                0 => default,
                1 => First,
                2 => Second,
                3 => Third,
                _ => Rest![Rest.Count - 1],
            };
        using var e = GetReversedEnumerator();
        while (e.MoveNext())
            if (predicate(e.Current))
                return e.Current;
        return default;
    }
#if !NETSTANDARD || NETSTANDARD1_3_OR_GREATER
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    readonly TypeCode IConvertible.GetTypeCode() => TypeCode.Object;
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    readonly bool IConvertible.ToBoolean(IFormatProvider? provider) => !IsEmpty;
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    readonly byte IConvertible.ToByte(IFormatProvider? provider) => unchecked((byte)Count);
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    readonly char IConvertible.ToChar(IFormatProvider? provider) => unchecked((char)Count);
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    readonly DateTime IConvertible.ToDateTime(IFormatProvider? provider) => new(Count, DateTimeKind.Utc);
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    readonly decimal IConvertible.ToDecimal(IFormatProvider? provider) => Count;
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    readonly double IConvertible.ToDouble(IFormatProvider? provider) => Count;
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    readonly short IConvertible.ToInt16(IFormatProvider? provider) => unchecked((short)Count);
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    readonly int IConvertible.ToInt32(IFormatProvider? provider) => Count;
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    readonly long IConvertible.ToInt64(IFormatProvider? provider) => Count;
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    readonly sbyte IConvertible.ToSByte(IFormatProvider? provider) => unchecked((sbyte)Count);
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    readonly float IConvertible.ToSingle(IFormatProvider? provider) => Count;
    /// <inheritdoc />
    [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    readonly string IConvertible.ToString(IFormatProvider? provider) => ToString();
    /// <inheritdoc />
    [DoesNotReturn, MethodImpl(MethodImplOptions.AggressiveInlining)]
    readonly object IConvertible.ToType(Type conversionType, IFormatProvider? provider) =>
        throw new InvalidOperationException();
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    readonly ushort IConvertible.ToUInt16(IFormatProvider? provider) => unchecked((ushort)Count);
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    readonly uint IConvertible.ToUInt32(IFormatProvider? provider) => unchecked((uint)Count);
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    readonly ulong IConvertible.ToUInt64(IFormatProvider? provider) => unchecked((ulong)Count);
#endif
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), MustDisposeResource(false), Pure]
    readonly IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), MustDisposeResource(false), Pure]
    readonly IEnumerator<T> IEnumerable<T>.GetEnumerator() => GetEnumerator();
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    static void RestFromLength(int length, out IList<T>? rest)
    {
        if (length is 0 or 1 or 2 or 3)
            RestFromLengthWithoutAllocations(length, out rest);
        else
            rest = new T[length - InlinedLength];
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    static void RestFromLengthWithoutAllocations(int length, out IList<T>? rest)
    {
        switch (length)
        {
            case <= 0:
                rest = null;
                break;
            case 1:
                UnsafelySetNullishTo(out rest, 1);
                break;
            case 2:
                UnsafelySetNullishTo(out rest, 2);
                break;
            case 3:
                rest = [];
                break;
            default:
                Unsafe.SkipInit(out rest);
                break;
        }
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    static bool Eq(T? x, T? y) => x is null ? y is null : y is not null && EqualityComparer<T>.Default.Equals(x, y);
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    readonly void BoundsCheck(int index, [ValueRange(1, int.MaxValue)] out int count)
    {
        count = Count;
        if (unchecked((uint)index >= count))
            throw new ArgumentOutOfRangeException(nameof(index), index, $"Must be between 0 and {count - 1}");
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining), MustUseReturnValue]
    bool RemoveHead(in T? _ = default)
    {
        if (_rest is [var head, ..])
        {
            _third = head;
            EnsureMutability().RemoveAt(0);
        }
        else
            UnsafelySetNullishTo(out _rest, 2);
        return true;
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining), MustUseReturnValue]
    IList<T> EnsureMutability() =>
        _rest = _rest switch
        {
            { IsReadOnly: false, Count: not 0 } x => x,
            { Count: not 0 } x => [.. x],
            _ => [],
        };
    /// <summary>An enumerator over <see cref="SmallList{T}"/>.</summary>
    [StructLayout(LayoutKind.Auto)]
    public struct Enumerator : IEnumerator<T>
    {
        readonly bool _isReversed;
        readonly int _count;
        readonly SmallList<T> _list;
        int _state = -1;
        /// <summary>Initializes a new instance of the <see cref="Enumerator"/> struct.</summary>
        /// <param name="list">The <see cref="SmallList{T}"/> to enumerate over.</param>
        /// <param name="isReversed">Determines whether to go backwards.</param>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public Enumerator(SmallList<T> list, bool isReversed = false)
        {
            _list = list;
            _isReversed = isReversed;
            _count = list.Count;
        }
        /// <inheritdoc />
        public T Current { [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get; private set; } = default!;
        /// <inheritdoc />
        readonly object? IEnumerator.Current
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => Current;
        }
        /// <inheritdoc />
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public readonly void Dispose() { }
        /// <inheritdoc />
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void Reset() => _state = -1;
        /// <inheritdoc />
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public bool MoveNext() =>
            ++_state < _count &&
            (Current = (_isReversed ? _count - _state - 1 : _state) switch
            {
                0 => _list._first!,
                1 => _list._second!,
                2 => _list._third!,
                var x => _list._rest![x - InlinedLength],
            }) is var _;
    }
}
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable once CheckNamespace
/// <summary>Determines control flow for loops.</summary>
public enum ControlFlow : byte
{
    /// <summary>The value indicating that the loop should continue.</summary>
    Continue,
    /// <summary>The value indicating that the loop should break.</summary>
    Break,
}
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable CheckNamespace RedundantNameQualifier
/// <summary>Provides extension methods for <see cref="char"/>.</summary>
    /// <summary>Removes the single character based on the index from the langword="string"/>.</summary>
    /// <param name="str">The builder to take the character from.</param>
    /// <param name="index">The index to remove.</param>
    /// <param name="popped">The resulting character that was removed, or <see langword="default"/>.</param>
    /// <returns>The parameter <paramref name="str"/>.</returns>
    public static string Pop(this string str, int index, out char popped)
    {
        if (index >= 0 && index < str.Length)
        {
            popped = str[index];
            return str.Remove(index, 1);
        }
        popped = '\0';
        return str;
    }
    /// <inheritdoc cref="Pop(StringBuilder, int, out char)"/>
    public static string Pop(this string str, Index index, out char popped) =>
        str.Pop(index.GetOffset(str.Length), out popped);
    /// <summary>Removes the substring based on the range from the langword="string"/>.</summary>
    /// <param name="str">The builder to take the character from.</param>
    /// <param name="range">The range to remove.</param>
    /// <param name="popped">The resulting character that was removed, or <see langword="default"/>.</param>
    /// <exception cref="ArgumentOutOfRangeException">
    /// The parameter <paramref name="range"/> is out of range when indexing the parameter <paramref name="str"/>.
    /// </exception>
    /// <returns>The parameter <paramref name="str"/>.</returns>
    public static string Pop(this string str, Range range, out string popped)
    {
        range.GetOffsetAndLength(str.Length, out var startIndex, out var length);
        popped = str[range];
        return str.Remove(startIndex, length);
    }
    /// <summary>Removes the substring based on the range from the <see langword="string"/>.</summary>
    /// <param name="str">The builder to take the character from.</param>
    /// <param name="range">The range to remove.</param>
    /// <exception cref="ArgumentOutOfRangeException">
    /// The parameter <paramref name="range"/> is out of range when indexing the parameter <paramref name="str"/>.
    /// </exception>
    /// <returns>The parameter <paramref name="str"/>.</returns>
    public static string Remove(this string str, Range range)
    {
        range.GetOffsetAndLength(str.Length, out var startIndex, out var length);
        return str.Remove(startIndex, length);
    }
    /// <summary>Removes the single character based on the index from the <see cref="StringBuilder"/>.</summary>
    /// <param name="builder">The builder to take the character from.</param>
    /// <param name="index">The index to remove.</param>
    /// <param name="popped">The resulting character that was removed, or <see langword="default"/>.</param>
    /// <returns>The parameter <paramref name="builder"/>.</returns>
    public static StringBuilder Pop(this StringBuilder builder, int index, out char popped)
    {
        if (index >= 0 && index < builder.Length)
        {
            popped = builder[index];
            return builder.Remove(index, 1);
        }
        popped = '\0';
        return builder;
    }
    /// <inheritdoc cref="Pop(StringBuilder, int, out char)"/>
    public static StringBuilder Pop(this StringBuilder builder, Index index, out char popped) =>
        builder.Pop(index.GetOffset(builder.Length), out popped);
    /// <summary>Removes the substring based on the range from the <see cref="StringBuilder"/>.</summary>
    /// <param name="builder">The builder to take the character from.</param>
    /// <param name="range">The range to remove.</param>
    /// <param name="popped">The resulting character that was removed, or <see langword="default"/>.</param>
    /// <exception cref="ArgumentOutOfRangeException">
    /// The parameter <paramref name="range"/> is out of range when indexing the parameter <paramref name="builder"/>.
    /// </exception>
    /// <returns>The parameter <paramref name="builder"/>.</returns>
    public static StringBuilder Pop(this StringBuilder builder, Range range, out string popped)
    {
        range.GetOffsetAndLength(builder.Length, out var startIndex, out var length);
#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
        popped = string.Create(
            length,
            (builder, startIndex),
            static (span, tuple) =>
            {
                var (builder, startIndex) = tuple;
                for (var i = 0; i < span.Length; i++)
                    span[i] = builder[i + startIndex];
            }
        );
#else
        StringBuilder poppedBuilder = new(length);
        for (var i = 0; i < length; i++)
            poppedBuilder[i] = builder[startIndex + i];
        popped = $"{poppedBuilder}";
#endif
        return builder.Remove(startIndex, length);
    }
    /// <summary>Removes the substring based on the range from the <see cref="StringBuilder"/>.</summary>
    /// <param name="builder">The builder to take the character from.</param>
    /// <param name="range">The range to remove.</param>
    /// <exception cref="ArgumentOutOfRangeException">
    /// The parameter <paramref name="range"/> is out of range when indexing the parameter <paramref name="builder"/>.
    /// </exception>
    /// <returns>The parameter <paramref name="builder"/>.</returns>
    public static StringBuilder Remove(this StringBuilder builder, Range range)
    {
        range.GetOffsetAndLength(builder.Length, out var startIndex, out var length);
        return builder.Remove(startIndex, length);
    }
    /// <summary>Creates the <see cref="StringBuilder"/> around the provided <see cref="string"/>.</summary>
    /// <param name="str">The <see cref="string"/> to create the <see cref="StringBuilder"/> around.</param>
    /// <returns>The <see cref="StringBuilder"/> of the parameter <paramref name="str"/>.</returns>
    [Pure]
    public static StringBuilder ToBuilder(this string? str) => new(str);
    /// <inheritdoc cref="string.Trim()"/>
    public static Memory<char> Trim(this Memory<char> memory) => memory.TrimStart().TrimEnd();
    /// <inheritdoc cref="string.Trim()"/>
    public static ReadOnlyMemory<char> Trim(this ReadOnlyMemory<char> memory) => memory.TrimStart().TrimEnd();
    /// <inheritdoc cref="string.TrimEnd(char[])"/>
    public static Memory<char> TrimEnd(this Memory<char> memory)
    {
        var span = memory.Span;
        for (var i = span.Length - 1; i >= 0; i--)
            if (!char.IsWhiteSpace(span[i]))
                return memory[..(i + 1)];
        return default;
    }
    /// <inheritdoc cref="string.TrimEnd(char[])"/>
    public static ReadOnlyMemory<char> TrimEnd(this ReadOnlyMemory<char> memory)
    {
        var span = memory.Span;
        for (var i = span.Length - 1; i >= 0; i--)
            if (!char.IsWhiteSpace(span[i]))
                return memory[..(i + 1)];
        return default;
    }
    /// <inheritdoc cref="string.TrimStart(char[])"/>
    public static Memory<char> TrimStart(this Memory<char> memory)
    {
        var span = memory.Span;
        for (var i = 0; i < span.Length; i++)
            if (!char.IsWhiteSpace(span[i]))
                return memory[i..];
        return default;
    }
    /// <inheritdoc cref="string.TrimStart(char[])"/>
    public static ReadOnlyMemory<char> TrimStart(this ReadOnlyMemory<char> memory)
    {
        var span = memory.Span;
        for (var i = 0; i < span.Length; i++)
            if (!char.IsWhiteSpace(span[i]))
                return memory[i..];
        return default;
    }
    /// <inheritdoc cref="string.Trim()"/>
    public static StringBuilder Trim(this StringBuilder builder) => builder.TrimStart().TrimEnd();
    /// <inheritdoc cref="string.TrimEnd(char[])"/>
    public static StringBuilder TrimEnd(this StringBuilder builder)
    {
        for (var i = builder.Length - 1; i >= 0; i--)
            if (!char.IsWhiteSpace(builder[i]))
                return builder.Remove(i + 1, builder.Length - i - 1);
        return builder.Remove(0, builder.Length);
    }
    /// <inheritdoc cref="string.TrimStart(char[])"/>
    public static StringBuilder TrimStart(this StringBuilder builder)
    {
        for (var i = 0; i < builder.Length; i++)
            if (!char.IsWhiteSpace(builder[i]))
                return builder.Remove(0, i);
        return builder.Remove(0, builder.Length);
    }
// SPDX-License-Identifier: MPL-2.0
#if !NET20 && !NET30
// ReSharper disable once CheckNamespace
/// <summary>Provides the deconstruction to extract the head and tail of a collection.</summary>
    /// <summary>Represents a list with no head.</summary>
    /// <typeparam name="T">The type of list to encapsulate.</typeparam>
    public sealed partial class HeadlessList<T>([ProvidesContext] IList<T> list) : IList<T>
    {
        /// <inheritdoc cref="IList{T}.this" />
        [CollectionAccess(Read), Pure]
        public T this[int index]
        {
            get => index is not -1 ? list[index + 1] : throw new ArgumentOutOfRangeException(nameof(index));
            set => list[index + 1] = index is not -1 ? value : throw new ArgumentOutOfRangeException(nameof(index));
        }
        /// <inheritdoc />
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), Pure]
        public bool IsReadOnly => list.IsReadOnly;
        /// <inheritdoc cref="ICollection{T}.Count" />
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), Pure]
        public int Count => list.Count - 1;
        /// <inheritdoc />
        [CollectionAccess(UpdatedContent)]
        public void Add(T item) => list.Add(item);
        /// <inheritdoc />
        [CollectionAccess(ModifyExistingContent)]
        public void Clear() => list.Clear();
        /// <inheritdoc />
        [CollectionAccess(Read)]
        public void CopyTo(T[] array, int arrayIndex)
        {
            for (var i = 0; i < Count && arrayIndex + i < array.Length; i++)
                array[arrayIndex + i] = this[i];
        }
        /// <inheritdoc />
        [CollectionAccess(UpdatedContent)]
        public void Insert(int index, T item) =>
            list.Insert(index is not -1 ? index + 1 : throw new ArgumentOutOfRangeException(nameof(index)), item);
        /// <inheritdoc />
        [CollectionAccess(ModifyExistingContent)]
        public void RemoveAt(int index) =>
            list.RemoveAt(index is not -1 ? index + 1 : throw new ArgumentOutOfRangeException(nameof(index)));
        /// <inheritdoc />
        [CollectionAccess(Read), Pure]
        public bool Contains(T item) => list.Contains(item);
        /// <inheritdoc />
        [CollectionAccess(Read | ModifyExistingContent), Pure]
        public bool Remove(T item) => list.Remove(item);
        /// <inheritdoc />
        [CollectionAccess(Read), Pure]
        public int IndexOf(T item) =>
            list.IndexOf(item) switch
            {
                0 => Find(item),
                -1 => -1,
                var x => x - 1,
            };
        /// <inheritdoc />
        [CollectionAccess(Read), Pure]
        IEnumerator IEnumerable.GetEnumerator()
        {
            var ret = ((IEnumerable)list).GetEnumerator();
            ret.MoveNext();
            return ret;
        }
        /// <inheritdoc />
        [CollectionAccess(Read), Pure]
        public IEnumerator<T> GetEnumerator()
        {
            var ret = list.GetEnumerator();
            ret.MoveNext();
            return ret;
        }
        /// <inheritdoc />
        [CollectionAccess(Read), Pure]
        public override string? ToString() => list.ToString();
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure, ValueRange(-1, int.MaxValue)]
        int Find(T item)
        {
            var count = list.Count - 1;
            for (var i = 0; i < count; i++)
                if (EqualityComparer<T>.Default.Equals(list[i + 1], item))
                    return i;
            return -1;
        }
    }
#endif
    /// <summary>Separates the head from the tail of an <see cref="ICollection{T}"/>.</summary>
    /// <typeparam name="T">The item in the collection.</typeparam>
    /// <param name="collection">The enumerable to split.</param>
    /// <param name="head">The first element of the parameter <paramref name="collection"/>.</param>
    /// <param name="tail">The rest of the parameter <paramref name="collection"/>.</param>
    public static void Deconstruct<T>(
        this IList<T>? collection,
        out T? head,
        [NotNullIfNotNull(nameof(collection))] out HeadlessList<T>? tail
    )
    {
        head = collection is null ? default : collection.FirstOrDefault();
        tail = collection.Tail();
    }
    /// <summary>Gets the tail of the <see cref="ICollection{T}"/>.</summary>
    /// <typeparam name="T">The item in the collection.</typeparam>
    /// <param name="collection">The collection to extract the tail from.</param>
    /// <returns>
    /// The encapsulation of the parameter <paramref name="collection"/> that prevents the head from being accessed.
    /// </returns>
    [Pure]
    [return: NotNullIfNotNull(nameof(collection))]
    public static HeadlessList<T>? Tail<T>(this IList<T>? collection) => collection is null ? null : new(collection);
// SPDX-License-Identifier: MPL-2.0
#if NET8_0_OR_GREATER
// ReSharper disable once CheckNamespace
/// <summary>Contains fast parsing of key-value pairs.</summary>
static class Kvp
{
    static class KvpCache<T>
#if !NO_ALLOWS_REF_STRUCT
        where T : allows ref struct
#endif
    {
        public delegate void SerializeWriter(scoped in T reader, out DefaultInterpolatedStringHandler writer);
        public delegate void DeserializeWriter(scoped ReadOnlySpan<char> reader, scoped ref T writer);
        static readonly ImmutableArray<MemberInfo> s_members = MakeMembers();
        [Pure]
        public static ImmutableArray<(string Key, bool IsCollection, DeserializeWriter Writer)> Deserializers { get; } =
            MakeDeserializers();
        [Pure]
        public static SerializeWriter Serializer { get; } = MakeSerializer();
        [Pure]
        static bool IsAdd(MethodInfo x) =>
            x.Name is nameof(IList.Add) && x.GetGenericArguments() is [] && x.GetParameters() is [_];
        [Pure]
        static bool IsCollection([NotNullWhen(true)] MethodInfo? adder, Type type) =>
            adder is not null && type.IsAssignableTo(typeof(ICollection)) && type.GetConstructor([]) is not null;
        [MustUseReturnValue]
        static string? Description(MemberInfo m)
        {
            const string Comment = "# ";
            if (m.GetCustomAttribute<DescriptionAttribute>()?.Description is not { } description)
                return null;
            var d = description.AsSpan();
            StringBuilder sb = new(Comment.Length + d.Length + 1);
#if NET9_0_OR_GREATER
            foreach (var range in d.SplitAny(BreakingSearch.GetSpan()[0]))
            {
                var line = d[range];
                sb.Append(line.IsEmpty ? "" : "# ").Append(line).AppendLine();
            }
#else
            foreach (var line in d.SplitOn(BreakingSearch.GetSpan()[0]))
                sb.Append(line.IsEmpty ? "" : "# ").Append(line).AppendLine();
#endif
            return sb.ToString();
        }
        static string ToString(ICollection values)
        {
            if (values.Count is 0)
                return "";
            var literalLength = (values.Count - 1) * 2;
            DefaultInterpolatedStringHandler dish = new(literalLength, values.Count, CultureInfo.InvariantCulture);
            var enumerator = values.GetEnumerator();
            try
            {
                if (enumerator.MoveNext())
                    dish.AppendFormatted(enumerator.Current);
                else
                    return dish.ToStringAndClear();
                while (enumerator.MoveNext())
                {
                    dish.AppendFormatted(", ");
                    dish.AppendFormatted(enumerator.Current);
                }
                return dish.ToStringAndClear();
            }
            finally
            {
                (enumerator as IDisposable)?.Dispose();
            }
        }
        [MustUseReturnValue]
        static Expression Convert(Type t, Expression exReader, Expression exTemp)
        {
#pragma warning disable IDE0340
            var spanToString = typeof(ReadOnlySpan<char>).GetMethod(nameof(ReadOnlySpan<char>.ToString), [])!;
#pragma warning restore IDE0340
            var exIFormatProvider = Expression.Constant(CultureInfo.InvariantCulture);
            var exReaderString = Expression.Call(exReader, spanToString);
            var exNumberStyles = Expression.Constant(NumberStyles.Any);
            var tru = Expression.Constant(true);
            return 0 switch
            {
                _ when t == typeof(string) => Expression.Assign(exTemp, exReaderString),
                _ when t.GetMethod(
                    nameof(int.TryParse),
                    [typeof(ReadOnlySpan<char>), typeof(NumberStyles), typeof(IFormatProvider), t.MakeByRefType()]
                ) is { } x => Expression.Call(x, exReader, exNumberStyles, exIFormatProvider, exTemp),
                _ when t.GetMethod(
                    nameof(int.TryParse),
                    [typeof(ReadOnlySpan<char>), typeof(IFormatProvider), t.MakeByRefType()]
                ) is { } x => Expression.Call(x, exReader, exIFormatProvider, exTemp),
                _ when t.GetMethod(nameof(int.TryParse), [typeof(ReadOnlySpan<char>), t.MakeByRefType()]) is
                    { } x => Expression.Call(x, exReader, exTemp),
                _ when t.GetMethod(
                    nameof(int.TryParse),
                    [typeof(string), typeof(NumberStyles), typeof(IFormatProvider), t.MakeByRefType()]
                ) is { } x => Expression.Call(x, exReaderString, exNumberStyles, exIFormatProvider, exTemp),
                _ when t.GetMethod(
                    nameof(int.TryParse),
                    [typeof(string), typeof(IFormatProvider), t.MakeByRefType()]
                ) is { } x => Expression.Call(x, exReaderString, exIFormatProvider, exTemp),
                _ when t.GetMethod(nameof(int.TryParse), [typeof(string), t.MakeByRefType()]) is { } x =>
                    Expression.Call(x, exReaderString, exTemp),
                _ when t.IsEnum => Expression.Call(typeof(Enum), nameof(Enum.TryParse), [t], exReader, tru, exTemp),
                _ => Expression.Assign(exTemp, Expression.Default(t)),
            };
        }
        [MustUseReturnValue]
        static ImmutableArray<(string, bool, DeserializeWriter)> MakeDeserializers()
        {
            var members = s_members.Where(x => x is FieldInfo { IsInitOnly: false } or PropertyInfo { CanWrite: true })
               .ToIList();
            var builder = ImmutableArray.CreateBuilder<(string, bool, DeserializeWriter)>(members.Count);
            foreach (var member in members)
            {
                var type = UnderlyingType(member);
                var adder = type.GetMethods().FirstOrDefault(IsAdd);
                var t = IsCollection(adder, type) ? adder.GetParameters()[0].ParameterType : type;
                var isFlagEnum = type.IsEnum && type.GetCustomAttribute<FlagsAttribute>() is not null;
                var exReader = Expression.Parameter(typeof(ReadOnlySpan<char>));
                var exWriter = Expression.Parameter(typeof(T).MakeByRefType());
                var exTemp = Expression.Variable(t);
                var exCall = Convert(t, exReader, exTemp);
                var fieldOrProperty = exWriter.FieldOrProperty(member);
                Expression exUpdate = IsCollection(adder, type)
                    ? Expression.IfThenElse(
                        Expression.ReferenceEqual(fieldOrProperty, Expression.Constant(null)),
                        Expression.Assign(fieldOrProperty, Expression.ListInit(Expression.New(type), exTemp)),
                        Expression.Call(fieldOrProperty, nameof(IList.Add), [], exTemp)
                    )
                    : Expression.Assign(
                        fieldOrProperty,
                        isFlagEnum
                            ? Expression.Convert(
                                Expression.Or(
                                    Expression.Convert(fieldOrProperty, type.GetEnumUnderlyingType()),
                                    Expression.Convert(exTemp, type.GetEnumUnderlyingType())
                                ),
                                type
                            )
                            : exTemp
                    );
                var exBlock = Expression.Block([exTemp], exCall, exUpdate);
                var lambda = Expression.Lambda<DeserializeWriter>(exBlock, exReader, exWriter).Compile();
                var key = member.Name.Trim();
                builder.Add((key, type.IsEnum || IsCollection(adder, type), lambda));
            }
            return builder.MoveToImmutable();
        }
        [MustUseReturnValue]
        static ImmutableArray<MemberInfo> MakeMembers()
        {
            const BindingFlags Flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy;
            var fields = typeof(T).GetFields(Flags);
            var properties = typeof(T).GetProperties(Flags).Where(x => x.GetIndexParameters() is []);
            return
            [
                ..fields.AsEnumerable<MemberInfo>()
                   .Concat(properties)
                   .OrderBy(x => x.GetCustomAttribute<JsonPropertyOrderAttribute>()?.Order ?? 0)
                   .ThenBy(x => x.Name, StringComparer.OrdinalIgnoreCase),
            ];
        }
        [MustUseReturnValue]
        static SerializeWriter MakeSerializer()
        {
            const string AppendFormatted = nameof(AppendFormatted),
                AppendLiteral = nameof(AppendLiteral),
                Assignment = " = ",
                Separator = "\n";
            [MustUseReturnValue]
            static int ConstantLength(MemberInfo m) => m.Name.Length + Assignment.Length + Separator.Length;
            var exReader = Expression.Parameter(typeof(T).MakeByRefType());
            var exWriter = Expression.Parameter(typeof(DefaultInterpolatedStringHandler).MakeByRefType());
            Type[] args = [typeof(int), typeof(int), typeof(IFormatProvider)];
            var constructor = typeof(DefaultInterpolatedStringHandler).GetConstructor(args)!;
            var members = s_members.Where(x => x is FieldInfo or PropertyInfo { CanRead: true }).ToIList();
            var literalLength = members.Sum(ConstantLength) + members.Select(Description).Sum(x => x?.Length);
            var exLiteralLength = Expression.Constant(literalLength);
            var exFormattedLength = Expression.Constant(members.Count);
            var exIFormatProvider = Expression.Constant(CultureInfo.InvariantCulture);
            var exNew = Expression.New(constructor, exLiteralLength, exFormattedLength, exIFormatProvider);
            List<Expression> exBlockArgs = [Expression.Assign(exWriter, exNew)];
            foreach (var member in members)
            {
                if (Description(member) is { } description)
                {
                    var exDescription = Expression.Constant(description);
                    var exAppendDescription = Expression.Call(exWriter, AppendLiteral, [], exDescription);
                    exBlockArgs.Add(exAppendDescription);
                }
                var exKey = Expression.Constant($"{member.Name}{Assignment}");
                var exAppendKey = Expression.Call(exWriter, AppendLiteral, [], exKey);
                exBlockArgs.Add(exAppendKey);
                var exMember = Expression.MakeMemberAccess(exReader, member);
                var underlyingType = UnderlyingType(member);
                var isCollection = underlyingType != typeof(string) &&
                    underlyingType.IsAssignableTo(typeof(ICollection));
                var exFormatted = Expression.Call(
                    exWriter,
                    AppendFormatted,
                    [isCollection ? typeof(string) : underlyingType],
                    isCollection
                        ? Expression.Call(((Converter<ICollection, string>)ToString).Method, exMember)
                        : exMember
                );
                exBlockArgs.Add(exFormatted);
                var separator = Expression.Constant(Separator);
                var exAppendSeparator = Expression.Call(exWriter, AppendLiteral, [], separator);
                exBlockArgs.Add(exAppendSeparator);
            }
            var exBlock = Expression.Block(exBlockArgs);
            return Expression.Lambda<SerializeWriter>(exBlock, exReader, exWriter).Compile();
        }
        [MustUseReturnValue]
        static Type UnderlyingType(MemberInfo member) =>
            member switch
            {
                FieldInfo f => f.FieldType,
                PropertyInfo p => p.PropertyType,
                _ => throw Unreachable,
            };
    }
    /// <summary>Serialize an object into a string.</summary>
    /// <typeparam name="T">The type of the object to serialize.</typeparam>
    /// <param name="value">The object to serialize.</param>
    /// <returns>The serialized object.</returns>
    [Pure]
    public static string Serialize<T>(scoped in T value)
#if !NO_ALLOWS_REF_STRUCT
        where T : allows ref struct
#endif
    {
        KvpCache<T>.Serializer(value, out var dish);
        return dish.ToStringAndClear();
    }
    /// <summary>Deserialize string into an object of the given type.</summary>
    /// <typeparam name="T">The type of the deserialized object.</typeparam>
    /// <param name="span">The string to deserialize.</param>
    /// <returns>The deserialized object.</returns>
    [Pure]
    public static T Deserialize<T>(scoped ReadOnlySpan<char> span)
#if NO_ALLOWS_REF_STRUCT
        where T : new()
#else
        where T : new(), allows ref struct
#endif
    {
        var ret = new T();
        Deserialize(span, ref ret);
        return ret;
    }
    /// <summary>Deserialize string into an object of the given type.</summary>
    /// <typeparam name="T">The type of the deserialized object.</typeparam>
    /// <param name="span">The string to deserialize.</param>
    /// <param name="writer">The object to write to.</param>
    /// <returns>The deserialized object.</returns>
    public static void Deserialize<T>(scoped ReadOnlySpan<char> span, scoped ref T writer)
#if !NO_ALLOWS_REF_STRUCT
        where T : allows ref struct
#endif
    {
        for (;
            span.IndexOfAny(BreakingSearch.GetSpan()[0]) is var separator;
            span = span.UnsafelySkip(separator + 1))
        {
            ProcessLine(span.UnsafelyTake(separator is -1 ? span.Length : separator), ref writer);
            if (separator is -1)
                break;
        }
    }
    /// <inheritdoc cref="Deserialize{T}(System.ReadOnlySpan{char}, ref T)"/>
    public static void Deserialize<T>(scoped ReadOnlySpan<char> span, T writer)
        where T : class =>
        Deserialize(span, ref writer);
    static void ProcessLine<T>(scoped ReadOnlySpan<char> span, scoped ref T writer)
#if !NO_ALLOWS_REF_STRUCT
        where T : allows ref struct
#endif
    {
        static void Match(
            in (string Key, bool IsCollection, KvpCache<T>.DeserializeWriter Writer) deserializer,
            scoped ReadOnlySpan<char> slice,
            int equals,
            ref T writer
        )
        {
            if (!slice.UnsafelyTake(equals).Trim().Equals(deserializer.Key, StringComparison.OrdinalIgnoreCase))
                return;
            slice = slice.UnsafelySkip(equals + 1);
            if (!deserializer.IsCollection)
            {
                deserializer.Writer(slice.Trim(), ref writer);
                return;
            }
            for (; slice.IndexOf(',') is var j; slice = slice.UnsafelySkip(j + 1))
            {
                deserializer.Writer((j is -1 ? slice : slice.UnsafelyTake(j)).Trim(), ref writer);
                if (j is -1)
                    return;
            }
        }
        if (span.IndexOfAny(';', '#') is not -1 and var comments)
            span = span.UnsafelyTake(comments);
        if (span.IndexOf('=') is not (not -1 and var equals))
            return;
        foreach (var deserializer in KvpCache<T>.Deserializers)
            Match(deserializer, span, equals, ref writer);
    }
}
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable once CheckNamespace EmptyNamespace
#if NET7_0_OR_GREATER
/// <summary>Computes the Fast Fourier Transform.</summary>
    /// <summary>Computes the Fast Fourier Transform in place.</summary>
    /// <typeparam name="T">The type of the samples.</typeparam>
    /// <param name="bluestein">The bluestein transform.</param>
    /// <param name="real">The real part.</param>
    /// <param name="imaginary">The imaginary part.</param>
    /// <exception cref="ArgumentOutOfRangeException">Any span provided does not have the same length.</exception>
    public static void FFT<T>(
        this (ImmutableArray<T> Real, ImmutableArray<T> Imaginary) bluestein,
        scoped Span<T> real,
        scoped Span<T> imaginary
    )
        where T : IRootFunctions<T>, ITrigonometricFunctions<T> =>
        FFT(bluestein.Real.AsSpan(), bluestein.Imaginary.AsSpan(), real, imaginary);
    /// <summary>Computes the Fast Fourier Transform in place.</summary>
    /// <typeparam name="T">The type of the samples.</typeparam>
    /// <param name="bre">The bluestein real part.</param>
    /// <param name="bim">The bluestein imaginary part.</param>
    /// <param name="re">The real part.</param>
    /// <param name="im">The imaginary part.</param>
    /// <exception cref="InvalidOperationException">Any span provided does not have the same length.</exception>
    public static void FFT<T>(
        scoped ReadOnlySpan<T> bre,
        scoped ReadOnlySpan<T> bim,
        scoped Span<T> re,
        scoped Span<T> im
    )
        where T : IRootFunctions<T>, ITrigonometricFunctions<T>
    {
        if (re.Length is var length && length != im.Length || length != bre.Length || length != bim.Length)
            throw new InvalidOperationException($"re/{re.Length}, im/{im.Length}, bre/{bre.Length}, bim/{bim.Length}");
        if (length is 0)
            return;
        var subLength = (int)(length * 2 - 1).RoundUpToPowerOf2();
        var rent = ArrayPool<T>.Shared.Rent(subLength * 4);
        Span<T> ar = rent.AsSpan(0, subLength),
            ai = rent.AsSpan(subLength, subLength),
            br = rent.AsSpan(subLength * 2, subLength),
            bi = rent.AsSpan(subLength * 3, subLength);
        bre.CopyTo(br);
        bim.CopyTo(bi);
        ar.UnsafelySkip(length).Clear();
        ai.UnsafelySkip(length).Clear();
        var i = subLength - length + 1;
        br.UnsafelySlice(length, i - length).Clear();
        bi.UnsafelySlice(length, i - length).Clear();
        for (; i < subLength; i++)
            (br[i], bi[i]) = (bre.UnsafelyIndex(subLength - i), bim.UnsafelyIndex(subLength - i));
        Radix2(br, bi, -1);
        for (i = 0; i < length; i++)
        {
            ar[i] = bre.UnsafelyIndex(i) * re.UnsafelyIndex(i) + bim.UnsafelyIndex(i) * im.UnsafelyIndex(i);
            ai[i] = bre.UnsafelyIndex(i) * im.UnsafelyIndex(i) - bim.UnsafelyIndex(i) * re.UnsafelyIndex(i);
        }
        Radix2(ar, ai, -1);
        for (i = 0; i < subLength; i++)
        {
            var r = ar.UnsafelyIndex(i);
            ar[i] = r * br.UnsafelyIndex(i) - ai.UnsafelyIndex(i) * bi.UnsafelyIndex(i);
            ai[i] = r * bi.UnsafelyIndex(i) + ai.UnsafelyIndex(i) * br.UnsafelyIndex(i);
        }
        Radix2(ar, ai, 1);
        T n = T.One / T.CreateChecked(subLength), halfRescale = (T.One / T.CreateChecked(length)).Sqrt();
        for (i = 0; i < length; i++)
        {
            re[i] = (n * bre.UnsafelyIndex(i) * ar[i] - n * -bim.UnsafelyIndex(i) * ai[i]) * halfRescale;
            im[i] = (n * bre.UnsafelyIndex(i) * ai[i] + n * -bim.UnsafelyIndex(i) * ar[i]) * halfRescale;
        }
        ArrayPool<T>.Shared.Return(rent);
    }
    /// <summary>Computes the Bluestein transform.</summary>
    /// <typeparam name="T">The type of the samples.</typeparam>
    /// <param name="length">The length.</param>
    /// <returns>The real and imaginary parts.</returns>
    public static (ImmutableArray<T> Real, ImmutableArray<T> Imaginary) Bluestein<T>(this int length)
        where T : ITrigonometricFunctions<T>
    {
        T[] re = new T[length], im = new T[length];
        var scale = T.Pi / T.CreateChecked(length);
        var i = 0;
#if NET9_0_OR_GREATER
        if (Vector<T>.IsSupported && Vector.IsHardwareAccelerated)
            for (; i <= length - Vector<T>.Count; i += Vector<T>.Count)
            {
                var step = Vector.CreateSequence(T.CreateChecked(i), T.One);
                var (sin, cos) = (scale * step * step).SinCos();
                sin.StoreUnsafe(ref MemoryMarshal.GetArrayDataReference(im), unchecked((nuint)i));
                cos.StoreUnsafe(ref MemoryMarshal.GetArrayDataReference(re), unchecked((nuint)i));
            }
#endif
        for (; i < length; i++)
            (im[i], re[i]) = (scale * T.CreateChecked(i) * T.CreateChecked(i)).SinCos();
        return (ImmutableCollectionsMarshal.AsImmutableArray(re), ImmutableCollectionsMarshal.AsImmutableArray(im));
    }
#if NET9_0_OR_GREATER
    /// <summary>Computes the Fast Fourier Transform in place and returns the maximum hypotenuse.</summary>
    /// <typeparam name="T">The type of the samples.</typeparam>
    /// <param name="bluestein">The bluestein transform.</param>
    /// <param name="realBuffer">The buffer that will be replaced with the hypotenuse of the fourier transform.</param>
    /// <param name="skipHypotOnLastHalf">
    /// Whether to skip calculating the hypotenuse on the second half of the buffer. This is because the nature of the
    /// fourier transform with all zeros for the imaginary buffer causes the real buffer to be always symmetrical.
    /// If this is set to <see langword="true"/>, only the first half of the buffer will have the computed hypotenuse.
    /// The second half will still be written to, but only with its real counterpart. If set to <see langword="false"/>,
    /// the whole buffer will be written to, which guarantees that the buffer will end up symmetric.
    /// </param>
    /// <exception cref="ArgumentOutOfRangeException">Any span provided does not have the same length.</exception>
    public static T MaxHypotFFT<T>(
        this (ImmutableArray<T> Real, ImmutableArray<T> Imaginary) bluestein,
        scoped Span<T> realBuffer,
        bool skipHypotOnLastHalf = false
    )
        where T : IFloatingPointIeee754<T>
    {
        var rent = ArrayPool<T>.Shared.Rent(realBuffer.Length);
        var imaginaryBuffer = rent.AsSpan().UnsafelyTake(realBuffer.Length);
        imaginaryBuffer.Clear();
        bluestein.FFT(realBuffer, imaginaryBuffer);
        var max = T.Epsilon;
        ref var real = ref MemoryMarshal.GetReference(realBuffer);
        ref var imaginary = ref MemoryMarshal.GetReference(imaginaryBuffer);
        var length = skipHypotOnLastHalf ? (realBuffer.Length + 1) / 2 : realBuffer.Length;
        if (!Vector<T>.IsSupported || !Vector.IsHardwareAccelerated || Vector<T>.Count > length)
        {
            ref readonly var end = ref Unsafe.Add(ref real, length);
            while (Unsafe.IsAddressLessThan(real, end))
            {
                max = max.Max(real = real.Hypot(imaginary));
                real = ref Unsafe.Add(ref real, 1)!;
                imaginary = ref Unsafe.Add(ref imaginary, 1)!;
            }
            return max;
        }
        var maxVector = Vector<T>.Zero;
        ref var realLast = ref Unsafe.Add(ref real, length - Vector<T>.Count);
        ref readonly var imaginaryLast = ref Unsafe.Add(ref imaginary, length - Vector<T>.Count);
        StoreUnsafe(ref real, imaginary, ref maxVector);
        real = ref Unsafe.Add(ref real, Vector<T>.Count)!;
        imaginary = ref Unsafe.Add(ref imaginary, Vector<T>.Count)!;
        while (Unsafe.IsAddressLessThan(real, realLast))
        {
            StoreUnsafe(ref real, imaginary, ref maxVector);
            real = ref Unsafe.Add(ref real, Vector<T>.Count)!;
            imaginary = ref Unsafe.Add(ref imaginary, Vector<T>.Count)!;
        }
        StoreUnsafe(ref realLast, imaginaryLast, ref maxVector);
        for (var index = 0; index < Vector<T>.Count; index++)
            max = max.Max(maxVector[index]);
        ArrayPool<T>.Shared.Return(rent);
        return max;
    }
#endif
    /// <summary>Performs a radix-2 step.</summary>
    /// <typeparam name="T">The type of the samples.</typeparam>
    /// <param name="re">The real part.</param>
    /// <param name="im">The imaginary part.</param>
    /// <param name="e">The exponent.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    static void Radix2<T>(Span<T> re, Span<T> im, int e)
        where T : ITrigonometricFunctions<T>
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        static void NextStep(Span<T> re, Span<T> im, T a, int i, int j)
        {
            var nextRe = a.Cos() * re.UnsafelyIndex(j) - a.Sin() * im.UnsafelyIndex(j);
            var nextIm = a.Cos() * im.UnsafelyIndex(j) + a.Sin() * re.UnsafelyIndex(j);
            (re[j], im[j]) = (re.UnsafelyIndex(i) - nextRe, im.UnsafelyIndex(i) - nextIm);
            (re[i], im[i]) = (re.UnsafelyIndex(i) + nextRe, im.UnsafelyIndex(i) + nextIm);
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        static void NextReorder(ref int i, int j, Span<T> re, Span<T> im)
        {
            if (i > j)
                (re[i], re[j], im[i], im[j]) = (re.UnsafelyIndex(j), re.UnsafelyIndex(i), im.UnsafelyIndex(j),
                    im.UnsafelyIndex(i));
            var length = re.Length;
            do
                i ^= length >>= 1;
            while ((i & length) is 0);
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        static void Reorder(Span<T> re, Span<T> im)
        {
            for (int i = 0, j = 0; j < re.Length - 1; j++)
                NextReorder(ref i, j, re, im);
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        static void Step(Span<T> re, Span<T> im, int e)
        {
            for (var s = 1; s < re.Length; s *= 2)
                for (var k = 0; k < s && T.CreateChecked(e * k) * T.Pi / T.CreateChecked(s) is var a; k++)
                    for (var i = k; i < re.Length; i += s * 2)
                        NextStep(re, im, a, i, i + s);
        }
        System.Diagnostics.Debug.Assert(re.Length == im.Length, "buffers must be the same length");
        Reorder(re, im);
        Step(re, im, e);
    }
#if NET9_0_OR_GREATER
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    static void StoreUnsafe<T>(ref T real, in T imaginary, ref Vector<T> max)
    {
        var hypot = Vector.LoadUnsafe(real).Hypot(Vector.LoadUnsafe(imaginary));
        max = Vector.Max(max, hypot);
        hypot.StoreUnsafe(ref real);
    }
#endif
#endif
// SPDX-License-Identifier: MPL-2.0
#if (NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) && !NO_SYSTEM_MEMORY
// ReSharper disable BadPreprocessorIndent CheckNamespace StructCanBeMadeReadOnly RedundantReadonlyModifier
#pragma warning disable CS8500, IDE0251, MA0102
/// <inheritdoc cref="Bits{T}"/>
#if CSHARPREPL
public
#endif
#if !NO_READONLY_STRUCTS
readonly
#endif
    partial struct Bits<T>
{
    /// <summary>An enumerator over <see cref="Bits{T}"/>.</summary>
    /// <param name="value">The item to use.</param>
    [StructLayout(LayoutKind.Auto)]
    public partial struct Enumerator(T value) : IEnumerator<T>
    {
        const int Start = -1;
        /// <summary>Gets the current mask.</summary>
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)]
        public nuint Mask
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get;
            [MethodImpl(MethodImplOptions.AggressiveInlining)] private set;
        }
        /// <summary>Gets the current index.</summary>
        [CLSCompliant(false), CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)]
        public nint Index
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get;
            [MethodImpl(MethodImplOptions.AggressiveInlining)] private set;
        } = Start;
        /// <summary>Gets the reconstruction of the original enumerable that can create this instance.</summary>
        [CollectionAccess(Read)]
        public readonly Bits<T> AsBits
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => value;
        }
        /// <summary>Gets the underlying value that is being enumerated.</summary>
        [CollectionAccess(Read)]
        public readonly T AsValue
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => value;
        }
        /// <inheritdoc />
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)]
        public readonly T Current
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
            get
            {
                T t = default;
                Unsafe.Add(ref Unsafe.As<T, nuint>(ref t), Index) = Mask;
                return t;
            }
        }
        /// <inheritdoc />
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)]
        readonly object IEnumerator.Current
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => Current;
        }
        /// <summary>Implicitly calls the constructor.</summary>
        /// <param name="value">The value to pass into the constructor.</param>
        /// <returns>A new instance of <see cref="Enumerator"/> with <paramref name="value"/> passed in.</returns>
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        public static implicit operator Enumerator(T value) => new(value);
        /// <summary>Implicitly calls <see cref="Current"/>.</summary>
        /// <param name="value">The value to call <see cref="Current"/>.</param>
        /// <returns>The value that was passed in to this instance.</returns>
        [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        public static explicit operator T(Enumerator value) => value.Current;
        /// <inheritdoc />
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining)]
        readonly void IDisposable.Dispose() { }
        /// <inheritdoc />
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void Reset()
        {
            Index = Start;
            Mask = 0;
        }
        /// <inheritdoc />
        [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining)]
        public bool MoveNext()
        {
            Mask <<= 1;
            if (Mask is 0)
            {
                Index++;
                Mask++;
            }
            if (Unsafe.SizeOf<T>() / Unsafe.SizeOf<nint>() is not 0 && FindNativelySized() ||
                Unsafe.SizeOf<T>() % Unsafe.SizeOf<nint>() is not 0 && FindRest())
                return true;
            Index = Unsafe.SizeOf<T>() / Unsafe.SizeOf<nint>();
            Mask = FalsyMask();
            return false;
        }
        /// <inheritdoc />
        [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        public readonly override string ToString()
        {
            var that = this;
            return that.ToRemainingString();
        }
        /// <summary>Enumerates over the remaining elements to give a <see cref="string"/> result.</summary>
        /// <returns>The <see cref="string"/> result of this instance.</returns>
        [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), MustUseReturnValue]
        public string ToRemainingString()
        {
            Span<char> span = stackalloc char[Unsafe.SizeOf<T>() * BitsInByte];
            ref var last = ref Unsafe.Add(ref MemoryMarshal.GetReference(span), Unsafe.SizeOf<T>() * BitsInByte - 1);
            span.Fill('0');
            while (MoveNext())
                Unsafe.Subtract(ref last, (int)(Index * (Unsafe.SizeOf<nint>() * BitsInByte) + TrailingZeroCount(Mask)))
                    ^= '\x01';
            return span.ToString();
        }
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        static nuint FalsyMask() => (nuint)1 << Unsafe.SizeOf<nint>() * BitsInByte - 2;
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        static nuint LastRest() => ((nuint)1 << Unsafe.SizeOf<T>() % Unsafe.SizeOf<nint>() * BitsInByte) - 1;
        [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        bool FindNativelySized()
        {
            if (Index < 0)
                return false;
            for (; Index < Unsafe.SizeOf<T>() / Unsafe.SizeOf<nint>(); Index++, Mask = 1)
                for (; Mask is not 0; Mask <<= 1)
                    if (IsNonZero())
                        return true;
            return false;
        }
        [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        bool FindRest()
        {
            if (Index != Unsafe.SizeOf<T>() / Unsafe.SizeOf<nint>())
                return false;
            for (; (Mask & LastRest()) is not 0; Mask <<= 1)
                if (IsNonZero())
                    return true;
            return false;
        }
        [CollectionAccess(Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        readonly bool IsNonZero() => (Unsafe.Add(ref Unsafe.As<T, nuint>(ref AsRef(value)), Index) & Mask) is not 0;
    }
}
#endif
// SPDX-License-Identifier: MPL-2.0
#if NET7_0_OR_GREATER
// ReSharper disable once CheckNamespace
/// <summary>Extension methods for <see cref="INumber{TSelf}"/>.</summary>
    /// <inheritdoc cref="IBinaryInteger{TSelf}.TryReadBigEndian(ReadOnlySpan{byte}, bool, out TSelf)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool TryReadBigEndian<TSelf>(this ReadOnlySpan<byte> source, bool isUnsigned, out TSelf value)
        where TSelf : IBinaryInteger<TSelf> =>
        TSelf.TryReadBigEndian(source, isUnsigned, out value);
    /// <inheritdoc cref="IBinaryInteger{TSelf}.TryReadLittleEndian(ReadOnlySpan{byte}, bool, out TSelf)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool TryReadLittleEndian<TSelf>(this ReadOnlySpan<byte> source, bool isUnsigned, out TSelf value)
        where TSelf : IBinaryInteger<TSelf> =>
        TSelf.TryReadLittleEndian(source, isUnsigned, out value);
    /// <inheritdoc cref="IBinaryInteger{TSelf}.TryWriteBigEndian(Span{byte}, out int)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool TryWriteBigEndian<TSelf>(this TSelf value, Span<byte> destination, out int bytesWritten)
        where TSelf : IBinaryInteger<TSelf> =>
        value.TryWriteBigEndian(destination, out bytesWritten);
    /// <inheritdoc cref="IBinaryInteger{TSelf}.TryWriteLittleEndian(Span{byte}, out int)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool TryWriteLittleEndian<TSelf>(this TSelf value, Span<byte> destination, out int bytesWritten)
        where TSelf : IBinaryInteger<TSelf> =>
        value.TryWriteLittleEndian(destination, out bytesWritten);
    /// <inheritdoc cref="INumberBase{TSelf}.IsCanonical"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsCanonical<TSelf>(this TSelf value)
        where TSelf : INumberBase<TSelf> =>
        TSelf.IsCanonical(value);
    /// <inheritdoc cref="INumberBase{TSelf}.IsComplexNumber"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsComplexNumber<TSelf>(this TSelf value)
        where TSelf : INumberBase<TSelf> =>
        TSelf.IsComplexNumber(value);
    /// <inheritdoc cref="INumberBase{TSelf}.IsEvenInteger"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsEvenInteger<TSelf>(this TSelf value)
        where TSelf : INumberBase<TSelf> =>
        TSelf.IsEvenInteger(value);
    /// <inheritdoc cref="INumberBase{TSelf}.IsFinite"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsFinite<TSelf>(this TSelf value)
        where TSelf : INumberBase<TSelf> =>
        TSelf.IsFinite(value);
    /// <inheritdoc cref="INumberBase{TSelf}.IsImaginaryNumber"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsImaginaryNumber<TSelf>(this TSelf value)
        where TSelf : INumberBase<TSelf> =>
        TSelf.IsImaginaryNumber(value);
    /// <inheritdoc cref="INumberBase{TSelf}.IsInfinity"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsInfinity<TSelf>(this TSelf value)
        where TSelf : INumberBase<TSelf> =>
        TSelf.IsInfinity(value);
    /// <inheritdoc cref="INumberBase{TSelf}.IsInteger"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsInteger<TSelf>(this TSelf value)
        where TSelf : INumberBase<TSelf> =>
        TSelf.IsInteger(value);
    /// <inheritdoc cref="INumberBase{TSelf}.IsNaN"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsNaN<TSelf>(this TSelf value)
        where TSelf : INumberBase<TSelf> =>
        TSelf.IsNaN(value);
    /// <inheritdoc cref="INumberBase{TSelf}.IsNegative"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsNegative<TSelf>(this TSelf value)
        where TSelf : INumberBase<TSelf> =>
        TSelf.IsNegative(value);
    /// <inheritdoc cref="INumberBase{TSelf}.IsNegativeInfinity"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsNegativeInfinity<TSelf>(this TSelf value)
        where TSelf : INumberBase<TSelf> =>
        TSelf.IsNegativeInfinity(value);
    /// <inheritdoc cref="INumberBase{TSelf}.IsNormal"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsNormal<TSelf>(this TSelf value)
        where TSelf : INumberBase<TSelf> =>
        TSelf.IsNormal(value);
    /// <inheritdoc cref="INumberBase{TSelf}.IsOddInteger"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsOddInteger<TSelf>(this TSelf value)
        where TSelf : INumberBase<TSelf> =>
        TSelf.IsOddInteger(value);
    /// <inheritdoc cref="INumberBase{TSelf}.IsPositive"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsPositive<TSelf>(this TSelf value)
        where TSelf : INumberBase<TSelf> =>
        TSelf.IsPositive(value);
    /// <inheritdoc cref="INumberBase{TSelf}.IsPositiveInfinity"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsPositiveInfinity<TSelf>(this TSelf value)
        where TSelf : INumberBase<TSelf> =>
        TSelf.IsPositiveInfinity(value);
    /// <inheritdoc cref="IBinaryNumber{TSelf}.IsPow2"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsPow2<TSelf>(this TSelf value)
        where TSelf : IBinaryNumber<TSelf> =>
        TSelf.IsPow2(value);
    /// <inheritdoc cref="INumberBase{TSelf}.IsRealNumber"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsRealNumber<TSelf>(this TSelf value)
        where TSelf : INumberBase<TSelf> =>
        TSelf.IsRealNumber(value);
    /// <inheritdoc cref="INumberBase{TSelf}.IsSubnormal"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsSubnormal<TSelf>(this TSelf value)
        where TSelf : INumberBase<TSelf> =>
        TSelf.IsSubnormal(value);
    /// <inheritdoc cref="INumberBase{TSelf}.IsZero"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsZero<TSelf>(this TSelf value)
        where TSelf : INumberBase<TSelf> =>
        TSelf.IsZero(value);
    /// <inheritdoc cref="IBinaryInteger{TSelf}.GetByteCount"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int GetByteCount<TSelf>(this TSelf x)
        where TSelf : IBinaryInteger<TSelf> =>
        x.GetByteCount();
    /// <inheritdoc cref="IBinaryInteger{TSelf}.WriteBigEndian(byte[])"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int WriteBigEndian<TSelf>(this TSelf value, byte[] destination)
        where TSelf : IBinaryInteger<TSelf> =>
        value.WriteBigEndian(destination);
    /// <inheritdoc cref="IBinaryInteger{TSelf}.WriteBigEndian(byte[], int)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int WriteBigEndian<TSelf>(this TSelf value, byte[] destination, int startIndex)
        where TSelf : IBinaryInteger<TSelf> =>
        value.WriteBigEndian(destination, startIndex);
    /// <inheritdoc cref="IBinaryInteger{TSelf}.WriteBigEndian(Span{byte})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int WriteBigEndian<TSelf>(this TSelf value, Span<byte> destination)
        where TSelf : IBinaryInteger<TSelf> =>
        value.WriteBigEndian(destination);
    /// <inheritdoc cref="IBinaryInteger{TSelf}.WriteLittleEndian(byte[])"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int WriteLittleEndian<TSelf>(this TSelf value, byte[] destination)
        where TSelf : IBinaryInteger<TSelf> =>
        value.WriteLittleEndian(destination);
    /// <inheritdoc cref="IBinaryInteger{TSelf}.WriteLittleEndian(byte[], int)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int WriteLittleEndian<TSelf>(this TSelf value, byte[] destination, int startIndex)
        where TSelf : IBinaryInteger<TSelf> =>
        value.WriteLittleEndian(destination, startIndex);
    /// <inheritdoc cref="IBinaryInteger{TSelf}.WriteLittleEndian(Span{byte})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int WriteLittleEndian<TSelf>(this TSelf value, Span<byte> destination)
        where TSelf : IBinaryInteger<TSelf> =>
        value.WriteLittleEndian(destination);
    /// <inheritdoc cref="IBinaryInteger{TSelf}.GetShortestBitLength"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int GetShortestBitLength<TSelf>(this TSelf x)
        where TSelf : IBinaryInteger<TSelf> =>
        x.GetShortestBitLength();
    /// <inheritdoc cref="IFloatingPoint{TSelf}.GetExponentByteCount"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int GetExponentByteCount<TSelf>(this TSelf x)
        where TSelf : IFloatingPoint<TSelf> =>
        x.GetExponentByteCount();
    /// <inheritdoc cref="IFloatingPoint{TSelf}.GetExponentShortestBitLength"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int GetExponentShortestBitLength<TSelf>(this TSelf x)
        where TSelf : IFloatingPoint<TSelf> =>
        x.GetExponentShortestBitLength();
    /// <inheritdoc cref="IFloatingPoint{TSelf}.GetSignificandBitLength"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int GetSignificandBitLength<TSelf>(this TSelf x)
        where TSelf : IFloatingPoint<TSelf> =>
        x.GetSignificandBitLength();
    /// <inheritdoc cref="IFloatingPoint{TSelf}.GetSignificandByteCount"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int GetSignificandByteCount<TSelf>(this TSelf x)
        where TSelf : IFloatingPoint<TSelf> =>
        x.GetSignificandByteCount();
    /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.ILogB"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int ILogB<TSelf>(TSelf x)
        where TSelf : IFloatingPointIeee754<TSelf> =>
        TSelf.ILogB(x);
    /// <inheritdoc cref="INumberBase{TSelf}.Radix"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int Radix<TSelf>()
        where TSelf : INumberBase<TSelf> =>
        TSelf.Radix;
    /// <inheritdoc cref="INumber{TSelf}.Sign"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int Sign<TSelf>(this TSelf value)
        where TSelf : INumber<TSelf> =>
        TSelf.Sign(value);
    /// <inheritdoc cref="INumberBase{TSelf}.Zero"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf AllBitsSet<TSelf>()
        where TSelf : IBinaryNumber<TSelf> =>
        TSelf.AllBitsSet;
    /// <inheritdoc cref="IBinaryNumber{TSelf}.Log2"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Log2<TSelf>(this TSelf value)
        where TSelf : IBinaryNumber<TSelf> =>
        TSelf.Log2(value);
    /// <inheritdoc cref="INumberBase{TSelf}.Abs"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Abs<TSelf>(this TSelf value)
        where TSelf : INumberBase<TSelf> =>
        TSelf.Abs(value);
    /// <inheritdoc cref="INumber{TSelf}.Clamp"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Clamp<TSelf>(this TSelf value, TSelf min, TSelf max)
        where TSelf : INumber<TSelf> =>
        TSelf.Clamp(value, min, max);
    /// <inheritdoc cref="INumberBase{TSelf}.Abs"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf CopySign<TSelf>(this TSelf value, TSelf sign)
        where TSelf : INumber<TSelf> =>
        TSelf.CopySign(value, sign);
    /// <inheritdoc cref="IExponentialFunctions{TSelf}.Exp"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Exp<TSelf>(this TSelf x)
        where TSelf : IExponentialFunctions<TSelf> =>
        TSelf.Exp(x);
    /// <inheritdoc cref="IExponentialFunctions{TSelf}.Exp10"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Exp10<TSelf>(this TSelf x)
        where TSelf : IExponentialFunctions<TSelf> =>
        TSelf.Exp10(x);
    /// <inheritdoc cref="IExponentialFunctions{TSelf}.Exp10M1"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Exp10M1<TSelf>(this TSelf x)
        where TSelf : IExponentialFunctions<TSelf> =>
        TSelf.Exp10M1(x);
    /// <inheritdoc cref="IExponentialFunctions{TSelf}.Exp2"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Exp2<TSelf>(this TSelf x)
        where TSelf : IExponentialFunctions<TSelf> =>
        TSelf.Exp2(x);
    /// <inheritdoc cref="IExponentialFunctions{TSelf}.Exp2M1"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Exp2M1<TSelf>(this TSelf x)
        where TSelf : IExponentialFunctions<TSelf> =>
        TSelf.Exp2M1(x);
    /// <inheritdoc cref="IExponentialFunctions{TSelf}.ExpM1"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf ExpM1<TSelf>(this TSelf x)
        where TSelf : IExponentialFunctions<TSelf> =>
        TSelf.ExpM1(x);
    /// <inheritdoc cref="IFloatingPoint{TSelf}.Ceiling"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Ceiling<TSelf>(this TSelf x)
        where TSelf : IFloatingPoint<TSelf> =>
        TSelf.Ceiling(x);
    /// <inheritdoc cref="IFloatingPoint{TSelf}.Floor"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Floor<TSelf>(this TSelf x)
        where TSelf : IFloatingPoint<TSelf> =>
        TSelf.Floor(x);
    /// <inheritdoc cref="IFloatingPoint{TSelf}.Round(TSelf)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Round<TSelf>(this TSelf x)
        where TSelf : IFloatingPoint<TSelf> =>
        TSelf.Round(x);
    /// <inheritdoc cref="IFloatingPoint{TSelf}.Round(TSelf, int)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Round<TSelf>(this TSelf x, int digits)
        where TSelf : IFloatingPoint<TSelf> =>
        TSelf.Round(x, digits);
    /// <inheritdoc cref="IFloatingPoint{TSelf}.Round(TSelf, int, MidpointRounding)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Round<TSelf>(this TSelf x, MidpointRounding mode)
        where TSelf : IFloatingPoint<TSelf> =>
        TSelf.Round(x, mode);
    /// <inheritdoc cref="IFloatingPoint{TSelf}.Round(TSelf, int, MidpointRounding)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Round<TSelf>(this TSelf x, int digits, MidpointRounding mode)
        where TSelf : IFloatingPoint<TSelf> =>
        TSelf.Round(x, digits, mode);
    /// <inheritdoc cref="IFloatingPoint{TSelf}.Truncate(TSelf)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Truncate<TSelf>(this TSelf x)
        where TSelf : IFloatingPoint<TSelf> =>
        TSelf.Truncate(x);
    /// <inheritdoc cref="IFloatingPoint{TSelf}.TryWriteExponentBigEndian(Span{byte}, out int)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool TryWriteExponentBigEndian<TSelf>(this TSelf x, Span<byte> destination, out int bytesWritten)
        where TSelf : IFloatingPoint<TSelf> =>
        x.TryWriteExponentBigEndian(destination, out bytesWritten);
    /// <inheritdoc cref="IFloatingPoint{TSelf}.TryWriteExponentBigEndian(Span{byte}, out int)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool TryWriteExponentLittleEndian<TSelf>(this TSelf x, Span<byte> destination, out int bytesWritten)
        where TSelf : IFloatingPoint<TSelf> =>
        x.TryWriteExponentLittleEndian(destination, out bytesWritten);
    /// <inheritdoc cref="IFloatingPoint{TSelf}.TryWriteSignificandBigEndian(Span{byte}, out int)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool TryWriteSignificandBigEndian<TSelf>(this TSelf x, Span<byte> destination, out int bytesWritten)
        where TSelf : IFloatingPoint<TSelf> =>
        x.TryWriteExponentLittleEndian(destination, out bytesWritten);
    /// <inheritdoc cref="IFloatingPoint{TSelf}.TryWriteSignificandLittleEndian(Span{byte}, out int)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool TryWriteSignificandLittleEndian<TSelf>(
        this TSelf x,
        Span<byte> destination,
        out int bytesWritten
    )
        where TSelf : IFloatingPoint<TSelf> =>
        x.TryWriteSignificandLittleEndian(destination, out bytesWritten);
    /// <inheritdoc cref="IFloatingPoint{TSelf}.WriteExponentBigEndian(byte[], int)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int WriteExponentBigEndian<TSelf>(this TSelf x, byte[] destination)
        where TSelf : IFloatingPoint<TSelf> =>
        x.WriteExponentBigEndian(destination);
    /// <inheritdoc cref="IFloatingPoint{TSelf}.WriteExponentBigEndian(byte[], int)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int WriteExponentBigEndian<TSelf>(this TSelf x, byte[] destination, int startIndex)
        where TSelf : IFloatingPoint<TSelf> =>
        x.WriteExponentBigEndian(destination, startIndex);
    /// <inheritdoc cref="IFloatingPoint{TSelf}.WriteExponentBigEndian(Span{byte})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int WriteExponentBigEndian<TSelf>(this TSelf x, Span<byte> destination)
        where TSelf : IFloatingPoint<TSelf> =>
        x.WriteExponentBigEndian(destination);
    /// <inheritdoc cref="IFloatingPoint{TSelf}.WriteExponentLittleEndian(byte[], int)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int WriteExponentLittleEndian<TSelf>(this TSelf x, byte[] destination)
        where TSelf : IFloatingPoint<TSelf> =>
        x.WriteExponentBigEndian(destination);
    /// <inheritdoc cref="IFloatingPoint{TSelf}.WriteExponentLittleEndian(byte[], int)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int WriteExponentLittleEndian<TSelf>(this TSelf x, byte[] destination, int startIndex)
        where TSelf : IFloatingPoint<TSelf> =>
        x.WriteExponentBigEndian(destination, startIndex);
    /// <inheritdoc cref="IFloatingPoint{TSelf}.WriteExponentLittleEndian(Span{byte})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int WriteExponentLittleEndian<TSelf>(this TSelf x, Span<byte> destination)
        where TSelf : IFloatingPoint<TSelf> =>
        x.WriteExponentBigEndian(destination);
    /// <inheritdoc cref="IFloatingPoint{TSelf}.WriteSignificandBigEndian(byte[], int)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int WriteSignificandBigEndian<TSelf>(this TSelf x, byte[] destination)
        where TSelf : IFloatingPoint<TSelf> =>
        x.WriteSignificandBigEndian(destination);
    /// <inheritdoc cref="IFloatingPoint{TSelf}.WriteSignificandBigEndian(byte[], int)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int WriteSignificandBigEndian<TSelf>(this TSelf x, byte[] destination, int startIndex)
        where TSelf : IFloatingPoint<TSelf> =>
        x.WriteSignificandBigEndian(destination, startIndex);
    /// <inheritdoc cref="IFloatingPoint{TSelf}.WriteSignificandBigEndian(Span{byte})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int WriteSignificandBigEndian<TSelf>(this TSelf x, Span<byte> destination)
        where TSelf : IFloatingPoint<TSelf> =>
        x.WriteSignificandBigEndian(destination);
    /// <inheritdoc cref="IFloatingPoint{TSelf}.WriteSignificandLittleEndian(byte[], int)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int WriteSignificandLittleEndian<TSelf>(this TSelf x, byte[] destination)
        where TSelf : IFloatingPoint<TSelf> =>
        x.WriteSignificandLittleEndian(destination);
    /// <inheritdoc cref="IFloatingPoint{TSelf}.WriteSignificandLittleEndian(byte[], int)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int WriteSignificandLittleEndian<TSelf>(this TSelf x, byte[] destination, int startIndex)
        where TSelf : IFloatingPoint<TSelf> =>
        x.WriteSignificandLittleEndian(destination, startIndex);
    /// <inheritdoc cref="IFloatingPoint{TSelf}.WriteSignificandLittleEndian(Span{byte})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int WriteSignificandLittleEndian<TSelf>(this TSelf x, Span<byte> destination)
        where TSelf : IFloatingPoint<TSelf> =>
        x.WriteSignificandLittleEndian(destination);
    /// <inheritdoc cref="IBinaryInteger{TSelf}.LeadingZeroCount"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf LeadingZeroCount<TSelf>(this TSelf x)
        where TSelf : IBinaryInteger<TSelf> =>
        TSelf.LeadingZeroCount(x);
    /// <inheritdoc cref="IBinaryInteger{TSelf}.PopCount"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf PopCount<TSelf>(this TSelf x)
        where TSelf : IBinaryInteger<TSelf> =>
        TSelf.PopCount(x);
    /// <inheritdoc cref="IBinaryInteger{TSelf}.ReadBigEndian(byte[], bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf ReadBigEndian<TSelf>(this byte[] source, bool isUnsigned)
        where TSelf : IBinaryInteger<TSelf> =>
        TSelf.ReadBigEndian(source, isUnsigned);
    /// <inheritdoc cref="IBinaryInteger{TSelf}.ReadBigEndian(byte[], int, bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf ReadBigEndian<TSelf>(this byte[] source, int startIndex, bool isUnsigned)
        where TSelf : IBinaryInteger<TSelf> =>
        TSelf.ReadBigEndian(source, startIndex, isUnsigned);
    /// <inheritdoc cref="IBinaryInteger{TSelf}.ReadBigEndian(ReadOnlySpan{byte}, bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf ReadBigEndian<TSelf>(this ReadOnlySpan<byte> source, bool isUnsigned)
        where TSelf : IBinaryInteger<TSelf> =>
        TSelf.ReadBigEndian(source, isUnsigned);
    /// <inheritdoc cref="IBinaryInteger{TSelf}.ReadLittleEndian(byte[], bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf ReadLittleEndian<TSelf>(this byte[] source, bool isUnsigned)
        where TSelf : IBinaryInteger<TSelf> =>
        TSelf.ReadLittleEndian(source, isUnsigned);
    /// <inheritdoc cref="IBinaryInteger{TSelf}.ReadLittleEndian(byte[], int, bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf ReadLittleEndian<TSelf>(this byte[] source, int startIndex, bool isUnsigned)
        where TSelf : IBinaryInteger<TSelf> =>
        TSelf.ReadLittleEndian(source, startIndex, isUnsigned);
    /// <inheritdoc cref="IBinaryInteger{TSelf}.ReadLittleEndian(ReadOnlySpan{byte}, bool)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf ReadLittleEndian<TSelf>(this ReadOnlySpan<byte> source, bool isUnsigned)
        where TSelf : IBinaryInteger<TSelf> =>
        TSelf.ReadLittleEndian(source, isUnsigned);
    /// <inheritdoc cref="IBinaryInteger{TSelf}.RotateLeft"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf RotateLeft<TSelf>(this TSelf value, int rotateAmount)
        where TSelf : IBinaryInteger<TSelf> =>
        TSelf.RotateLeft(value, rotateAmount);
    /// <inheritdoc cref="IBinaryInteger{TSelf}.RotateRight"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf RotateRight<TSelf>(this TSelf value, int rotateAmount)
        where TSelf : IBinaryInteger<TSelf> =>
        TSelf.RotateRight(value, rotateAmount);
    /// <inheritdoc cref="IBinaryInteger{TSelf}.TrailingZeroCount"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf TrailingZeroCount<TSelf>(this TSelf value)
        where TSelf : IBinaryInteger<TSelf> =>
        TSelf.TrailingZeroCount(value);
    /// <inheritdoc cref="IFloatingPointConstants{TSelf}.E"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf E<TSelf>()
        where TSelf : IFloatingPointConstants<TSelf> =>
        TSelf.E;
    /// <inheritdoc cref="IFloatingPointConstants{TSelf}.Pi"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Pi<TSelf>()
        where TSelf : IFloatingPointConstants<TSelf> =>
        TSelf.Pi;
    /// <inheritdoc cref="IFloatingPointConstants{TSelf}.Tau"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Tau<TSelf>()
        where TSelf : IFloatingPointConstants<TSelf> =>
        TSelf.Tau;
    /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.Epsilon"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Epsilon<TSelf>()
        where TSelf : IFloatingPointIeee754<TSelf> =>
        TSelf.Epsilon;
    /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.NaN"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf NaN<TSelf>()
        where TSelf : IFloatingPointIeee754<TSelf> =>
        TSelf.NaN;
    /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.NegativeInfinity"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf NegativeInfinity<TSelf>()
        where TSelf : IFloatingPointIeee754<TSelf> =>
        TSelf.NegativeInfinity;
    /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.NegativeZero"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf NegativeZero<TSelf>()
        where TSelf : IFloatingPointIeee754<TSelf> =>
        TSelf.NegativeZero;
    /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf PositiveInfinity<TSelf>()
        where TSelf : IFloatingPointIeee754<TSelf> =>
        TSelf.PositiveInfinity;
    /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.Atan2"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Atan2<TSelf>(TSelf y, TSelf x)
        where TSelf : IFloatingPointIeee754<TSelf> =>
        TSelf.Atan2(y, x);
    /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.Atan2Pi"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Atan2Pi<TSelf>(TSelf y, TSelf x)
        where TSelf : IFloatingPointIeee754<TSelf> =>
        TSelf.Atan2Pi(y, x);
    /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.BitDecrement"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf BitDecrement<TSelf>(TSelf x)
        where TSelf : IFloatingPointIeee754<TSelf> =>
        TSelf.BitDecrement(x);
    /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.BitIncrement"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf BitIncrement<TSelf>(TSelf x)
        where TSelf : IFloatingPointIeee754<TSelf> =>
        TSelf.BitIncrement(x);
    /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.FusedMultiplyAdd"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf FusedMultiplyAdd<TSelf>(TSelf left, TSelf right, TSelf addend)
        where TSelf : IFloatingPointIeee754<TSelf> =>
        TSelf.FusedMultiplyAdd(left, right, addend);
    /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.Ieee754Remainder"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Ieee754Remainder<TSelf>(TSelf left, TSelf right)
        where TSelf : IFloatingPointIeee754<TSelf> =>
        TSelf.Ieee754Remainder(left, right);
#if NET8_0_OR_GREATER
    /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.Lerp"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Lerp<TSelf>(TSelf value1, TSelf value2, TSelf amount)
        where TSelf : IFloatingPointIeee754<TSelf> =>
        TSelf.Lerp(value1, value2, amount);
#endif
    /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.ReciprocalEstimate"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf ReciprocalEstimate<TSelf>(TSelf x)
        where TSelf : IFloatingPointIeee754<TSelf> =>
        TSelf.ReciprocalEstimate(x);
    /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.ReciprocalSqrtEstimate"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf ReciprocalSqrtEstimate<TSelf>(TSelf x)
        where TSelf : IFloatingPointIeee754<TSelf> =>
        TSelf.ReciprocalSqrtEstimate(x);
    /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.ScaleB"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf ScaleB<TSelf>(TSelf x, int n)
        where TSelf : IFloatingPointIeee754<TSelf> =>
        TSelf.ScaleB(x, n);
    /// <inheritdoc cref="IHyperbolicFunctions{TSelf}.Acosh"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Acosh<TSelf>(this TSelf x)
        where TSelf : IHyperbolicFunctions<TSelf> =>
        TSelf.Acosh(x);
    /// <inheritdoc cref="IHyperbolicFunctions{TSelf}.Asinh"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Asinh<TSelf>(this TSelf x)
        where TSelf : IHyperbolicFunctions<TSelf> =>
        TSelf.Asinh(x);
    /// <inheritdoc cref="IHyperbolicFunctions{TSelf}.Atanh"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Atanh<TSelf>(this TSelf x)
        where TSelf : IHyperbolicFunctions<TSelf> =>
        TSelf.Atanh(x);
    /// <inheritdoc cref="IHyperbolicFunctions{TSelf}.Cosh"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Cosh<TSelf>(this TSelf x)
        where TSelf : IHyperbolicFunctions<TSelf> =>
        TSelf.Cosh(x);
    /// <inheritdoc cref="IHyperbolicFunctions{TSelf}.Sinh"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Sinh<TSelf>(this TSelf x)
        where TSelf : IHyperbolicFunctions<TSelf> =>
        TSelf.Sinh(x);
    /// <inheritdoc cref="IHyperbolicFunctions{TSelf}.Tanh"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Tanh<TSelf>(this TSelf x)
        where TSelf : IHyperbolicFunctions<TSelf> =>
        TSelf.Tanh(x);
    /// <inheritdoc cref="ILogarithmicFunctions{TSelf}.Log(TSelf)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Log<TSelf>(this TSelf x)
        where TSelf : ILogarithmicFunctions<TSelf> =>
        TSelf.Log(x);
    /// <inheritdoc cref="ILogarithmicFunctions{TSelf}.Log(TSelf, TSelf)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Log<TSelf>(this TSelf x, TSelf newBase)
        where TSelf : ILogarithmicFunctions<TSelf> =>
        TSelf.Log(x, newBase);
    /// <inheritdoc cref="ILogarithmicFunctions{TSelf}.LogP1"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf LogP1<TSelf>(this TSelf x)
        where TSelf : ILogarithmicFunctions<TSelf> =>
        TSelf.LogP1(x);
    /// <inheritdoc cref="ILogarithmicFunctions{TSelf}.Log2"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf LogTwo<TSelf>(this TSelf x)
        where TSelf : ILogarithmicFunctions<TSelf> =>
        TSelf.Log2(x);
    /// <inheritdoc cref="ILogarithmicFunctions{TSelf}.Log2P1"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Log2P1<TSelf>(this TSelf x)
        where TSelf : ILogarithmicFunctions<TSelf> =>
        TSelf.Log2P1(x);
    /// <inheritdoc cref="ILogarithmicFunctions{TSelf}.Log10"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Log10<TSelf>(this TSelf x)
        where TSelf : ILogarithmicFunctions<TSelf> =>
        TSelf.Log10(x);
    /// <inheritdoc cref="ILogarithmicFunctions{TSelf}.Log10P1"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Log10P1<TSelf>(this TSelf x)
        where TSelf : ILogarithmicFunctions<TSelf> =>
        TSelf.Log10P1(x);
#if NET9_0_OR_GREATER
    /// <inheritdoc cref="INumberBase{TSelf}.MultiplyAddEstimate"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf MultiplyAddEstimate<TSelf>(this TSelf left, TSelf right, TSelf addend)
        where TSelf : INumberBase<TSelf> =>
        TSelf.MultiplyAddEstimate(left, right, addend);
#endif
    /// <inheritdoc cref="INumber{TSelf}.Min"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Min<TSelf>(this TSelf x, TSelf y)
        where TSelf : INumber<TSelf> =>
        TSelf.Min(x, y);
    /// <inheritdoc cref="INumberBase{TSelf}.MinMagnitude"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf MinMagnitude<TSelf>(this TSelf x, TSelf y)
        where TSelf : INumberBase<TSelf> =>
        TSelf.MinMagnitude(x, y);
    /// <inheritdoc cref="INumberBase{TSelf}.MinMagnitudeNumber"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf MinMagnitudeNumber<TSelf>(this TSelf x, TSelf y)
        where TSelf : INumberBase<TSelf> =>
        TSelf.MinMagnitudeNumber(x, y);
    /// <inheritdoc cref="INumber{TSelf}.MinNumber"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf MinNumber<TSelf>(this TSelf value, TSelf sign)
        where TSelf : INumber<TSelf> =>
        TSelf.MinNumber(value, sign);
    /// <inheritdoc cref="INumber{TSelf}.Max"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Max<TSelf>(this TSelf x, TSelf y)
        where TSelf : INumber<TSelf> =>
        TSelf.Max(x, y);
    /// <inheritdoc cref="INumberBase{TSelf}.MaxMagnitude"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf MaxMagnitude<TSelf>(this TSelf x, TSelf y)
        where TSelf : INumberBase<TSelf> =>
        TSelf.MaxMagnitude(x, y);
    /// <inheritdoc cref="INumberBase{TSelf}.MaxMagnitudeNumber"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf MaxMagnitudeNumber<TSelf>(this TSelf x, TSelf y)
        where TSelf : INumberBase<TSelf> =>
        TSelf.MaxMagnitudeNumber(x, y);
    /// <inheritdoc cref="INumber{TSelf}.MaxNumber"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf MaxNumber<TSelf>(this TSelf x, TSelf y)
        where TSelf : INumber<TSelf> =>
        TSelf.MaxNumber(x, y);
    /// <inheritdoc cref="INumberBase{TSelf}.One"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf One<TSelf>()
        where TSelf : INumberBase<TSelf> =>
        TSelf.One;
    /// <inheritdoc cref="INumberBase{TSelf}.Zero"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Zero<TSelf>()
        where TSelf : INumberBase<TSelf> =>
        TSelf.Zero;
    /// <inheritdoc cref="IPowerFunctions{TSelf}.Pow"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Pow<TSelf>(this TSelf x, TSelf y)
        where TSelf : IPowerFunctions<TSelf> =>
        TSelf.Pow(x, y);
    /// <inheritdoc cref="IRootFunctions{TSelf}.Cbrt"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Cbrt<TSelf>(this TSelf x)
        where TSelf : IRootFunctions<TSelf> =>
        TSelf.Cbrt(x);
    /// <inheritdoc cref="IRootFunctions{TSelf}.Hypot"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Hypot<TSelf>(this TSelf x, TSelf y)
        where TSelf : IRootFunctions<TSelf> =>
        TSelf.Hypot(x, y);
    /// <inheritdoc cref="IRootFunctions{TSelf}.RootN"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf RootN<TSelf>(this TSelf x, int n)
        where TSelf : IRootFunctions<TSelf> =>
        TSelf.RootN(x, n);
    /// <inheritdoc cref="IRootFunctions{TSelf}.Sqrt"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Sqrt<TSelf>(this TSelf x)
        where TSelf : IRootFunctions<TSelf> =>
        TSelf.Sqrt(x);
    /// <inheritdoc cref="ISignedNumber{TSelf}.NegativeOne"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf NegativeOne<TSelf>()
        where TSelf : ISignedNumber<TSelf> =>
        TSelf.NegativeOne;
    /// <inheritdoc cref="ITrigonometricFunctions{TSelf}.Acos"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Acos<TSelf>(this TSelf x)
        where TSelf : ITrigonometricFunctions<TSelf> =>
        TSelf.Acos(x);
    /// <inheritdoc cref="ITrigonometricFunctions{TSelf}.AcosPi"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf AcosPi<TSelf>(this TSelf x)
        where TSelf : ITrigonometricFunctions<TSelf> =>
        TSelf.AcosPi(x);
    /// <inheritdoc cref="ITrigonometricFunctions{TSelf}.Asin"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Asin<TSelf>(this TSelf x)
        where TSelf : ITrigonometricFunctions<TSelf> =>
        TSelf.Asin(x);
    /// <inheritdoc cref="ITrigonometricFunctions{TSelf}.AsinPi"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf AsinPi<TSelf>(this TSelf x)
        where TSelf : ITrigonometricFunctions<TSelf> =>
        TSelf.AsinPi(x);
    /// <inheritdoc cref="ITrigonometricFunctions{TSelf}.Atan"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Atan<TSelf>(this TSelf x)
        where TSelf : ITrigonometricFunctions<TSelf> =>
        TSelf.Atan(x);
    /// <inheritdoc cref="ITrigonometricFunctions{TSelf}.AtanPi"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf AtanPi<TSelf>(this TSelf x)
        where TSelf : ITrigonometricFunctions<TSelf> =>
        TSelf.AtanPi(x);
    /// <inheritdoc cref="ITrigonometricFunctions{TSelf}.Cos"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Cos<TSelf>(this TSelf x)
        where TSelf : ITrigonometricFunctions<TSelf> =>
        TSelf.Cos(x);
    /// <inheritdoc cref="ITrigonometricFunctions{TSelf}.CosPi"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf CosPi<TSelf>(this TSelf x)
        where TSelf : ITrigonometricFunctions<TSelf> =>
        TSelf.CosPi(x);
#if NET8_0_OR_GREATER
    /// <inheritdoc cref="ITrigonometricFunctions{TSelf}.DegreesToRadians"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf DegreesToRadians<TSelf>(this TSelf x)
        where TSelf : ITrigonometricFunctions<TSelf> =>
        TSelf.DegreesToRadians(x);
    /// <inheritdoc cref="ITrigonometricFunctions{TSelf}.RadiansToDegrees"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf RadiansToDegrees<TSelf>(this TSelf x)
        where TSelf : ITrigonometricFunctions<TSelf> =>
        TSelf.RadiansToDegrees(x);
#endif
    /// <inheritdoc cref="ITrigonometricFunctions{TSelf}.Sin"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Sin<TSelf>(this TSelf x)
        where TSelf : ITrigonometricFunctions<TSelf> =>
        TSelf.Sin(x);
    /// <inheritdoc cref="ITrigonometricFunctions{TSelf}.SinPi"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf SinPi<TSelf>(this TSelf x)
        where TSelf : ITrigonometricFunctions<TSelf> =>
        TSelf.SinPi(x);
    /// <inheritdoc cref="ITrigonometricFunctions{TSelf}.Tan"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf Tan<TSelf>(this TSelf x)
        where TSelf : ITrigonometricFunctions<TSelf> =>
        TSelf.Tan(x);
    /// <inheritdoc cref="ITrigonometricFunctions{TSelf}.TanPi"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TSelf TanPi<TSelf>(this TSelf x)
        where TSelf : ITrigonometricFunctions<TSelf> =>
        TSelf.TanPi(x);
    /// <inheritdoc cref="IBinaryInteger{TSelf}.DivRem"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static (TSelf Quotient, TSelf Remainder) DivRem<TSelf>(this TSelf left, TSelf right)
        where TSelf : IBinaryInteger<TSelf> =>
        TSelf.DivRem(left, right);
    /// <inheritdoc cref="ITrigonometricFunctions{TSelf}.SinCos"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static (TSelf Sin, TSelf Cos) SinCos<TSelf>(this TSelf x)
        where TSelf : ITrigonometricFunctions<TSelf> =>
        TSelf.SinCos(x);
    /// <inheritdoc cref="ITrigonometricFunctions{TSelf}.SinCosPi"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static (TSelf Sin, TSelf Cos) SinCosPi<TSelf>(this TSelf x)
        where TSelf : ITrigonometricFunctions<TSelf> =>
        TSelf.SinCosPi(x);
    /// <inheritdoc cref="INumberBase{TSelf}.CreateChecked{TOther}"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TOther CreateChecked<TSelf, TOther>(this TSelf value)
        where TSelf : INumberBase<TSelf>
        where TOther : INumberBase<TOther> =>
        TOther.CreateChecked(value);
    /// <inheritdoc cref="INumberBase{TSelf}.CreateSaturating{TOther}"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TOther CreateSaturating<TSelf, TOther>(this TSelf value)
        where TSelf : INumberBase<TSelf>
        where TOther : INumberBase<TOther> =>
        TOther.CreateSaturating(value);
    /// <inheritdoc cref="INumberBase{TSelf}.CreateTruncating{TOther}"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static TOther CreateTruncating<TSelf, TOther>(this TSelf value)
        where TSelf : INumberBase<TSelf>
        where TOther : INumberBase<TOther> =>
        TOther.CreateTruncating(value);
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable once CheckNamespace
/// <summary>Contains methods to convert HSV (Hue, Saturation, and Value) into color values.</summary>
    /// <summary>The alias for the maximum number that the <see langword="byte"/> can hold.</summary>
    const byte M = byte.MaxValue;
    /// <summary>Converts the HSV values to RGB.</summary>
    /// <remarks><para>
    /// Implementation based on
    /// <a href="https://github.com/SGauvin/HsvConverter/blob/master/HsvConverter.cpp">SGauvin's HsvConverter</a>.
    /// </para></remarks>
    /// <param name="hue">The hue, generally ranging from <c>0</c> to <c>1529</c>.</param>
    /// <param name="saturation">The saturation.</param>
    /// <param name="value">The value.</param>
    /// <returns>The RGB components of the HSV parameters.</returns>
    public static (byte, byte, byte) ToRgb(ushort hue, byte saturation = M, byte value = M) =>
        (hue %= M * 6) switch
        {
            < M => (value, (byte)(V(hue % M, saturation) * value / M), (byte)((M - saturation) * value / M)),
            < M * 2 => ((byte)(V(M - hue % M, saturation) * value / M), value, (byte)((M - saturation) * value / M)),
            < M * 3 => ((byte)((M - saturation) * value / M), value, (byte)(V(hue % M, saturation) * value / M)),
            < M * 4 => ((byte)((M - saturation) * value / M), (byte)(V(M - hue % M, saturation) * value / M), value),
            < M * 5 => ((byte)(V(hue % M, saturation) * value / M), (byte)((M - saturation) * value / M), value),
            _ => (value, (byte)((M - saturation) * value / M), (byte)(V(M - hue % M, saturation) * value / M)),
        };
#if NET7_0_OR_GREATER
    /// <summary>Converts the HSV values to RGB.</summary>
    /// <remarks><para>
    /// Implementation based on
    /// <a href="https://github.com/SGauvin/HsvConverter/blob/master/HsvConverter.cpp">SGauvin's HsvConverter</a>.
    /// </para></remarks>
    /// <param name="hue">The hue, generally ranging from <c>0</c> to <c>1529</c>.</param>
    /// <param name="saturation">The saturation.</param>
    /// <param name="value">The value.</param>
    /// <returns>The RGB components of the HSV parameters.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static (byte, byte, byte) ToRgb<T>(this T hue, byte saturation = M, byte value = M)
        where T : IComparisonOperators<T, T, bool>, IModulusOperators<T, T, T>, INumberBase<T> =>
        ToRgb(ushort.CreateChecked(hue.Mod(T.CreateChecked(M * 6))), saturation, value);
#endif
#if XNA
    /// <summary>Converts the HSV values to <see cref="Color"/>.</summary>
    /// <remarks><para>
    /// Implementation based on
    /// <a href="https://github.com/SGauvin/HsvConverter/blob/master/HsvConverter.cpp">SGauvin's HsvConverter</a>.
    /// </para></remarks>
    /// <param name="hue">The hue, generally ranging from <c>0</c> to <c>1529</c>.</param>
    /// <param name="saturation">The saturation.</param>
    /// <param name="value">The value.</param>
    /// <param name="alpha">The alpha channel.</param>
    /// <returns>The RGB components of the HSV parameters.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Color ToColor(ushort hue, byte saturation = M, byte value = M, byte alpha = M)
    {
        var (r, g, b) = ToRgb(hue, saturation, value);
        return new(r, g, b, alpha);
    }
#if NET7_0_OR_GREATER
    /// <summary>Converts the HSV values to RGB.</summary>
    /// <remarks><para>
    /// Implementation based on
    /// <a href="https://github.com/SGauvin/HsvConverter/blob/master/HsvConverter.cpp">SGauvin's HsvConverter</a>.
    /// </para></remarks>
    /// <param name="hue">The hue, generally ranging from <c>0</c> to <c>1529</c>.</param>
    /// <param name="saturation">The saturation.</param>
    /// <param name="value">The value.</param>
    /// <param name="alpha">The alpha channel.</param>
    /// <returns>The RGB components of the HSV parameters.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Color ToColor<T>(this T hue, byte saturation = M, byte value = M, byte alpha = M)
        where T : IComparisonOperators<T, T, bool>, IModulusOperators<T, T, T>, INumberBase<T> =>
        ToColor(ushort.CreateChecked(hue.Mod(T.CreateChecked(M * 6))), saturation, value, alpha);
#endif
#endif
    /// <summary>Computes the value for one of the RGB channels.</summary>
    /// <remarks><para>
    /// Implementation based on
    /// <a href="https://github.com/SGauvin/HsvConverter/blob/master/HsvConverter.cpp">SGauvin's HsvConverter</a>.
    /// </para></remarks>
    /// <param name="color">The color.</param>
    /// <param name="saturation">The saturation.</param>
    /// <returns>The value for the RGB channel.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    static byte V(int color, byte saturation) => (byte)((byte)color + (M - saturation) * (M - (byte)color) / M);
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable once CheckNamespace
[StructLayout(LayoutKind.Sequential)]
public sealed class Pinnable<T>
{
#if !(NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) || NO_SYSTEM_MEMORY
    public static Pinnable<T> Default { get; } = new();
#endif
    public T Data = default!;
}
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable CheckNamespace RedundantUsingDirective
/// <summary>Extension methods to attempt to grab the length from enumerables.</summary>
    /// <summary>Tries to count the elements in the enumerable.</summary>
    /// <typeparam name="T">The type of element in the <see cref="IEnumerable{T}"/>.</typeparam>
    /// <param name="enumerable">The enumerable to count.</param>
    /// <returns>
    /// If relatively cheap to compute, the number of elements in the parameter
    /// <paramref name="enumerable"/>; otherwise, <see langword="null"/>.</returns>
    [NonNegativeValue]
    public static int? TryCount<T>([NoEnumeration] this IEnumerable<T>? enumerable) =>
        enumerable switch
        {
            null => null,
            string { Length: var length } => length,
            IReadOnlyCollection<T> { Count: var count } => count,
            _ => enumerable.TryGetNonEnumeratedCount(out var count) ? count : null,
        };
// SPDX-License-Identifier: MPL-2.0
#if (NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) && !NO_SYSTEM_MEMORY
#pragma warning disable CS8500, IDE0004, MA0051
// ReSharper disable BadPreprocessorIndent CheckNamespace CognitiveComplexity RedundantCast StructCanBeMadeReadOnly
/// <inheritdoc cref="Bits{T}"/>
#if CSHARPREPL
public
#endif
#if !NO_READONLY_STRUCTS
readonly
#endif
    partial struct Bits<T>
{
    /// <summary>Computes the Bitwise-AND computation, writing it to the second argument.</summary>
    /// <param name="read">The <typeparamref name="T"/> to read from.</param>
    /// <param name="write">The <typeparamref name="T"/> to write to.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void And(scoped in T read, scoped ref T write)
    {
        ref byte l = ref Unsafe.As<T, byte>(ref AsRef(read)),
            r = ref Unsafe.As<T, byte>(ref AsRef(write)),
            upper = ref Unsafe.Add(ref l, Unsafe.SizeOf<T>());
#if NET8_0_OR_GREATER
        if (Vector512.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 64)
        {
            while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, 63)))
            {
                Vector512.BitwiseAnd(Vector512.LoadUnsafe(ref l), Vector512.LoadUnsafe(ref r)).StoreUnsafe(ref r);
                l = ref Unsafe.Add(ref l, 64);
                r = ref Unsafe.Add(ref r, 64);
            }
            if (Unsafe.SizeOf<T>() % 64 is 0)
                return;
        }
#endif
#if NET7_0_OR_GREATER
        if (Vector256.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 32)
        {
            while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, 31)))
            {
                Vector256.BitwiseAnd(Vector256.LoadUnsafe(ref l), Vector256.LoadUnsafe(ref r)).StoreUnsafe(ref r);
                l = ref Unsafe.Add(ref l, 32);
                r = ref Unsafe.Add(ref r, 32);
            }
            if (Unsafe.SizeOf<T>() % 32 is 0)
                return;
        }
        if (Vector128.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 16)
        {
            while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, 15)))
            {
                Vector128.BitwiseAnd(Vector128.LoadUnsafe(ref l), Vector128.LoadUnsafe(ref r)).StoreUnsafe(ref r);
                l = ref Unsafe.Add(ref l, 16);
                r = ref Unsafe.Add(ref r, 16);
            }
            if (Unsafe.SizeOf<T>() % 16 is 0)
                return;
        }
        if (Vector64.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 8)
        {
            while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, 7)))
            {
                Vector64.BitwiseAnd(Vector64.LoadUnsafe(ref l), Vector64.LoadUnsafe(ref r)).StoreUnsafe(ref r);
                l = ref Unsafe.Add(ref l, 8);
                r = ref Unsafe.Add(ref r, 8);
            }
            if (Unsafe.SizeOf<T>() % 8 is 0)
                return;
        }
#endif
        while (Unsafe.IsAddressLessThan(
            ref l,
            ref Unsafe.SubtractByteOffset(ref upper, (nint)Unsafe.SizeOf<nuint>() - 1)
        ))
        {
            Unsafe.As<byte, nuint>(ref r) &= Unsafe.As<byte, nuint>(ref l);
            l = ref Unsafe.Add(ref l, (nint)Unsafe.SizeOf<nuint>());
            r = ref Unsafe.Add(ref r, (nint)Unsafe.SizeOf<nuint>());
        }
        while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, sizeof(ulong) - 1)))
        {
            Unsafe.As<byte, ulong>(ref r) &= Unsafe.As<byte, ulong>(ref l);
            l = ref Unsafe.Add(ref l, sizeof(ulong));
            r = ref Unsafe.Add(ref r, sizeof(ulong));
        }
        while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, sizeof(uint) - 1)))
        {
            Unsafe.As<byte, uint>(ref r) &= Unsafe.As<byte, uint>(ref l);
            l = ref Unsafe.Add(ref l, sizeof(uint));
            r = ref Unsafe.Add(ref r, sizeof(uint));
        }
        while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, sizeof(ushort) - 1)))
        {
            Unsafe.As<byte, ushort>(ref r) &= Unsafe.As<byte, ushort>(ref l);
            l = ref Unsafe.Add(ref l, sizeof(ushort));
            r = ref Unsafe.Add(ref r, sizeof(ushort));
        }
        while (Unsafe.IsAddressLessThan(ref l, ref upper))
        {
            Unsafe.As<byte, byte>(ref r) &= Unsafe.As<byte, byte>(ref l);
            l = ref Unsafe.Add(ref l, 1);
            r = ref Unsafe.Add(ref r, 1);
        }
    }
    /// <summary>Computes the Bitwise-AND-NOT computation, writing it to the second argument.</summary>
    /// <param name="read">The <typeparamref name="T"/> to read from.</param>
    /// <param name="write">The <typeparamref name="T"/> to write to.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void AndNot(scoped in T read, scoped ref T write)
    {
        ref byte l = ref Unsafe.As<T, byte>(ref AsRef(read)),
            r = ref Unsafe.As<T, byte>(ref AsRef(write)),
            upper = ref Unsafe.Add(ref l, Unsafe.SizeOf<T>());
#if NET8_0_OR_GREATER
        if (Vector512.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 64)
        {
            while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, 63)))
            {
                Vector512.AndNot(Vector512.LoadUnsafe(ref l), Vector512.LoadUnsafe(ref r)).StoreUnsafe(ref r);
                l = ref Unsafe.Add(ref l, 64);
                r = ref Unsafe.Add(ref r, 64);
            }
            if (Unsafe.SizeOf<T>() % 64 is 0)
                return;
        }
#endif
#if NET7_0_OR_GREATER
        if (Vector256.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 32)
        {
            while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, 31)))
            {
                Vector256.AndNot(Vector256.LoadUnsafe(ref l), Vector256.LoadUnsafe(ref r)).StoreUnsafe(ref r);
                l = ref Unsafe.Add(ref l, 32);
                r = ref Unsafe.Add(ref r, 32);
            }
            if (Unsafe.SizeOf<T>() % 32 is 0)
                return;
        }
        if (Vector128.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 16)
        {
            while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, 15)))
            {
                Vector128.AndNot(Vector128.LoadUnsafe(ref l), Vector128.LoadUnsafe(ref r)).StoreUnsafe(ref r);
                l = ref Unsafe.Add(ref l, 16);
                r = ref Unsafe.Add(ref r, 16);
            }
            if (Unsafe.SizeOf<T>() % 16 is 0)
                return;
        }
        if (Vector64.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 8)
        {
            while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, 7)))
            {
                Vector64.AndNot(Vector64.LoadUnsafe(ref l), Vector64.LoadUnsafe(ref r)).StoreUnsafe(ref r);
                l = ref Unsafe.Add(ref l, 8);
                r = ref Unsafe.Add(ref r, 8);
            }
            if (Unsafe.SizeOf<T>() % 8 is 0)
                return;
        }
#endif
        while (Unsafe.IsAddressLessThan(
            ref l,
            ref Unsafe.SubtractByteOffset(ref upper, (nint)Unsafe.SizeOf<nuint>() - 1)
        ))
        {
            Unsafe.As<byte, nuint>(ref r) &= ~Unsafe.As<byte, nuint>(ref l);
            l = ref Unsafe.Add(ref l, (nint)Unsafe.SizeOf<nuint>());
            r = ref Unsafe.Add(ref r, (nint)Unsafe.SizeOf<nuint>());
        }
        while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, sizeof(ulong) - 1)))
        {
            Unsafe.As<byte, ulong>(ref r) &= ~Unsafe.As<byte, ulong>(ref l);
            l = ref Unsafe.Add(ref l, sizeof(ulong));
            r = ref Unsafe.Add(ref r, sizeof(ulong));
        }
        while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, sizeof(uint) - 1)))
        {
            Unsafe.As<byte, uint>(ref r) &= ~Unsafe.As<byte, uint>(ref l);
            l = ref Unsafe.Add(ref l, sizeof(uint));
            r = ref Unsafe.Add(ref r, sizeof(uint));
        }
        while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, sizeof(ushort) - 1)))
        {
            Unsafe.As<byte, ushort>(ref r) &= (ushort)~Unsafe.As<byte, ushort>(ref l);
            l = ref Unsafe.Add(ref l, sizeof(ushort));
            r = ref Unsafe.Add(ref r, sizeof(ushort));
        }
        while (Unsafe.IsAddressLessThan(ref l, ref upper))
        {
            Unsafe.As<byte, byte>(ref r) &= (byte)~Unsafe.As<byte, byte>(ref l);
            l = ref Unsafe.Add(ref l, 1);
            r = ref Unsafe.Add(ref r, 1);
        }
    }
    /// <summary>Computes the Bitwise-NOT computation, writing it to the first argument.</summary>
    /// <param name="reference">The <typeparamref name="T"/> to read and write from.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void Not(scoped ref T reference)
    {
        ref byte x = ref Unsafe.As<T, byte>(ref AsRef(reference)), upper = ref Unsafe.Add(ref x, Unsafe.SizeOf<T>());
#if NET8_0_OR_GREATER
        if (Vector512.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 64)
        {
            while (Unsafe.IsAddressLessThan(ref x, ref Unsafe.SubtractByteOffset(ref upper, 63)))
            {
                Vector512.OnesComplement(Vector512.LoadUnsafe(ref x)).StoreUnsafe(ref x);
                x = ref Unsafe.Add(ref x, 64);
            }
            if (Unsafe.SizeOf<T>() % 64 is 0)
                return;
        }
#endif
#if NET7_0_OR_GREATER
        if (Vector256.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 32)
        {
            while (Unsafe.IsAddressLessThan(ref x, ref Unsafe.SubtractByteOffset(ref upper, 31)))
            {
                Vector256.OnesComplement(Vector256.LoadUnsafe(ref x)).StoreUnsafe(ref x);
                x = ref Unsafe.Add(ref x, 32);
            }
            if (Unsafe.SizeOf<T>() % 32 is 0)
                return;
        }
        if (Vector128.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 16)
        {
            while (Unsafe.IsAddressLessThan(ref x, ref Unsafe.SubtractByteOffset(ref upper, 15)))
            {
                Vector128.OnesComplement(Vector128.LoadUnsafe(ref x)).StoreUnsafe(ref x);
                x = ref Unsafe.Add(ref x, 16);
            }
            if (Unsafe.SizeOf<T>() % 16 is 0)
                return;
        }
        if (Vector64.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 8)
        {
            while (Unsafe.IsAddressLessThan(ref x, ref Unsafe.SubtractByteOffset(ref upper, 7)))
            {
                Vector64.OnesComplement(Vector64.LoadUnsafe(ref x)).StoreUnsafe(ref x);
                x = ref Unsafe.Add(ref x, 8);
            }
            if (Unsafe.SizeOf<T>() % 8 is 0)
                return;
        }
#endif
        while (Unsafe.IsAddressLessThan(
            ref x,
            ref Unsafe.SubtractByteOffset(ref upper, (nint)Unsafe.SizeOf<nuint>() - 1)
        ))
        {
            Unsafe.As<byte, nuint>(ref x) = ~Unsafe.As<byte, nuint>(ref x);
            x = ref Unsafe.Add(ref x, Unsafe.SizeOf<nuint>());
        }
        while (Unsafe.IsAddressLessThan(ref x, ref Unsafe.SubtractByteOffset(ref upper, sizeof(ulong) - 1)))
        {
            Unsafe.As<byte, ulong>(ref x) = ~Unsafe.As<byte, ulong>(ref x);
            x = ref Unsafe.Add(ref x, sizeof(ulong));
        }
        while (Unsafe.IsAddressLessThan(ref x, ref Unsafe.SubtractByteOffset(ref upper, sizeof(uint) - 1)))
        {
            Unsafe.As<byte, uint>(ref x) = ~Unsafe.As<byte, uint>(ref x);
            x = ref Unsafe.Add(ref x, sizeof(uint));
        }
        while (Unsafe.IsAddressLessThan(ref x, ref Unsafe.SubtractByteOffset(ref upper, sizeof(ushort) - 1)))
        {
            Unsafe.As<byte, ushort>(ref x) = (ushort)~Unsafe.As<byte, ushort>(ref x);
            x = ref Unsafe.Add(ref x, sizeof(ushort));
        }
        while (Unsafe.IsAddressLessThan(ref x, ref upper))
        {
            Unsafe.As<byte, byte>(ref x) &= (byte)~Unsafe.As<byte, byte>(ref x);
            x = ref Unsafe.Add(ref x, 1);
        }
    }
    /// <summary>Computes the Bitwise-OR computation, writing it to the second argument.</summary>
    /// <param name="read">The <typeparamref name="T"/> to read from.</param>
    /// <param name="write">The <typeparamref name="T"/> to write to.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void Or(scoped in T read, scoped ref T write)
    {
        ref byte l = ref Unsafe.As<T, byte>(ref AsRef(read)),
            r = ref Unsafe.As<T, byte>(ref AsRef(write)),
            upper = ref Unsafe.Add(ref l, Unsafe.SizeOf<T>());
#if NET8_0_OR_GREATER
        if (Vector512.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 64)
        {
            while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, 63)))
            {
                Vector512.BitwiseOr(Vector512.LoadUnsafe(ref l), Vector512.LoadUnsafe(ref r)).StoreUnsafe(ref r);
                l = ref Unsafe.Add(ref l, 64);
                r = ref Unsafe.Add(ref r, 64);
            }
            if (Unsafe.SizeOf<T>() % 64 is 0)
                return;
        }
#endif
#if NET7_0_OR_GREATER
        if (Vector256.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 32)
        {
            while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, 31)))
            {
                Vector256.BitwiseOr(Vector256.LoadUnsafe(ref l), Vector256.LoadUnsafe(ref r)).StoreUnsafe(ref r);
                l = ref Unsafe.Add(ref l, 32);
                r = ref Unsafe.Add(ref r, 32);
            }
            if (Unsafe.SizeOf<T>() % 32 is 0)
                return;
        }
        if (Vector128.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 16)
        {
            while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, 15)))
            {
                Vector128.BitwiseOr(Vector128.LoadUnsafe(ref l), Vector128.LoadUnsafe(ref r)).StoreUnsafe(ref r);
                l = ref Unsafe.Add(ref l, 16);
                r = ref Unsafe.Add(ref r, 16);
            }
            if (Unsafe.SizeOf<T>() % 16 is 0)
                return;
        }
        if (Vector64.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 8)
        {
            while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, 7)))
            {
                Vector64.BitwiseOr(Vector64.LoadUnsafe(ref l), Vector64.LoadUnsafe(ref r)).StoreUnsafe(ref r);
                l = ref Unsafe.Add(ref l, 8);
                r = ref Unsafe.Add(ref r, 8);
            }
            if (Unsafe.SizeOf<T>() % 8 is 0)
                return;
        }
#endif
        while (Unsafe.IsAddressLessThan(
            ref l,
            ref Unsafe.SubtractByteOffset(ref upper, (nint)Unsafe.SizeOf<nuint>() - 1)
        ))
        {
            Unsafe.As<byte, nuint>(ref r) |= Unsafe.As<byte, nuint>(ref l);
            l = ref Unsafe.Add(ref l, Unsafe.SizeOf<nuint>());
            r = ref Unsafe.Add(ref r, Unsafe.SizeOf<nuint>());
        }
        while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, sizeof(ulong) - 1)))
        {
            Unsafe.As<byte, ulong>(ref r) |= Unsafe.As<byte, ulong>(ref l);
            l = ref Unsafe.Add(ref l, sizeof(ulong));
            r = ref Unsafe.Add(ref r, sizeof(ulong));
        }
        while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, sizeof(uint) - 1)))
        {
            Unsafe.As<byte, uint>(ref r) |= Unsafe.As<byte, uint>(ref l);
            l = ref Unsafe.Add(ref l, sizeof(uint));
            r = ref Unsafe.Add(ref r, sizeof(uint));
        }
        while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, sizeof(ushort) - 1)))
        {
            Unsafe.As<byte, ushort>(ref r) |= Unsafe.As<byte, ushort>(ref l);
            l = ref Unsafe.Add(ref l, sizeof(ushort));
            r = ref Unsafe.Add(ref r, sizeof(ushort));
        }
        while (Unsafe.IsAddressLessThan(ref l, ref upper))
        {
            Unsafe.As<byte, byte>(ref r) |= Unsafe.As<byte, byte>(ref l);
            l = ref Unsafe.Add(ref l, 1);
            r = ref Unsafe.Add(ref r, 1);
        }
    }
    /// <summary>Computes the Bitwise-XOR computation, writing it to the second argument.</summary>
    /// <param name="read">The <typeparamref name="T"/> to read from.</param>
    /// <param name="write">The <typeparamref name="T"/> to write to.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void Xor(scoped in T read, scoped ref T write)
    {
        ref byte l = ref Unsafe.As<T, byte>(ref AsRef(read)),
            r = ref Unsafe.As<T, byte>(ref AsRef(write)),
            upper = ref Unsafe.Add(ref l, Unsafe.SizeOf<T>());
#if NET8_0_OR_GREATER
        if (Vector512.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 64)
        {
            while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, 63)))
            {
                Vector512.Xor(Vector512.LoadUnsafe(ref l), Vector512.LoadUnsafe(ref r)).StoreUnsafe(ref r);
                l = ref Unsafe.Add(ref l, 64);
                r = ref Unsafe.Add(ref r, 64);
            }
            if (Unsafe.SizeOf<T>() % 64 is 0)
                return;
        }
#endif
#if NET7_0_OR_GREATER
        if (Vector256.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 32)
        {
            while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, 31)))
            {
                Vector256.Xor(Vector256.LoadUnsafe(ref l), Vector256.LoadUnsafe(ref r)).StoreUnsafe(ref r);
                l = ref Unsafe.Add(ref l, 32);
                r = ref Unsafe.Add(ref r, 32);
            }
            if (Unsafe.SizeOf<T>() % 32 is 0)
                return;
        }
        if (Vector128.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 16)
        {
            while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, 15)))
            {
                Vector128.Xor(Vector128.LoadUnsafe(ref l), Vector128.LoadUnsafe(ref r)).StoreUnsafe(ref r);
                l = ref Unsafe.Add(ref l, 16);
                r = ref Unsafe.Add(ref r, 16);
            }
            if (Unsafe.SizeOf<T>() % 16 is 0)
                return;
        }
        if (Vector64.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 8)
        {
            while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, 7)))
            {
                Vector64.Xor(Vector64.LoadUnsafe(ref l), Vector64.LoadUnsafe(ref r)).StoreUnsafe(ref r);
                l = ref Unsafe.Add(ref l, 8);
                r = ref Unsafe.Add(ref r, 8);
            }
            if (Unsafe.SizeOf<T>() % 8 is 0)
                return;
        }
#endif
        while (Unsafe.IsAddressLessThan(
            ref l,
            ref Unsafe.SubtractByteOffset(ref upper, (nint)Unsafe.SizeOf<nuint>() - 1)
        ))
        {
            Unsafe.As<byte, nuint>(ref r) ^= Unsafe.As<byte, nuint>(ref l);
            l = ref Unsafe.Add(ref l, Unsafe.SizeOf<nuint>());
            r = ref Unsafe.Add(ref r, Unsafe.SizeOf<nuint>());
        }
        while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, sizeof(ulong) - 1)))
        {
            Unsafe.As<byte, ulong>(ref r) ^= Unsafe.As<byte, ulong>(ref l);
            l = ref Unsafe.Add(ref l, sizeof(ulong));
            r = ref Unsafe.Add(ref r, sizeof(ulong));
        }
        while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, sizeof(uint) - 1)))
        {
            Unsafe.As<byte, uint>(ref r) ^= Unsafe.As<byte, uint>(ref l);
            l = ref Unsafe.Add(ref l, sizeof(uint));
            r = ref Unsafe.Add(ref r, sizeof(uint));
        }
        while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, sizeof(ushort) - 1)))
        {
            Unsafe.As<byte, ushort>(ref r) ^= Unsafe.As<byte, ushort>(ref l);
            l = ref Unsafe.Add(ref l, sizeof(ushort));
            r = ref Unsafe.Add(ref r, sizeof(ushort));
        }
        while (Unsafe.IsAddressLessThan(ref l, ref upper))
        {
            Unsafe.As<byte, byte>(ref r) ^= Unsafe.As<byte, byte>(ref l);
            l = ref Unsafe.Add(ref l, 1);
            r = ref Unsafe.Add(ref r, 1);
        }
    }
    /// <summary>Determines whether both references of <typeparamref name="T"/> contain the same bits.</summary>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameters <paramref name="left"/> and <paramref name="right"/>
    /// point to values with the same bits as each other; otherwise, <see langword="false"/>.
    /// </returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool Eq(scoped in T left, scoped in T right)
    {
        ref byte l = ref Unsafe.As<T, byte>(ref AsRef(left)),
            r = ref Unsafe.As<T, byte>(ref AsRef(right)),
            upper = ref Unsafe.Add(ref l, Unsafe.SizeOf<T>());
#if NET8_0_OR_GREATER
        if (Vector512.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 64)
        {
            while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, 63)))
            {
                if (!Vector512.EqualsAll(Vector512.LoadUnsafe(ref l), Vector512.LoadUnsafe(ref r)))
                    return false;
                l = ref Unsafe.Add(ref l, 64);
                r = ref Unsafe.Add(ref r, 64);
            }
            if (Unsafe.SizeOf<T>() % 64 is 0)
                return true;
        }
#endif
#if NET7_0_OR_GREATER
        if (Vector256.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 32)
        {
            while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, 31)))
            {
                if (!Vector256.EqualsAll(Vector256.LoadUnsafe(ref l), Vector256.LoadUnsafe(ref r)))
                    return false;
                l = ref Unsafe.Add(ref l, 32);
                r = ref Unsafe.Add(ref r, 32);
            }
            if (Unsafe.SizeOf<T>() % 32 is 0)
                return true;
        }
        if (Vector128.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 16)
        {
            while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, 15)))
            {
                if (!Vector128.EqualsAll(Vector128.LoadUnsafe(ref l), Vector128.LoadUnsafe(ref r)))
                    return false;
                l = ref Unsafe.Add(ref l, 16);
                r = ref Unsafe.Add(ref r, 16);
            }
            if (Unsafe.SizeOf<T>() % 16 is 0)
                return true;
        }
        if (Vector64.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 8)
        {
            while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, 7)))
            {
                if (!Vector64.EqualsAll(Vector64.LoadUnsafe(ref l), Vector64.LoadUnsafe(ref r)))
                    return false;
                l = ref Unsafe.Add(ref l, 8);
                r = ref Unsafe.Add(ref r, 8);
            }
            if (Unsafe.SizeOf<T>() % 8 is 0)
                return true;
        }
#endif
        while (Unsafe.IsAddressLessThan(
            ref l,
            ref Unsafe.SubtractByteOffset(ref upper, (nint)Unsafe.SizeOf<nuint>() - 1)
        ))
        {
            if (Unsafe.As<byte, nuint>(ref l) != Unsafe.As<byte, nuint>(ref r))
                return false;
            l = ref Unsafe.Add(ref l, Unsafe.SizeOf<nuint>());
            r = ref Unsafe.Add(ref r, Unsafe.SizeOf<nuint>());
        }
        while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, sizeof(ulong) - 1)))
        {
            if (Unsafe.As<byte, ulong>(ref l) != Unsafe.As<byte, ulong>(ref r))
                return false;
            l = ref Unsafe.Add(ref l, sizeof(ulong));
            r = ref Unsafe.Add(ref r, sizeof(ulong));
        }
        while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, sizeof(uint) - 1)))
        {
            if (Unsafe.As<byte, uint>(ref l) != Unsafe.As<byte, uint>(ref r))
                return false;
            l = ref Unsafe.Add(ref l, sizeof(uint));
            r = ref Unsafe.Add(ref r, sizeof(uint));
        }
        while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.SubtractByteOffset(ref upper, sizeof(ushort) - 1)))
        {
            if (Unsafe.As<byte, ushort>(ref l) == Unsafe.As<byte, ushort>(ref r))
                return false;
            l = ref Unsafe.Add(ref l, sizeof(ushort));
            r = ref Unsafe.Add(ref r, sizeof(ushort));
        }
        while (Unsafe.IsAddressLessThan(ref l, ref upper))
        {
            if (l != r)
                return false;
            l = ref Unsafe.Add(ref l, 1);
            r = ref Unsafe.Add(ref r, 1);
        }
        return true;
    }
    /// <summary>Determines whether the reference of <typeparamref name="T"/> contains all zeros.</summary>
    /// <param name="reference">The reference to determine if it is zeroed.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="reference"/>
    /// points to a value with all zeros; otherwise, <see langword="false"/>.
    /// </returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool Eq0(scoped in T reference)
    {
        ref byte x = ref Unsafe.As<T, byte>(ref AsRef(reference)), upper = ref Unsafe.Add(ref x, 1);
#if NET8_0_OR_GREATER
        if (Vector512.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 64)
        {
            while (Unsafe.IsAddressLessThan(ref x, ref Unsafe.SubtractByteOffset(ref upper, 63)))
            {
                if (!Vector512.EqualsAll(Vector512.LoadUnsafe(ref x), Vector512<byte>.Zero))
                    return false;
                x = ref Unsafe.Add(ref x, 64);
            }
            if (Unsafe.SizeOf<T>() % 64 is 0)
                return true;
        }
#endif
#if NET7_0_OR_GREATER
        if (Vector256.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 32)
        {
            while (Unsafe.IsAddressLessThan(ref x, ref Unsafe.SubtractByteOffset(ref upper, 31)))
            {
                if (!Vector256.EqualsAll(Vector256.LoadUnsafe(ref x), Vector256<byte>.Zero))
                    return false;
                x = ref Unsafe.Add(ref x, 32);
            }
            if (Unsafe.SizeOf<T>() % 32 is 0)
                return true;
        }
        if (Vector128.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 16)
        {
            while (Unsafe.IsAddressLessThan(ref x, ref Unsafe.SubtractByteOffset(ref upper, 15)))
            {
                if (!Vector128.EqualsAll(Vector128.LoadUnsafe(ref x), Vector128<byte>.Zero))
                    return false;
                x = ref Unsafe.Add(ref x, 16);
            }
            if (Unsafe.SizeOf<T>() % 16 is 0)
                return true;
        }
        if (Vector64.IsHardwareAccelerated && Unsafe.SizeOf<T>() >= 8)
        {
            while (Unsafe.IsAddressLessThan(ref x, ref Unsafe.SubtractByteOffset(ref upper, 7)))
            {
                if (!Vector64.EqualsAll(Vector64.LoadUnsafe(ref x), Vector64<byte>.Zero))
                    return false;
                x = ref Unsafe.Add(ref x, 8);
            }
            if (Unsafe.SizeOf<T>() % 8 is 0)
                return true;
        }
#endif
        while (Unsafe.IsAddressLessThan(
            ref x,
            ref Unsafe.SubtractByteOffset(ref upper, (nint)Unsafe.SizeOf<nuint>() - 1)
        ))
        {
            if (Unsafe.As<byte, nuint>(ref x) is not 0)
                return false;
            x = ref Unsafe.Add(ref x, Unsafe.SizeOf<nuint>());
        }
        while (Unsafe.IsAddressLessThan(ref x, ref Unsafe.SubtractByteOffset(ref upper, sizeof(ulong) - 1)))
        {
            if (Unsafe.As<byte, ulong>(ref x) is not 0)
                return false;
            x = ref Unsafe.Add(ref x, sizeof(ulong));
        }
        while (Unsafe.IsAddressLessThan(ref x, ref Unsafe.SubtractByteOffset(ref upper, sizeof(uint) - 1)))
        {
            if (Unsafe.As<byte, uint>(ref x) is not 0)
                return false;
            x = ref Unsafe.Add(ref x, sizeof(uint));
        }
        while (Unsafe.IsAddressLessThan(ref x, ref Unsafe.SubtractByteOffset(ref upper, sizeof(ushort) - 1)))
        {
            if (Unsafe.As<byte, ushort>(ref x) is not 0)
                return false;
            x = ref Unsafe.Add(ref x, sizeof(ushort));
        }
        while (Unsafe.IsAddressLessThan(ref x, ref upper))
        {
            if (x is not 0)
                return false;
            x = ref Unsafe.Add(ref x, 1);
        }
        return true;
    }
    /// <summary>Clamps a value such that it is not smaller or larger than the defined amount.</summary>
    /// <param name="number">The bits to clamp.</param>
    /// <param name="min">The minimum accepted value.</param>
    /// <param name="max">The maximum accepted value.</param>
    /// <returns>
    /// The parameter <paramref name="number"/> if its bits are greater or equal to the parameter
    /// <paramref name="min"/>, and lesser or equal to the parameter <paramref name="number"/>; otherwise,
    /// <paramref name="min"/> if the parameter <paramref name="number"/> is lesser than
    /// <paramref name="min"/>; otherwise, <paramref name="max"/>.
    /// </returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ref readonly T Clamp(in T number, in T min, in T max) => ref Max(Min(number, max), min);
    /// <summary>Returns the reference that contains the greater bits.</summary>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>
    /// The parameter <paramref name="left"/> if its bits are greater or equal to the
    /// parameter <paramref name="right"/>; otherwise, <paramref name="right"/>.
    /// </returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ref readonly T Max(in T left, in T right)
    {
        ref T l = ref AsRef(left), r = ref AsRef(right), upper = ref Unsafe.Add(ref l, 1);
        while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.Subtract(ref upper, (nint)Unsafe.SizeOf<nuint>() - 1)))
        {
            if (Unsafe.As<T, nuint>(ref l) != Unsafe.As<T, nuint>(ref r))
                return ref Unsafe.As<T, nuint>(ref l) > Unsafe.As<T, nuint>(ref r) ? ref left : ref right;
            l = ref Unsafe.AddByteOffset(ref l, (nint)Unsafe.SizeOf<nuint>());
        }
        while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.Subtract(ref upper, sizeof(ulong) - 1)))
        {
            if (Unsafe.As<T, ulong>(ref l) != Unsafe.As<T, ulong>(ref r))
                return ref Unsafe.As<T, ulong>(ref l) > Unsafe.As<T, ulong>(ref r) ? ref left : ref right;
            l = ref Unsafe.AddByteOffset(ref l, (nint)sizeof(ulong));
        }
        while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.Subtract(ref upper, sizeof(uint) - 1)))
        {
            if (Unsafe.As<T, uint>(ref l) != Unsafe.As<T, uint>(ref r))
                return ref Unsafe.As<T, uint>(ref l) > Unsafe.As<T, uint>(ref r) ? ref left : ref right;
            l = ref Unsafe.AddByteOffset(ref l, (nint)sizeof(uint));
        }
        while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.Subtract(ref upper, sizeof(ushort) - 1)))
        {
            if (Unsafe.As<T, ushort>(ref l) != Unsafe.As<T, ushort>(ref r))
                return ref Unsafe.As<T, ushort>(ref l) > Unsafe.As<T, ushort>(ref r) ? ref left : ref right;
            l = ref Unsafe.AddByteOffset(ref l, (nint)sizeof(ushort));
        }
        while (Unsafe.IsAddressLessThan(ref l, ref upper))
        {
            if (Unsafe.As<T, byte>(ref l) != Unsafe.As<T, byte>(ref r))
                return ref Unsafe.As<T, byte>(ref l) > Unsafe.As<T, byte>(ref r) ? ref left : ref right;
            l = ref Unsafe.AddByteOffset(ref l, 1);
        }
        return ref left;
    }
    /// <summary>Returns the reference that contains the lesser bits.</summary>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>
    /// The parameter <paramref name="left"/> if its bits are greater or equal to the
    /// parameter <paramref name="right"/>; otherwise, <paramref name="right"/>.
    /// </returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ref readonly T Min(in T left, in T right)
    {
        ref T l = ref AsRef(left), r = ref AsRef(right), upper = ref Unsafe.Add(ref l, 1);
        while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.Subtract(ref upper, (nint)Unsafe.SizeOf<nuint>() - 1)))
        {
            if (Unsafe.As<T, nuint>(ref l) != Unsafe.As<T, nuint>(ref r))
                return ref Unsafe.As<T, nuint>(ref l) < Unsafe.As<T, nuint>(ref r) ? ref left : ref right;
            l = ref Unsafe.AddByteOffset(ref l, (nint)Unsafe.SizeOf<nuint>());
        }
        while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.Subtract(ref upper, sizeof(ulong) - 1)))
        {
            if (Unsafe.As<T, ulong>(ref l) != Unsafe.As<T, ulong>(ref r))
                return ref Unsafe.As<T, ulong>(ref l) < Unsafe.As<T, ulong>(ref r) ? ref left : ref right;
            l = ref Unsafe.AddByteOffset(ref l, (nint)sizeof(ulong));
        }
        while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.Subtract(ref upper, sizeof(uint) - 1)))
        {
            if (Unsafe.As<T, uint>(ref l) != Unsafe.As<T, uint>(ref r))
                return ref Unsafe.As<T, uint>(ref l) < Unsafe.As<T, uint>(ref r) ? ref left : ref right;
            l = ref Unsafe.AddByteOffset(ref l, (nint)sizeof(uint));
        }
        while (Unsafe.IsAddressLessThan(ref l, ref Unsafe.Subtract(ref upper, sizeof(ushort) - 1)))
        {
            if (Unsafe.As<T, ushort>(ref l) != Unsafe.As<T, ushort>(ref r))
                return ref Unsafe.As<T, ushort>(ref l) < Unsafe.As<T, ushort>(ref r) ? ref left : ref right;
            l = ref Unsafe.AddByteOffset(ref l, (nint)sizeof(ushort));
        }
        while (Unsafe.IsAddressLessThan(ref l, ref upper))
        {
            if (Unsafe.As<T, byte>(ref l) != Unsafe.As<T, byte>(ref r))
                return ref Unsafe.As<T, byte>(ref l) < Unsafe.As<T, byte>(ref r) ? ref left : ref right;
            l = ref Unsafe.AddByteOffset(ref l, 1);
        }
        return ref left;
    }
}
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable once CheckNamespace
/// <summary>Provides methods for unfolding.</summary>
    /// <summary>Applies a selector and collects the returned items recursively until the value becomes null.</summary>
    /// <typeparam name="T">The type of value.</typeparam>
    /// <param name="value">The initial value.</param>
    /// <param name="converter">The converter to apply.</param>
    /// <returns>
    /// The parameter <paramref name="value"/>, followed by each non-null
    /// returned value from the parameter <paramref name="converter"/>.
    /// </returns>
    [Pure]
    public static IEnumerable<T> FindPathToNull<T>(this T? value, Converter<T, T?> converter)
        where T : class
    {
        while (value is not null)
        {
            yield return value;
            value = converter(value);
        }
    }
    /// <inheritdoc cref="FindPathToNull{T}"/>
    [DoesNotReturn, EditorBrowsable(EditorBrowsableState.Never), Obsolete("The return value is always not null.", true)]
    public static IEnumerable<T> FindPathToEmptyNullable<T>(this T _, Converter<T, T> converter)
        where T : struct =>
        throw Unreachable;
    /// <inheritdoc cref="FindPathToNull{T}"/>
    [Pure]
    public static IEnumerable<T> FindPathToEmptyNullable<T>(this T value, Converter<T, T?> converter)
        where T : struct
    {
        T? maybe = value;
        while (maybe is { } yes)
        {
            yield return yes;
            maybe = converter(yes);
        }
    }
    /// <inheritdoc cref="FindPathToNull{T}"/>
    [DoesNotReturn, EditorBrowsable(EditorBrowsableState.Never), Obsolete("The return value is always not null.", true)]
    public static IEnumerable<T> FindPathToEmptyNullable<T>(this T? _, Converter<T, T> converter)
        where T : struct =>
        throw Unreachable;
    /// <inheritdoc cref="FindPathToNull{T}"/>
    [Pure]
    public static IEnumerable<T> FindPathToEmptyNullable<T>(this T? value, Converter<T, T?> converter)
        where T : struct =>
        value is { } t ? FindPathToEmptyNullable(t, converter) : [];
    /// <inheritdoc cref="FindPathToNull{T}"/>
    [Pure]
    public static SmallList<T> FindSmallPathToNull<T>(this T? value, Converter<T, T?> converter)
        where T : class
    {
        SmallList<T> output = default;
        while (value is not null)
        {
            output.Add(value);
            value = converter(value);
        }
        return output;
    }
    /// <inheritdoc cref="FindPathToNull{T}"/>
    [DoesNotReturn, EditorBrowsable(EditorBrowsableState.Never), Obsolete("The return value is always not null.", true)]
    public static SmallList<T> FindSmallPathToEmptyNullable<T>(this T _, Converter<T, T> converter)
        where T : struct =>
        throw Unreachable;
    /// <inheritdoc cref="FindPathToNull{T}"/>
    [Pure]
    public static SmallList<T> FindSmallPathToEmptyNullable<T>(this T value, Converter<T, T?> converter)
        where T : struct
    {
        SmallList<T> output = [];
        T? maybe = value;
        while (maybe is { } yes)
        {
            output.Add(yes);
            maybe = converter(yes);
        }
        return output;
    }
    /// <inheritdoc cref="FindPathToNull{T}"/>
    [DoesNotReturn, EditorBrowsable(EditorBrowsableState.Never), Obsolete("The return value is always not null.", true)]
    public static SmallList<T> FindSmallPathToEmptyNullable<T>(this T? _, Converter<T, T> converter)
        where T : struct =>
        throw Unreachable;
    /// <inheritdoc cref="FindPathToNull{T}"/>
    [Pure]
    public static SmallList<T> FindSmallPathToEmptyNullable<T>(this T? value, Converter<T, T?> converter)
        where T : struct =>
        value is { } t ? FindSmallPathToEmptyNullable(t, converter) : [];
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable once CheckNamespace EmptyNamespace
#if !NET20 && !NET30 && !NET471_OR_GREATER && !NETSTANDARD1_6_OR_GREATER && !NETCOREAPP
/// <summary>Adds support for Append and Prepend in lower frameworks.</summary>
    /// <summary>Appends a value to the end of the sequence.</summary>
    /// <typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
    /// <param name="source">A sequence of values.</param>
    /// <param name="element">The value to append to <paramref name="source"/>.</param>
    /// <returns>A new sequence that ends with <paramref name="element"/>.</returns>
    public static IEnumerable<TSource> Append<TSource>(this IEnumerable<TSource> source, TSource element) =>
        source.Concat(element.Yield());
    /// <summary>Prepends a value to the end of the sequence.</summary>
    /// <typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
    /// <param name="source">A sequence of values.</param>
    /// <param name="element">The value to prepend to <paramref name="source"/>.</param>
    /// <returns>A new sequence that starts with <paramref name="element"/>.</returns>
    public static IEnumerable<TSource> Prepend<TSource>(this IEnumerable<TSource> source, TSource element) =>
        element.Yield().Concat(source);
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable CheckNamespace StructCanBeMadeReadOnly
/// <summary>Extension methods that act as factories for <see cref="Yes{T}"/>.</summary>
    /// <summary>A factory for creating iterator types that yield the same item forever.</summary>
    /// <typeparam name="T">The type of the item to yield.</typeparam>
    /// <param name="value">The item to use.</param>
    [StructLayout(LayoutKind.Auto)]
    public
#if !NO_READONLY_STRUCTS
        readonly
#endif
        partial struct Yes<T>([ProvidesContext] T value) : IEnumerable<T>, IEnumerator<T>
    {
        /// <inheritdoc />
        [CollectionAccess(Read), ProvidesContext, Pure]
        public T Current => value;
        /// <inheritdoc />
        [CollectionAccess(Read), Pure]
        object IEnumerator.Current => value ?? new object();
        /// <summary>Implicitly calls the constructor.</summary>
        /// <param name="value">The value to pass into the constructor.</param>
        /// <returns>A new instance of <see cref="Yes{T}"/> with <paramref name="value"/> passed in.</returns>
        [CollectionAccess(Read), Pure]
        public static implicit operator Yes<T>([ProvidesContext] T value) => new(value);
        /// <summary>Implicitly calls <see cref="Current"/>.</summary>
        /// <param name="value">The value to call <see cref="Current"/>.</param>
        /// <returns>The value that was passed in to this instance.</returns>
        [CollectionAccess(Read), Pure]
        public static implicit operator T(Yes<T> value) => value.Current;
        /// <summary>Returns itself.</summary>
        /// <remarks><para>Used to allow <see langword="foreach"/> to be used on <see cref="Yes{T}"/>.</para></remarks>
        /// <returns>Itself.</returns>
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MustDisposeResource(false), Pure]
        public Yes<T> GetEnumerator() => this;
        /// <inheritdoc />
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)]
        void IDisposable.Dispose() { }
        /// <inheritdoc />
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)]
        void IEnumerator.Reset() { }
        /// <inheritdoc />
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), Pure]
        bool IEnumerator.MoveNext() => true;
        /// <inheritdoc />
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MustDisposeResource(false), Pure]
        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
        /// <inheritdoc />
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MustDisposeResource(false), Pure]
        IEnumerator<T> IEnumerable<T>.GetEnumerator() => GetEnumerator();
    }
    /// <summary>Creates a <see cref="Yes{T}"/> from an item.</summary>
    /// <typeparam name="T">The type of item.</typeparam>
    /// <param name="source">The item.</param>
    /// <returns>The <see cref="Yes{T}"/> instance that can be yielded forever.</returns>
    [Pure]
    public static Yes<T> Forever<T>(this T source) => source;
// SPDX-License-Identifier: MPL-2.0
#if !NET20 && !NET30
// ReSharper disable once CheckNamespace
/// <summary>Provides methods for creating combinations of items.</summary>
    /// <summary>Generates all combinations of the nested enumerable.</summary>
    /// <typeparam name="T">The type of nested enumerable.</typeparam>
    /// <param name="iterator">The input to generate combinations of.</param>
    /// <returns>Every combination of the items in <paramref name="iterator"/>.</returns>
    [Pure]
#if NETFRAMEWORK && !NET45_OR_GREATER
    public static IEnumerable<IList<T>> Combinations<T>(
#else
    public static IEnumerable<IReadOnlyList<T>> Combinations<T>(
#endif
        [InstantHandle] this IEnumerable<IEnumerable<T>> iterator
    ) =>
#if NETFRAMEWORK && !NET45_OR_GREATER
        iterator.Select(x => x.ToIList()).ToIList().Combinations();
#else
        iterator.Select(x => x.ReadOnly()).ReadOnly().Combinations();
#endif
    /// <summary>Generates all combinations of the nested list.</summary>
    /// <typeparam name="T">The type of nested list.</typeparam>
    /// <param name="lists">The input to generate combinations of.</param>
    /// <returns>Every combination of the items in <paramref name="lists"/>.</returns>
    [Pure]
#if NETFRAMEWORK && !NET45_OR_GREATER
    public static IEnumerable<IList<T>> Combinations<T>(this IList<IList<T>> lists)
#else
    public static IEnumerable<IReadOnlyList<T>> Combinations<T>(this IReadOnlyList<IReadOnlyList<T>> lists)
#endif
    {
        if (lists.Any(x => x is []))
            yield break;
        int count = lists.Count, index = 0, pos = 0;
        var indices = new int[count];
        var accumulator = new T[count];
        while (true)
        {
            while (pos < accumulator.Length)
            {
                indices[pos] = index;
                accumulator[pos] = lists[pos][index];
                index = 0;
                pos++;
            }
            var result = new T[count];
            Array.Copy(accumulator, result, count);
            yield return result;
            do
            {
                if (pos is 0)
                    yield break;
                index = indices[--pos] + 1;
            } while (index >= lists[pos].Count);
        }
    }
    /// <summary>Generates all combinations of the nested list.</summary>
    /// <typeparam name="T">The type of nested list.</typeparam>
    /// <param name="lists">The input to generate combinations of.</param>
    /// <returns>Every combination of the items in <paramref name="lists"/>.</returns>
    [Pure]
    public static IEnumerable<SmallList<T>> Combinations<T>(this SmallList<SmallList<T>> lists)
    {
        foreach (var list in lists)
            if (list.IsEmpty)
                return [];
        return lists.CombinationsIterator();
    }
    /// <summary>Generates all combinations of the nested enumerable.</summary>
    /// <typeparam name="T">The type of nested enumerable.</typeparam>
    /// <param name="iterator">The input to generate combinations of.</param>
    /// <returns>Every combination of the items in <paramref name="iterator"/>.</returns>
    [Pure]
    public static IEnumerable<SmallList<T>> SmallListCombinations<T>(
        [InstantHandle] this IEnumerable<IEnumerable<T>> iterator
    ) =>
        iterator.Select(x => x.ToSmallList()).ToSmallList().Combinations();
    static IEnumerable<SmallList<T>> CombinationsIterator<T>(this SmallList<SmallList<T>> lists)
    {
        int count = lists.Count, index = 0, pos = 0;
        var indices = SmallList<int>.Uninit(count);
        var accumulator = SmallList<T>.Uninit(count);
        while (true)
        {
            while (pos < accumulator.Count)
            {
                indices[pos] = index;
                accumulator[pos] = lists[pos][index];
                index = 0;
                pos++;
            }
            yield return accumulator.Cloned;
            do
            {
                if (pos is 0)
                    yield break;
                index = indices[--pos] + 1;
            } while (index >= lists[pos].Count);
        }
    }
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable RedundantNameQualifier
// ReSharper disable once CheckNamespace
/// <summary>Class for obtaining the underlying data for lists.</summary>
#if !NET9_0_OR_GREATER
    /// <summary>Contains the cached method for obtaining the underlying array.</summary>
    /// <typeparam name="T">The element type within the collection.</typeparam>
    static class ListCache<T>
    {
        /// <summary>Gets the converter.</summary>
        public static Converter<List<T>, T[]> Converter { get; } =
#if !NETSTANDARD || NETSTANDARD2_0_OR_GREATER
            typeof(List<T>)
               .GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
               .FirstOrDefault(x => x.FieldType == typeof(T[])) is { } method
                ? CreateGetter(method)
                :
#endif
                x => [.. x];
#if !NETSTANDARD || NETSTANDARD2_0_OR_GREATER
        /// <summary>Creates the getter to the inner array.</summary>
        /// <param name="field">The field to the list's array.</param>
        /// <exception cref="InvalidOperationException">The field has no declaring type.</exception>
        /// <returns>The getter to the inner array.</returns>
        static Converter<List<T>, T[]> CreateGetter(FieldInfo field)
        {
            if (field.DeclaringType is not { } declaringType)
                throw new InvalidOperationException("Field has no declaring type.");
            var param = System.Linq.Expressions.Expression.Parameter(declaringType, field.Name);
            var access = System.Linq.Expressions.Expression.Field(param, field);
            return System.Linq.Expressions.Expression.Lambda<Converter<List<T>, T[]>>(access, param).Compile();
#endif
        }
    }
#endif
    /// <summary>Gets the underlying array of the <see cref="List{T}"/>.</summary>
    /// <remarks><para>
    /// While unlikely, it is theoretically possible that the framework's implementation of
    /// <see cref="List{T}"/> lacks any references to its underlying array, or at least
    /// directly. In that case, a new array is made, holding no reference to the list.
    /// </para><para>
    /// If you want to ensure maximum compatibility, the implementation should not rely on whether
    /// mutations within the array would affect the <see cref="List{T}"/>, and vice versa.
    /// </para><para>
    /// Regardless of framework, mutations within the array will not notify the list during its enumerations which can
    /// easily cause bugs to slip through.
    /// </para><para>
    /// The array may contain uninitialized memory for all elements past <see cref="List{T}.Count"/>.
    /// </para><para>
    /// Uses of this method include obtaining a <see cref="ReadOnlySpan{T}"/> or <see cref="Span{T}"/> outside of
    /// .NET 5+ projects, as <c>CollectionsMarshal.AsSpan&lt;T&gt;</c> is not available there, or obtaining
    /// <c>ReadOnlyMemory&lt;T&gt;</c> or <c>Memory&lt;T&gt;</c> of a <see cref="List{T}"/>, normally impossible,
    /// or if growth of an array is no longer needed but the contents are expected to be long-lasting.
    /// </para><para>
    /// Whatever your use case, remember this: "It's not a b&#x0075;g, it's an undocumented feature.".
    /// </para></remarks>
    /// <typeparam name="T">The type of list.</typeparam>
    /// <param name="list">The list to obtain the underlying array.</param>
    /// <returns>The array of the parameter <paramref name="list"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T[] UnsafelyToArray<T>(this List<T> list)
#if NET9_0_OR_GREATER
    {
        [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_items")]
        static extern ref readonly T[] Items(List<T> list);
        return Items(list);
    }
#else
        =>
            ListCache<T>.Converter(list);
#endif
// SPDX-License-Identifier: MPL-2.0
#if ROSLYN
// ReSharper disable CheckNamespace RedundantNameQualifier UseSymbolAlias
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
/// <summary>
/// Helper type that allows signature help to make better decisions about which overload the user is likely choosing
/// when the compiler itself bails out and gives a generic list of options.
/// </summary>
/// <remarks><para>
/// This implementation is based on a modified version of
/// <a href="https://github.com/dotnet/roslyn/blob/main/src/Features/CSharp/Portable/SignatureHelp/LightweightOverloadResolution.cs">
/// <c>Microsoft.CodeAnalysis.CSharp.SignatureHelp.LightweightOverloadResolution</c>
/// </a>.
/// </para></remarks>
readonly struct LightweightOverloadResolution(
    SemanticModel semanticModel,
    int position,
    SeparatedSyntaxList<ArgumentSyntax> arguments
)
{
    /// <summary>Contains the resulting overload.</summary>
    /// <param name="Method">The <see cref="IMethodSymbol"/> to use.</param>
    /// <param name="ParameterIndex">The index of the parameter to highlight.</param>
    public record struct Overload(IMethodSymbol? Method, int ParameterIndex)
    {
        /// <summary>Gets the instance indicating that no overload was found.</summary>
        [Pure]
        public static Overload None => new(null, -1);
    }
    /// <summary>Performs the overload resolution.</summary>
    /// <param name="symbolInfo">The <see cref="SymbolInfo"/> to use.</param>
    /// <param name="candidates">The different overloads.</param>
    /// <returns>The overload to use.</returns>
    public Overload RefineOverloadAndPickParameter(SymbolInfo symbolInfo, ImmutableArray<IMethodSymbol> candidates) =>
        symbolInfo.Symbol is IMethodSymbol method
            ? TryFindParameterIndexIfCompatibleMethod(method)
            : GuessCurrentSymbolAndParameter(candidates);
    /// <summary>Finds the parameter index if the method is compatible.</summary>
    /// <param name="method">The <see cref="IMethodSymbol"/> to check.</param>
    /// <returns>The index of the parameter if the method is compatible, <c>-1</c> otherwise.</returns>
    public int FindParameterIndexIfCompatibleMethod(IMethodSymbol method) =>
        TryFindParameterIndexIfCompatibleMethod(method) is (not null, var parameterIndex) ? parameterIndex : -1;
    /// <summary>Determines whether the expression is empty.</summary>
    /// <param name="expression">The expression to check.</param>
    /// <returns>Whether the parameter <paramref name="expression"/> is empty.</returns>
    static bool IsEmptyArgument(SyntaxNode expression) => expression.Span.IsEmpty;
    /// <summary>Deals with a partial invocation and finds the respective overload.</summary>
    /// <param name="methodGroup">The different overloads.</param>
    /// <returns>The overload to use.</returns>
    Overload GuessCurrentSymbolAndParameter(ImmutableArray<IMethodSymbol> methodGroup)
    {
        if (arguments is [])
            return Overload.None;
        foreach (var method in methodGroup)
        {
            var (candidateMethod, parameterIndex) = TryFindParameterIndexIfCompatibleMethod(method);
            if (candidateMethod is not null)
                return new(candidateMethod, parameterIndex);
        }
        return Overload.None;
    }
    /// <summary>
    /// Simulates overload resolution with the arguments provided so far
    /// and determines if you might be calling this overload.
    /// </summary>
    /// <returns>
    /// Returns true if an overload is acceptable. In that case, we output the parameter that
    /// should be highlighted given the cursor's position in the partial invocation.
    /// </returns>
    Overload TryFindParameterIndexIfCompatibleMethod(IMethodSymbol method)
    {
        var argumentToParameterMap =
            arguments.Count <= 256 ? stackalloc int[arguments.Count] : new int[arguments.Count];
        argumentToParameterMap.Fill(-1);
        if (!TryPrepareArgumentToParameterMap(method, argumentToParameterMap))
            return Overload.None;
        var parameters = method.Parameters;
        for (var argumentIndex = 0; argumentIndex < arguments.Count; argumentIndex++)
        {
            var parameterIndex = argumentToParameterMap[argumentIndex];
            if (parameterIndex < 0)
                continue;
            var parameter = parameters[parameterIndex];
            var argument = arguments[argumentIndex];
            if (IsCompatibleArgument(argument, parameter))
                continue;
            return Overload.None;
        }
        var argumentIndexToSave = GetArgumentIndex();
        var foundParameterIndex = -1;
        if (argumentIndexToSave >= 0)
        {
            foundParameterIndex = argumentToParameterMap[argumentIndexToSave];
            if (foundParameterIndex < 0)
                foundParameterIndex = FirstUnspecifiedParameter(argumentToParameterMap);
        }
        System.Diagnostics.Debug.Assert(
            foundParameterIndex < parameters.Length,
            "foundParameterIndex < parameters.Length"
        );
        return new(method, foundParameterIndex);
    }
    /// <summary>Determines if the given argument is compatible with the given parameter.</summary>
    /// <param name="argument">The argument to check.</param>
    /// <param name="parameter">The parameter to check.</param>
    /// <returns>
    /// <see langword="true"/> if the argument is compatible with the parameter, <see langword="false"/> otherwise.
    /// </returns>
    bool IsCompatibleArgument(ArgumentSyntax argument, IParameterSymbol parameter)
    {
        var parameterRefKind = parameter.RefKind;
        if (parameterRefKind is RefKind.None)
        {
            if (IsEmptyArgument(argument.Expression))
                return true;
            var type = parameter.Type;
            if (parameter.IsParams &&
                type is IArrayTypeSymbol arrayType &&
                semanticModel.ClassifyConversion(argument.Expression, arrayType.ElementType).IsImplicit)
                return true;
            return semanticModel.ClassifyConversion(argument.Expression, type).IsImplicit;
        }
        var argumentRefKind = argument.GetRefKind();
        if (parameterRefKind == argumentRefKind)
            return true;
        return parameterRefKind is RefKind.In && argumentRefKind is RefKind.None;
    }
    /// <summary>Highlights the first unspecified parameter.</summary>
    /// <param name="argumentToParameterMap">The input map.</param>
    /// <returns>The index of the first unspecified parameter.</returns>
    int FirstUnspecifiedParameter(Span<int> argumentToParameterMap)
    {
        var specified = arguments.Count <= 1024 ? stackalloc bool[arguments.Count] : new bool[arguments.Count];
        specified.Clear();
        for (var i = 0; i < arguments.Count; i++)
        {
            var parameterIndex = argumentToParameterMap[i];
            if (parameterIndex >= 0 && parameterIndex < arguments.Count)
                specified[parameterIndex] = true;
        }
        for (var i = 0; i < specified.Length; i++)
            if (!specified[i])
                return i;
        return 0;
    }
    /// <summary>Find the parameter index corresponding to each argument provided.</summary>
    /// <param name="method">The method to prepare.</param>
    /// <param name="argumentToParameterMap">The output map.</param>
    /// <returns>Whether or not the method could be prepared.</returns>
#pragma warning disable MA0051
    bool TryPrepareArgumentToParameterMap(IMethodSymbol method, Span<int> argumentToParameterMap)
#pragma warning restore MA0051
    {
        System.Diagnostics.Debug.Assert(
            argumentToParameterMap.Length == arguments.Count,
            "argumentToParameterMap.Length == arguments.Count"
        );
        var currentParameterIndex = 0;
        var seenOutOfPositionArgument = false;
        var inParams = false;
        for (var argumentIndex = 0; argumentIndex < arguments.Count; argumentIndex++)
        {
            if (argumentIndex >= method.Parameters.Length && !inParams)
                return false;
            var argument = arguments[argumentIndex];
            if (argument is { NameColon.Name.Identifier.ValueText: var argumentName })
            {
                var namedParameterIndex = 0;
                for (;
                    namedParameterIndex < method.Parameters.Length &&
                    method.Parameters[namedParameterIndex].Name == argumentName;
                    namedParameterIndex++) { }
                if (namedParameterIndex == method.Parameters.Length)
                    return false;
                if (namedParameterIndex != currentParameterIndex)
                    seenOutOfPositionArgument = true;
                AddArgumentToParameterMapping(argumentIndex, namedParameterIndex, argumentToParameterMap);
            }
            else if (IsEmptyArgument(argument.Expression))
            {
                if (!seenOutOfPositionArgument)
                    AddArgumentToParameterMapping(argumentIndex, currentParameterIndex, argumentToParameterMap);
            }
            else if (seenOutOfPositionArgument)
                return false;
            else
                AddArgumentToParameterMapping(argumentIndex, currentParameterIndex, argumentToParameterMap);
        }
        return true;
        void AddArgumentToParameterMapping(
            int argumentIndex,
            int parameterIndex,
            Span<int> argumentToParameterMap
        )
        {
            System.Diagnostics.Debug.Assert(parameterIndex >= 0, "parameterIndex >= 0");
            System.Diagnostics.Debug.Assert(
                parameterIndex < method.Parameters.Length,
                "parameterIndex < method.Parameters.Length"
            );
            inParams |= method.Parameters[parameterIndex].IsParams;
            argumentToParameterMap[argumentIndex] = parameterIndex;
            if (!seenOutOfPositionArgument && !inParams)
                currentParameterIndex++;
        }
    }
    /// <summary>
    /// Given the cursor position, find which argument is active.
    /// This will be useful to later find which parameter should be highlighted.
    /// </summary>
    int GetArgumentIndex()
    {
        for (var i = 0; i < arguments.Count - 1; i++)
            if (position <= arguments.GetSeparator(i).Span.Start)
                return i;
        return arguments.Count - 1;
    }
}
#endif
// SPDX-License-Identifier: MPL-2.0
#if XNA
#pragma warning disable CS1591, SA1602
/// <summary>Contains the set of all key modifiers.</summary>
[CLSCompliant(false), Flags]
public enum KeyMods : ushort
{
    None,
    LeftShift,
    RightShift,
    Shift = RightShift | LeftShift,
    LeftCtrl = 1 << 6,
    RightCtrl = 1 << 7,
    Ctrl = RightCtrl | LeftCtrl,
    LeftAlt = 1 << 8,
    RightAlt = 1 << 9,
    Alt = RightAlt | LeftAlt,
    LeftGui = 1 << 10,
    RightGui = 1 << 11,
    Gui = RightGui | LeftGui,
    NumLock = 1 << 12,
    CapsLock = 1 << 13,
    AltGr = 1 << 14,
    Reserved = 1 << 15,
}
#endif
// SPDX-License-Identifier: MPL-2.0
#if NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP
// ReSharper disable RedundantUsingDirective
// ReSharper disable CheckNamespace NullableWarningSuppressionIsUsed RedundantSuppressNullableWarningExpression
// ReSharper disable once RedundantNameQualifier
/// <summary>Methods that provide access to generic operators, for frameworks that do not support it.</summary>
    /// <summary>Increments the value.</summary>
    /// <typeparam name="T">The type of value to increment.</typeparam>
    /// <param name="t">The value to increment.</param>
    /// <exception cref="MissingMethodException">The type <typeparamref name="T"/> is unsupported.</exception>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void Increment<T>(ref T t)
    {
        if (typeof(T) == typeof(byte))
            Unsafe.As<T, byte>(ref t)++;
        else if (typeof(T) == typeof(double))
            Unsafe.As<T, double>(ref t)++;
        else if (typeof(T) == typeof(float))
            Unsafe.As<T, float>(ref t)++;
        else if (typeof(T) == typeof(int))
            Unsafe.As<T, int>(ref t)++;
        else if (typeof(T) == typeof(nint))
            Unsafe.As<T, nint>(ref t)++;
        else if (typeof(T) == typeof(nuint))
            Unsafe.As<T, nuint>(ref t)++;
        else if (typeof(T) == typeof(sbyte))
            Unsafe.As<T, sbyte>(ref t)++;
        else if (typeof(T) == typeof(short))
            Unsafe.As<T, short>(ref t)++;
        else if (typeof(T) == typeof(uint))
            Unsafe.As<T, uint>(ref t)++;
        else if (typeof(T) == typeof(ulong))
            Unsafe.As<T, ulong>(ref t)++;
        else if (typeof(T) == typeof(ushort))
            Unsafe.As<T, ushort>(ref t)++;
        else if (DirectOperators<T>.IsSupported)
            t = DirectOperators<T>.Increment(t);
        else
            Fail<T>();
    }
    /// <summary>Determines whether the current type <typeparamref name="T"/> is supported.</summary>
    /// <typeparam name="T">The type to check.</typeparam>
    /// <returns>Whether the current type <typeparamref name="T"/> is supported.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsSupported<T>() => DirectOperators<T>.IsSupported;
    /// <summary>Performs an addition operation to return the sum.</summary>
    /// <typeparam name="T">The type of value to add.</typeparam>
    /// <param name="l">The left-hand side.</param>
    /// <param name="r">The right-hand side.</param>
    /// <exception cref="MissingMethodException">The type <typeparamref name="T"/> is unsupported.</exception>
    /// <returns>The sum of the parameters <paramref name="l"/> and <paramref name="r"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T Adder<T>(T l, T r) =>
        0 switch
        {
            _ when typeof(T) == typeof(byte) => (T)(object)(byte)((byte)(object)l! + (byte)(object)r!),
            _ when typeof(T) == typeof(double) => (T)(object)((double)(object)l! + (double)(object)r!),
            _ when typeof(T) == typeof(float) => (T)(object)((float)(object)l! + (float)(object)r!),
            _ when typeof(T) == typeof(int) => (T)(object)((int)(object)l! + (int)(object)r!),
            _ when typeof(T) == typeof(nint) => (T)(object)((nint)(object)l! + (nint)(object)r!),
            _ when typeof(T) == typeof(nuint) => (T)(object)((nuint)(object)l! + (nuint)(object)r!),
            _ when typeof(T) == typeof(sbyte) => (T)(object)(sbyte)((sbyte)(object)l! + (sbyte)(object)r!),
            _ when typeof(T) == typeof(short) => (T)(object)(short)((short)(object)l! + (short)(object)r!),
            _ when typeof(T) == typeof(uint) => (T)(object)((uint)(object)l! + (uint)(object)r!),
            _ when typeof(T) == typeof(ulong) => (T)(object)((ulong)(object)l! + (ulong)(object)r!),
            _ when typeof(T) == typeof(ushort) => (T)(object)(ushort)((ushort)(object)l! + (ushort)(object)r!),
            _ when DirectOperators<T>.IsSupported => DirectOperators<T>.Adder(l, r),
            _ => Fail<T>(),
        };
    /// <summary>Performs a dividing operation to return the quotient.</summary>
    /// <typeparam name="T">The type of value to divide.</typeparam>
    /// <param name="l">The left-hand side.</param>
    /// <param name="r">The right-hand side.</param>
    /// <exception cref="MissingMethodException">The type <typeparamref name="T"/> is unsupported.</exception>
    /// <returns>The quotient of the parameters <paramref name="l"/> and <paramref name="r"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T Divider<T>(T l, int r) =>
        0 switch
        {
            _ when typeof(T) == typeof(byte) => (T)(object)(byte)((byte)(object)l! / r),
            _ when typeof(T) == typeof(double) => (T)(object)((double)(object)l! / r),
            _ when typeof(T) == typeof(float) => (T)(object)((float)(object)l! / r),
            _ when typeof(T) == typeof(int) => (T)(object)((int)(object)l! / r),
            _ when typeof(T) == typeof(nint) => (T)(object)((nint)(object)l! / r),
            _ when typeof(T) == typeof(nuint) => (T)(object)((nuint)(object)l! / (nuint)r),
            _ when typeof(T) == typeof(sbyte) => (T)(object)(sbyte)((sbyte)(object)l! / r),
            _ when typeof(T) == typeof(short) => (T)(object)(short)((short)(object)l! / r),
            _ when typeof(T) == typeof(uint) => (T)(object)((uint)(object)l! / r),
            _ when typeof(T) == typeof(ulong) => (T)(object)((ulong)(object)l! / (ulong)r),
            _ when typeof(T) == typeof(ushort) => (T)(object)(ushort)((ushort)(object)l! / r),
            _ when DirectOperators<T>.IsSupported => DirectOperators<T>.Divider(l, r),
            _ => Fail<T>(),
        };
    /// <summary>Gets the maximum value.</summary>
    /// <typeparam name="T">The type of value to get the maximum value of.</typeparam>
    /// <returns>The maximum value of <typeparamref name="T"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T MaxValue<T>() => DirectOperators<T>.MaxValue;
    /// <summary>Gets the minimum value.</summary>
    /// <typeparam name="T">The type of value to get the minimum value of.</typeparam>
    /// <returns>The minimum value of <typeparamref name="T"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T MinValue<T>() => DirectOperators<T>.MinValue;
    /// <summary>Throws the exception used by <see cref="OperatorCaching"/> to propagate errors.</summary>
    /// <typeparam name="T">The type that failed.</typeparam>
    /// <exception cref="MissingMethodException">The type <typeparamref name="T"/> is unsupported.</exception>
    /// <returns>This method does not return.</returns>
    [DoesNotReturn, MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Fail<T>() =>
        throw new MissingMethodException(typeof(T).FullName, "op_Addition/op_Division/op_Increment");
    /// <summary>Caches operators.</summary>
    /// <typeparam name="T">The containing member of operators.</typeparam>
    public sealed partial class DirectOperators<T>
    {
        const BindingFlags Flags = BindingFlags.Public | BindingFlags.Static;
        static readonly Type[]
            s_binary = [typeof(T), typeof(T)],
            s_unary = [typeof(T)];
        static DirectOperators()
        {
            try
            {
                Increment = Make("op_Increment", Expression.Increment);
                Adder = Make<T>("op_Addition", Expression.AddChecked);
                Divider = Make<int>("op_Division", (x, y) => Expression.Divide(x, Expression.Convert(y, typeof(T))));
            }
            catch (InvalidOperationException)
            {
                IsSupported = false;
            }
        }
        /// <summary>
        /// Gets a value indicating whether the functions can be used.
        /// <see cref="MinValue"/> can be used regardless of its output.
        /// </summary>
        [CLSCompliant(false)]
#pragma warning disable RCS1158
        public static bool IsSupported
#pragma warning restore RCS1158
        {
            [MemberNotNullWhen(true, nameof(Adder), nameof(Divider), nameof(Increment)),
             MethodImpl(MethodImplOptions.AggressiveInlining),
             Pure]
            get;
        } = true;
        /// <summary>Gets the minimum value.</summary>
        public static T MaxValue { [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get; } =
            (typeof(T).IsEnum ? typeof(T).GetEnumUnderlyingType() : typeof(T)) switch
            {
                var x when x == typeof(byte) => (T)(object)byte.MaxValue,
                var x when x == typeof(double) => (T)(object)double.MaxValue,
                var x when x == typeof(float) => (T)(object)float.MaxValue,
                var x when x == typeof(int) => (T)(object)int.MaxValue,
#if NET5_0_OR_GREATER
                var x when x == typeof(nint) => (T)(object)nint.MaxValue,
                var x when x == typeof(nuint) => (T)(object)nuint.MaxValue,
#endif
                var x when x == typeof(sbyte) => (T)(object)sbyte.MaxValue,
                var x when x == typeof(short) => (T)(object)short.MaxValue,
                var x when x == typeof(uint) => (T)(object)uint.MaxValue,
                var x when x == typeof(ulong) => (T)(object)ulong.MaxValue,
                var x when x == typeof(ushort) => (T)(object)ushort.MaxValue,
                _ => typeof(T).GetField(nameof(MaxValue), Flags)?.GetValue(null) is T t ? t : default!,
            };
        /// <summary>Gets the minimum value.</summary>
        public static T MinValue { [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get; } =
            (typeof(T).IsEnum ? typeof(T).GetEnumUnderlyingType() : typeof(T)) switch
            {
                var x when x == typeof(byte) => (T)(object)byte.MinValue,
                var x when x == typeof(double) => (T)(object)double.MinValue,
                var x when x == typeof(float) => (T)(object)float.MinValue,
                var x when x == typeof(int) => (T)(object)int.MinValue,
#if NET5_0_OR_GREATER
                var x when x == typeof(nint) => (T)(object)nint.MinValue,
                var x when x == typeof(nuint) => (T)(object)nuint.MinValue,
#endif
                var x when x == typeof(sbyte) => (T)(object)sbyte.MinValue,
                var x when x == typeof(short) => (T)(object)short.MinValue,
                var x when x == typeof(uint) => (T)(object)uint.MinValue,
                var x when x == typeof(ulong) => (T)(object)ulong.MinValue,
                var x when x == typeof(ushort) => (T)(object)ushort.MinValue,
                _ => typeof(T).GetField(nameof(MinValue), Flags)?.GetValue(null) is T t ? t : default!,
            };
        /// <summary>Gets the function for dividing.</summary>
        public static Converter<T?, T>? Increment { [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get; }
        /// <summary>Gets the function for adding.</summary>
        public static Func<T?, T?, T>? Adder { [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get; }
        /// <summary>Gets the function for dividing.</summary>
        public static Func<T?, int, T>? Divider { [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get; }
        [Pure]
        static Converter<T?, T> Make(string name, [InstantHandle] Func<Expression, UnaryExpression> go) =>
            typeof(T).GetMethod(name, Flags, null, s_unary, null) is not { } method &&
            Expression.Parameter(typeof(T), "unit") is var unit
                ? Expression.Lambda<Converter<T?, T>>(go(unit), unit).Compile()
                : (Converter<T?, T>)Delegate.CreateDelegate(typeof(Converter<T?, T>), method);
        [Pure]
        static Func<T?, TRight?, T> Make<TRight>(
            string name,
            [InstantHandle] Func<Expression, Expression, BinaryExpression> go
        ) =>
            (typeof(T).GetMethod(name, Flags, null, s_binary, null) is not { } method ||
                (Func<T?, T?, T>)Delegate.CreateDelegate(typeof(Func<T?, T?, T>), method) is not { } func) &&
            Expression.Parameter(typeof(T), "left") is var left &&
            Expression.Parameter(typeof(TRight), "right") is var right
                ? Expression.Lambda<Func<T?, TRight?, T>>(go(left, right), left, right).Compile()
                : (x, y) => func(x, (T?)(object?)y);
    }
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable once CheckNamespace
/// <summary>Provides methods to use callbacks within a statement.</summary>
    /// <summary>Executes an <see cref="Action{T}"/>, and returns the argument.</summary>
    /// <typeparam name="T">The type of value and action parameter.</typeparam>
    /// <param name="value">The value to pass into the callback.</param>
    /// <param name="action">The callback to perform.</param>
    /// <returns>The parameter <paramref name="value"/>.</returns>
    public static T Peek<T>(this T value, [InstantHandle] Action<T> action)
    {
        action(value);
        return value;
    }
#if !NETFRAMEWORK
    /// <summary>Executes a <see langword="delegate"/> pointer, and returns the argument.</summary>
    /// <typeparam name="T">The type of value and delegate pointer parameter.</typeparam>
    /// <param name="value">The value to pass into the callback.</param>
    /// <param name="call">The callback to perform.</param>
    /// <exception cref="ArgumentNullException">
    /// The value <paramref name="call"/> points to <see langword="null"/>.
    /// </exception>
    /// <returns>The parameter <paramref name="value"/>.</returns>
    public static unsafe T Peek<T>(this T value, [InstantHandle] delegate*<T, void> call)
    {
        if (call is not null)
            call(value);
        return value;
    }
#endif
// SPDX-License-Identifier: MPL-2.0
#pragma warning disable GlobalUsingsAnalyzer
// ReSharper disable once CheckNamespace RedundantUsingDirective.Global
/// <summary>Provides a reference for an <see cref="UnreachableException"/>.</summary>
    /// <summary>Gets the <see cref="Exception"/> that a collection cannot be empty.</summary>
    public static InvalidOperationException CannotBeEmpty { get; } = new("Buffer is empty.");
    /// <summary>Gets the <see cref="Exception"/> that represents an unreachable state.</summary>
    public static UnreachableException Unreachable { get; } = new();
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable NullableWarningSuppressionIsUsed RedundantUnsafeContext
// ReSharper disable once CheckNamespace
/// <summary>Extension methods that act as factories for <see cref="SmallList{T}"/>.</summary>
    /// <summary>Collects the enumerable; allocating the heaped list lazily.</summary>
    /// <typeparam name="T">The type of the <paramref name="iterable"/> and the <see langword="return"/>.</typeparam>
    /// <param name="iterable">The collection to turn into a <see cref="SmallList{T}"/>.</param>
    /// <returns>A <see cref="SmallList{T}"/> of <paramref name="iterable"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SmallList<T> ToSmallList<T>([InstantHandle] this IEnumerable<T>? iterable) =>
        iterable is null ? default : [..iterable];
    /// <summary>Mutates the enumerator; allocating the heaped list lazily.</summary>
    /// <typeparam name="T">The type of the <paramref name="iterator"/> and the <see langword="return"/>.</typeparam>
    /// <param name="iterator">The collection to turn into a <see cref="SmallList{T}"/>.</param>
    /// <returns>A <see cref="SmallList{T}"/> of <paramref name="iterator"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SmallList<T> ToSmallList<T>(this IEnumerator<T>? iterator) => new(iterator);
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable ArrangeStaticMemberQualifier NullableWarningSuppressionIsUsed
// ReSharper disable once CheckNamespace
/// <summary>Extension methods for iterating over a set of elements, or for generating new ones.</summary>
    /// <summary>
    /// The <see langword="for"/> statement executes a statement or a block of statements while a specified
    /// Boolean expression evaluates to <see langword="true"/>.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-for-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <param name="upper">The length to reach to in the for loop.</param>
    /// <param name="action">The action for each loop.</param>
    /// <returns>The parameter <paramref name="upper"/>.</returns>
    [NonNegativeValue]
    public static int For([NonNegativeValue] this int upper, [InstantHandle] Action action)
    {
        for (var i = 0; i < upper; i++)
            action();
        return upper;
    }
    /// <summary>
    /// The <see langword="for"/> statement executes a statement or a block of statements while a specified
    /// Boolean expression evaluates to <see langword="true"/>.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-for-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <param name="upper">The length to reach to in the for loop.</param>
    /// <param name="action">The action for each loop.</param>
    /// <returns>The parameter <paramref name="upper"/>.</returns>
    [NonNegativeValue]
    public static int For([NonNegativeValue] this int upper, [InstantHandle] Action<int> action)
    {
        for (var i = 0; i < upper; i++)
            action(i);
        return upper;
    }
    /// <summary>
    /// The <see langword="for"/> statement executes a statement or a block of statements while a specified
    /// Boolean expression evaluates to <see langword="true"/>.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-for-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <typeparam name="TExternal">The type of external parameter to pass into the callback.</typeparam>
    /// <param name="upper">The length to reach to in the for loop.</param>
    /// <param name="external">Any external parameter to be passed repeatedly into the callback.</param>
    /// <param name="action">The action for each loop.</param>
    /// <returns>The parameter <paramref name="upper"/>.</returns>
    [NonNegativeValue]
    public static int For<TExternal>(
        [NonNegativeValue] this int upper,
        TExternal external,
        [InstantHandle] Action<TExternal> action
    )
    {
        for (var i = 0; i < upper; i++)
            action(external);
        return upper;
    }
    /// <summary>
    /// The <see langword="for"/> statement executes a statement or a block of statements while a specified
    /// Boolean expression evaluates to <see langword="true"/>.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-for-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <typeparam name="TExternal">The type of external parameter to pass into the callback.</typeparam>
    /// <param name="upper">The length to reach to in the for loop.</param>
    /// <param name="external">Any external parameter to be passed repeatedly into the callback.</param>
    /// <param name="action">The action for each loop.</param>
    /// <returns>The parameter <paramref name="upper"/>.</returns>
    [NonNegativeValue]
    public static int For<TExternal>(
        [NonNegativeValue] this int upper,
        TExternal external,
        [InstantHandle] Action<int, TExternal> action
    )
    {
        for (var i = 0; i < upper; i++)
            action(i, external);
        return upper;
    }
#if !NET20 && !NET30
    /// <summary>
    /// The <see langword="foreach"/> statement executes a statement or a block of statements for each element in an
    /// instance of the type that implements the <see cref="IEnumerable{T}"/> interface.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-foreach-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <typeparam name="T">The type of iterator.</typeparam>
    /// <param name="iterable">The collection of items to go through one-by-one.</param>
    /// <param name="action">The action to do on each item in <paramref name="iterable"/>.</param>
    /// <returns>The parameter <paramref name="iterable"/>.</returns>
    public static ICollection<T> For<T>(
        [InstantHandle] this IEnumerable<T> iterable,
        [InstantHandle] Action<T> action
    )
    {
        var list = iterable.ToICollection();
        foreach (var item in list)
            action(item);
        return list;
    }
    /// <summary>
    /// The <see langword="foreach"/> statement executes a statement or a block of statements for each element in an
    /// instance of the type that implements the <see cref="IEnumerable{T}"/> interface.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-foreach-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <typeparam name="T">The type of iterator.</typeparam>
    /// <typeparam name="TExternal">The type of external parameter to pass into the callback.</typeparam>
    /// <param name="iterable">The collection of items to go through one-by-one.</param>
    /// <param name="external">Any external parameter to be passed repeatedly into the callback.</param>
    /// <param name="action">The action to do on each item in <paramref name="iterable"/>.</param>
    /// <returns>The parameter <paramref name="iterable"/>.</returns>
    public static ICollection<T> For<T, TExternal>(
        [InstantHandle] this IEnumerable<T> iterable,
        TExternal external,
        [InstantHandle] Action<T, TExternal> action
    )
    {
        var list = iterable.ToICollection();
        foreach (var item in list)
            action(item, external);
        return list;
    }
    /// <summary>
    /// The <see langword="foreach"/> statement executes a statement or a block of statements for each element in an
    /// instance of the type that implements the <see cref="IEnumerable{T}"/> interface.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-foreach-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <typeparam name="T">The type of iterator.</typeparam>
    /// <param name="iterable">The collection of items to go through one-by-one.</param>
    /// <param name="action">The action to do on each item in <paramref name="iterable"/>.</param>
    /// <returns>The parameter <paramref name="iterable"/>.</returns>
    public static ICollection<T> For<T>(
        [InstantHandle] this IEnumerable<T> iterable,
        [InstantHandle] Action<T, int> action
    )
    {
        var list = iterable.ToICollection();
        var i = 0;
        foreach (var item in list)
            action(item, checked(i++));
        return list;
    }
    /// <summary>
    /// The <see langword="foreach"/> statement executes a statement or a block of statements for each element in an
    /// instance of the type that implements the <see cref="IEnumerable{T}"/> interface.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-foreach-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <typeparam name="T">The type of iterator.</typeparam>
    /// <typeparam name="TExternal">The type of external parameter to pass into the callback.</typeparam>
    /// <param name="iterable">The collection of items to go through one-by-one.</param>
    /// <param name="external">Any external parameter to be passed repeatedly into the callback.</param>
    /// <param name="action">The action to do on each item in <paramref name="iterable"/>.</param>
    /// <returns>The parameter <paramref name="iterable"/>.</returns>
    public static ICollection<T> For<T, TExternal>(
        [InstantHandle] this IEnumerable<T> iterable,
        TExternal external,
        [InstantHandle] Action<T, int, TExternal> action
    )
    {
        var list = iterable.ToICollection();
        var i = 0;
        foreach (var item in list)
            action(item, checked(i++), external);
        return list;
    }
#endif
    /// <summary>
    /// The <see langword="foreach"/> statement executes a statement or a block of statements for each element in an
    /// instance of the type that implements the <see cref="IEnumerable{T}"/> interface.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-foreach-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <typeparam name="TKey">The type of key in the dictionary.</typeparam>
    /// <typeparam name="TValue">The type of value in the dictionary.</typeparam>
    /// <param name="dictionary">The collection of items to go through one-by-one.</param>
    /// <param name="action">The action to do on each item in <paramref name="dictionary"/>.</param>
    /// <returns>The parameter <paramref name="dictionary"/>.</returns>
    public static IDictionary<TKey, TValue> For<TKey, TValue>(
        [InstantHandle] this IDictionary<TKey, TValue> dictionary,
        [InstantHandle] Action<TKey, TValue> action
    )
        where TKey : notnull
    {
        foreach (var kvp in dictionary)
            action(kvp.Key, kvp.Value);
        return dictionary;
    }
    /// <summary>
    /// The <see langword="foreach"/> statement executes a statement or a block of statements for each element in an
    /// instance of the type that implements the <see cref="IEnumerable{T}"/> interface.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-foreach-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <typeparam name="TKey">The type of key in the dictionary.</typeparam>
    /// <typeparam name="TValue">The type of value in the dictionary.</typeparam>
    /// <typeparam name="TExternal">The type of external parameter to pass into the callback.</typeparam>
    /// <param name="dictionary">The collection of items to go through one-by-one.</param>
    /// <param name="external">Any external parameter to be passed repeatedly into the callback.</param>
    /// <param name="action">The action to do on each item in <paramref name="dictionary"/>.</param>
    /// <returns>The parameter <paramref name="dictionary"/>.</returns>
    public static IDictionary<TKey, TValue> For<TKey, TValue, TExternal>(
        [InstantHandle] this IDictionary<TKey, TValue> dictionary,
        TExternal external,
        [InstantHandle] Action<TKey, TValue, TExternal> action
    )
        where TKey : notnull
    {
        foreach (var kvp in dictionary)
            action(kvp.Key, kvp.Value, external);
        return dictionary;
    }
    /// <summary>
    /// The <see langword="foreach"/> statement executes a statement or a block of statements for each element in an
    /// instance of the type that implements the <see cref="IEnumerable{T}"/> interface.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-foreach-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <typeparam name="TKey">The type of key in the dictionary.</typeparam>
    /// <typeparam name="TValue">The type of value in the dictionary.</typeparam>
    /// <param name="dictionary">The collection of items to go through one-by-one.</param>
    /// <param name="action">The action to do on each item in <paramref name="dictionary"/>.</param>
    /// <returns>The parameter <paramref name="dictionary"/>.</returns>
    public static IDictionary<TKey, TValue> For<TKey, TValue>(
        [InstantHandle] this IDictionary<TKey, TValue> dictionary,
        [InstantHandle] Action<TKey, TValue, int> action
    )
        where TKey : notnull
    {
        var i = 0;
        foreach (var kvp in dictionary)
            action(kvp.Key, kvp.Value, checked(i++));
        return dictionary;
    }
    /// <summary>
    /// The <see langword="foreach"/> statement executes a statement or a block of statements for each element in an
    /// instance of the type that implements the <see cref="IEnumerable{T}"/> interface.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-foreach-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <typeparam name="TKey">The type of key in the dictionary.</typeparam>
    /// <typeparam name="TValue">The type of value in the dictionary.</typeparam>
    /// <typeparam name="TExternal">The type of external parameter to pass into the callback.</typeparam>
    /// <param name="dictionary">The collection of items to go through one-by-one.</param>
    /// <param name="external">Any external parameter to be passed repeatedly into the callback.</param>
    /// <param name="action">The action to do on each item in <paramref name="dictionary"/>.</param>
    /// <returns>The parameter <paramref name="dictionary"/>.</returns>
    public static IDictionary<TKey, TValue> For<TKey, TValue, TExternal>(
        [InstantHandle] this IDictionary<TKey, TValue> dictionary,
        TExternal external,
        [InstantHandle] Action<TKey, TValue, int, TExternal> action
    )
        where TKey : notnull
    {
        var i = 0;
        foreach (var kvp in dictionary)
            action(kvp.Key, kvp.Value, checked(i++), external);
        return dictionary;
    }
#if !NET20 && !NET30
    /// <summary>
    /// The <see langword="for"/> statement executes a statement or a block of statements while a specified
    /// Boolean expression evaluates to <see langword="true"/>.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-for-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <param name="num">The range of numbers to iterate over in the <see langword="for"/> loop.</param>
    /// <returns>An enumeration from a range's start to end.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<int> For(this int num) =>
        num >= 0 ? Enumerable.Range(0, num) : Enumerable.Repeat(-num, -num).Select((x, i) => x - i - 1);
    /// <summary>Gets an enumeration of a number.</summary>
    /// <param name="num">The index to count up or down to.</param>
    /// <returns>An enumeration from 0 to the index's value, or vice versa.</returns>
    [MustDisposeResource, Pure]
    public static IEnumerator<int> GetEnumerator(this int num) => num.For().GetEnumerator();
    /// <summary>
    /// The <see langword="for"/> statement executes a statement or a block of statements while a specified
    /// Boolean expression evaluates to <see langword="true"/>.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-for-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <typeparam name="TExternal">The type of external parameter to pass into the callback.</typeparam>
    /// <param name="upper">The length to reach to in the for loop.</param>
    /// <param name="external">Any external parameter to be passed repeatedly into the callback.</param>
    /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="int"/> from ranges 0 to <paramref name="upper"/> - 1.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<TExternal> For<TExternal>([NonNegativeValue] this int upper, TExternal external) =>
        Enumerable.Repeat(external, upper);
    /// <summary>
    /// The <see langword="for"/> statement executes a statement or a block of statements while a specified
    /// Boolean expression evaluates to <see langword="true"/>.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-for-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <typeparam name="TResult">The type of iterator.</typeparam>
    /// <param name="upper">The length to reach to in the for loop.</param>
    /// <param name="func">The function for each loop.</param>
    /// <returns>All instances that <paramref name="func"/> used in an <see cref="IEnumerable{T}"/>.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<TResult> For<TResult>(
        [NonNegativeValue] this int upper,
        [InstantHandle] Func<TResult> func
    ) =>
        Enumerable.Repeat(func, upper).Select(x => x());
    /// <summary>
    /// The <see langword="for"/> statement executes a statement or a block of statements while a specified
    /// Boolean expression evaluates to <see langword="true"/>.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-for-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <typeparam name="TResult">The type of iterator.</typeparam>
    /// <param name="upper">The length to reach to in the for loop.</param>
    /// <param name="func">The function for each loop.</param>
    /// <returns>All instances that <paramref name="func"/> used in an <see cref="IEnumerable{T}"/>.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<TResult> For<TResult>(
        [NonNegativeValue] this int upper,
        [InstantHandle] Converter<int, TResult> func
    ) =>
        Enumerable.Repeat(func, upper).Select((x, i) => x(i));
#endif
#if NET7_0_OR_GREATER
    /// <summary>
    /// The <see langword="for"/> statement executes a statement or a block of statements while a specified
    /// Boolean expression evaluates to <see langword="true"/>.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-for-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <typeparam name="T">The type of number for the loop.</typeparam>
    /// <param name="upper">The range of numbers to iterate over in the <see langword="for"/> loop.</param>
    /// <returns>An enumeration from a range's start to end.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<T> For<T>(this T upper)
        where T : IComparisonOperators<T?, T?, bool>,
        ISubtractionOperators<T, T, T>,
        IIncrementOperators<T>
    {
        var isNegative = upper < default(T);
        var abs = isNegative ? default(T)! - upper : upper;
        for (T? i = default; i < abs; i!++)
            yield return isNegative ? upper - i! : i!;
    }
    /// <summary>Gets an enumeration of a number.</summary>
    /// <typeparam name="T">The type of number for the loop.</typeparam>
    /// <param name="num">The index to count up or down to.</param>
    /// <returns>An enumeration from 0 to the index's value, or vice versa.</returns>
    [MustDisposeResource, Pure]
    public static IEnumerator<T> GetEnumerator<T>(this T num)
        where T : IComparisonOperators<T?, T?, bool>,
        ISubtractionOperators<T, T, T>,
        IIncrementOperators<T> =>
        num.For().GetEnumerator();
    /// <summary>
    /// The <see langword="for"/> statement executes a statement or a block of statements while a specified
    /// Boolean expression evaluates to <see langword="true"/>.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-for-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <typeparam name="T">The type of number for the loop.</typeparam>
    /// <typeparam name="TExternal">The type of external parameter to pass into the callback.</typeparam>
    /// <param name="upper">The length to reach to in the for loop.</param>
    /// <param name="external">Any external parameter to be passed repeatedly into the callback.</param>
    /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="int"/> from ranges 0 to <paramref name="upper"/> - 1.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<TExternal> For<T, TExternal>([NonNegativeValue] this T upper, TExternal external)
        where T : IComparisonOperators<T?, T?, bool>, ISubtractionOperators<T, T, T>, IIncrementOperators<T>
    {
        var abs = upper < default(T) ? default(T)! - upper : upper;
        for (T? i = default; i < abs; i!++)
            yield return external;
    }
    /// <summary>
    /// The <see langword="for"/> statement executes a statement or a block of statements while a specified
    /// Boolean expression evaluates to <see langword="true"/>.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-for-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <typeparam name="T">The type of number for the loop.</typeparam>
    /// <typeparam name="TResult">The type of iterator.</typeparam>
    /// <param name="upper">The length to reach to in the for loop.</param>
    /// <param name="func">The function for each loop.</param>
    /// <returns>All instances that <paramref name="func"/> used in an <see cref="IEnumerable{T}"/>.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<TResult> For<T, TResult>(
        [NonNegativeValue] this T upper,
        [InstantHandle] Func<TResult> func
    )
        where T : IComparisonOperators<T?, T?, bool>, ISubtractionOperators<T, T, T>, IIncrementOperators<T>
    {
        var abs = upper < default(T) ? default(T)! - upper : upper;
        for (T? i = default; i < abs; i!++)
            yield return func();
    }
    /// <summary>
    /// The <see langword="for"/> statement executes a statement or a block of statements while a specified
    /// Boolean expression evaluates to <see langword="true"/>.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-for-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <typeparam name="T">The type of number for the loop.</typeparam>
    /// <typeparam name="TResult">The type of iterator.</typeparam>
    /// <param name="upper">The length to reach to in the for loop.</param>
    /// <param name="func">The function for each loop.</param>
    /// <returns>All instances that <paramref name="func"/> used in an <see cref="IEnumerable{T}"/>.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<TResult> For<T, TResult>(
        [NonNegativeValue] this T upper,
        [InstantHandle] Converter<T, TResult> func
    )
        where T : IComparisonOperators<T?, T?, bool>, ISubtractionOperators<T, T, T>, IIncrementOperators<T>
    {
        var isNegative = upper < default(T);
        var abs = isNegative ? default(T)! - upper : upper;
        for (T? i = default; i < abs; i!++)
            yield return func(isNegative ? upper - i! : i!);
    }
    /// <summary>
    /// The <see langword="for"/> statement executes a statement or a block of statements while a specified
    /// Boolean expression evaluates to <see langword="true"/>.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-for-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <typeparam name="T">The type of number for the loop.</typeparam>
    /// <param name="upper">The length to reach to in the for loop.</param>
    /// <param name="action">The action for each loop.</param>
    /// <returns>The parameter <paramref name="upper"/>.</returns>
    [NonNegativeValue]
    public static T For<T>([NonNegativeValue] this T upper, [InstantHandle] Action action)
        where T : IComparisonOperators<T?, T, bool>, IIncrementOperators<T>
    {
        for (T? i = default; i < upper; i!++)
            action();
        return upper;
    }
    /// <summary>
    /// The <see langword="for"/> statement executes a statement or a block of statements while a specified
    /// Boolean expression evaluates to <see langword="true"/>.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-for-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <typeparam name="T">The type of number for the loop.</typeparam>
    /// <param name="upper">The length to reach to in the for loop.</param>
    /// <param name="action">The action for each loop.</param>
    /// <returns>The parameter <paramref name="upper"/>.</returns>
    [NonNegativeValue]
    public static T For<T>([NonNegativeValue] this T upper, [InstantHandle] Action<T> action)
        where T : IComparisonOperators<T?, T, bool>, IIncrementOperators<T>
    {
        for (T? i = default; i < upper; i!++)
            action(i!);
        return upper;
    }
    /// <summary>
    /// The <see langword="for"/> statement executes a statement or a block of statements while a specified
    /// Boolean expression evaluates to <see langword="true"/>.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-for-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <typeparam name="T">The type of number for the loop.</typeparam>
    /// <typeparam name="TExternal">The type of external parameter to pass into the callback.</typeparam>
    /// <param name="upper">The length to reach to in the for loop.</param>
    /// <param name="external">Any external parameter to be passed repeatedly into the callback.</param>
    /// <param name="action">The action for each loop.</param>
    /// <returns>The parameter <paramref name="upper"/>.</returns>
    [NonNegativeValue]
    public static T For<T, TExternal>(
        [NonNegativeValue] this T upper,
        TExternal external,
        [InstantHandle] Action<TExternal> action
    )
        where T : IComparisonOperators<T?, T, bool>, IIncrementOperators<T>
    {
        for (T? i = default; i < upper; i!++)
            action(external);
        return upper;
    }
    /// <summary>
    /// The <see langword="for"/> statement executes a statement or a block of statements while a specified
    /// Boolean expression evaluates to <see langword="true"/>.
    /// </summary>
    /// <remarks><para><a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/statements/iteration-statements#the-for-statement">
    /// See here for more information.
    /// </a></para></remarks>
    /// <typeparam name="T">The type of number for the loop.</typeparam>
    /// <typeparam name="TExternal">The type of external parameter to pass into the callback.</typeparam>
    /// <param name="upper">The length to reach to in the for loop.</param>
    /// <param name="external">Any external parameter to be passed repeatedly into the callback.</param>
    /// <param name="action">The action for each loop.</param>
    /// <returns>The parameter <paramref name="upper"/>.</returns>
    [NonNegativeValue]
    public static T For<T, TExternal>(
        [NonNegativeValue] this T upper,
        TExternal external,
        [InstantHandle] Action<T, TExternal> action
    )
        where T : IComparisonOperators<T?, T, bool>, IIncrementOperators<T>
    {
        for (T? i = default; i < upper; i!++)
            action(i!, external);
        return upper;
    }
#endif
    /// <inheritdoc cref="System.Array.FindAll{T}(T[], Predicate{T})"/>
    public static T[] FindAll<T>(this T[] array, [InstantHandle] Predicate<T> match) => Array.FindAll(array, match);
    /// <inheritdoc cref="System.Array.ConvertAll{TInput, TOutput}(TInput[], Converter{TInput, TOutput})"/>
    public static TOutput[] ConvertAll<TInput, TOutput>(
        this TInput[] array,
        [InstantHandle] Converter<TInput, TOutput> converter
    ) =>
        Array.ConvertAll(array, converter);
#if NETCOREAPP || ROSLYN
    /// <inheritdoc cref="System.Array.ConvertAll{TInput, TOutput}(TInput[], Converter{TInput, TOutput})"/>
    public static ImmutableArray<TOutput> ConvertAll<TInput, TOutput>(
        this ImmutableArray<TInput> array,
        [InstantHandle] Converter<TInput, TOutput> converter
    ) =>
        ImmutableCollectionsMarshal.AsImmutableArray(ImmutableCollectionsMarshal.AsArray(array)!.ConvertAll(converter));
#endif
    /// <inheritdoc cref="System.Array.AsReadOnly{T}(T[])"/>
    public static System.Collections.ObjectModel.ReadOnlyCollection<T> AsReadOnly<T>(this T[]? array) =>
        Array.AsReadOnly(array ?? []);
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable once CheckNamespace
/// <summary>Contains a myriad of strings that list all whitespace characters.</summary>
    /// <summary>All Unicode characters where <c>White_Space=yes</c>, and are line breaks.</summary>
    public const string Breaking = "\n\v\f\r\u0085\u2028\u2029";
    /// <summary>All Unicode characters where <c>White_Space=yes</c>, and are not a line break.</summary>
    public const string NonBreaking =
        "\t\u0020\u00A0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000";
    /// <summary>All Unicode characters where <c>White_Space=no</c>, but appears to be whitespace.</summary>
    public const string Related = "\u180E\u200B\u200C\u200D\u2060\uFEFF";
    /// <summary>All Unicode characters where <c>White_Space=yes</c>.</summary>
    public const string Unicode = $"{Breaking}{NonBreaking}";
    /// <summary>All Unicode characters that appear to be whitespace.</summary>
    public const string Combined = $"{Unicode}{Related}";
#if NET8_0_OR_GREATER
    /// <inheritdoc cref="Breaking"/>
    public static OnceMemoryManager<SearchValues<char>> BreakingSearch
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get;
    } = new(SearchValues.Create(Breaking));
    /// <inheritdoc cref="NonBreaking"/>
    public static OnceMemoryManager<SearchValues<char>> NonBreakingSearch
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get;
    } = new(SearchValues.Create(NonBreaking));
    /// <inheritdoc cref="Related"/>
    public static OnceMemoryManager<SearchValues<char>> RelatedSearch
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get;
    } = new(SearchValues.Create(Related));
    /// <inheritdoc cref="Unicode"/>
    public static OnceMemoryManager<SearchValues<char>> UnicodeSearch
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get;
    } = new(SearchValues.Create(Unicode));
    /// <inheritdoc cref="Combined"/>
    public static OnceMemoryManager<SearchValues<char>> CombinedSearch
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get;
    } = new(SearchValues.Create(Combined));
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable BadPreprocessorIndent CheckNamespace ConvertToAutoPropertyWhenPossible InvertIf RedundantNameQualifier RedundantReadonlyModifier RedundantUsingDirective StructCanBeMadeReadOnly UseSymbolAlias
#pragma warning disable CS8631, IDE0032, RCS1158
#if NET8_0_OR_GREATER
// -
#else
#endif
/// <summary>Methods to split spans into multiple spans.</summary>
    /// <summary>The type that indicates to match all elements.</summary>
    public struct MatchAll;
    /// <summary>The type that indicates to match any element.</summary>
    public struct MatchAny;
    /// <summary>The type that indicates to match exactly one element.</summary>
    public struct MatchOne;
    /// <summary>Determines whether both splits are eventually equal when concatenating all slices.</summary>
    /// <typeparam name="TSeparator">The type of separator for the left-hand side.</typeparam>
    /// <typeparam name="TStrategy">The strategy for splitting for the left-hand side.</typeparam>
    /// <typeparam name="TOtherSeparator">The type of separator for the right-hand side.</typeparam>
    /// <typeparam name="TOtherStrategy">The strategy for splitting for the right-hand side.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="comparison">The <see cref="StringComparison"/> to compare the strings with.</param>
    /// <returns>
    /// The value <paramref langword="true"/> if both sequences are equal, otherwise; <paramref langword="false"/>.
    /// </returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool ConcatEqual<TSeparator, TStrategy, TOtherSeparator, TOtherStrategy>(
        this scoped SplitSpan<char, TSeparator, TStrategy> left,
        scoped SplitSpan<char, TOtherSeparator, TOtherStrategy> right,
        StringComparison comparison
    )
#if !NET7_0_OR_GREATER
        where TSeparator : IEquatable<TSeparator>?
        where TOtherSeparator : IEquatable<TOtherSeparator>?
#endif
    {
        if (left.GetEnumerator() is var e && right.GetEnumerator() is var otherE && !e.MoveNext())
            return !otherE.MoveNext();
        if (!otherE.MoveNext())
            return false;
        ReadOnlySpan<char> reader = e.Current, otherReader = otherE.Current;
        while (true)
            if (EqualityMoveNext(ref e, ref otherE, ref reader, ref otherReader, comparison, out var ret))
                return ret;
    }
    /// <summary>Splits a span by the specified separator.</summary>
    /// <typeparam name="T">The type of element from the span.</typeparam>
    /// <param name="span">The span to split.</param>
    /// <param name="separator">The separator.</param>
    /// <returns>The enumerable object that references the parameter <paramref name="span"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<T, T, MatchAny> SplitOnAny<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> separator)
#if UNMANAGED_SPAN
        where T : unmanaged, IEquatable<T>
#else
        where T : IEquatable<T>
#endif
        =>
            new(span, separator);
    /// <inheritdoc cref="SplitOnAny{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<T, T, MatchAny> SplitOnAny<T>(this Span<T> span, ReadOnlySpan<T> separator)
#if UNMANAGED_SPAN
        where T : unmanaged, IEquatable<T>
#else
        where T : IEquatable<T>
#endif
        =>
            span.ReadOnly().SplitOnAny(separator);
    /// <summary>Splits a span by the specified separator.</summary>
    /// <typeparam name="T">The type of element from the span.</typeparam>
    /// <param name="span">The span to split.</param>
    /// <param name="separator">The separator.</param>
    /// <returns>The enumerable object that references the parameter <paramref name="span"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<T, T, MatchAll> SplitOn<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> separator)
#if UNMANAGED_SPAN
        where T : unmanaged, IEquatable<T>
#else
        where T : IEquatable<T>
#endif
        =>
            new(span, separator);
    /// <inheritdoc cref="SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<T, T, MatchAll> SplitOn<T>(this Span<T> span, ReadOnlySpan<T> separator)
#if UNMANAGED_SPAN
        where T : unmanaged, IEquatable<T>
#else
        where T : IEquatable<T>
#endif
        =>
            span.ReadOnly().SplitOn(separator);
#if NET8_0_OR_GREATER
    /// <inheritdoc cref="SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<T, SearchValues<T>, MatchAny> SplitOn<T>(
        this ReadOnlySpan<T> span,
        in SearchValues<T> separator
    )
        where T : IEquatable<T> =>
        new(span, In(separator));
    /// <inheritdoc cref="SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<T, SearchValues<T>, MatchAny> SplitOn<T>(
        this Span<T> span,
        in SearchValues<T> separator
    )
        where T : IEquatable<T> =>
        span.ReadOnly().SplitOn(separator);
#endif
    /// <inheritdoc cref="SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<T, T, MatchOne> SplitOn<T>(this ReadOnlySpan<T> span, in T separator)
#if UNMANAGED_SPAN
        where T : unmanaged, IEquatable<T>
#else
        where T : IEquatable<T>?
#endif
        =>
            new(span, In(separator));
    /// <inheritdoc cref="SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<T, T, MatchOne> SplitOn<T>(this Span<T> span, in T separator)
#if UNMANAGED_SPAN
        where T : unmanaged, IEquatable<T>
#else
        where T : IEquatable<T>?
#endif
        =>
            span.ReadOnly().SplitOn(separator);
#if (NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) && !NO_SYSTEM_MEMORY
    /// <inheritdoc cref="SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<byte, byte, MatchOne> SplitOn(this ReadOnlySpan<byte> span, byte separator) =>
        new(span, separator.AsSpan());
    /// <inheritdoc cref="SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<byte, byte, MatchOne> SplitOn(this Span<byte> span, byte separator) =>
        span.ReadOnly().SplitOn(separator);
    /// <inheritdoc cref="SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<char, char, MatchOne> SplitOn(this ReadOnlySpan<char> span, char separator) =>
        new(span, separator.AsSpan());
    /// <inheritdoc cref="SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<char, char, MatchOne> SplitOn(this Span<char> span, char separator) =>
        span.ReadOnly().SplitOn(separator);
    /// <inheritdoc cref="SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<sbyte, sbyte, MatchOne> SplitOn(this ReadOnlySpan<sbyte> span, sbyte separator) =>
        new(span, separator.AsSpan());
    /// <inheritdoc cref="SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<sbyte, sbyte, MatchOne> SplitOn(this Span<sbyte> span, sbyte separator) =>
        span.ReadOnly().SplitOn(separator);
    /// <inheritdoc cref="SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<short, short, MatchOne> SplitOn(this ReadOnlySpan<short> span, short separator) =>
        new(span, separator.AsSpan());
    /// <inheritdoc cref="SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<short, short, MatchOne> SplitOn(this Span<short> span, short separator) =>
        span.ReadOnly().SplitOn(separator);
    /// <inheritdoc cref="SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<ushort, ushort, MatchOne> SplitOn(this ReadOnlySpan<ushort> span, ushort separator) =>
        new(span, separator.AsSpan());
    /// <inheritdoc cref="SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<ushort, ushort, MatchOne> SplitOn(this Span<ushort> span, ushort separator) =>
        span.ReadOnly().SplitOn(separator);
    /// <inheritdoc cref="SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<char, char, MatchOne> SplitSpanOn(this string? span, char separator) =>
        span.AsSpan().SplitOn(separator);
#endif
    /// <inheritdoc cref="SplitOnAny{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<char, char, MatchAny> SplitSpanOnAny(this string? span, string? separator) =>
        span.AsSpan().SplitOnAny(separator.AsSpan());
    /// <inheritdoc cref="SplitOnAny{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<char, char, MatchAny> SplitOnAny(this string? span, ReadOnlySpan<char> separator) =>
        span.AsSpan().SplitOnAny(separator);
    /// <inheritdoc cref="SplitOnAny{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<char, char, MatchAny> SplitOnAny(this ReadOnlySpan<char> span, string? separator) =>
        span.SplitOnAny(separator.AsSpan());
    /// <inheritdoc cref="SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<char, char, MatchAll> SplitSpanOn(this string? span, string? separator) =>
        span.AsSpan().SplitOn(separator.AsSpan());
    /// <inheritdoc cref="SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<char, char, MatchAll> SplitOn(this string? span, ReadOnlySpan<char> separator) =>
        span.AsSpan().SplitOn(separator);
    /// <inheritdoc cref="SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<char, char, MatchAll> SplitOn(this ReadOnlySpan<char> span, string? separator) =>
        span.SplitOn(separator.AsSpan());
    /// <inheritdoc cref="SplitLines(ReadOnlySpan{char})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<char, ComptimeString, MatchAny> SplitSpanLines(this string? span) =>
        span.AsSpan().SplitLines();
    /// <summary>Splits a span by line breaks.</summary>
    /// <remarks><para>Line breaks are considered any character in <see cref="Breaking"/>.</para></remarks>
    /// <param name="span">The span to split.</param>
    /// <returns>The enumerable object that references the parameter <paramref name="span"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<char, ComptimeString, MatchAny> SplitLines(this ReadOnlySpan<char> span) =>
#if NET8_0_OR_GREATER
        new(span, BreakingSearch.GetSpan());
#else
        new(span, Breaking.AsSpan());
#endif
    /// <inheritdoc cref="SplitLines(ReadOnlySpan{char})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<char, ComptimeString, MatchAny> SplitLines(this Span<char> span) =>
        span.ReadOnly().SplitLines();
    /// <inheritdoc cref="SplitWhitespace(ReadOnlySpan{char})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<char, ComptimeString, MatchAny> SplitSpanWhitespace(this string? span) =>
        span.AsSpan().SplitWhitespace();
    /// <summary>Splits a span by whitespace.</summary>
    /// <remarks><para>Whitespace is considered any character in <see cref="Unicode"/>.</para></remarks>
    /// <param name="span">The span to split.</param>
    /// <returns>The enumerable object that references the parameter <paramref name="span"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<char, ComptimeString, MatchAny> SplitWhitespace(this ReadOnlySpan<char> span) =>
#if NET8_0_OR_GREATER
        new(span, UnicodeSearch.Memory.Span);
#else
        new(span, Unicode.AsSpan());
#endif
    /// <inheritdoc cref="SplitWhitespace(ReadOnlySpan{char})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<char, ComptimeString, MatchAny> SplitWhitespace(this Span<char> span) =>
        span.ReadOnly().SplitWhitespace();
#if NET8_0_OR_GREATER
    /// <inheritdoc cref="SplitOn{T}(ReadOnlySpan{T}, in SearchValues{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitSpan<char, SearchValues<char>, MatchAny> SplitSpanOn(
        this string? span,
        in SearchValues<char> separator
    ) =>
        span.AsSpan().SplitOn(separator);
#endif
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    static bool EqualityMoveNext<TSeparator, TStrategy, TOtherSeparator, TOtherStrategy>(
        scoped ref SplitSpan<char, TSeparator, TStrategy>.Enumerator that,
        scoped ref SplitSpan<char, TOtherSeparator, TOtherStrategy>.Enumerator other,
        scoped ref ReadOnlySpan<char> reader,
        scoped ref ReadOnlySpan<char> otherReader,
        StringComparison comparison,
        out bool ret
    )
#if !NET7_0_OR_GREATER
        where TSeparator : IEquatable<TSeparator>?
        where TOtherSeparator : IEquatable<TOtherSeparator>?
#endif
    {
        if (reader.Length is var length && otherReader.Length is var otherLength && length == otherLength)
            return SameLength(ref that, ref other, ref reader, ref otherReader, comparison, out ret);
        if (length < otherLength)
        {
            if (!reader.Equals(otherReader.UnsafelyTake(length), comparison) || !that.MoveNext())
            {
                ret = false;
                return true;
            }
            reader = that.Current;
            otherReader = otherReader.UnsafelySkip(length);
            Unsafe.SkipInit(out ret);
            return false;
        }
        if (!reader.UnsafelyTake(otherLength).Equals(otherReader, comparison) || !other.MoveNext())
        {
            ret = false;
            return true;
        }
        reader = reader.UnsafelySkip(otherLength);
        otherReader = other.Current;
        Unsafe.SkipInit(out ret);
        return false;
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    static bool SameLength<TSeparator, TStrategy, TOtherSeparator, TOtherStrategy>(
        scoped ref SplitSpan<char, TSeparator, TStrategy>.Enumerator that,
        scoped ref SplitSpan<char, TOtherSeparator, TOtherStrategy>.Enumerator other,
        scoped ref ReadOnlySpan<char> reader,
        scoped ref ReadOnlySpan<char> otherReader,
        StringComparison comparison,
        out bool ret
    )
#if !NET7_0_OR_GREATER
        where TSeparator : IEquatable<TSeparator>?
        where TOtherSeparator : IEquatable<TOtherSeparator>?
#endif
    {
        if (!reader.Equals(otherReader, comparison))
        {
            ret = false;
            return true;
        }
        if (!that.MoveNext())
        {
            ret = !other.MoveNext();
            return true;
        }
        if (!other.MoveNext())
        {
            ret = false;
            return true;
        }
        reader = that.Current;
        otherReader = other.Current;
        Unsafe.SkipInit(out ret);
        return false;
    }
/// <summary>Represents a split entry.</summary>
/// <typeparam name="TBody">The type of element from the span.</typeparam>
/// <typeparam name="TSeparator">The type of separator.</typeparam>
/// <typeparam name="TStrategy">The strategy for splitting elements.</typeparam>
/// <param name="body">The line to split.</param>
/// <param name="separator">The separator.</param>
[StructLayout(LayoutKind.Auto)]
[method: MethodImpl(MethodImplOptions.AggressiveInlining)]
#if CSHARPREPL
public
#endif
#if !NO_READONLY_STRUCTS
readonly
#endif
#if !NO_REF_STRUCTS
    ref
#endif
    partial struct SplitSpan<TBody, TSeparator, TStrategy>(ReadOnlySpan<TBody> body, ReadOnlySpan<TSeparator> separator)
#if UNMANAGED_SPAN
    where TBody : unmanaged, IEquatable<TBody>?
#else
    where TBody : IEquatable<TBody>?
#endif
#if !NET7_0_OR_GREATER
    where TSeparator : IEquatable<TSeparator>?
#endif
{
    /// <summary>Represents the accumulator function for the enumeration of this type.</summary>
    /// <typeparam name="TAccumulator">The type of the accumulator value.</typeparam>
    /// <param name="accumulator">The accumulator.</param>
    /// <param name="next">The next slice from the enumeration.</param>
    /// <returns>The final accumulator value.</returns>
    public delegate TAccumulator Accumulator<TAccumulator>(TAccumulator accumulator, ReadOnlySpan<TBody> next)
#if !NO_ALLOWS_REF_STRUCT
        where TAccumulator : allows ref struct
#endif
    ;
    readonly ReadOnlySpan<TBody> _body = body;
    readonly ReadOnlySpan<TSeparator> _separator = separator;
    /// <summary>Initializes a new instance of the <see cref="SplitSpan{T, TSeparator, TStrategy}"/> struct.</summary>
    /// <param name="body">The line to split.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public SplitSpan(ReadOnlySpan<TBody> body)
        : this(body, default) { }
    /// <summary>Gets the error thrown by this type.</summary>
    public static NotSupportedException Error
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        get => new($"Unrecognized type: {typeof(TStrategy).Name}");
    }
    /// <summary>Gets the line to split.</summary>
    public readonly ReadOnlySpan<TBody> Body
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => _body;
    }
    /// <summary>Gets the first element.</summary>
    public readonly ReadOnlySpan<TBody> First
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        get => GetEnumerator() is var e && e.MoveNext() ? e.Current : default;
    }
    /// <summary>Gets the last element.</summary>
    public readonly ReadOnlySpan<TBody> Last
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        get => GetReversedEnumerator() is var e && e.MoveNext() ? e.Current : default;
    }
    /// <summary>Gets the separator.</summary>
    public readonly ReadOnlySpan<TSeparator> Separator
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => _separator;
    }
    /// <summary>Gets the single element.</summary>
    public readonly ReadOnlySpan<TBody> Single
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        get => GetEnumerator() is var e && e.MoveNext() && e.Current is var ret && !e.MoveNext() ? ret : default;
    }
    /// <summary>Gets the specified index.</summary>
    /// <param name="index">The index to get.</param>
    public readonly ReadOnlySpan<TBody> this[[NonNegativeValue] int index]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        get
        {
            var e = GetEnumerator();
            for (; index >= 0; index--)
                if (!e.MoveNext())
                    return default;
            return e.Current;
        }
    }
    /// <summary>Gets the specified index.</summary>
    /// <param name="index">The index to get.</param>
    public readonly ReadOnlySpan<TBody> this[Index index]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        get
        {
            if (index.Value is var value && !index.IsFromEnd)
                return this[value];
            var backwards = GetReversedEnumerator();
            for (; value > 0; value--)
                if (!backwards.MoveNext())
                    return default;
            return backwards.Current;
        }
    }
    /// <summary>Gets the specified range.</summary>
    /// <param name="range">The range to get.</param>
    public readonly SplitSpan<TBody, TSeparator, TStrategy> this[Range range]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        get =>
            new(
                _body.OffsetOf(this[range.Start]) is not -1 and var start &&
                this[Decrement(range.End)] is var slice &&
                _body.OffsetOf(slice) is not -1 and var end &&
                end + slice.Length - start is > 0 and var length
                    ? _body.UnsafelySlice(start, length)
                    : default,
                _separator
            );
    }
    /// <summary>Determines whether both splits are equal.</summary>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>Whether both splits are equal.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool operator ==(
        scoped SplitSpan<TBody, TSeparator, TStrategy> left,
        scoped SplitSpan<TBody, TSeparator, TStrategy> right
    ) =>
        left.Equals(right);
    /// <summary>Determines whether both splits are not equal.</summary>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>Whether both splits are not equal.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool operator !=(
        scoped SplitSpan<TBody, TSeparator, TStrategy> left,
        scoped SplitSpan<TBody, TSeparator, TStrategy> right
    ) =>
        !left.Equals(right);
    /// <summary>
    /// Explicitly converts the parameter by creating the new instance of
    /// <see cref="SplitSpan{TBody, TSeparator, TStrategy}"/> by using the constructor
    /// <see cref="SplitSpan{TBody, TSeparator, TStrategy}(ReadOnlySpan{TBody})"/>.
    /// </summary>
    /// <param name="body">The parameter to pass onto the constructor.</param>
    /// <returns>
    /// The new instance of SplitSpan{TBody, TSeparator, TStrategy} by passing the parameter <paramref name="body"/>
    /// to the constructor <see cref="SplitSpan{TBody, TSeparator, TStrategy}(ReadOnlySpan{TBody})"/>.
    /// </returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static explicit operator SplitSpan<TBody, TSeparator, TStrategy>(ReadOnlySpan<TBody> body) => new(body);
    /// <summary>Separates the head from the tail of this <see cref="SplitSpan{T, TSeparator, TStrategy}"/>.</summary>
    /// <param name="head">The first element of this enumeration.</param>
    /// <param name="tail">The rest of this enumeration.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public readonly void Deconstruct(out ReadOnlySpan<TBody> head, out SplitSpan<TBody, TSeparator, TStrategy> tail)
    {
        if (GetEnumerator() is var e && !e.MoveNext())
        {
            head = default;
            tail = default;
            return;
        }
        head = e.Current;
        tail = new(e.Body, _separator);
    }
    /// <summary>Determines whether both splits are eventually equal when concatenating all slices.</summary>
    /// <typeparam name="TOtherSeparator">The type of separator for the other side.</typeparam>
    /// <typeparam name="TOtherStrategy">The strategy for splitting for the other side.</typeparam>
    /// <param name="other">The other side.</param>
    /// <returns>
    /// The value <paramref langword="true"/> if both sequences are equal, otherwise; <paramref langword="false"/>.
    /// </returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly bool ConcatEqual<TOtherSeparator, TOtherStrategy>(
        SplitSpan<TBody, TOtherSeparator, TOtherStrategy> other
    )
#if !NET7_0_OR_GREATER
        where TOtherSeparator : IEquatable<TOtherSeparator>?
#endif
    {
        if (GetEnumerator() is var e && other.GetEnumerator() is var otherE && !e.MoveNext())
            return !otherE.MoveNext();
        if (!otherE.MoveNext())
            return false;
        ReadOnlySpan<TBody> reader = e.Current, otherReader = otherE.Current;
        while (true)
            if (e.EqualityMoveNext(ref otherE, ref reader, ref otherReader, out var ret))
                return ret;
    }
#if NET6_0_OR_GREATER
    /// <summary>Determines whether both splits are eventually equal when concatenating all slices.</summary>
    /// <typeparam name="TOtherSeparator">The type of separator for the other side.</typeparam>
    /// <typeparam name="TOtherStrategy">The strategy for splitting for the other side.</typeparam>
    /// <param name="other">The other side.</param>
    /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> to use.</param>
    /// <returns>
    /// The value <paramref langword="true"/> if both sequences are equal, otherwise; <paramref langword="false"/>.
    /// </returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly bool ConcatEqual<TOtherSeparator, TOtherStrategy>(
        SplitSpan<TBody, TOtherSeparator, TOtherStrategy> other,
        IEqualityComparer<TBody> comparer
    )
#if !NET7_0_OR_GREATER
        where TOtherSeparator : IEquatable<TOtherSeparator>?
#endif
    {
        if (GetEnumerator() is var e && other.GetEnumerator() is var otherE && !e.MoveNext())
            return !otherE.MoveNext();
        if (!otherE.MoveNext())
            return false;
        ReadOnlySpan<TBody> reader = e.Current, otherReader = otherE.Current;
        while (true)
            if (e.EqualityMoveNext(ref otherE, ref reader, ref otherReader, comparer, out var ret))
                return ret;
    }
#endif
    /// <inheritdoc />
    [MethodImpl(MethodImplOptions.AggressiveInlining), Obsolete("Always returns false", true), Pure]
    public readonly override bool Equals(object? obj) => false;
    /// <inheritdoc cref="IEquatable{T}.Equals(T)" />
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly bool Equals(scoped SplitSpan<TBody, TSeparator, TStrategy> other) =>
        _body.SequenceEqual(other._body) && _separator.SequenceEqual(other._separator);
    /// <summary>Determines whether both splits are equal.</summary>
    /// <typeparam name="TOtherSeparator">The type of separator for the right-hand side.</typeparam>
    /// <typeparam name="TOtherStrategy">The strategy for splitting elements for the right-hand side.</typeparam>
    /// <param name="other">The side to compare to.</param>
    /// <returns>
    /// The value <paramref langword="true"/> if both sequences are equal, otherwise; <paramref langword="false"/>.
    /// </returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly bool SequenceEqual<TOtherSeparator, TOtherStrategy>(
        scoped SplitSpan<TBody, TOtherSeparator, TOtherStrategy> other
    )
#if !NET7_0_OR_GREATER
        where TOtherSeparator : IEquatable<TOtherSeparator>?
#endif
    {
        Enumerator e = this;
        var eOther = other.GetEnumerator();
        while (e.MoveNext())
            if (!eOther.MoveNext() || !e.Current.SequenceEqual(eOther.Current))
                return false;
        return !eOther.MoveNext();
    }
#if NET6_0_OR_GREATER
    /// <summary>Determines whether both splits are equal.</summary>
    /// <typeparam name="TOtherSeparator">The type of separator for the right-hand side.</typeparam>
    /// <typeparam name="TOtherStrategy">The strategy for splitting elements for the right-hand side.</typeparam>
    /// <param name="other">The side to compare to.</param>
    /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> to use.</param>
    /// <returns>
    /// The value <paramref langword="true"/> if both sequences are equal, otherwise; <paramref langword="false"/>.
    /// </returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly bool SequenceEqual<TOtherSeparator, TOtherStrategy>(
        scoped SplitSpan<TBody, TOtherSeparator, TOtherStrategy> other,
        IEqualityComparer<TBody> comparer
    )
#if !NET7_0_OR_GREATER
        where TOtherSeparator : IEquatable<TOtherSeparator>?
#endif
    {
        Enumerator e = this;
        var eOther = other.GetEnumerator();
        while (e.MoveNext())
            if (!eOther.MoveNext() || !e.Current.SequenceEqual(eOther.Current, comparer))
                return false;
        return !eOther.MoveNext();
    }
#endif
    /// <summary>Computes the length.</summary>
    /// <returns>The length.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly int Count()
    {
        var count = 0;
        for (var e = GetEnumerator(); e.MoveNext(); count++) { }
        return count;
    }
    /// <inheritdoc />
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly override int GetHashCode() => unchecked(typeof(TBody).GetHashCode() * 31);
    /// <inheritdoc />
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly override string ToString() =>
        typeof(TBody) == typeof(char)
            ? Aggregate(new StringBuilder(), StringBuilderAccumulator).ToString()
            : $"[[{ToArrays().Conjoin("], [")}]]";
    /// <summary>
    /// Converts the elements of the collection to a <see cref="string"/> representation,
    /// using the specified divider between elements.
    /// </summary>
    /// <param name="divider">The divider to insert between elements.</param>
    /// <returns>A <see cref="string"/> representation of the collection.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly string ToString(scoped ReadOnlySpan<TBody> divider)
    {
        var e = GetEnumerator();
        if (!e.MoveNext())
            return "";
        IList<TBody> ret = [];
        foreach (var next in e.Current)
            ret.Add(next);
        while (e.MoveNext())
        {
            foreach (var next in divider)
                ret.Add(next);
            foreach (var next in e.Current)
                ret.Add(next);
        }
        return ret.Conjoin(typeof(TBody) == typeof(char) ? "" : ", ");
    }
    /// <summary>Copies the values to a new <see cref="string"/> array.</summary>
    /// <returns>The <see cref="string"/> array containing the copied values of this instance.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly string[] ToStringArray()
    {
        IList<string> ret = [];
        foreach (var next in this)
            ret.Add(typeof(TBody) == typeof(char) ? next.ToString() : next.ToArray().Conjoin());
        return [..ret];
    }
    /// <summary>Gets the accumulated result of a set of callbacks where each element is passed in.</summary>
    /// <typeparam name="TAccumulator">The type of the accumulator value.</typeparam>
    /// <param name="seed">The accumulator.</param>
    /// <param name="func">An accumulator function to be invoked on each element.</param>
    /// <returns>The accumulated result of <paramref name="seed"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), MustUseReturnValue]
    public readonly TAccumulator Aggregate<TAccumulator>(
        TAccumulator seed,
        [InstantHandle, RequireStaticDelegate] Accumulator<TAccumulator> func
    )
#if !NO_ALLOWS_REF_STRUCT
        where TAccumulator : allows ref struct
#endif
    {
        var accumulator = seed;
        foreach (var next in this)
            accumulator = func(accumulator, next);
        return accumulator;
    }
    /// <summary>Copies the values to a new flattened array.</summary>
    /// <returns>The array containing the copied values of this instance.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly TBody[] ToArray()
    {
        IList<TBody> ret = [];
        foreach (var next in this)
            foreach (var element in next)
                ret.Add(element);
        return [..ret];
    }
    /// <summary>Copies the values to a new flattened array.</summary>
    /// <param name="divider">The separator between each element.</param>
    /// <returns>The array containing the copied values of this instance.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly TBody[] ToArray(scoped ReadOnlySpan<TBody> divider)
    {
        if (GetEnumerator() is var e && !e.MoveNext())
            return [];
        IList<TBody> ret = [];
        foreach (var next in e.Current)
            ret.Add(next);
        while (e.MoveNext())
        {
            foreach (var next in divider)
                ret.Add(next);
            foreach (var next in e.Current)
                ret.Add(next);
        }
        return [..ret];
    }
    /// <summary>Copies the values to a new nested array.</summary>
    /// <returns>The nested array containing the copied values of this instance.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly TBody[][] ToArrays()
    {
        IList<TBody[]> ret = [];
        foreach (var next in this)
            ret.Add(next.ToArray());
        return [..ret];
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    static unsafe StringBuilder StringBuilderAccumulator(StringBuilder builder, scoped ReadOnlySpan<TBody> span)
#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
        =>
            builder.Append(To<char>.From(span));
#else
    {
#pragma warning disable CS8500
#if NETFRAMEWORK && !NET46_OR_GREATER || NETSTANDARD && !NETSTANDARD1_3_OR_GREATER
        fixed (TBody* pin = span)
        {
            var ptr = span.Align(pin);
            for (var i = 0; i < span.Length; i++)
                builder.Append(((char*)ptr)[i]);
        }
        return builder;
#else
        fixed (TBody* ptr = span)
            return builder.Append((char*)span.Align(ptr), span.Length);
#endif
#pragma warning restore CS8500
    }
#endif
    /// <summary>Decrements the index. If already <c>0</c>, flips the "from end" boolean.</summary>
    /// <param name="index">The index to decrement.</param>
    /// <returns>The decremented index.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    static Index Decrement(Index index) =>
#if NET8_0_OR_GREATER
        Unsafe.SizeOf<Index>() is sizeof(int) ?
            Unsafe.BitCast<int, Index>(Unsafe.BitCast<Index, int>(index) - 1) :
#endif
            index is { Value: 0, IsFromEnd: false } ? new(0, true) :
                new(index.IsFromEnd ? index.Value + 1 : index.Value - 1, index.IsFromEnd);
}
// SPDX-License-Identifier: MPL-2.0
#if XNA
/// <summary>Contains scaling methods for resolutions.</summary>
    /// <summary>Gets the height of the screen.</summary>
    /// <param name="device">The current width.</param>
    /// <returns>The width of the screen.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int Height(this GraphicsDevice device) =>
        OperatingSystem.IsAndroid() ? device.DisplayMode.Height : device.Viewport.Height;
    /// <summary>Gets the width of the screen.</summary>
    /// <param name="device">The current width.</param>
    /// <returns>The width of the screen.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int Width(this GraphicsDevice device) =>
        OperatingSystem.IsAndroid() ? device.DisplayMode.Width : device.Viewport.Width;
    /// <summary>Gets the resolution for <see cref="SpriteBatch.Draw(Texture2D, Rectangle, Color)"/>.</summary>
    /// <param name="device">The current width and height.</param>
    /// <param name="w">The native width.</param>
    /// <param name="h">The native height.</param>
    /// <returns>The <see cref="Rectangle"/> for <see cref="SpriteBatch.Draw(Texture2D, Rectangle, Color)"/>.</returns>
    public static Rectangle Resolution(this GraphicsDevice device, float w, float h)
    {
        var (currentWidth, currentHeight) = (device.Width(), device.Height());
        var (scaledWidth, scaledHeight) = (currentWidth / w, currentHeight / h);
        var min = scaledWidth.Min(scaledHeight);
        var (width, height) = ((int)(min * w), (int)(min * h));
        var (x, y) = ((currentWidth - width) / 2, (currentHeight - height) / 2);
        return new(x, y, width, height);
    }
    /// <summary>Gets the resolution for <see cref="SpriteBatch.Draw(Texture2D, Rectangle, Color)"/>.</summary>
    /// <param name="device">The current width and height.</param>
    /// <param name="v">The native resolution.</param>
    /// <returns>The <see cref="Rectangle"/> for <see cref="SpriteBatch.Draw(Texture2D, Rectangle, Color)"/>.</returns>
    public static Rectangle Resolution(this GraphicsDevice device, Vector2 v) => device.Resolution(v.X, v.Y);
    /// <inheritdoc cref="Rectangle.Inflate(int, int)"/>
    public static Rectangle Inflated(this Rectangle rectangle, int amount)
    {
        rectangle.Inflate(amount, amount);
        return rectangle;
    }
    /// <inheritdoc cref="Rectangle.Inflate(int, int)"/>
    public static Rectangle Inflated(this Rectangle rectangle, int horizontalAmount, int verticalAmount)
    {
        rectangle.Inflate(horizontalAmount, verticalAmount);
        return rectangle;
    }
    /// <inheritdoc cref="Rectangle.Inflate(float, float)"/>
    public static Rectangle Inflated(this Rectangle rectangle, float amount)
    {
        rectangle.Inflate(amount, amount);
        return rectangle;
    }
    /// <inheritdoc cref="Rectangle.Inflate(float, float)"/>
    public static Rectangle Inflated(this Rectangle rectangle, float horizontalAmount, float verticalAmount)
    {
        rectangle.Inflate(horizontalAmount, verticalAmount);
        return rectangle;
    }
    /// <inheritdoc cref="Rectangle.Offset(int, int)"/>
    public static Rectangle Offsetted(this Rectangle rectangle, int amount)
    {
        rectangle.Offset(amount, amount);
        return rectangle;
    }
    /// <inheritdoc cref="Rectangle.Offset(int, int)"/>
    public static Rectangle Offsetted(this Rectangle rectangle, int horizontalAmount, int verticalAmount)
    {
        rectangle.Offset(horizontalAmount, verticalAmount);
        return rectangle;
    }
    /// <inheritdoc cref="Rectangle.Offset(float, float)"/>
    public static Rectangle Offsetted(this Rectangle rectangle, float amount)
    {
        rectangle.Offset(amount, amount);
        return rectangle;
    }
    /// <inheritdoc cref="Rectangle.Offset(float, float)"/>
    public static Rectangle Offsetted(this Rectangle rectangle, float horizontalAmount, float verticalAmount)
    {
        rectangle.Offset(horizontalAmount, verticalAmount);
        return rectangle;
    }
    /// <summary>Multiples some quantity with the given <see cref="Rectangle"/>.</summary>
    /// <param name="rectangle">The <see cref="Rectangle"/> to multiply.</param>
    /// <param name="amount">The amount to multiply with.</param>
    /// <returns>The scaled up <see cref="Rectangle"/>.</returns>
    public static Rectangle Multiplied(this Rectangle rectangle, int amount) => Multiplied(rectangle, amount, amount);
    /// <summary>Multiples some quantity with the given <see cref="Rectangle"/>.</summary>
    /// <param name="rectangle">The <see cref="Rectangle"/> to multiply.</param>
    /// <param name="x">The amount to multiply with horizontally.</param>
    /// <param name="y">The amount to multiply with vertically.</param>
    /// <returns>The scaled up <see cref="Rectangle"/>.</returns>
    public static Rectangle Multiplied(this Rectangle rectangle, int x, int y) =>
        new(rectangle.X * x, rectangle.Y * y, rectangle.Width * x, rectangle.Height * y);
    /// <summary>Multiples some quantity with the given <see cref="Rectangle"/>.</summary>
    /// <param name="rectangle">The <see cref="Rectangle"/> to multiply.</param>
    /// <param name="amount">The amount to multiply with.</param>
    /// <returns>The scaled up <see cref="Rectangle"/>.</returns>
    public static Rectangle Multiplied(this Rectangle rectangle, float amount) => Multiplied(rectangle, amount, amount);
    /// <summary>Multiples some quantity with the given <see cref="Rectangle"/>.</summary>
    /// <param name="rectangle">The <see cref="Rectangle"/> to multiply.</param>
    /// <param name="x">The amount to multiply with horizontally.</param>
    /// <param name="y">The amount to multiply with vertically.</param>
    /// <returns>The scaled up <see cref="Rectangle"/>.</returns>
    public static Rectangle Multiplied(this Rectangle rectangle, float x, float y) =>
        new((int)(rectangle.X * x), (int)(rectangle.Y * y), (int)(rectangle.Width * x), (int)(rectangle.Height * y));
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable once CheckNamespace
#if !NET20 && !NET30
/// <summary>Extension methods that act as factories for <see cref="Split{T}"/>.</summary>
    /// <summary>Gets all booleans, in the order defined by <see cref="Split{T}"/>.</summary>
    public static bool[] Booleans { get; } = [true, false];
    /// <summary>Splits an <see cref="IEnumerable{T}"/> in two based on a number.</summary>
    /// <typeparam name="T">The type of the collection.</typeparam>
    /// <param name="source">The collection to split.</param>
    /// <param name="count">The number of elements in the first half.</param>
    /// <returns>
    /// A <see cref="Split{T}"/> instance that contains 2 enumerables containing the two halves of the underlying
    /// collection. The first half is as long as the parameter <paramref name="count"/> or shorter.
    /// </returns>
    [Pure]
    public static Split<IEnumerable<T>> SplitAt<T>(this ICollection<T> source, [NonNegativeValue] int count) =>
        new(source.Take(count), source.Skip(count));
    /// <summary>Splits an <see cref="IEnumerable{T}"/> in two based on a method provided.</summary>
    /// <typeparam name="T">The type of the collection.</typeparam>
    /// <param name="source">The collection to split.</param>
    /// <param name="predicate">The method that decides where the item ends up.</param>
    /// <returns>
    /// A <see cref="Split{T}"/> instance that contains 2 enumerables containing the two halves of the underlying
    /// collection. The first half lasts until the first element that returned <see langword="true"/>.
    /// </returns>
    [Pure]
    public static Split<IEnumerable<T>> SplitWhen<T>(
        [InstantHandle] this ICollection<T> source,
        [InstantHandle] Func<T, bool> predicate
    )
    {
        var index = source.TakeWhile(x => !predicate(x)).Count();
        return source.SplitAt(index);
    }
    /// <summary>Splits an <see cref="IEnumerable{T}"/> in two based on a method provided.</summary>
    /// <typeparam name="T">The type of the collection.</typeparam>
    /// <param name="source">The collection to split.</param>
    /// <param name="predicate">The method that decides where the item ends up.</param>
    /// <returns>
    /// A <see cref="Split{T}"/> instance that contains 2 lists containing the elements that returned
    /// <see langword="true"/> and <see langword="false"/>.
    /// </returns>
    [MustUseReturnValue]
    public static Split<List<T>> SplitBy<T>(
        [InstantHandle] this IEnumerable<T> source,
        [InstantHandle] Predicate<T> predicate
    )
    {
        List<T> t = [], f = [];
        foreach (var item in source)
            (predicate(item) ? t : f).Add(item);
        return new(t, f);
    }
    /// <summary>Splits an <see cref="IEnumerable{T}"/> in two based on a method provided.</summary>
    /// <typeparam name="T">The type of the collection.</typeparam>
    /// <param name="source">The collection to split.</param>
    /// <param name="predicate">The method that decides where the item ends up.</param>
    /// <returns>
    /// A <see cref="Split{T}"/> instance that contains 2 lists containing the elements that returned
    /// <see langword="true"/> and <see langword="false"/>.
    /// </returns>
    [MustUseReturnValue]
    public static Split<SmallList<T>> SmallSplitBy<T>(
        [InstantHandle] this IEnumerable<T> source,
        [InstantHandle] Predicate<T> predicate
    )
    {
        SmallList<T> t = [], f = [];
        foreach (var item in source)
            (predicate(item) ? t : f).Add(item);
        return new(t, f);
    }
#endif
/// <summary>Represents a fixed collection of 2 items.</summary>
/// <typeparam name="T">The type of item in the collection.</typeparam>
/// <param name="truthy">The value representing a <see langword="true"/> value.</param>
/// <param name="falsy">The value representing a <see langword="false"/> value.</param>
public sealed partial class Split<T>(T truthy, T falsy) : ICollection<T>,
    IDictionary<bool, T>,
    IReadOnlyCollection<T>,
    IReadOnlyDictionary<bool, T>
{
    /// <summary>Initializes a new instance of the <see cref="Split{T}"/> class.</summary>
    /// <param name="value">The value representing both values.</param>
    public Split(T value)
        : this(value, value) { }
    /// <summary>Gets <see cref="Truthy"/> and <see cref="Falsy"/> within an array, in that order.</summary>
    [Pure]
    public T[] Array => [truthy, falsy];
    /// <summary>Gets or sets the value representing a <see langword="false"/> value.</summary>
    [Pure]
    public T Falsy
    {
        get => falsy;
        set => falsy = value;
    }
    /// <summary>Gets or sets the value representing a <see langword="true"/> value.</summary>
    [Pure]
    public T Truthy
    {
        get => truthy;
        set => truthy = value;
    }
    /// <inheritdoc cref="ICollection{T}.IsReadOnly" />
    [Pure]
    bool ICollection<T>.IsReadOnly => false;
    /// <inheritdoc cref="ICollection{T}.Count" />
    [Pure, ValueRange(2)]
    int ICollection<T>.Count => 2;
    /// <inheritdoc />
    [Pure]
    public ICollection<T> Values => this;
    /// <inheritdoc cref="ICollection{T}.IsReadOnly" />
    [Pure]
    bool ICollection<KeyValuePair<bool, T>>.IsReadOnly => false;
    /// <inheritdoc cref="ICollection{T}.Count" />
    [Pure, ValueRange(2)]
    int ICollection<KeyValuePair<bool, T>>.Count => 2;
    /// <inheritdoc />
    [Pure]
    ICollection<bool> IDictionary<bool, T>.Keys => Booleans;
    /// <inheritdoc cref="Array"/>
    [Pure]
    public KeyValuePair<bool, T>[] ArrayPair => [new(true, truthy), new(false, falsy)];
    /// <inheritdoc cref="IDictionary{TKey, TValue}.this" />
    [Pure]
    public T this[bool key]
    {
        get => key ? truthy : falsy;
        set => _ = key ? truthy = value : falsy = value;
    }
    /// <inheritdoc cref="ICollection{T}.Count" />
    [Pure, ValueRange(2)]
    int IReadOnlyCollection<T>.Count => 2;
    /// <inheritdoc cref="ICollection{T}.Count" />
    [Pure, ValueRange(2)]
    int IReadOnlyCollection<KeyValuePair<bool, T>>.Count => 2;
    /// <inheritdoc />
    [Pure]
    IEnumerable<bool> IReadOnlyDictionary<bool, T>.Keys => Booleans;
    /// <inheritdoc />
    [Pure]
    IEnumerable<T> IReadOnlyDictionary<bool, T>.Values => Values;
    /// <summary>
    /// Implicitly converts the parameter by creating the new instance of <see cref="Split{T}"/>
    /// by using the constructor <see cref="Split{T}(T, T)"/>.
    /// </summary>
    /// <param name="tuple">The parameter to pass onto the constructor.</param>
    /// <returns>
    /// The new instance of <see cref="Split{T}"/> by passing the parameter <paramref name="tuple"/>
    /// to the constructor <see cref="Split{T}(T, T)"/>.
    /// </returns>
    [Pure]
    public static implicit operator Split<T>((T Truthy, T Falsy) tuple) => new(tuple.Truthy, tuple.Falsy);
    /// <inheritdoc />
    public void CopyTo(T[] array, [NonNegativeValue] int arrayIndex)
    {
        array[arrayIndex] = truthy;
        array[arrayIndex + 1] = falsy;
    }
    /// <inheritdoc />
    [Pure]
    public bool Contains(T item) =>
        EqualityComparer<T>.Default.Equals(truthy, item) || EqualityComparer<T>.Default.Equals(falsy, item);
    /// <inheritdoc />
    [Pure]
    public IEnumerator<T> GetEnumerator() => ((IEnumerable<T>)Array).GetEnumerator();
    /// <inheritdoc />
    void ICollection<T>.Add(T item) { }
    /// <inheritdoc cref="ICollection{T}.Clear" />
    void ICollection<T>.Clear() { }
    /// <inheritdoc />
    [Pure]
    bool ICollection<T>.Remove(T item) => false;
    /// <inheritdoc />
    [Pure]
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
    /// <inheritdoc />
    public void Add(bool key, T value) => _ = key ? truthy = value : falsy = value;
    /// <inheritdoc />
    public void Add(KeyValuePair<bool, T> item) => _ = item.Key ? truthy = item.Value : falsy = item.Value;
    /// <inheritdoc />
    public void CopyTo(KeyValuePair<bool, T>[] array, [NonNegativeValue] int arrayIndex)
    {
        array[arrayIndex] = new(true, truthy);
        array[arrayIndex + 1] = new(false, falsy);
    }
    /// <inheritdoc />
    [Pure]
    public bool Contains(KeyValuePair<bool, T> item) =>
        item.Key
            ? EqualityComparer<T>.Default.Equals(truthy, item.Value)
            : EqualityComparer<T>.Default.Equals(falsy, item.Value);
    /// <inheritdoc cref="IDictionary{TKey, TValue}.TryGetValue" />
    [Pure]
    public bool TryGetValue(bool key, out T value)
    {
        value = key ? truthy : falsy;
        return true;
    }
    /// <inheritdoc cref="ICollection{T}.Clear" />
    void ICollection<KeyValuePair<bool, T>>.Clear() { }
    /// <inheritdoc />
    [Pure]
    bool ICollection<KeyValuePair<bool, T>>.Remove(KeyValuePair<bool, T> item) => false;
    /// <inheritdoc />
    [Pure]
    bool IDictionary<bool, T>.Remove(bool key) => false;
    /// <inheritdoc cref="IDictionary{TKey, TValue}.ContainsKey" />
    [Pure]
    bool IDictionary<bool, T>.ContainsKey(bool key) => true;
    /// <inheritdoc />
    [Pure]
    IEnumerator<KeyValuePair<bool, T>> IEnumerable<KeyValuePair<bool, T>>.GetEnumerator() =>
        ((IEnumerable<KeyValuePair<bool, T>>)ArrayPair).GetEnumerator();
    /// <inheritdoc cref="IReadOnlyDictionary{TKey, TValue}.ContainsKey" />
    [Pure]
    bool IReadOnlyDictionary<bool, T>.ContainsKey(bool key) => true;
    /// <summary>Deconstructs a <see cref="Split{T}"/> into its components.</summary>
    /// <param name="t">The value to get assigned as <see cref="Truthy"/>.</param>
    /// <param name="f">The value to get assigned as <see cref="Falsy"/>.</param>
    public void Deconstruct(out T t, out T f)
    {
        t = truthy;
        f = falsy;
    }
    /// <inheritdoc />
    [Pure]
    public override string ToString() => $"Split({truthy}, {falsy})";
}
// SPDX-License-Identifier: MPL-2.0
#if !NET20 && !NET30
// ReSharper disable once CheckNamespace
/// <summary>Extension methods to create cartesian products.</summary>
    /// <summary>Creates a cartesian product from two collections.</summary>
    /// <remarks><para>The cartesian product is defined as the set of ordered pairs.</para></remarks>
    /// <typeparam name="T1">The type of item in the first set.</typeparam>
    /// <typeparam name="T2">The type of item in the second set.</typeparam>
    /// <param name="first">The first set to create a cartesian product of.</param>
    /// <param name="second">The second set to create a cartesian product of.</param>
    /// <returns>
    /// The cartesian product of the parameter <paramref name="first"/> and <paramref name="second"/>.
    /// </returns>
    [LinqTunnel, Pure]
    public static IEnumerable<(T1 First, T2 Second)> CartesianProduct<T1, T2>(
        this IEnumerable<T1> first,
        IEnumerable<T2> second
    ) =>
        first.SelectMany(_ => second, (x, y) => (x, y)) is var e &&
        first.TryCount() is { } f &&
        second.TryCount() is { } s
            ? e.WithCount(f * s)
            : e;
    /// <summary>Creates a cartesian product from three collections.</summary>
    /// <remarks><para>The cartesian product is defined as the set of ordered pairs.</para></remarks>
    /// <typeparam name="T1">The type of item in the first set.</typeparam>
    /// <typeparam name="T2">The type of item in the second set.</typeparam>
    /// <typeparam name="T3">The type of item in the third set.</typeparam>
    /// <param name="first">The first set to create a cartesian product of.</param>
    /// <param name="second">The second set to create a cartesian product of.</param>
    /// <param name="third">The third set to create a cartesian product of.</param>
    /// <returns>
    /// The cartesian product of the parameter <paramref name="first"/>,
    /// <paramref name="second"/>, and <paramref name="third"/>.
    /// </returns>
    [LinqTunnel, Pure]
    public static IEnumerable<(T1 First, T2 Second, T3 Third)> CartesianProduct<T1, T2, T3>(
        this IEnumerable<T1> first,
        IEnumerable<T2> second,
        IEnumerable<T3> third
    ) =>
        first
           .SelectMany(_ => second, (x, y) => (x, y))
           .SelectMany(_ => third, (xy, z) => (xy.x, xy.y, z)) is var e &&
        first.TryCount() is { } f &&
        second.TryCount() is { } s &&
        third.TryCount() is { } t
            ? e.WithCount(f * s * t)
            : e;
    /// <summary>Creates a cartesian product from four collections.</summary>
    /// <remarks><para>The cartesian product is defined as the set of ordered pairs.</para></remarks>
    /// <typeparam name="T1">The type of item in the first set.</typeparam>
    /// <typeparam name="T2">The type of item in the second set.</typeparam>
    /// <typeparam name="T3">The type of item in the third set.</typeparam>
    /// <typeparam name="T4">The type of item in the fourth set.</typeparam>
    /// <param name="first">The first set to create a cartesian product of.</param>
    /// <param name="second">The second set to create a cartesian product of.</param>
    /// <param name="third">The third set to create a cartesian product of.</param>
    /// <param name="fourth">The fourth set to create a cartesian product of.</param>
    /// <returns>
    /// The cartesian product of the parameter <paramref name="first"/>, <paramref name="second"/>,
    /// <paramref name="third"/>, and <paramref name="fourth"/>.
    /// </returns>
    [LinqTunnel, Pure]
    public static IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth)> CartesianProduct<T1, T2, T3, T4>(
        this IEnumerable<T1> first,
        IEnumerable<T2> second,
        IEnumerable<T3> third,
        IEnumerable<T4> fourth
    ) =>
        first
           .SelectMany(_ => second, (x, y) => (x, y))
           .SelectMany(_ => third, (xy, z) => (xy, z))
           .SelectMany(_ => fourth, (xyz, w) => (xyz.xy.x, xyz.xy.y, xyz.z, w)) is var e &&
        first.TryCount() is { } f &&
        second.TryCount() is { } s &&
        third.TryCount() is { } t &&
        fourth.TryCount() is { } u
            ? e.WithCount(f * s * t * u)
            : e;
    /// <summary>Creates a cartesian product from n-collections.</summary>
    /// <remarks><para>The cartesian product is defined as the set of ordered pairs.</para></remarks>
    /// <typeparam name="T">The type of item in the set.</typeparam>
    /// <param name="first">The first set to create a cartesian product of.</param>
    /// <param name="rest">The rest of the sets to create a cartesian product of.</param>
    /// <returns>
    /// The cartesian product of the parameter <paramref name="first"/>, and all of <paramref name="rest"/>.
    /// </returns>
    public static IEnumerable<IEnumerable<T>> CartesianProduct<T>(
        this IEnumerable<T> first,
        params IEnumerable<T>[] rest
    ) =>
        Enumerable.Repeat(first, 1).Concat(rest).CartesianProduct();
    /// <summary>Creates a cartesian product from n-collections.</summary>
    /// <remarks><para>The cartesian product is defined as the set of ordered pairs.</para></remarks>
    /// <typeparam name="T">The type of item in the set.</typeparam>
    /// <param name="iterable">The sets to create a cartesian product of.</param>
    /// <returns>The cartesian product of all of the parameter <paramref name="iterable"/>.</returns>
    public static IEnumerable<IEnumerable<T>> CartesianProduct<T>(this IEnumerable<IEnumerable<T>> iterable) =>
        iterable.Aggregate(
            Enumerable.Repeat((IEnumerable<T>)[], 1),
            (sum, next) => sum.SelectMany(_ => next, (s, n) => s.Concat(Enumerable.Repeat(n, 1)))
        );
#endif
// SPDX-License-Identifier: MPL-2.0
#if !NET20 && !NET30
// ReSharper disable once CheckNamespace
/// <summary>Extension methods that negate functions from <see cref="Enumerable"/>.</summary>
    /// <summary>Negated <see cref="Enumerable.Distinct{T}(IEnumerable{T}, IEqualityComparer{T})"/>.</summary>
    /// <remarks><para>
    /// Filters out unique elements within an <see cref="IEnumerable{T}"/>.
    /// Each duplicate appears exactly once within the returned value.
    /// </para></remarks>
    /// <typeparam name="T">The type of <see cref="IEnumerable{T}"/> and <see cref="IEqualityComparer{T}"/>.</typeparam>
    /// <param name="source">The source to filter.</param>
    /// <param name="comparer">The comparer to assess distinctiveness.</param>
    /// <returns>The parameter <paramref name="source"/>, filtering out all elements that only appear once.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<T> DistinctDuplicates<T>(
        [NoEnumeration] this IEnumerable<T> source,
        IEqualityComparer<T>? comparer = null
    ) =>
        source.GroupDuplicates(comparer).Select(x => x.Key);
    /// <summary>Negated <see cref="Enumerable.Distinct{T}(IEnumerable{T}, IEqualityComparer{T})"/>.</summary>
    /// <remarks><para>
    /// Filters out unique elements within an <see cref="IEnumerable{T}"/>.
    /// Each duplicate appears two or more times within the returned value.
    /// </para></remarks>
    /// <typeparam name="T">The type of <see cref="IEnumerable{T}"/> and <see cref="IEqualityComparer{T}"/>.</typeparam>
    /// <param name="source">The source to filter.</param>
    /// <param name="comparer">The comparer to assess distinctiveness.</param>
    /// <returns>The parameter <paramref name="source"/>, filtering out all elements that only appear once.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<T> Duplicates<T>(
        [NoEnumeration] this IEnumerable<T> source,
        IEqualityComparer<T>? comparer = null
    ) =>
        source.GroupDuplicates(comparer).SelectMany(x => x);
    /// <summary>Negated <see cref="Enumerable.Distinct{T}(IEnumerable{T}, IEqualityComparer{T})"/>.</summary>
    /// <remarks><para>Filters out unique elements within an <see cref="IEnumerable{T}"/>.</para></remarks>
    /// <typeparam name="T">The type of <see cref="IEnumerable{T}"/> and <see cref="IEqualityComparer{T}"/>.</typeparam>
    /// <param name="source">The source to filter.</param>
    /// <param name="comparer">The comparer to assess distinctiveness.</param>
    /// <returns>The parameter <paramref name="source"/>, filtering out all elements that only appear once.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<IGrouping<T, T>> GroupDuplicates<T>(
        [NoEnumeration] this IEnumerable<T> source,
        IEqualityComparer<T>? comparer = null
    ) =>
        source.GroupBy(x => x, comparer).Where(x => x.Skip(1).Any());
    /// <summary>Negated <see cref="Enumerable.SkipWhile{T}(IEnumerable{T}, Func{T, int, bool})"/>.</summary>
    /// <returns>
    /// An <see cref="IEnumerable{T}" /> that contains the elements from the input sequence starting at
    /// the first element in the linear series that does pass the test specified by the predicate.
    /// </returns>
    /// <inheritdoc cref="Enumerable.SkipWhile{T}(IEnumerable{T}, Func{T, int, bool})"/>
    [LinqTunnel, Pure]
    public static IEnumerable<T> SkipUntil<T>([NoEnumeration] this IEnumerable<T> source, Func<T, bool> predicate) =>
        source.SkipWhile(x => !predicate(x));
    /// <summary>
    /// Negated
    /// <see cref="Enumerable.SelectMany{TSource, TResult}(IEnumerable{TSource}, Func{TSource, IEnumerable{TResult}})"/>.
    /// </summary>
    /// <remarks><para>
    /// Splits the <see cref="IEnumerable{T}"/> into multiple <see cref="IEnumerable{T}"/>
    /// instances in at most the specified length.
    /// </para></remarks>
    /// <typeparam name="T">The type of the <see cref="IEnumerable{T}"/>.</typeparam>
    /// <param name="source">The <see cref="IEnumerable{T}"/> to chop into slices.</param>
    /// <param name="count">The maximum length of any given returned <see cref="IEnumerable{T}"/> instances.</param>
    /// <returns>The wrapper of the parameter <paramref name="source"/> that returns slices of it.</returns>
    [Pure]
    public static IEnumerable<IEnumerable<T>> SplitEvery<T>(
        [InstantHandle] this IEnumerable<T> source,
        [ValueRange(1, int.MaxValue)] int count
    )
    {
        if (count <= 0)
            yield break;
        using var e = source.GetEnumerator();
        while (e.MoveNext())
            yield return e.SplitEvery(count);
    }
    /// <summary>Negated <see cref="Enumerable.TakeWhile{T}(IEnumerable{T}, Func{T, int, bool})"/>.</summary>
    /// <returns>
    /// An <see cref="IEnumerable{T}" /> that contains the elements from the input
    /// sequence that occur before the element at which the test no longer fails.
    /// </returns>
    /// <inheritdoc cref="Enumerable.TakeWhile{T}(IEnumerable{T}, Func{T, int, bool})"/>
    [LinqTunnel, Pure]
    public static IEnumerable<T> TakeUntil<T>([NoEnumeration] this IEnumerable<T> source, Func<T, bool> predicate) =>
        source.TakeWhile(x => !predicate(x));
    /// <summary>Negated <see cref="Enumerable.TakeWhile{T}(IEnumerable{T}, Func{T, int, bool})"/>.</summary>
    /// <returns>
    /// An <see cref="IEnumerable{T}" /> that contains elements from
    /// the input sequence that do not satisfy the condition.
    /// </returns>
    /// <inheritdoc cref="Enumerable.TakeWhile{T}(IEnumerable{T}, Func{T, int, bool})"/>
    [LinqTunnel, Pure]
    public static IEnumerable<T> TakeUntil<T>(
        [NoEnumeration] this IEnumerable<T> source,
        Func<T, int, bool> predicate
    ) =>
        source.TakeWhile((x, y) => !predicate(x, y));
    /// <summary>Negated <see cref="Enumerable.Where{T}(IEnumerable{T}, Func{T, bool})"/>.</summary>
    /// <returns>
    /// An <see cref="IEnumerable{T}" /> that contains elements from
    /// the input sequence that do not satisfy the condition.
    /// </returns>
    /// <inheritdoc cref="Enumerable.Where{T}(IEnumerable{T}, Func{T, bool})"/>
    [LinqTunnel, Pure]
    public static IEnumerable<T> Omit<T>([NoEnumeration] this IEnumerable<T> source, Func<T, bool> predicate) =>
        source.Where(x => !predicate(x));
    /// <summary>Negated <see cref="Enumerable.Where{T}(IEnumerable{T}, Func{T, int, bool})"/>.</summary>
    /// <returns>
    /// An <see cref="IEnumerable{T}" /> that contains elements from
    /// the input sequence that do not satisfy the condition.
    /// </returns>
    /// <inheritdoc cref="Enumerable.Where{T}(IEnumerable{T}, Func{T, int, bool})"/>
    [LinqTunnel, Pure]
    public static IEnumerable<T> Omit<T>(
        [NoEnumeration] this IEnumerable<T> source,
        Func<T, int, bool> predicate
    ) =>
        source.Where((x, y) => !predicate(x, y));
    static IEnumerable<T> SplitEvery<T>(this IEnumerator<T> e, [ValueRange(1, int.MaxValue)] int count)
    {
        do
            yield return e.Current;
        while (--count > 0 && e.MoveNext());
    }
#endif
// SPDX-License-Identifier: MPL-2.0
#if NET5_0_OR_GREATER
// ReSharper disable once CheckNamespace
/// <summary>Extension methods for <see cref="Vector{T}"/>.</summary>
#if NET8_0_OR_GREATER
    /// <inheritdoc cref="IFloatingPoint{TSelf}.Ceiling"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static Vector<T> Ceiling<T>(this Vector<T> x) =>
        typeof(T) == typeof(float) ? (Vector<T>)(object)Vector.Ceiling((Vector<float>)(object)x) :
        typeof(T) == typeof(double) ? (Vector<T>)(object)Vector.Ceiling((Vector<double>)(object)x) :
        default;
    /// <inheritdoc cref="IFloatingPoint{TSelf}.Floor"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static Vector<T> Floor<T>(this Vector<T> x) =>
        typeof(T) == typeof(float) ? (Vector<T>)(object)Vector.Floor((Vector<float>)(object)x) :
        typeof(T) == typeof(double) ? (Vector<T>)(object)Vector.Floor((Vector<double>)(object)x) :
        default;
#endif
#if NET9_0_OR_GREATER
    /// <inheritdoc cref="ITrigonometricFunctions{TSelf}.Cos"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static Vector<T> Cos<T>(this Vector<T> x) =>
        typeof(T) == typeof(float) ? (Vector<T>)(object)Vector.Cos((Vector<float>)(object)x) :
        typeof(T) == typeof(double) ? (Vector<T>)(object)Vector.Cos((Vector<double>)(object)x) :
        default;
    /// <inheritdoc cref="ITrigonometricFunctions{TSelf}.DegreesToRadians"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static Vector<T> DegreesToRadians<T>(this Vector<T> x) =>
        typeof(T) == typeof(float) ? (Vector<T>)(object)Vector.DegreesToRadians((Vector<float>)(object)x) :
        typeof(T) == typeof(double) ? (Vector<T>)(object)Vector.DegreesToRadians((Vector<double>)(object)x) :
        default;
    /// <inheritdoc cref="IExponentialFunctions{TSelf}.Exp"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static Vector<T> Exp<T>(this Vector<T> x) =>
        typeof(T) == typeof(float) ? (Vector<T>)(object)Vector.Exp((Vector<float>)(object)x) :
        typeof(T) == typeof(double) ? (Vector<T>)(object)Vector.Exp((Vector<double>)(object)x) :
        default;
    /// <inheritdoc cref="IFloatingPointIeee754{TSelf}.FusedMultiplyAdd"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static Vector<T> FusedMultiplyAdd<T>(this Vector<T> x, Vector<T> y, Vector<T> z) =>
        typeof(T) == typeof(float) ? (Vector<T>)(object)Vector.FusedMultiplyAdd(
            (Vector<float>)(object)x,
            (Vector<float>)(object)y,
            (Vector<float>)(object)z
        ) :
        typeof(T) == typeof(double) ? (Vector<T>)(object)Vector.FusedMultiplyAdd(
            (Vector<double>)(object)x,
            (Vector<double>)(object)y,
            (Vector<double>)(object)z
        ) :
        default;
    /// <inheritdoc cref="IRootFunctions{TSelf}.Hypot"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static Vector<T> Hypot<T>(this Vector<T> x, Vector<T> y) =>
        typeof(T) == typeof(float) ?
            (Vector<T>)(object)Vector.Hypot((Vector<float>)(object)x, (Vector<float>)(object)y) :
            typeof(T) == typeof(double) ?
                (Vector<T>)(object)Vector.Hypot((Vector<double>)(object)x, (Vector<double>)(object)y) : default;
    /// <inheritdoc cref="ILogarithmicFunctions{TSelf}.Log(TSelf)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static Vector<T> Log<T>(this Vector<T> x) =>
        typeof(T) == typeof(float) ? (Vector<T>)(object)Vector.Log((Vector<float>)(object)x) :
        typeof(T) == typeof(double) ? (Vector<T>)(object)Vector.Log((Vector<double>)(object)x) :
        default;
    /// <inheritdoc cref="ITrigonometricFunctions{TSelf}.DegreesToRadians"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static Vector<T> Log2<T>(this Vector<T> x) =>
        typeof(T) == typeof(float) ? (Vector<T>)(object)Vector.Log2((Vector<float>)(object)x) :
        typeof(T) == typeof(double) ? (Vector<T>)(object)Vector.Log2((Vector<double>)(object)x) :
        default;
    /// <inheritdoc cref="INumberBase{TSelf}.MultiplyAddEstimate"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static Vector<T> MultiplyAddEstimate<T>(this Vector<T> x, Vector<T> y, Vector<T> z) =>
        typeof(T) == typeof(float) ? (Vector<T>)(object)Vector.MultiplyAddEstimate(
            (Vector<float>)(object)x,
            (Vector<float>)(object)y,
            (Vector<float>)(object)z
        ) :
        typeof(T) == typeof(double) ? (Vector<T>)(object)Vector.MultiplyAddEstimate(
            (Vector<double>)(object)x,
            (Vector<double>)(object)y,
            (Vector<double>)(object)z
        ) :
        default;
    /// <inheritdoc cref="ITrigonometricFunctions{TSelf}.RadiansToDegrees"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static Vector<T> RadiansToDegrees<T>(this Vector<T> x) =>
        typeof(T) == typeof(float) ? (Vector<T>)(object)Vector.RadiansToDegrees((Vector<float>)(object)x) :
        typeof(T) == typeof(double) ? (Vector<T>)(object)Vector.RadiansToDegrees((Vector<double>)(object)x) :
        default;
    /// <inheritdoc cref="IFloatingPoint{TSelf}.Round(TSelf)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static Vector<T> Round<T>(this Vector<T> x) =>
        typeof(T) == typeof(float) ? (Vector<T>)(object)Vector.Round((Vector<float>)(object)x) :
        typeof(T) == typeof(double) ? (Vector<T>)(object)Vector.Round((Vector<double>)(object)x) :
        default;
    /// <inheritdoc cref="ITrigonometricFunctions{TSelf}.Sin"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static Vector<T> Sin<T>(this Vector<T> x) =>
        typeof(T) == typeof(float) ? (Vector<T>)(object)Vector.Sin((Vector<float>)(object)x) :
        typeof(T) == typeof(double) ? (Vector<T>)(object)Vector.Sin((Vector<double>)(object)x) :
        default;
    /// <inheritdoc cref="ITrigonometricFunctions{TSelf}.SinCos"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static (Vector<T> Sin, Vector<T> Cos) SinCos<T>(this Vector<T> x) =>
        typeof(T) == typeof(float) ? ((Vector<T>, Vector<T>))(object)Vector.SinCos((Vector<float>)(object)x) :
        typeof(T) == typeof(double) ? ((Vector<T>, Vector<T>))(object)Vector.SinCos((Vector<double>)(object)x) :
        default;
    /// <inheritdoc cref="IFloatingPoint{TSelf}.Truncate"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static Vector<T> Truncate<T>(this Vector<T> x) =>
        typeof(T) == typeof(float) ? (Vector<T>)(object)Vector.Truncate((Vector<float>)(object)x) :
        typeof(T) == typeof(double) ? (Vector<T>)(object)Vector.Truncate((Vector<double>)(object)x) :
        default;
#endif
#endif
// SPDX-License-Identifier: MPL-2.0
#if !NET20 && !NET30
// ReSharper disable BadPreprocessorIndent CheckNamespace StructCanBeMadeReadOnly
/// <summary>Extension methods that act as factories for <see cref="Once{T}"/>.</summary>
    /// <summary>Creates a <see cref="Once{T}"/> from an item.</summary>
    /// <typeparam name="T">The type of item.</typeparam>
    /// <param name="source">The item.</param>
    /// <param name="condition">The condition that must be true for <paramref name="source"/> to be used.</param>
    /// <returns>The <see cref="Once{T}"/> instance that can be yielded once.</returns>
    [Pure]
    public static Once<T> Yield<T>(this T source, bool condition = true) => condition ? source : [];
    /// <summary>Creates a <see cref="Once{T}"/> from an item.</summary>
    /// <typeparam name="T">The type of item.</typeparam>
    /// <param name="source">The item.</param>
    /// <param name="condition">The condition that must be true for <paramref name="source"/> to be used.</param>
    /// <returns>The <see cref="Once{T}"/> instance that can be yielded once.</returns>
    [Pure]
    public static Once<T> Yield<T>(this T source, Predicate<T> condition) => condition(source) ? source : [];
    /// <summary>Creates a <see cref="Once{T}"/> from an item if it isn't null.</summary>
    /// <typeparam name="T">The type of item.</typeparam>
    /// <param name="source">The item.</param>
    /// <returns>The <see cref="Once{T}"/> instance that can be yielded once.</returns>
    [Pure]
    public static Once<T> YieldValued<T>(this T? source)
        where T : class =>
        source is null ? [] : source;
    /// <summary>Creates a <see cref="Once{T}"/> from an item if it isn't null.</summary>
    /// <typeparam name="T">The type of item.</typeparam>
    /// <param name="source">The item.</param>
    /// <returns>The <see cref="Once{T}"/> instance that can be yielded once.</returns>
    [Pure]
    public static Once<T> YieldValued<T>(this T? source)
        where T : struct =>
        source.HasValue ? source.Value : [];
/// <summary>A factory for creating iterator types that yields an item once.</summary>
/// <typeparam name="T">The type of the item to yield.</typeparam>
/// <param name="value">The item to use.</param>
[StructLayout(LayoutKind.Auto)]
#if CSHARPREPL
public
#endif
#if !NO_READONLY_STRUCTS
readonly
#endif
    partial struct Once<T>([ProvidesContext] T value) : IComparable<Once<T>>,
    IEquatable<Once<T>>,
    IList<T>,
    IOrderedEnumerable<T>,
    IReadOnlyList<T>,
    IReadOnlySet<T>,
    ISet<T>
{
    /// <inheritdoc cref="ICollection{T}.IsReadOnly"/>
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), Pure]
    bool ICollection<T>.IsReadOnly => true;
    /// <inheritdoc cref="ICollection{T}.Count"/>
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), Pure]
    int IReadOnlyCollection<T>.Count => HasValue ? 1 : 0;
    /// <inheritdoc cref="ICollection{T}.Count"/>
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), Pure]
    int ICollection<T>.Count => HasValue ? 1 : 0;
    /// <summary>Gets a value indicating whether this is a default value.</summary>
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), Pure]
    public bool HasValue { get; } = true;
    /// <summary>Gets the item to use.</summary>
    [CollectionAccess(Read), ProvidesContext, Pure]
    public T Current => value;
    /// <inheritdoc cref="IList{T}.this"/>
    [Pure]
    T IList<T>.this[int _]
    {
        [CollectionAccess(Read)] get => value;
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)] set { }
    }
    /// <inheritdoc cref="IList{T}.this[int]"/>
    [CollectionAccess(Read), Pure]
    T IReadOnlyList<T>.this[int _] => value;
    /// <summary>Implicitly calls the constructor.</summary>
    /// <param name="value">The value to pass into the constructor.</param>
    /// <returns>A new instance of <see cref="Once{T}"/> with <paramref name="value"/> passed in.</returns>
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), Pure]
    public static explicit operator Once<T>([ProvidesContext] Enumerator value) => value.Current;
    /// <summary>Implicitly calls the constructor.</summary>
    /// <param name="value">The value to pass into the constructor.</param>
    /// <returns>A new instance of <see cref="Once{T}"/> with <paramref name="value"/> passed in.</returns>
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), Pure]
    public static implicit operator Once<T>([ProvidesContext] T value) => new(value);
    /// <summary>Implicitly calls <see cref="Current"/>.</summary>
    /// <param name="value">The value to call <see cref="Current"/>.</param>
    /// <returns>The value that was passed in to this instance.</returns>
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), Pure]
    public static implicit operator Enumerator([ProvidesContext] Once<T> value) => value.Current;
    /// <summary>Implicitly calls <see cref="Current"/>.</summary>
    /// <param name="value">The value to call <see cref="Current"/>.</param>
    /// <returns>The value that was passed in to this instance.</returns>
    [CollectionAccess(Read), Pure]
    public static implicit operator T(Once<T> value) => value.Current;
    /// <summary>Determines whether both items are equal.</summary>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>Whether both items are equal.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool operator ==(Once<T> left, Once<T> right) => left.Equals(right);
    /// <summary>Determines whether both items are unequal.</summary>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>Whether both items are not unequal.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool operator !=(Once<T> left, Once<T> right) => !left.Equals(right);
    /// <summary>Determines whether the left-hand side is greater than the right.</summary>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>Whether the left-hand side is greater than the right.</returns>
    public static bool operator >(Once<T> left, Once<T> right) => left.CompareTo(right) > 0;
    /// <summary>Determines whether the left-hand side is greater than or equal to the right.</summary>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>Whether the left-hand side is greater than or equal to the right.</returns>
    public static bool operator >=(Once<T> left, Once<T> right) => left.CompareTo(right) >= 0;
    /// <summary>Determines whether the left-hand side is less than the right.</summary>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>Whether the left-hand side is less than the right.</returns>
    public static bool operator <(Once<T> left, Once<T> right) => left.CompareTo(right) < 0;
    /// <summary>Determines whether the left-hand side is less than or equal to than the right.</summary>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>Whether the left-hand side is less than or equal to than the right.</returns>
    public static bool operator <=(Once<T> left, Once<T> right) => left.CompareTo(right) <= 0;
    /// <inheritdoc />
    [CollectionAccess(Read)]
    public void CopyTo(T[] array, int arrayIndex) => array[arrayIndex] = value;
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)]
    void ICollection<T>.Add(T? item) { }
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)]
    void ICollection<T>.Clear() { }
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)]
    void IList<T>.Insert(int index, T? item) { }
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)]
    void IList<T>.RemoveAt(int index) { }
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)]
    void ISet<T>.ExceptWith(IEnumerable<T>? other) { }
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)]
    void ISet<T>.IntersectWith(IEnumerable<T>? other) { }
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)]
    void ISet<T>.SymmetricExceptWith(IEnumerable<T>? other) { }
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)]
    void ISet<T>.UnionWith(IEnumerable<T>? other) { }
    /// <inheritdoc cref="ICollection{T}.Contains"/>
    [CollectionAccess(Read), Pure]
    public bool Contains(T item) => EqualityComparer<T>.Default.Equals(value, item);
    /// <inheritdoc cref="ISet{T}.IsProperSubsetOf" />
    [CollectionAccess(Read), Pure]
    public bool IsProperSubsetOf([InstantHandle] IEnumerable<T> other) =>
        HasValue
            ? other.Any()
            : other.ToICollection() is { Count: > 1 } c && Overlaps(c);
    /// <inheritdoc cref="ISet{T}.IsProperSupersetOf" />
    [CollectionAccess(Read), Pure]
    public bool IsProperSupersetOf([InstantHandle] IEnumerable<T> other) => HasValue && !other.Any();
    /// <inheritdoc cref="ISet{T}.IsSubsetOf" />
    [CollectionAccess(Read), Pure]
    public bool IsSubsetOf([InstantHandle] IEnumerable<T> other) => !HasValue || Overlaps(other);
    /// <inheritdoc cref="ISet{T}.IsSupersetOf" />
    [CollectionAccess(Read), Pure]
    public bool IsSupersetOf([InstantHandle] IEnumerable<T> other) =>
        !HasValue || other.ToICollection() is { Count: <= 1 } c && Overlaps(c);
    /// <inheritdoc cref="ISet{T}.Overlaps" />
    [CollectionAccess(Read), Pure]
    public bool Overlaps([InstantHandle] IEnumerable<T> other) => other.Contains(value);
    /// <inheritdoc cref="ISet{T}.SetEquals" />
    [CollectionAccess(Read), Pure]
    public bool SetEquals([InstantHandle] IEnumerable<T> other) => HasValue ? !other.Any() : other.SequenceEqual(this);
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), Pure]
    bool ICollection<T>.Remove(T? item) => false;
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), Pure]
    bool ISet<T>.Add(T? item) => false;
    /// <inheritdoc />
    [CollectionAccess(Read), Pure]
    public override bool Equals(object? other) => other is Once<T> once && Equals(once);
    /// <inheritdoc />
    [CollectionAccess(Read), Pure]
    public bool Equals(Once<T> other) => EqualityComparer<T>.Default.Equals(value, other);
    /// <inheritdoc />
    [CollectionAccess(Read), Pure]
    public int CompareTo(Once<T> other) => Comparer<T>.Default.Compare(value, other.Current);
    /// <inheritdoc />
    [CollectionAccess(Read), Pure]
    public override int GetHashCode() =>
        value is null ? -2 : unchecked(EqualityComparer<T>.Default.GetHashCode(value) * 37);
    /// <inheritdoc />
    [CollectionAccess(Read), Pure]
    public int IndexOf(T item) => Contains(item) ? 0 : -1;
    /// <inheritdoc />
    [CollectionAccess(Read), Pure]
    public override string ToString() => value?.ToString() ?? "";
    /// <summary>
    /// Returns itself. Used to tell the compiler that it can be used in a <see langword="foreach"/> loop.
    /// </summary>
    /// <returns>Itself.</returns>
    [CollectionAccess(Read), MustDisposeResource(false), Pure]
    public Enumerator GetEnumerator() => HasValue ? new(value) : default;
    /// <inheritdoc />
    [CollectionAccess(Read), MustDisposeResource(false), Pure]
    IEnumerator<T> IEnumerable<T>.GetEnumerator() => GetEnumerator();
    /// <inheritdoc />
    [CollectionAccess(Read), MustDisposeResource(false), Pure]
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), MustDisposeResource(false), Pure]
    IOrderedEnumerable<T> IOrderedEnumerable<T>.CreateOrderedEnumerable<TKey>(
        Func<T, TKey> keySelector,
        IComparer<TKey>? comparer,
        bool descending
    ) =>
        this;
    /// <summary>An enumerator over <see cref="Once{T}"/>.</summary>
    /// <param name="value">The item to use.</param>
    [StructLayout(LayoutKind.Auto)]
    public partial struct Enumerator(T value) : IEnumerator<T>
    {
        static readonly object s_fallback = new();
        readonly bool _hasValue = true;
        bool _canMove = true;
        /// <inheritdoc />
        [CollectionAccess(Read), Pure]
        public readonly T Current => value;
        /// <inheritdoc />
        [CollectionAccess(Read), Pure]
        readonly object IEnumerator.Current => value ?? s_fallback;
        /// <summary>Implicitly calls the constructor.</summary>
        /// <param name="value">The value to pass into the constructor.</param>
        /// <returns>A new instance of <see cref="Once{T}"/> with <paramref name="value"/> passed in.</returns>
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), Pure]
        public static implicit operator Enumerator(T value) => new(value);
        /// <summary>Implicitly calls <see cref="Current"/>.</summary>
        /// <param name="value">The value to call <see cref="Current"/>.</param>
        /// <returns>The value that was passed in to this instance.</returns>
        [CollectionAccess(Read), Pure]
        public static explicit operator T(Enumerator value) => value.Current;
        /// <inheritdoc />
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)]
        readonly void IDisposable.Dispose() { }
        /// <inheritdoc />
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)]
        public bool MoveNext() => _canMove && !(_canMove = false);
        /// <inheritdoc />
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)]
        public void Reset() => _canMove = _hasValue;
    }
}
#endif
// SPDX-License-Identifier: MPL-2.0
#pragma warning disable GlobalUsingsAnalyzer
// ReSharper disable once RedundantUsingDirective.Global
// ReSharper disable once CheckNamespace
/// <summary>Methods to get elements of a tuple.</summary>
    /// <summary>Gets the first item of the tuple.</summary>
    /// <typeparam name="T1">The first type of the tuple.</typeparam>
    /// <typeparam name="T2">The second type of the tuple.</typeparam>
    /// <param name="tuple">The tuple to get the value from.</param>
    /// <returns>
    /// The field <see cref="System.ValueTuple{T1, T2}.Item1"/> from the parameter <paramref name="tuple"/>.
    /// </returns>
    public static T1 First<T1, T2>((T1, T2) tuple) => tuple.Item1;
    /// <summary>Gets the second item of the tuple.</summary>
    /// <typeparam name="T1">The first type of the tuple.</typeparam>
    /// <typeparam name="T2">The second type of the tuple.</typeparam>
    /// <param name="tuple">The tuple to get the value from.</param>
    /// <returns>
    /// The field <see cref="System.ValueTuple{T1, T2}.Item2"/> from the parameter <paramref name="tuple"/>.
    /// </returns>
    public static T2 Second<T1, T2>((T1, T2) tuple) => tuple.Item2;
#if !NET20 && !NET30 && !NET47 && !NETSTANDARD2_0
    /// <summary>Gets the enumeration of the tuple.</summary>
    /// <param name="tuple">The tuple to enumerate.</param>
    /// <returns>The enumeration of the parameter <paramref name="tuple"/>.</returns>
    public static IEnumerable<object?> AsEnumerable(this ITuple tuple) => tuple.Length.For(i => tuple[i]);
    /// <summary>Gets the enumeration of the tuple.</summary>
    /// <typeparam name="T">The type of tuple.</typeparam>
    /// <param name="tuple">The tuple to enumerate.</param>
    /// <returns>The enumeration of the parameter <paramref name="tuple"/>.</returns>
    public static IEnumerable<object?> AsEnumerable<T>(this T tuple)
        where T : ITuple =>
        tuple.Length.For(i => tuple[i]);
    /// <summary>Turns the tuples into key-value pairs.</summary>
    /// <typeparam name="TKey">
    /// Corresponds to the first generic argument both in the tuple and <see cref="KeyValuePair{TKey, TValue}"/>.
    /// </typeparam>
    /// <typeparam name="TValue">
    /// Corresponds to the second generic argument both in the tuple and <see cref="KeyValuePair{TKey, TValue}"/>.
    /// </typeparam>
    /// <param name="tuples">The <see cref="IEnumerable{T}"/> to convert.</param>
    /// <returns>
    /// The <see cref="KeyValuePair{TKey, TValue}"/> instances of the parameter <paramref name="tuples"/>.
    /// </returns>
    [LinqTunnel, Pure]
    public static IEnumerable<KeyValuePair<TKey, TValue>> KeyValued<TKey, TValue>(
#if !CSHARPREPL
        params
#endif
            IEnumerable<(TKey Key, TValue Value)> tuples
    ) =>
        tuples.Select(x => new KeyValuePair<TKey, TValue>(x.Key, x.Value));
#endif
// SPDX-License-Identifier: MPL-2.0
#if XNA
/// <summary>Provides the component that draws the frame rate.</summary>
/// <remarks><para>
/// Adapted from <a href="https://blogs.msdn.microsoft.com/shawnhar/2007/06/08/displaying-the-framerate/">Shawn Hargreaves's implementation</a>.
/// </para></remarks>
/// <param name="game">The game for this component.</param>
/// <param name="font">The font to draw with.</param>
/// <param name="batch">The batch to draw to.</param>
/// <param name="resolution">The function that gets the resolution of the application.</param>
public sealed class FrameRateCounter(Game game, SpriteFont font, SpriteBatch batch, Func<Vector2> resolution)
    : DrawableGameComponent(game)
{
    const string Format = "FPS: ";
    /// <summary>Initializes a new instance of the <see cref="FrameRateCounter"/> class.</summary>
    /// <param name="game">The game to draw to.</param>
    /// <param name="font">The font to draw with.</param>
    /// <param name="batch">The batch to draw to.</param>
    public FrameRateCounter(Game game, SpriteFont font, SpriteBatch batch)
        : this(game, font, batch, () => new(game.Window.ClientBounds.Width, game.Window.ClientBounds.Height)) { }
    /// <summary>Initializes a new instance of the <see cref="FrameRateCounter"/> class.</summary>
    /// <param name="game">The game to draw to.</param>
    /// <param name="font">The font to draw with.</param>
    public FrameRateCounter(Letterboxed2DGame game, SpriteFont font)
        : this(game, font, game.Batch, () => new(game.Width, game.Height)) { }
    static readonly TimeSpan s_frequency = TimeSpan.FromSeconds(1);
    readonly StringBuilder _builder = new(Format, Format.Length + 10);
    int _counter, _rate;
    TimeSpan _elapsed = TimeSpan.Zero;
    /// <summary>Gets the batch.</summary>
    public SpriteBatch Batch => batch;
    /// <summary>Gets the scale to draw the font at.</summary>
    public Vector2 Scale { get; set; } = Vector2.One;
    public override void Draw(GameTime gameTime)
    {
        if (!Visible)
            return;
        _counter++;
        _builder.Remove(Format.Length, _builder.Length - Format.Length).Append(_rate);
        const float Factor = 24;
        var position = resolution() / Factor;
        batch.DrawString(font, _builder, position + Vector2.One, Color.Black, 0, default, Scale, SpriteEffects.None, 0);
        batch.DrawString(font, _builder, position, Color.White, 0, default, Scale, SpriteEffects.None, 0);
    }
    public override void Update(GameTime gameTime)
    {
        if (!Enabled)
            return;
        _elapsed += gameTime.ElapsedGameTime;
        if (_elapsed <= s_frequency)
            return;
        _elapsed -= s_frequency;
        (_counter, _rate) = (0, _counter);
    }
}
#endif
// SPDX-License-Identifier: MPL-2.0
#pragma warning disable GlobalUsingsAnalyzer
// ReSharper disable once RedundantUsingDirective.Global
// ReSharper disable once CheckNamespace
/// <summary>Methods to create methods.</summary>
    sealed class Compared<T>(Comparison<T?> comparer) : IComparer<T>
    {
        /// <inheritdoc />
        public int Compare(T? x, T? y) => comparer(x, y);
    }
    sealed class Compared<T, TResult>(Converter<T?, TResult> converter, IComparer<TResult> comparer) : IComparer<T>
    {
        /// <inheritdoc />
        public int Compare(T? x, T? y) => comparer.Compare(converter(x), converter(y));
    }
    sealed class Equated<T>(Func<T?, T?, bool> comparer, Func<T, int> hashCode) : IEqualityComparer<T>
    {
        /// <summary>Initializes a new instance of the <see cref="Equated{T}"/> class.</summary>
        /// <param name="comparer">The comparer to convert.</param>
        public Equated(IComparer<T> comparer)
            : this(FromIComparer(comparer), Default) { }
        /// <summary>Returns 0.</summary>
        /// <param name="_">The discard.</param>
        /// <returns>The value 0.</returns>
        public static int Default(T? _) => 0;
        /// <inheritdoc />
        public bool Equals(T? x, T? y) => comparer(x, y);
        /// <inheritdoc />
        public int GetHashCode(T obj) => hashCode(obj);
        /// <summary>Returns the equality function based on the <see cref="IComparer{T}"/>.</summary>
        /// <param name="comparer">The comparer to evaluate equality.</param>
        /// <returns>The equality function that wraps <paramref name="comparer"/>.</returns>
        static Func<T?, T?, bool> FromIComparer(IComparer<T> comparer) => (x, y) => comparer.Compare(x!, y!) is 0;
    }
    sealed class Equated<T, TResult>(Converter<T?, TResult> converter, IEqualityComparer<TResult> equalityComparer)
        : IEqualityComparer<T>
    {
        /// <inheritdoc />
        public bool Equals(T? x, T? y) => equalityComparer.Equals(converter(x), converter(y));
        /// <inheritdoc />
        public int GetHashCode(T obj) => equalityComparer.GetHashCode(converter(obj)!);
    }
    /// <summary>The number of bits in a byte.</summary>
    public const int BitsInByte = 8;
    /// <summary>Gets all the types currently loaded.</summary>
    [Pure]
    public static IEnumerable<Type> AllTypes =>
        AppDomain.CurrentDomain.GetAssemblies().AsEnumerable().SelectMany(x => x.TryGetTypes());
    /// <summary>Invokes a method.</summary>
    /// <param name="del">The method to invoke.</param>
    public static void Invoke([InstantHandle] Action del) => del();
    /// <summary>Performs nothing.</summary>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void Noop()
    {
    }
    /// <summary>Performs nothing.</summary>
    /// <typeparam name="T">The type of discard.</typeparam>
    /// <param name="_">The discard.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void Noop<T>(T _)
    {
    }
    /// <summary>Performs nothing.</summary>
    /// <typeparam name="T1">The first type of discard.</typeparam>
    /// <typeparam name="T2">The second type of discard.</typeparam>
    /// <param name="_">The first discard.</param>
    /// <param name="__">The second discard.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void Noop<T1, T2>(T1 _, T2 __)
    {
    }
    /// <summary>Gets a consistent prime number based on the line number this was called from.</summary>
    /// <param name="line">Automatically filled by compilers; the line number where this method was called.</param>
    /// <returns>The consistent pseudo-random prime number.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure, ValueRange(Primes.Min, Primes.MaxInt16)]
    public static short Prime([CallerLineNumber] int line = 0) => Primes.Index(line);
    /// <summary>Creates the <see cref="IComparer{T}"/> from the mapping.</summary>
    /// <typeparam name="T">The type to compare.</typeparam>
    /// <param name="comparison">The <see cref="Comparison{T}"/> to use.</param>
    /// <returns>The <see cref="IComparer{T}"/> that wraps the parameter <paramref name="comparison"/>.</returns>
    public static IComparer<T> Comparing<T>(Comparison<T?> comparison) => new Compared<T>(comparison);
    /// <summary>Creates the <see cref="IComparer{T}"/> from the mapping.</summary>
    /// <typeparam name="T">The type to compare.</typeparam>
    /// <typeparam name="TResult">The resulting value from the mapping used for comparison.</typeparam>
    /// <param name="converter">The converter to use.</param>
    /// <param name="comparer">If specified, the way the result of the delegate should be sorted.</param>
    /// <returns>The <see cref="IComparer{T}"/> that wraps the parameter <paramref name="converter"/>.</returns>
    public static IComparer<T> Comparing<T, TResult>(
        Converter<T?, TResult> converter,
        IComparer<TResult>? comparer = null
    ) =>
        new Compared<T, TResult>(converter, comparer ?? Comparer<TResult>.Default);
    /// <summary>Creates the <see cref="IComparer{T}"/> from the mapping.</summary>
    /// <typeparam name="T">The type to compare.</typeparam>
    /// <param name="comparison">The <see cref="Comparison{T}"/> to use.</param>
    /// <returns>The <see cref="IComparer{T}"/> that wraps the parameter <paramref name="comparison"/>.</returns>
    public static IEqualityComparer<T> AsEquality<T>(this IComparer<T> comparison) => new Equated<T>(comparison);
    /// <summary>Creates the <see cref="IEqualityComparer{T}"/> from the mapping.</summary>
    /// <typeparam name="T">The type to compare.</typeparam>
    /// <typeparam name="TResult">The resulting value from the mapping used for comparison.</typeparam>
    /// <param name="converter">The converter to use.</param>
    /// <param name="comparer">If specified, the way the result of the delegate should be sorted.</param>
    /// <returns>The <see cref="IComparer{T}"/> that wraps the parameter <paramref name="converter"/>.</returns>
    public static IEqualityComparer<T> Equating<T, TResult>(
        Converter<T?, TResult> converter,
        IEqualityComparer<TResult>? comparer = null
    ) =>
        new Equated<T, TResult>(converter, comparer ?? EqualityComparer<TResult>.Default);
    /// <summary>Creates the <see cref="IEqualityComparer{T}"/> from the mapping.</summary>
    /// <typeparam name="T">The type to compare.</typeparam>
    /// <param name="comparer">The comparer to use.</param>
    /// <param name="hashCode">If specified, the hash code algorithm.</param>
    /// <returns>The <see cref="IComparer{T}"/> that wraps the parameter <paramref name="comparer"/>.</returns>
    public static IEqualityComparer<T> Equating<T>(Func<T?, T?, bool> comparer, Func<T, int>? hashCode = null) =>
        new Equated<T>(comparer, hashCode ?? Equated<T>.Default);
    /// <inheritdoc cref="Invoke"/>
    public static TResult Invoke<TResult>([InstantHandle] Func<TResult> del) => del();
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable MissingIndent UsePositionalDeconstructionPattern
// ReSharper disable once CheckNamespace
/// <summary>Methods that deconstructs <see cref="Version"/> instances.</summary>
    /// <summary>Deconstructs this instance into the major version.</summary>
    /// <remarks><para>
    /// If the passed in value is <see langword="null"/>, all out parameters are zero-initialized.
    /// </para></remarks>
    /// <param name="version">The <see cref="Version"/> to deconstruct.</param>
    /// <param name="major">The resulting major version.</param>
    public static void Deconstruct(this Version? version, [NonNegativeValue] out int major) =>
        major = version?.Major ?? 0;
    /// <summary>Deconstructs this instance into the major and minor versions.</summary>
    /// <remarks><para>
    /// If the passed in value is <see langword="null"/>, all out parameters are zero-initialized.
    /// </para></remarks>
    /// <param name="version">The <see cref="Version"/> to deconstruct.</param>
    /// <param name="major">The resulting major version.</param>
    /// <param name="minor">The resulting minor version.</param>
    public static void Deconstruct(
        this Version? version,
        [NonNegativeValue] out int major,
        [NonNegativeValue] out int minor
    )
    {
        if (version is { Major: var maj, Minor: var min })
        {
            major = maj;
            minor = min;
            return;
        }
        major = 0;
        minor = 0;
    }
    /// <summary>Deconstructs this instance into the major, minor, and build versions.</summary>
    /// <remarks><para>
    /// If the passed in value is <see langword="null"/>, all out parameters are zero-initialized.
    /// </para></remarks>
    /// <param name="version">The <see cref="Version"/> to deconstruct.</param>
    /// <param name="major">The resulting major version.</param>
    /// <param name="minor">The resulting minor version.</param>
    /// <param name="build">The resulting build version.</param>
    public static void Deconstruct(
        this Version? version,
        [NonNegativeValue] out int major,
        [NonNegativeValue] out int minor,
        [NonNegativeValue] out int build
    )
    {
        if (version is { Major: var maj, Minor: var min, Build: var bui })
        {
            major = maj;
            minor = min;
            build = bui;
            return;
        }
        major = 0;
        minor = 0;
        build = 0;
    }
    /// <summary>Deconstructs this instance into the major, minor, build, and revision versions.</summary>
    /// <remarks><para>
    /// If the passed in value is <see langword="null"/>, all out parameters are zero-initialized.
    /// </para></remarks>
    /// <param name="version">The <see cref="Version"/> to deconstruct.</param>
    /// <param name="major">The resulting major version.</param>
    /// <param name="minor">The resulting minor version.</param>
    /// <param name="build">The resulting build version.</param>
    /// <param name="revision">The resulting revision version.</param>
    public static void Deconstruct(
        this Version? version,
        [NonNegativeValue] out int major,
        [NonNegativeValue] out int minor,
        [NonNegativeValue] out int build,
        [NonNegativeValue] out int revision
    )
    {
        if (version is { Major: var maj, Minor: var min, Build: var bui, Revision: var rev })
        {
            major = maj;
            minor = min;
            build = bui;
            revision = rev;
            return;
        }
        major = 0;
        minor = 0;
        build = 0;
        revision = 0;
    }
    /// <summary>
    /// Deconstructs this instance into the major, minor, build, major revision, and minor revision versions.
    /// </summary>
    /// <remarks><para>
    /// If the passed in value is <see langword="null"/>, all out parameters are zero-initialized.
    /// </para></remarks>
    /// <param name="version">The <see cref="Version"/> to deconstruct.</param>
    /// <param name="major">The resulting major version.</param>
    /// <param name="minor">The resulting minor version.</param>
    /// <param name="build">The resulting build version.</param>
    /// <param name="majorRevision">The resulting major revision version.</param>
    /// <param name="minorRevision">The resulting minor revision version.</param>
    public static void Deconstruct(
        this Version? version,
        [NonNegativeValue] out int major,
        [NonNegativeValue] out int minor,
        [NonNegativeValue] out int build,
        [NonNegativeValue] out int majorRevision,
        [NonNegativeValue] out int minorRevision
    )
    {
        if (version is
        {
            Major: var maj, Minor: var min, Build: var bui, MajorRevision: var majRev, MinorRevision: var minRev,
        })
        {
            major = maj;
            minor = min;
            build = bui;
            majorRevision = majRev;
            minorRevision = minRev;
            return;
        }
        major = 0;
        minor = 0;
        build = 0;
        majorRevision = 0;
        minorRevision = 0;
    }
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable BadPreprocessorIndent CheckNamespace ConvertToAutoPropertyWhenPossible ForeachCanBeConvertedToQueryUsingAnotherGetEnumerator InvertIf RedundantNameQualifier RedundantReadonlyModifier RedundantUsingDirective StructCanBeMadeReadOnly UseSymbolAlias
#pragma warning disable CS8631, IDE0032
#if NET8_0_OR_GREATER
// -
#else
#endif
/// <summary>Methods to split spans into multiple spans.</summary>
    /// <summary>
    /// Defines the values for <see cref="SplitMemory{TBody, TSeparator, TStrategy}"/> without a compile-time strategy.
    /// </summary>
    /// <typeparam name="TBody">The type of element from the span.</typeparam>
    /// <typeparam name="TSeparator">The type of separator.</typeparam>
    public interface ISplitMemory<TBody, TSeparator> : IEnumerable<ReadOnlyMemory<TBody>>
    {
        /// <summary>Gets the body.</summary>
        public ReadOnlyMemory<TBody> Body { [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get; }
        /// <summary>Gets the separator.</summary>
        public ReadOnlyMemory<TSeparator> Separator { [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get; }
    }
    /// <inheritdoc cref="SplitSpanFactory.ConcatEqual{TSeparator, TStrategy, TOtherSeparator, TOtherStrategy}"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool ConcatEqual<TSeparator, TStrategy, TOtherSeparator, TOtherStrategy>(
        this SplitMemory<char, TSeparator, TStrategy> left,
        SplitMemory<char, TOtherSeparator, TOtherStrategy> right,
        StringComparison comparison
    )
#if !NET7_0_OR_GREATER
        where TSeparator : IEquatable<TSeparator>?
        where TOtherSeparator : IEquatable<TOtherSeparator>?
#endif
        =>
            left.SplitSpan.ConcatEqual(right.SplitSpan, comparison);
    /// <inheritdoc cref="SplitSpanFactory.SplitOnAny{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<T, T, MatchAny> SplitOnAny<T>(this ReadOnlyMemory<T> span, ReadOnlyMemory<T> separator)
        where T : IEquatable<T> =>
        new(span, separator);
    /// <inheritdoc cref="SplitSpanFactory.SplitOnAny{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<T, T, MatchAny> SplitOnAny<T>(this Memory<T> span, ReadOnlyMemory<T> separator)
        where T : IEquatable<T> =>
        span.ReadOnly().SplitOnAny(separator);
    /// <inheritdoc cref="SplitSpanFactory.SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<T, T, MatchAll> SplitOn<T>(this ReadOnlyMemory<T> span, ReadOnlyMemory<T> separator)
        where T : IEquatable<T> =>
        new(span, separator);
    /// <inheritdoc cref="SplitSpanFactory.SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<T, T, MatchAll> SplitOn<T>(this Memory<T> span, ReadOnlyMemory<T> separator)
        where T : IEquatable<T> =>
        span.ReadOnly().SplitOn(separator);
#if NET8_0_OR_GREATER
    /// <inheritdoc cref="SplitSpanFactory.SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<T, SearchValues<T>, MatchAny> SplitOn<T>(
        this ReadOnlyMemory<T> span,
        OnceMemoryManager<SearchValues<T>> separator
    )
        where T : IEquatable<T> =>
        new(span, separator.Memory);
    /// <inheritdoc cref="SplitSpanFactory.SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<T, SearchValues<T>, MatchAny> SplitOn<T>(
        this Memory<T> span,
        OnceMemoryManager<SearchValues<T>> separator
    )
        where T : IEquatable<T> =>
        span.ReadOnly().SplitOn(separator);
#endif
    /// <inheritdoc cref="SplitSpanFactory.SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<T, T, MatchOne> SplitOn<T>(this ReadOnlyMemory<T> span, OnceMemoryManager<T> separator)
        where T : IEquatable<T> =>
        new(span, separator.Memory);
    /// <inheritdoc cref="SplitSpanFactory.SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<T, T, MatchOne> SplitOn<T>(this Memory<T> span, OnceMemoryManager<T> separator)
        where T : IEquatable<T> =>
        span.ReadOnly().SplitOn(separator);
#if (NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) && !NO_SYSTEM_MEMORY
    /// <inheritdoc cref="SplitSpanFactory.SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<byte, byte, MatchOne> SplitOn(this Memory<byte> span, byte separator) =>
        span.ReadOnly().SplitOn(separator);
    /// <inheritdoc cref="SplitSpanFactory.SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<byte, byte, MatchOne> SplitOn(this ReadOnlyMemory<byte> span, byte separator) =>
        new(span, separator.AsMemory());
    /// <inheritdoc cref="SplitSpanFactory.SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<char, char, MatchOne> SplitOn(this Memory<char> span, char separator) =>
        span.ReadOnly().SplitOn(separator);
    /// <inheritdoc cref="SplitSpanFactory.SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<char, char, MatchOne> SplitOn(this ReadOnlyMemory<char> span, char separator) =>
        new(span, separator.AsMemory());
    /// <inheritdoc cref="SplitSpanFactory.SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<sbyte, sbyte, MatchOne> SplitOn(this Memory<sbyte> span, sbyte separator) =>
        span.ReadOnly().SplitOn(separator);
    /// <inheritdoc cref="SplitSpanFactory.SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<sbyte, sbyte, MatchOne> SplitOn(this ReadOnlyMemory<sbyte> span, sbyte separator) =>
        new(span, separator.AsMemory());
    /// <inheritdoc cref="SplitSpanFactory.SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<short, short, MatchOne> SplitOn(this Memory<short> span, short separator) =>
        span.ReadOnly().SplitOn(separator);
    /// <inheritdoc cref="SplitSpanFactory.SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<short, short, MatchOne> SplitOn(this ReadOnlyMemory<short> span, short separator) =>
        new(span, separator.AsMemory());
    /// <inheritdoc cref="SplitSpanFactory.SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<ushort, ushort, MatchOne> SplitOn(this Memory<ushort> span, ushort separator) =>
        span.ReadOnly().SplitOn(separator);
    /// <inheritdoc cref="SplitSpanFactory.SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<ushort, ushort, MatchOne> SplitOn(this ReadOnlyMemory<ushort> span, ushort separator) =>
        new(span, separator.AsMemory());
    /// <inheritdoc cref="SplitSpanFactory.SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<char, char, MatchOne> SplitOn(this string? span, char separator) =>
        new(span.AsMemory(), separator.AsMemory());
#endif
    /// <inheritdoc cref="SplitSpanFactory.SplitOnAny{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<char, char, MatchAny> SplitOnAny(this string? span, string? separator) =>
        span.AsMemory().SplitOnAny(separator.AsMemory());
    /// <inheritdoc cref="SplitSpanFactory.SplitOnAny{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<char, char, MatchAny> SplitOnAny(this string? span, ReadOnlyMemory<char> separator) =>
        span.AsMemory().SplitOnAny(separator);
    /// <inheritdoc cref="SplitSpanFactory.SplitOnAny{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<char, char, MatchAny> SplitOnAny(this ReadOnlyMemory<char> span, string? separator) =>
        span.SplitOnAny(separator.AsMemory());
    /// <inheritdoc cref="SplitSpanFactory.SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<char, char, MatchAll> SplitOn(this string? span, string? separator) =>
        span.AsMemory().SplitOn(separator.AsMemory());
    /// <inheritdoc cref="SplitSpanFactory.SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<char, char, MatchAll> SplitOn(this string? span, ReadOnlyMemory<char> separator) =>
        span.AsMemory().SplitOn(separator);
    /// <inheritdoc cref="SplitSpanFactory.SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<char, char, MatchAll> SplitOn(this ReadOnlyMemory<char> span, string? separator) =>
        span.SplitOn(separator.AsMemory());
    /// <inheritdoc cref="SplitSpanFactory.SplitLines(ReadOnlySpan{char})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<char, ComptimeString, MatchAny> SplitLines(this string? span) =>
        span.AsMemory().SplitLines();
    /// <inheritdoc cref="SplitSpanFactory.SplitLines(ReadOnlySpan{char})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<char, ComptimeString, MatchAny> SplitLines(this ReadOnlyMemory<char> span) =>
#if NET8_0_OR_GREATER
        new(span, BreakingSearch.Memory);
#else
        new(span, Breaking.AsMemory());
#endif
    /// <inheritdoc cref="SplitSpanFactory.SplitLines(ReadOnlySpan{char})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<char, ComptimeString, MatchAny> SplitLines(this Memory<char> span) =>
        span.ReadOnly().SplitLines();
    /// <inheritdoc cref="SplitSpanFactory.SplitWhitespace(ReadOnlySpan{char})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<char, ComptimeString, MatchAny> SplitWhitespace(this string? span) =>
        span.AsMemory().SplitWhitespace();
    /// <inheritdoc cref="SplitSpanFactory.SplitWhitespace(ReadOnlySpan{char})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<char, ComptimeString, MatchAny> SplitWhitespace(this ReadOnlyMemory<char> span) =>
#if NET8_0_OR_GREATER
        new(span, UnicodeSearch.Memory);
#else
        new(span, Unicode.AsMemory());
#endif
    /// <inheritdoc cref="SplitSpanFactory.SplitWhitespace(ReadOnlySpan{char})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<char, ComptimeString, MatchAny> SplitWhitespace(this Memory<char> span) =>
        span.ReadOnly().SplitWhitespace();
#if NET8_0_OR_GREATER
    /// <inheritdoc cref="SplitSpanFactory.SplitOn{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static SplitMemory<char, SearchValues<char>, MatchAny> SplitOn(
        this string? span,
        OnceMemoryManager<SearchValues<char>> separator
    ) =>
        span.AsMemory().SplitOn(separator);
#endif
/// <summary>Represents a split entry.</summary>
/// <typeparam name="TBody">The type of element from the span.</typeparam>
/// <typeparam name="TSeparator">The type of separator.</typeparam>
/// <typeparam name="TStrategy">The strategy for splitting elements.</typeparam>
[StructLayout(LayoutKind.Auto)]
[method: MethodImpl(MethodImplOptions.AggressiveInlining)]
#if CSHARPREPL
public
#endif
#if !NO_READONLY_STRUCTS
readonly
#endif
    partial struct SplitMemory<TBody, TSeparator, TStrategy>(
        ReadOnlyMemory<TBody> body,
        ReadOnlyMemory<TSeparator> separator
    ) : IEquatable<object>,
    IEquatable<SplitMemory<TBody, TSeparator, TStrategy>>,
    ISplitMemory<TBody, TSeparator>
    where TBody : IEquatable<TBody>?
#if !NET7_0_OR_GREATER
    where TSeparator : IEquatable<TSeparator>?
#endif
{
    /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.Accumulator{TAccumulator}"/>
    public delegate TAccumulator RefAccumulator<TAccumulator>(TAccumulator accumulator, ReadOnlyMemory<TBody> next)
#if !NO_ALLOWS_REF_STRUCT
        where TAccumulator : allows ref struct
#endif
    ;
    readonly ReadOnlyMemory<TBody> _body = body;
    readonly ReadOnlyMemory<TSeparator> _separator = separator;
    /// <summary>
    /// Initializes a new instance of the <see cref="SplitMemory{TBody, TSeparator, TStrategy}"/> struct.
    /// </summary>
    /// <param name="body">The line to split.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public SplitMemory(ReadOnlyMemory<TBody> body)
        : this(body, default) { }
    /// <inheritdoc />
    public readonly ReadOnlyMemory<TBody> Body
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => _body;
    }
    /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.First"/>
    public readonly ReadOnlyMemory<TBody> First
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => SplitSpan.First.AsMemory(_body);
    }
    /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.Last"/>
    public readonly ReadOnlyMemory<TBody> Last
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => SplitSpan.Last.AsMemory(_body);
    }
    /// <inheritdoc />
    public readonly ReadOnlyMemory<TSeparator> Separator
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => _separator;
    }
    /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.Single"/>
    public readonly ReadOnlyMemory<TBody> Single
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => SplitSpan.Single.AsMemory(_body);
    }
    /// <summary>Gets itself as <see cref="SplitSpan{TBody, TSeparator, TStrategy}"/>.</summary>
    public readonly SplitSpan<TBody, TSeparator, TStrategy> SplitSpan
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => new(_body.Span, _separator.Span);
    }
    /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.this[int]"/>
    public readonly ReadOnlyMemory<TBody> this[[NonNegativeValue] int index]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => SplitSpan[index].AsMemory(_body);
    }
    /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.this[int]"/>
    public readonly ReadOnlyMemory<TBody> this[Index index]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => SplitSpan[index].AsMemory(_body);
    }
    /// <summary>Gets the specified range.</summary>
    /// <param name="range">The range to get.</param>
    public readonly SplitMemory<TBody, TSeparator, TStrategy> this[Range range]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        get => new(SplitSpan[range].Body.AsMemory(_body), Separator);
    }
    /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.op_Equality"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool operator ==(
        SplitMemory<TBody, TSeparator, TStrategy> left,
        SplitMemory<TBody, TSeparator, TStrategy> right
    ) =>
        left.Equals(right);
    /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.op_Inequality"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool operator !=(
        SplitMemory<TBody, TSeparator, TStrategy> left,
        SplitMemory<TBody, TSeparator, TStrategy> right
    ) =>
        !left.Equals(right);
    /// <summary>
    /// Explicitly converts the parameter by creating the new instance of
    /// <see cref="SplitMemory{TBody, TSeparator, TStrategy}"/> by using the constructor
    /// <see cref="SplitMemory{TBody, TSeparator, TStrategy}(ReadOnlyMemory{TBody})"/>.
    /// </summary>
    /// <param name="body">The parameter to pass onto the constructor.</param>
    /// <returns>
    /// The new instance of <see cref="SplitMemory{TBody, TSeparator, TStrategy}"/>
    /// by passing the parameter <paramref name="body"/> to the constructor
    /// <see cref="SplitMemory{TBody, TSeparator, TStrategy}(ReadOnlyMemory{TBody})"/>.
    /// </returns>
    [Pure]
    public static explicit operator SplitMemory<TBody, TSeparator, TStrategy>(ReadOnlyMemory<TBody> body) => new(body);
    /// <summary>
    /// Implicitly converts the parameter by creating the new instance of
    /// <see cref="SplitMemory{TBody, TSeparator, TStrategy}"/> by using the constructor
    /// <see cref="SplitMemory{TBody, TSeparator, TStrategy}(ReadOnlyMemory{TBody}, ReadOnlyMemory{TSeparator})"/>.
    /// </summary>
    /// <param name="tuple">The parameter to pass onto the constructor.</param>
    /// <returns>
    /// The new instance of <see cref="SplitMemory{TBody, TSeparator, TStrategy}"/>
    /// by passing the parameter <paramref name="tuple"/> to the constructor
    /// <see cref="SplitMemory{TBody, TSeparator, TStrategy}(ReadOnlyMemory{TBody}, ReadOnlyMemory{TSeparator})"/>.
    /// </returns>
    [Pure]
    public static implicit operator SplitMemory<TBody, TSeparator, TStrategy>(
        (ReadOnlyMemory<TBody> Body, ReadOnlyMemory<TSeparator> Separator) tuple
    ) =>
        new(tuple.Body, tuple.Separator);
    /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.Deconstruct"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public readonly void Deconstruct(out ReadOnlyMemory<TBody> head, out SplitMemory<TBody, TSeparator, TStrategy> tail)
    {
        if (GetEnumerator() is var e && !e.MoveNext())
        {
            head = default;
            tail = default;
            return;
        }
        head = e.Current;
        tail = new(e.Body, _separator);
    }
    /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.ConcatEqual{TOtherSeparator,TOtherStrategy}(SplitSpan{TBody, TOtherSeparator, TOtherStrategy})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly bool ConcatEqual<TOtherSeparator, TOtherStrategy>(
        SplitMemory<TBody, TOtherSeparator, TOtherStrategy> other
    )
#if !NET7_0_OR_GREATER
        where TOtherSeparator : IEquatable<TOtherSeparator>?
#endif
        =>
            SplitSpan.ConcatEqual(other.SplitSpan);
#if NET6_0_OR_GREATER
    /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.ConcatEqual{TOtherSeparator,TOtherStrategy}(SplitSpan{TBody, TOtherSeparator, TOtherStrategy}, IEqualityComparer{TBody})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly bool ConcatEqual<TOtherSeparator, TOtherStrategy>(
        SplitMemory<TBody, TOtherSeparator, TOtherStrategy> other,
        IEqualityComparer<TBody> comparer
    )
#if !NET7_0_OR_GREATER
        where TOtherSeparator : IEquatable<TOtherSeparator>?
#endif
        =>
            SplitSpan.ConcatEqual(other.SplitSpan, comparer);
#endif
    /// <inheritdoc cref="object.Equals(object)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly override bool Equals(object? obj) =>
        obj is SplitMemory<TBody, TSeparator, TStrategy> other && Equals(other);
    /// <inheritdoc cref="IEquatable{T}.Equals(T)" />
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly bool Equals(SplitMemory<TBody, TSeparator, TStrategy> other) =>
        _body.Span.SequenceEqual(other._body.Span) &&
        _separator.Span.SequenceEqual(To<TSeparator>.From(other._separator.Span));
    /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.SequenceEqual{TOtherSeparator, TOtherStrategy}(SplitSpan{TBody, TOtherSeparator, TOtherStrategy})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly bool SequenceEqual<TOtherSeparator, TOtherStrategy>(
        SplitMemory<TBody, TOtherSeparator, TOtherStrategy> other
    )
#if !NET7_0_OR_GREATER
        where TOtherSeparator : IEquatable<TOtherSeparator>?
#endif
        =>
            SplitSpan.SequenceEqual(other.SplitSpan);
#if NET6_0_OR_GREATER
    /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.SequenceEqual{TOtherSeparator, TOtherStrategy}(SplitSpan{TBody, TOtherSeparator, TOtherStrategy}, IEqualityComparer{TBody})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly bool SequenceEqual<TOtherSeparator, TOtherStrategy>(
        SplitMemory<TBody, TOtherSeparator, TOtherStrategy> other,
        IEqualityComparer<TBody> comparer
    )
#if !NET7_0_OR_GREATER
        where TOtherSeparator : IEquatable<TOtherSeparator>?
#endif
        =>
            SplitSpan.SequenceEqual(other.SplitSpan, comparer);
#endif
    /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.Count"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly int Count()
    {
        var e = GetEnumerator();
        var count = 0;
        while (e.MoveNext())
            count++;
        return count;
    }
    /// <inheritdoc />
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly override int GetHashCode() =>
        unchecked(typeof(SplitMemory<TBody, TSeparator, TStrategy>).GetHashCode() * 7);
    /// <inheritdoc />
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly override string ToString() => SplitSpan.ToString();
    /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.ToString(ReadOnlySpan{TBody})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly string ToString(ReadOnlyMemory<TBody> divider) => ToString(divider.Span);
    /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.ToString(ReadOnlySpan{TBody})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly string ToString(scoped ReadOnlySpan<TBody> divider) => SplitSpan.ToString(divider);
    /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.ToStringArray"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly string[] ToStringArray() => SplitSpan.ToStringArray();
    /// <summary>Copies the values to a new <see cref="ReadOnlyMemory{T}"/> <see cref="Array"/>.</summary>
    /// <returns>
    /// The <see cref="ReadOnlyMemory{T}"/> <see cref="Array"/> containing the copied values of this instance.
    /// </returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly ReadOnlyMemory<TBody>[] ToArrayMemories() => [..this];
    /// <inheritdoc cref="ToArrayMemories(ReadOnlyMemory{TBody})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly ReadOnlyMemory<TBody>[] ToArrayMemories(ReadOnlyMemory<TBody> divider)
    {
        if (GetEnumerator() is var e && !e.MoveNext())
            return [];
        List<ReadOnlyMemory<TBody>> ret = [e.Current];
        while (e.MoveNext())
        {
            ret.Add(divider);
            ret.Add(e.Current);
        }
        return [..ret];
    }
    /// <inheritdoc cref="IEnumerable{T}.GetEnumerator"/>
    [MustDisposeResource(false), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly Enumerator GetEnumerator() => new(this);
    /// <inheritdoc cref="IEnumerable{T}.GetEnumerator"/>
    [MustDisposeResource(false), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly ReversedEnumerator GetReversedEnumerator() => new(this);
    /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.Skipped"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), MustUseReturnValue]
    public readonly SplitMemory<TBody, TSeparator, TStrategy> Skipped([NonNegativeValue] int count)
    {
        Enumerator e = this;
        for (; count > 0 && e.MoveNext(); count--) { }
        return e.SplitMemory;
    }
    /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.SkippedLast"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), MustUseReturnValue]
    public readonly SplitMemory<TBody, TSeparator, TStrategy> SkippedLast([NonNegativeValue] int count)
    {
        ReversedEnumerator e = this;
        for (; count > 0 && e.MoveNext(); count--) { }
        return e.SplitMemory;
    }
    /// <inheritdoc />
    [MustDisposeResource(false), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
    /// <inheritdoc />
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    IEnumerator<ReadOnlyMemory<TBody>> IEnumerable<ReadOnlyMemory<TBody>>.GetEnumerator() => GetEnumerator();
    /// <summary>Gets the accumulated result of a set of callbacks where each element is passed in.</summary>
    /// <typeparam name="TAccumulator">The type of the accumulator value.</typeparam>
    /// <param name="seed">The accumulator.</param>
    /// <param name="func">An accumulator function to be invoked on each element.</param>
    /// <returns>The accumulated result of <paramref name="seed"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), MustUseReturnValue]
    public readonly TAccumulator Aggregate<TAccumulator>(
        TAccumulator seed,
        [InstantHandle, RequireStaticDelegate] RefAccumulator<TAccumulator> func
    )
#if !NO_ALLOWS_REF_STRUCT
        where TAccumulator : allows ref struct
#endif
    {
        var accumulator = seed;
        foreach (var next in this)
            accumulator = func(accumulator, next);
        return accumulator;
    }
    /// <inheritdoc cref="SplitSpan{TBody,TSeparator,TStrategy}.Aggregate{TAccumulator}(TAccumulator, SplitSpan{TBody, TSeparator, TStrategy}.Accumulator{TAccumulator})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), MustUseReturnValue]
    public readonly TAccumulator Aggregate<TAccumulator>(
        TAccumulator seed,
        [InstantHandle, RequireStaticDelegate] Func<TAccumulator, ReadOnlyMemory<TBody>, TAccumulator> func
    )
#if !NO_ALLOWS_REF_STRUCT
        where TAccumulator : allows ref struct
#endif
    {
        var accumulator = seed;
        foreach (var next in this)
            accumulator = func(accumulator, next);
        return accumulator;
    }
    /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.ToArray()"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly TBody[] ToArray() => SplitSpan.ToArray();
    /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.ToArray(ReadOnlySpan{TBody})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly TBody[] ToArray(ReadOnlyMemory<TBody> divider) => ToArray(divider.Span);
    /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.ToArray(ReadOnlySpan{TBody})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly TBody[] ToArray(scoped ReadOnlySpan<TBody> divider) => SplitSpan.ToArray(divider);
    /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.ToArrays"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly TBody[][] ToArrays() => SplitSpan.ToArrays();
    /// <summary>
    /// Represents the enumeration object that views <see cref="SplitMemory{TBody, TSeparator, TStrategy}"/>.
    /// </summary>
    [StructLayout(LayoutKind.Auto)]
    [method: MethodImpl(MethodImplOptions.AggressiveInlining)]
    public partial struct Enumerator(ReadOnlyMemory<TBody> body, ReadOnlyMemory<TSeparator> separator)
        : IEnumerator<ReadOnlyMemory<TBody>>
    {
        readonly ReadOnlyMemory<TSeparator> _separator = separator;
        readonly ReadOnlyMemory<TBody> _original = body;
        ReadOnlyMemory<TBody> _body = body, _current;
        /// <summary>Initializes a new instance of the <see cref="Enumerator"/> struct.</summary>
        /// <param name="body">The body.</param>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public Enumerator(ReadOnlyMemory<TBody> body)
            : this(body, default) { }
        /// <summary>Initializes a new instance of the <see cref="Enumerator"/> struct.</summary>
        /// <param name="split">The enumerable to enumerate.</param>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public Enumerator(SplitMemory<TBody, TSeparator, TStrategy> split)
            : this(split._body, split._separator) { }
        /// <inheritdoc cref="SplitMemory{TBody, TSeparator, TStrategy}.Body"/>
        public readonly ReadOnlyMemory<TBody> Body
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => _body;
            [MethodImpl(MethodImplOptions.AggressiveInlining)] init => _body = value;
        }
        /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.Enumerator.SplitSpan"/>
        public readonly SplitMemory<TBody, TSeparator, TStrategy> SplitMemory
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
            get => new(_body, _separator);
        }
        /// <inheritdoc />
        readonly object IEnumerator.Current
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => _current;
        }
        /// <inheritdoc />
        public readonly ReadOnlyMemory<TBody> Current
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => _current;
        }
        /// <inheritdoc cref="SplitMemory{TBody, TSeparator, TStrategy}.Separator"/>
        public readonly ReadOnlyMemory<TSeparator> Separator
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => _separator;
            [MethodImpl(MethodImplOptions.AggressiveInlining)] init => _separator = value;
        }
        /// <summary>
        /// Explicitly converts the parameter by creating the new instance
        /// of <see cref="Enumerator"/> by using the constructor
        /// <see cref="SplitMemory{TBody, TSeparator, TStrategy}.Enumerator(ReadOnlyMemory{TBody})"/>.
        /// </summary>
        /// <param name="body">The parameter to pass onto the constructor.</param>
        /// <returns>
        /// The new instance of <see cref="Enumerator"/> by passing the
        /// parameter <paramref name="body"/> to the constructor
        /// <see cref="SplitMemory{TBody, TSeparator, TStrategy}.Enumerator(ReadOnlyMemory{TBody})"/>.
        /// </returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        public static explicit operator SplitMemory<TBody, TSeparator, TStrategy>
            .Enumerator(ReadOnlyMemory<TBody> body) =>
            new(body);
        /// <summary>
        /// Implicitly converts the parameter by creating the new instance
        /// of <see cref="Enumerator"/> by using the constructor
        /// <see cref="SplitMemory{TBody, TSeparator, TStrategy}.Enumerator(ReadOnlyMemory{TBody}, ReadOnlyMemory{TSeparator})"/>.
        /// </summary>
        /// <param name="tuple">The parameter to pass onto the constructor.</param>
        /// <returns>
        /// The new instance of <see cref="Enumerator"/> by passing the
        /// parameter <paramref name="tuple"/> to the constructor
        /// <see cref="SplitMemory{TBody, TSeparator, TStrategy}.Enumerator(ReadOnlyMemory{TBody}, ReadOnlyMemory{TSeparator})"/>.
        /// </returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        public static implicit operator SplitMemory<TBody, TSeparator, TStrategy>.Enumerator(
            (ReadOnlyMemory<TBody> Body, ReadOnlyMemory<TSeparator> Separator) tuple
        ) =>
            new(tuple.Body, tuple.Separator);
        /// <summary>
        /// Implicitly converts the parameter by creating the new instance
        /// of <see cref="Enumerator"/> by using the constructor
        /// <see cref="SplitMemory{TBody, TSeparator, TStrategy}.Enumerator(SplitMemory{TBody, TSeparator, TStrategy})"/>.
        /// </summary>
        /// <param name="split">The parameter to pass onto the constructor.</param>
        /// <returns>
        /// The new instance of <see cref="Enumerator"/> by passing the
        /// parameter <paramref name="split"/> to the constructor
        /// <see cref="SplitMemory{TBody, TSeparator, TStrategy}.Enumerator(SplitMemory{TBody, TSeparator, TStrategy})"/>.
        /// </returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        public static implicit operator SplitMemory<TBody, TSeparator, TStrategy>
            .Enumerator(SplitMemory<TBody, TSeparator, TStrategy> split) =>
            new(split);
        /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.Enumerator.Move"/>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool Move(
            ReadOnlyMemory<TSeparator> sep,
            scoped ref ReadOnlyMemory<TBody> body,
            out ReadOnlyMemory<TBody> current
        )
        {
            var b = body.Span;
            var ret = SplitSpan<TBody, TSeparator, TStrategy>.Enumerator.Move(sep.Span, ref b, out var c);
            current = c.AsMemory(body);
            body = b.AsMemory(body);
            return ret;
        }
        /// <inheritdoc />
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public bool MoveNext() => Move(_separator, ref _body, out _current);
        /// <inheritdoc />
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        readonly void IDisposable.Dispose() { }
        /// <inheritdoc />
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        void IEnumerator.Reset() => _body = _original;
    }
    /// <summary>
    /// Represents the enumeration object that views <see cref="SplitMemory{T, TSeparator, TStrategy}"/>.
    /// </summary>
    [StructLayout(LayoutKind.Auto)]
    [method: MethodImpl(MethodImplOptions.AggressiveInlining)]
    public partial struct ReversedEnumerator(ReadOnlyMemory<TBody> body, ReadOnlyMemory<TSeparator> separator)
        : IEnumerator<ReadOnlyMemory<TBody>>
    {
        readonly ReadOnlyMemory<TBody> _original = body;
        readonly ReadOnlyMemory<TSeparator> _separator = separator;
        ReadOnlyMemory<TBody> _body = body, _current;
        /// <summary>Initializes a new instance of the <see cref="ReversedEnumerator"/> struct.</summary>
        /// <param name="body">The body.</param>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public ReversedEnumerator(ReadOnlyMemory<TBody> body)
            : this(body, default) { }
        /// <summary>Initializes a new instance of the <see cref="ReversedEnumerator"/> struct.</summary>
        /// <param name="split">The enumerable to enumerate.</param>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public ReversedEnumerator(SplitMemory<TBody, TSeparator, TStrategy> split)
            : this(split._body, split._separator) { }
        /// <inheritdoc cref="SplitMemory{T, TSeparator, TStrategy}.Body"/>
        public readonly ReadOnlyMemory<TBody> Body
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => _body;
            [MethodImpl(MethodImplOptions.AggressiveInlining)] init => _body = value;
        }
        /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.ReversedEnumerator.SplitSpan"/>
        public readonly SplitMemory<TBody, TSeparator, TStrategy> SplitMemory
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
            get => new(_body, _separator);
        }
        /// <inheritdoc />
        readonly object IEnumerator.Current
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => _current;
        }
        /// <inheritdoc cref="IEnumerator{T}.Current"/>
        public readonly ReadOnlyMemory<TBody> Current
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => _current;
        }
        /// <inheritdoc cref="SplitMemory{T, TSeparator, TStrategy}.Separator"/>
        public readonly ReadOnlyMemory<TSeparator> Separator
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => _separator;
            [MethodImpl(MethodImplOptions.AggressiveInlining)] init => _separator = value;
        }
        /// <summary>
        /// Explicitly converts the parameter by creating the new instance
        /// of <see cref="ReversedEnumerator"/> by using the constructor
        /// <see cref="SplitMemory{TBody, TSeparator, TStrategy}.ReversedEnumerator(ReadOnlyMemory{TBody})"/>.
        /// </summary>
        /// <param name="body">The parameter to pass onto the constructor.</param>
        /// <returns>
        /// The new instance of <see cref="ReversedEnumerator"/> by passing
        /// the parameter <paramref name="body"/> to the constructor
        /// <see cref="SplitMemory{TBody, TSeparator, TStrategy}.ReversedEnumerator(ReadOnlyMemory{TBody})"/>.
        /// </returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        public static explicit operator SplitMemory<TBody, TSeparator, TStrategy>.ReversedEnumerator(
            ReadOnlyMemory<TBody> body
        ) =>
            new(body);
        /// <summary>
        /// Implicitly converts the parameter by creating the new instance
        /// of <see cref="ReversedEnumerator"/> by using the constructor
        /// <see cref="SplitMemory{TBody, TSeparator, TStrategy}.ReversedEnumerator(ReadOnlyMemory{TBody}, ReadOnlyMemory{TSeparator})"/>.
        /// </summary>
        /// <param name="tuple">The parameter to pass onto the constructor.</param>
        /// <returns>
        /// The new instance of <see cref="ReversedEnumerator"/> by passing
        /// the parameter <paramref name="tuple"/> to the constructor
        /// <see cref="SplitMemory{TBody, TSeparator, TStrategy}.ReversedEnumerator(ReadOnlyMemory{TBody}, ReadOnlyMemory{TSeparator})"/>.
        /// </returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        public static implicit operator SplitMemory<TBody, TSeparator, TStrategy>.ReversedEnumerator(
            (ReadOnlyMemory<TBody> Body, ReadOnlyMemory<TSeparator> Separator) tuple
        ) =>
            new(tuple.Body, tuple.Separator);
        /// <summary>
        /// Implicitly converts the parameter by creating the new instance
        /// of <see cref="ReversedEnumerator"/> by using the constructor
        /// <see cref="SplitMemory{TBody, TSeparator, TStrategy}.ReversedEnumerator(SplitMemory{TBody, TSeparator, TStrategy})"/>.
        /// </summary>
        /// <param name="split">The parameter to pass onto the constructor.</param>
        /// <returns>
        /// The new instance of <see cref="ReversedEnumerator"/> by passing
        /// the parameter <paramref name="split"/> to the constructor
        /// <see cref="SplitMemory{TBody, TSeparator, TStrategy}.ReversedEnumerator(SplitMemory{TBody, TSeparator, TStrategy})"/>.
        /// </returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        public static implicit operator SplitMemory<TBody, TSeparator, TStrategy>.ReversedEnumerator(
            SplitMemory<TBody, TSeparator, TStrategy> split
        ) =>
            new(split);
        /// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}.Enumerator.Move"/>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool MoveNext(
            ReadOnlyMemory<TSeparator> sep,
            scoped ref ReadOnlyMemory<TBody> body,
            out ReadOnlyMemory<TBody> current
        )
        {
            var b = body.Span;
            var ret = SplitSpan<TBody, TSeparator, TStrategy>.ReversedEnumerator.Move(sep.Span, ref b, out var c);
            current = c.AsMemory(body);
            body = b.AsMemory(body);
            return ret;
        }
        /// <inheritdoc />
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public bool MoveNext() => MoveNext(_separator, ref _body, out _current);
        /// <inheritdoc />
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        readonly void IDisposable.Dispose() { }
        /// <inheritdoc />
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        void IEnumerator.Reset() => _body = _original;
    }
}
// SPDX-License-Identifier: MPL-2.0
#if XNA
/// <summary>Provides thread-safe access to keyboard input.</summary>
    /// <summary>Converts <see cref="GamePadButtons"/> to <see cref="Buttons"/>.</summary>
    /// <param name="state">The <see cref="GamePadButtons"/> to convert.</param>
    /// <returns>The <see cref="Buttons"/> equivalent.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure,
     UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_buttons")]
    public static extern ref readonly Buttons AsButtons(this in GamePadButtons state);
    /// <summary>Converts <see cref="MouseState"/> to <see cref="MouseButtons"/>.</summary>
    /// <param name="state">The <see cref="MouseState"/> to convert.</param>
    /// <returns>The <see cref="MouseButtons"/> equivalent.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ref readonly MouseButtons ToMouseButtons(this in MouseState state)
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure,
         UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_buttons")]
        static extern ref readonly byte Buttons(in MouseState state);
        return ref Unsafe.As<byte, MouseButtons>(ref AsRef(Buttons(in state)));
    }
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable once CheckNamespace EmptyNamespace
#if (NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) && !NO_SYSTEM_MEMORY
// ReSharper disable once RedundantUsingDirective
/// <inheritdoc cref="SpanSimdQueries"/>
// ReSharper disable NullableWarningSuppressionIsUsed RedundantNameQualifier RedundantSuppressNullableWarningExpression UseSymbolAlias
    /// <inheritdoc cref="Enumerable.Max{T}(IEnumerable{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Max<T>(this IMemoryOwner<T> enumerable)
#if !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            MinMax<T, SMax>(enumerable.Memory.Span);
    /// <inheritdoc cref="Enumerable.Max{T}(IEnumerable{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Max<T>(this Memory<T> enumerable)
#if !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            MinMax<T, SMax>(enumerable.Span);
    /// <inheritdoc cref="Enumerable.Max{T}(IEnumerable{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Max<T>(this scoped Span<T> enumerable)
#if UNMANAGED_SPAN
        where T : unmanaged
#elif !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            MinMax<T, SMax>(enumerable);
    /// <inheritdoc cref="Enumerable.Max{T}(IEnumerable{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Max<T>(this ReadOnlyMemory<T> enumerable)
#if !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            MinMax<T, SMax>(enumerable.Span);
    /// <inheritdoc cref="Enumerable.Max{T}(IEnumerable{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Max<T>(this scoped ReadOnlySpan<T> enumerable)
#if UNMANAGED_SPAN
        where T : unmanaged
#elif !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            MinMax<T, SMax>(enumerable);
    /// <inheritdoc cref="Enumerable.Min{T}(IEnumerable{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Min<T>(this IMemoryOwner<T> enumerable)
#if !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            MinMax<T, SMin>(enumerable.Memory.Span);
    /// <inheritdoc cref="Enumerable.Min{T}(IEnumerable{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Min<T>(this Memory<T> enumerable)
#if !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            MinMax<T, SMin>(enumerable.Span);
    /// <inheritdoc cref="Enumerable.Min{T}(IEnumerable{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Min<T>(this scoped Span<T> enumerable)
#if UNMANAGED_SPAN
        where T : unmanaged
#elif !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            MinMax<T, SMin>(enumerable);
    /// <inheritdoc cref="Enumerable.Min{T}(IEnumerable{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Min<T>(this ReadOnlyMemory<T> enumerable)
#if !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            MinMax<T, SMin>(enumerable.Span);
    /// <inheritdoc cref="Enumerable.Min{T}(IEnumerable{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Min<T>(this scoped ReadOnlySpan<T> enumerable)
#if UNMANAGED_SPAN
        where T : unmanaged
#elif !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            MinMax<T, SMin>(enumerable);
#if NET6_0_OR_GREATER
    /// <inheritdoc cref="Enumerable.MaxBy{TSource, TKey}(IEnumerable{TSource}, Func{TSource, TKey})"/>
#else
    /// <inheritdoc cref="EnumerableMinMax.MaxBy{TSource, TKey}(IEnumerable{TSource}, Func{TSource, TKey})"/>
#endif
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Max<T, TResult>(
        this IMemoryOwner<T> enumerable,
        [InstantHandle, RequireStaticDelegate] Converter<T, TResult> keySelector
    )
#if !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            MinMax<T, TResult, SMax>(enumerable.Memory.Span, keySelector);
#if NET6_0_OR_GREATER
    /// <inheritdoc cref="Enumerable.MaxBy{TSource, TKey}(IEnumerable{TSource}, Func{TSource, TKey})"/>
#else
    /// <inheritdoc cref="EnumerableMinMax.MaxBy{TSource, TKey}(IEnumerable{TSource}, Func{TSource, TKey})"/>
#endif
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Max<T, TResult>(
        this Memory<T> enumerable,
        [InstantHandle, RequireStaticDelegate] Converter<T, TResult> keySelector
    )
#if !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            MinMax<T, TResult, SMax>(enumerable.Span, keySelector);
#if NET6_0_OR_GREATER
    /// <inheritdoc cref="Enumerable.MaxBy{TSource, TKey}(IEnumerable{TSource}, Func{TSource, TKey})"/>
#else
    /// <inheritdoc cref="EnumerableMinMax.MaxBy{TSource, TKey}(IEnumerable{TSource}, Func{TSource, TKey})"/>
#endif
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Max<T, TResult>(
        this scoped Span<T> enumerable,
        [InstantHandle, RequireStaticDelegate] Converter<T, TResult> keySelector
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#elif !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            MinMax<T, TResult, SMax>(enumerable, keySelector);
#if NET6_0_OR_GREATER
    /// <inheritdoc cref="Enumerable.MaxBy{TSource, TKey}(IEnumerable{TSource}, Func{TSource, TKey})"/>
#else
    /// <inheritdoc cref="EnumerableMinMax.MaxBy{TSource, TKey}(IEnumerable{TSource}, Func{TSource, TKey})"/>
#endif
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Max<T, TResult>(
        this ReadOnlyMemory<T> enumerable,
        [InstantHandle, RequireStaticDelegate] Converter<T, TResult> keySelector
    )
#if !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            MinMax<T, TResult, SMax>(enumerable.Span, keySelector);
#if NET6_0_OR_GREATER
    /// <inheritdoc cref="Enumerable.MaxBy{TSource, TKey}(IEnumerable{TSource}, Func{TSource, TKey})"/>
#else
    /// <inheritdoc cref="EnumerableMinMax.MaxBy{TSource, TKey}(IEnumerable{TSource}, Func{TSource, TKey})"/>
#endif
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Max<T, TResult>(
        this scoped ReadOnlySpan<T> enumerable,
        [InstantHandle, RequireStaticDelegate] Converter<T, TResult> keySelector
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#elif !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            MinMax<T, TResult, SMax>(enumerable, keySelector);
#if NET6_0_OR_GREATER
    /// <inheritdoc cref="Enumerable.MinBy{TSource, TKey}(IEnumerable{TSource}, Func{TSource, TKey})"/>
#else
    /// <inheritdoc cref="EnumerableMinMax.MinBy{TSource, TKey}(IEnumerable{TSource}, Func{TSource, TKey})"/>
#endif
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Min<T, TResult>(
        this IMemoryOwner<T> enumerable,
        [InstantHandle, RequireStaticDelegate] Converter<T, TResult> keySelector
    )
#if !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            MinMax<T, TResult, SMin>(enumerable.Memory.Span, keySelector);
#if NET6_0_OR_GREATER
    /// <inheritdoc cref="Enumerable.MinBy{TSource, TKey}(IEnumerable{TSource}, Func{TSource, TKey})"/>
#else
    /// <inheritdoc cref="EnumerableMinMax.MinBy{TSource, TKey}(IEnumerable{TSource}, Func{TSource, TKey})"/>
#endif
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Min<T, TResult>(
        this Memory<T> enumerable,
        [InstantHandle, RequireStaticDelegate] Converter<T, TResult> keySelector
    )
#if !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            MinMax<T, TResult, SMin>(enumerable.Span, keySelector);
#if NET6_0_OR_GREATER
    /// <inheritdoc cref="Enumerable.MinBy{TSource, TKey}(IEnumerable{TSource}, Func{TSource, TKey})"/>
#else
    /// <inheritdoc cref="EnumerableMinMax.MinBy{TSource, TKey}(IEnumerable{TSource}, Func{TSource, TKey})"/>
#endif
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Min<T, TResult>(
        this scoped Span<T> enumerable,
        [InstantHandle, RequireStaticDelegate] Converter<T, TResult> keySelector
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#elif !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            MinMax<T, TResult, SMin>(enumerable, keySelector);
#if NET6_0_OR_GREATER
    /// <inheritdoc cref="Enumerable.MinBy{TSource, TKey}(IEnumerable{TSource}, Func{TSource, TKey})"/>
#else
    /// <inheritdoc cref="EnumerableMinMax.MinBy{TSource, TKey}(IEnumerable{TSource}, Func{TSource, TKey})"/>
#endif
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Min<T, TResult>(
        this ReadOnlyMemory<T> enumerable,
        [InstantHandle, RequireStaticDelegate] Converter<T, TResult> keySelector
    )
#if !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            MinMax<T, TResult, SMin>(enumerable.Span, keySelector);
#if NET6_0_OR_GREATER
    /// <inheritdoc cref="Enumerable.MinBy{TSource, TKey}(IEnumerable{TSource}, Func{TSource, TKey})"/>
#else
    /// <inheritdoc cref="EnumerableMinMax.MinBy{TSource, TKey}(IEnumerable{TSource}, Func{TSource, TKey})"/>
#endif
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Min<T, TResult>(
        this scoped ReadOnlySpan<T> enumerable,
        [InstantHandle, RequireStaticDelegate] Converter<T, TResult> keySelector
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#elif !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            MinMax<T, TResult, SMin>(enumerable, keySelector);
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    static bool Compare<T, TS>(T l, T r) =>
        0 switch
        {
            _ when typeof(TS) == typeof(SMax) && typeof(T) == typeof(byte) => (byte)(object)l! > (byte)(object)r!,
            _ when typeof(TS) == typeof(SMin) && typeof(T) == typeof(byte) => (byte)(object)l! < (byte)(object)r!,
            _ when typeof(TS) == typeof(SMax) && typeof(T) == typeof(double) => (double)(object)l! > (double)(object)r!,
            _ when typeof(TS) == typeof(SMin) && typeof(T) == typeof(double) => (double)(object)l! < (double)(object)r!,
            _ when typeof(TS) == typeof(SMax) && typeof(T) == typeof(float) => (float)(object)l! > (float)(object)r!,
            _ when typeof(TS) == typeof(SMin) && typeof(T) == typeof(float) => (float)(object)l! < (float)(object)r!,
            _ when typeof(TS) == typeof(SMax) && typeof(T) == typeof(int) => (int)(object)l! > (int)(object)r!,
            _ when typeof(TS) == typeof(SMin) && typeof(T) == typeof(int) => (int)(object)l! < (int)(object)r!,
            _ when typeof(TS) == typeof(SMax) && typeof(T) == typeof(nint) => (nint)(object)l! > (nint)(object)r!,
            _ when typeof(TS) == typeof(SMin) && typeof(T) == typeof(nint) => (nint)(object)l! < (nint)(object)r!,
            _ when typeof(TS) == typeof(SMax) && typeof(T) == typeof(nuint) => (nuint)(object)l! > (nuint)(object)r!,
            _ when typeof(TS) == typeof(SMin) && typeof(T) == typeof(nuint) => (nuint)(object)l! < (nuint)(object)r!,
            _ when typeof(TS) == typeof(SMax) && typeof(T) == typeof(sbyte) => (sbyte)(object)l! > (sbyte)(object)r!,
            _ when typeof(TS) == typeof(SMin) && typeof(T) == typeof(sbyte) => (sbyte)(object)l! < (sbyte)(object)r!,
            _ when typeof(TS) == typeof(SMax) && typeof(T) == typeof(short) => (short)(object)l! > (short)(object)r!,
            _ when typeof(TS) == typeof(SMin) && typeof(T) == typeof(short) => (short)(object)l! < (short)(object)r!,
            _ when typeof(TS) == typeof(SMax) && typeof(T) == typeof(uint) => (uint)(object)l! > (uint)(object)r!,
            _ when typeof(TS) == typeof(SMin) && typeof(T) == typeof(uint) => (uint)(object)l! < (uint)(object)r!,
            _ when typeof(TS) == typeof(SMax) && typeof(T) == typeof(ulong) => (ulong)(object)l! > (ulong)(object)r!,
            _ when typeof(TS) == typeof(SMin) && typeof(T) == typeof(ulong) => (ulong)(object)l! < (ulong)(object)r!,
            _ when typeof(TS) == typeof(SMax) && typeof(T) == typeof(ushort) => (ushort)(object)l! > (ushort)(object)r!,
            _ when typeof(TS) == typeof(SMin) && typeof(T) == typeof(ushort) => (ushort)(object)l! < (ushort)(object)r!,
            _ when typeof(TS) == typeof(SMax) => Comparer<T>.Default.Compare(l, r) > 0,
            _ when typeof(TS) == typeof(SMin) => Comparer<T>.Default.Compare(l, r) < 0,
            _ => throw Unreachable,
        };
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    static System.Numerics.Vector<T> LoadUnsafe<T>(scoped in T source)
#if !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
#if CSHARPREPL
            System.Numerics.Vector.LoadUnsafe(ref AsRef(source));
#elif NET8_0_OR_GREATER
            System.Numerics.Vector.LoadUnsafe(source);
#else
            Unsafe.ReadUnaligned<System.Numerics.Vector<T>>(ref Unsafe.As<T, byte>(ref AsRef(source)));
#endif
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    static T MinMax<T, TS>(this scoped ReadOnlySpan<T> span)
#if UNMANAGED_SPAN
        where T : unmanaged
#elif !NET8_0_OR_GREATER
        where T : struct
#endif
    {
        T value;
        if (span.IsEmpty)
            return default!;
        if (!IsNumericPrimitive<T>() ||
#if NET7_0_OR_GREATER
            !System.Numerics.Vector<T>.IsSupported ||
#endif
            !System.Numerics.Vector.IsHardwareAccelerated ||
            span.Length < System.Numerics.Vector<T>.Count
        )
        {
            value = span.UnsafelyIndex(0);
            for (var i = 1; i < span.Length; i++)
                if (span.UnsafelyIndex(i) is var next && Compare<T, TS>(next, value))
                    value = next;
            return value;
        }
        ref var current = ref MemoryMarshal.GetReference(span);
        ref var lastVectorStart = ref Unsafe.Add(ref current, span.Length - System.Numerics.Vector<T>.Count);
        var best = LoadUnsafe(current);
        current = ref Unsafe.Add(ref current, System.Numerics.Vector<T>.Count)!;
        for (;
            Unsafe.IsAddressLessThan(ref current, ref lastVectorStart);
            current = ref Unsafe.Add(ref current, System.Numerics.Vector<T>.Count)!)
            best = 0 switch
            {
                _ when typeof(TS) == typeof(SMax) => System.Numerics.Vector.Max(best, LoadUnsafe(current)),
                _ when typeof(TS) == typeof(SMin) => System.Numerics.Vector.Min(best, LoadUnsafe(current)),
                _ => throw Unreachable,
            };
        best = 0 switch
        {
            _ when typeof(TS) == typeof(SMax) => System.Numerics.Vector.Max(best, LoadUnsafe(lastVectorStart)),
            _ when typeof(TS) == typeof(SMin) => System.Numerics.Vector.Min(best, LoadUnsafe(lastVectorStart)),
            _ => throw Unreachable,
        };
        value = best[0];
        for (var i = 1; i < System.Numerics.Vector<T>.Count; i++)
            if (0 switch
            {
                _ when typeof(TS) == typeof(SMax) => Compare<T, TS>(best[i], value),
                _ when typeof(TS) == typeof(SMin) => Compare<T, TS>(best[i], value),
                _ => throw Unreachable,
            })
                value = best[i];
        return value;
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining), MustUseReturnValue]
    static T MinMax<T, TResult, TS>(
        this scoped ReadOnlySpan<T> enumerable,
        [InstantHandle, RequireStaticDelegate] Converter<T, TResult> converter
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
    {
        if (enumerable.IsEmpty)
            return default!;
        ref var bestValue = ref MemoryMarshal.GetReference(enumerable);
        ref var current = ref Unsafe.Add(ref bestValue, 1);
        ref var last = ref Unsafe.Add(ref bestValue, enumerable.Length);
        var bestKey = converter(bestValue);
        for (; Unsafe.IsAddressLessThan(ref current, ref last); current = ref Unsafe.Add(ref current, 1)!)
            if (converter(current) is var next &&
                0 switch
                {
                    _ when typeof(TS) == typeof(SMax) => Compare<TResult, TS>(next, bestKey),
                    _ when typeof(TS) == typeof(SMin) => Compare<TResult, TS>(next, bestKey),
                    _ => throw Unreachable,
                })
            {
                bestKey = next;
                bestValue = ref current;
            }
        return bestValue;
    }
    struct SMin;
    struct SMax;
#endif
// SPDX-License-Identifier: MPL-2.0
#if !NETFRAMEWORK || NET40_OR_GREATER
// ReSharper disable once CheckNamespace
/// <summary>Provides methods to create and operate on <see cref="AggregateException"/> instances.</summary>
    /// <summary>Asserts that the <paramref name="exception"/> is <see langword="null"/>.</summary>
    /// <param name="exception">The <see cref="AggregateException"/> to assert.</param>
    /// <exception cref="AggregateException">The <paramref name="exception"/> is not <see langword="null"/>.</exception>
    public static void ExpectNull(this AggregateException? exception)
    {
        if (exception is not null)
            throw exception;
    }
    /// <summary>Asserts that the <paramref name="exceptions"/> are empty.</summary>
    /// <param name="exceptions">The collection of <see cref="Exception"/> instances.</param>
    /// <param name="message">The message of the <see cref="AggregateException"/> instance.</param>
    /// <exception cref="AggregateException">The <paramref name="exceptions"/> are non-empty.</exception>
    public static void ThrowAny(this ICollection<Exception> exceptions, string? message = null) =>
        ExpectNull(Aggregate(exceptions));
    /// <summary>Summarizes the collection of <see cref="Exception"/> instances.</summary>
    /// <param name="exceptions">The collection of <see cref="Exception"/> instances.</param>
    /// <param name="separator">The separator to use.</param>
    /// <returns>One long <see cref="string"/>.</returns>
    public static string Messages(this AggregateException exceptions, char separator) =>
        exceptions.InnerExceptions.Select(x => x.Message).Conjoin(separator);
    /// <summary>Summarizes the collection of <see cref="Exception"/> instances.</summary>
    /// <param name="exceptions">The collection of <see cref="Exception"/> instances.</param>
    /// <param name="separator">The separator to use.</param>
    /// <returns>One long <see cref="string"/>.</returns>
    public static string Messages(this AggregateException exceptions, string separator = ", ") =>
        exceptions.InnerExceptions.Select(x => x.Message).Conjoin(separator);
    /// <summary>
    /// Creates an <see cref="AggregateException"/> from a collection of <see cref="Exception"/> instances.
    /// </summary>
    /// <param name="exceptions">The collection of <see cref="Exception"/> instances.</param>
    /// <param name="message">The message of the <see cref="AggregateException"/> instance.</param>
    /// <returns>
    /// The <see cref="AggregateException"/> instance from the parameter
    /// <paramref name="exceptions"/> if it is not empty; otherwise, <see langword="null"/>.
    /// </returns>
    [Pure]
    public static AggregateException? Aggregate(this ICollection<Exception> exceptions, string? message = null) =>
        exceptions.Count is 0 ? null : new(message, exceptions);
#endif
// SPDX-License-Identifier: MPL-2.0
#if !NETFRAMEWORK || NET35_OR_GREATER
// ReSharper disable CheckNamespace RedundantNameQualifier
/// <summary>Provides methods to do math on enums without overhead from boxing.</summary>
[UsedImplicitly]
    /// <summary>Checks if the left-hand side implements the right-hand side.</summary>
    /// <remarks><para>The conversion and operation are unchecked, and treated as <see cref="int"/>.</para></remarks>
    /// <typeparam name="T">The type of <see cref="Enum"/> to perform the operation on.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="left"/> has the values
    /// of the parameter <paramref name="right"/>; otherwise, <see langword="false"/>.
    /// </returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool Has<T>(this T left, T right)
        where T : struct, Enum =>
        (left.AsInt() & right.AsInt()) == right.AsInt();
    /// <summary>Performs a conversion operation.</summary>
    /// <remarks><para>The conversion and operation are unchecked, and treated as <see cref="int"/>.</para></remarks>
    /// <typeparam name="T">The type of <see cref="Enum"/> to perform the operation on.</typeparam>
    /// <param name="value">The value.</param>
    /// <returns>The <see cref="int"/> cast of <paramref name="value"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int AsInt<T>(this T value)
        where T : struct, Enum =>
#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_0_OR_GREATER
        0 switch
        {
            _ when typeof(T).GetEnumUnderlyingType() == typeof(byte) => (byte)(object)value,
            _ when typeof(T).GetEnumUnderlyingType() == typeof(sbyte) => (sbyte)(object)value,
            _ when typeof(T).GetEnumUnderlyingType() == typeof(short) => (short)(object)value,
            _ when typeof(T).GetEnumUnderlyingType() == typeof(ushort) => (ushort)(object)value,
            _ when typeof(T).GetEnumUnderlyingType() == typeof(int) => (int)(object)value,
            _ when typeof(T).GetEnumUnderlyingType() == typeof(uint) => (int)(uint)(object)value,
            _ when typeof(T).GetEnumUnderlyingType() == typeof(long) => (int)(long)(object)value,
            _ when typeof(T).GetEnumUnderlyingType() == typeof(ulong) => (int)(ulong)(object)value,
            _ when typeof(T).GetEnumUnderlyingType() == typeof(nint) => (int)(nint)(object)value,
            _ when typeof(T).GetEnumUnderlyingType() == typeof(nuint) => (int)(nuint)(object)value,
            _ => throw Unreachable,
        };
#else
        MathCaching<T>.From(value);
#endif
    /// <summary>Performs a conversion operation.</summary>
    /// <remarks><para>The conversion and operation are unchecked, and treated as <see cref="int"/>.</para></remarks>
    /// <typeparam name="T">The type of <see cref="Enum"/> to perform the operation on.</typeparam>
    /// <param name="value">The value.</param>
    /// <returns>The <typeparamref name="T"/> cast of <paramref name="value"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T As<T>(this int value)
        where T : struct, Enum =>
#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_0_OR_GREATER
        0 switch
        {
            _ when typeof(T).GetEnumUnderlyingType() == typeof(byte) => (T)(object)(byte)value,
            _ when typeof(T).GetEnumUnderlyingType() == typeof(sbyte) => (T)(object)(sbyte)value,
            _ when typeof(T).GetEnumUnderlyingType() == typeof(short) => (T)(object)(short)value,
            _ when typeof(T).GetEnumUnderlyingType() == typeof(ushort) => (T)(object)(ushort)value,
            _ when typeof(T).GetEnumUnderlyingType() == typeof(int) => (T)(object)value,
            _ when typeof(T).GetEnumUnderlyingType() == typeof(uint) => (T)(object)(uint)value,
            _ when typeof(T).GetEnumUnderlyingType() == typeof(long) => (T)(object)(long)value,
            _ when typeof(T).GetEnumUnderlyingType() == typeof(ulong) => (T)(object)(ulong)value,
            _ when typeof(T).GetEnumUnderlyingType() == typeof(nint) => (T)(object)(nint)value,
            _ when typeof(T).GetEnumUnderlyingType() == typeof(nuint) => (T)(object)(nuint)value,
            _ => throw Unreachable,
        };
#else
        MathCaching<T>.To(value);
#endif
    /// <summary>Performs a negation operation.</summary>
    /// <remarks><para>The conversion and operation are unchecked, and treated as <see cref="int"/>.</para></remarks>
    /// <typeparam name="T">The type of <see cref="Enum"/> to perform the operation on.</typeparam>
    /// <param name="value">The value.</param>
    /// <returns>The negated value of the parameter <paramref name="value"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T Negate<T>(this T value)
        where T : struct, Enum =>
        (-value.AsInt()).As<T>();
    /// <summary>Performs an decrement operation.</summary>
    /// <remarks><para>The conversion and operation are unchecked, and treated as <see cref="int"/>.</para></remarks>
    /// <typeparam name="T">The type of <see cref="Enum"/> to perform the operation on.</typeparam>
    /// <param name="value">The value.</param>
    /// <returns>The predecessor of the parameter <paramref name="value"/>; the number immediately before it.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T Predecessor<T>(this T value)
        where T : struct, Enum =>
        (value.AsInt() - 1).As<T>();
    /// <summary>Performs a increment operation.</summary>
    /// <remarks><para>The conversion and operation are unchecked, and treated as <see cref="int"/>.</para></remarks>
    /// <typeparam name="T">The type of <see cref="Enum"/> to perform the operation on.</typeparam>
    /// <param name="value">The value.</param>
    /// <returns>The predecessor of the parameter <paramref name="value"/>; the number immediately after it.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T Successor<T>(this T value)
        where T : struct, Enum =>
        (value.AsInt() + 1).As<T>();
    /// <summary>Performs an addition operation.</summary>
    /// <remarks><para>The conversion and operation are unchecked, and treated as <see cref="int"/>.</para></remarks>
    /// <typeparam name="T">The type of <see cref="Enum"/> to perform the operation on.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>The sum of the parameters <paramref name="left"/> and <paramref name="right"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T Add<T>(this T left, T right)
        where T : struct, Enum =>
        (left.AsInt() + right.AsInt()).As<T>();
    /// <summary>Performs a subtraction operation.</summary>
    /// <remarks><para>The conversion and operation are unchecked, and treated as <see cref="int"/>.</para></remarks>
    /// <typeparam name="T">The type of <see cref="Enum"/> to perform the operation on.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>The difference of the parameters <paramref name="left"/> and <paramref name="right"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T Subtract<T>(this T left, T right)
        where T : struct, Enum =>
        (left.AsInt() - right.AsInt()).As<T>();
    /// <summary>Performs a multiplication operation.</summary>
    /// <remarks><para>The conversion and operation are unchecked, and treated as <see cref="int"/>.</para></remarks>
    /// <typeparam name="T">The type of <see cref="Enum"/> to perform the operation on.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>The product of the parameters <paramref name="left"/> and <paramref name="right"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T Multiply<T>(this T left, T right)
        where T : struct, Enum =>
        (left.AsInt() * right.AsInt()).As<T>();
    /// <summary>Performs a division operation.</summary>
    /// <remarks><para>The conversion and operation are unchecked, and treated as <see cref="int"/>.</para></remarks>
    /// <typeparam name="T">The type of <see cref="Enum"/> to perform the operation on.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>The quotient of the parameters <paramref name="left"/> and <paramref name="right"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T Divide<T>(this T left, T right)
        where T : struct, Enum =>
        (left.AsInt() / right.AsInt()).As<T>();
    /// <summary>Performs a modulo operation.</summary>
    /// <remarks><para>The conversion and operation are unchecked, and treated as <see cref="int"/>.</para></remarks>
    /// <typeparam name="T">The type of <see cref="Enum"/> to perform the operation on.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>The remainder of the parameters <paramref name="left"/> and <paramref name="right"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T Modulo<T>(this T left, T right)
        where T : struct, Enum =>
        (left.AsInt() % right.AsInt()).As<T>();
    /// <summary>Computes the product of a sequence of <typeparamref name="T"/> values.</summary>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <param name="source">A sequence of <typeparamref name="T"/> values to calculate the product of.</param>
    /// <returns>The product of the values in the sequence.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T Product<T>(this IEnumerable<T> source)
        where T : struct, Enum =>
        source.Aggregate(Multiply);
    /// <summary>Computes the sum of a sequence of <typeparamref name="T"/> values.</summary>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <param name="source">A sequence of <typeparamref name="T"/> values to calculate the sum of.</param>
    /// <returns>The sum of the values in the sequence.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T Sum<T>(this IEnumerable<T> source)
        where T : struct, Enum
#if NET5_0_OR_GREATER
        =>
            source.TryGetSpan(out var span) ? span.Sum() : source.Aggregate(Add);
#else
        =>
            source.Aggregate(Add);
#endif
#if !NETSTANDARD2_1_OR_GREATER && !NETCOREAPP3_0_OR_GREATER
    static class MathCaching<T>
        where T : struct, Enum
    {
        public static Converter<T, int> From { [Pure] get; } = Make<Converter<T, int>>(false);
        public static Converter<int, T> To { [Pure] get; } = Make<Converter<int, T>>(true);
        [MustUseReturnValue]
        static TFunc Make<TFunc>(bool isReverse)
            where TFunc : Delegate
        {
            var parameter =
                System.Linq.Expressions.Expression.Parameter(isReverse ? typeof(int) : typeof(T), nameof(T));
            var underlying = Enum.GetUnderlyingType(typeof(T));
            System.Linq.Expressions.Expression cast =
                isReverse ? parameter : System.Linq.Expressions.Expression.Convert(parameter, underlying);
            cast = underlying != typeof(int)
                ? System.Linq.Expressions.Expression.Convert(parameter, isReverse ? underlying : typeof(int))
                : cast;
            cast = isReverse ? System.Linq.Expressions.Expression.Convert(cast, typeof(T)) : cast;
            return System.Linq.Expressions.Expression.Lambda<TFunc>(cast, parameter).Compile();
        }
    }
#endif
#endif
// SPDX-License-Identifier: MPL-2.0
#if NETFRAMEWORK || NETSTANDARD2_0_OR_GREATER || NETCOREAPP2_0_OR_GREATER
// ReSharper disable CheckNamespace
/// <summary>Provides methods to check for unmanaged types.</summary>
    static readonly Dictionary<Type, bool> s_fullyUnmanaged = [];
    /// <summary>Gets the type name, with its generics extended.</summary>
    /// <param name="type">The <see cref="Type"/> to get the name of.</param>
    /// <returns>The name of the parameter <paramref name="type"/>.</returns>
    [Pure]
    public static bool IsUnmanaged([NotNullWhen(true)] this Type? type) =>
        type is not null &&
        (s_fullyUnmanaged.TryGetValue(type, out var answer) ? answer :
            !type.IsValueType ? s_fullyUnmanaged[type] = false :
            type.IsEnum || type.IsPointer || type.IsPrimitive ? s_fullyUnmanaged[type] = true :
            s_fullyUnmanaged[type] = type.IsGenericTypeDefinition
                ? type
                   .GetCustomAttributes()
                   .Any(x => x?.GetType().FullName is "System.Runtime.CompilerServices.IsUnmanagedAttribute")
                : Array.TrueForAll(
                    type.GetFields(
                        BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
                    ),
                    x => IsUnmanaged(x.FieldType)
                ));
#endif
// SPDX-License-Identifier: MPL-2.0
#if !NETSTANDARD || NETSTANDARD2_0_OR_GREATER
#if NETFRAMEWORK || NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_0_OR_GREATER && !NET5_0_OR_GREATER
#pragma warning disable GlobalUsingsAnalyzer
#pragma warning restore GlobalUsingsAnalyzer
#endif
// ReSharper disable once CheckNamespace
#if NETFRAMEWORK || NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_0_OR_GREATER && !NET5_0_OR_GREATER
#endif
/// <summary>Provides methods for exiting the program.</summary>
    /// <remarks><para>This method represents the exit code 0, indicating success.</para></remarks>
    /// <inheritdoc cref="With{T}"/>
    [ContractAnnotation("=> halt"),
     DoesNotReturn,
     SecuritySafeCritical,
#if NETFRAMEWORK || NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_0_OR_GREATER && !NET5_0_OR_GREATER
     SecurityPermission(Demand, Flags = UnmanagedCode),
#endif
    ]
    public static Exception Success(string? message = null) => With<Exception>(message, 0);
    /// <remarks><para>This method represents the exit code 1, indicating failure.</para></remarks>
    /// <inheritdoc cref="With{T}"/>
    [ContractAnnotation("=> halt"),
     DoesNotReturn,
     SecuritySafeCritical,
#if NETFRAMEWORK || NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_0_OR_GREATER && !NET5_0_OR_GREATER
     SecurityPermission(Demand, Flags = UnmanagedCode),
#endif
    ]
    public static Exception Failure(string? message = null) => With<Exception>(message, 1);
    /// <remarks><para>This method represents the exit code 2, indicating invalid parameters.</para></remarks>
    /// <inheritdoc cref="With{T}"/>
    [ContractAnnotation("=> halt"),
     DoesNotReturn,
     SecuritySafeCritical,
#if NETFRAMEWORK || NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_0_OR_GREATER && !NET5_0_OR_GREATER
     SecurityPermission(Demand, Flags = UnmanagedCode),
#endif
    ]
    public static Exception Usage(string? message = null) => With<Exception>(message, 2);
    /// <typeparam name="T">Only used for type coercion.</typeparam>
    /// <inheritdoc cref="Success"/>
    [ContractAnnotation("=> halt"),
     DoesNotReturn,
     SecuritySafeCritical,
#if NETFRAMEWORK || NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_0_OR_GREATER && !NET5_0_OR_GREATER
     SecurityPermission(Demand, Flags = UnmanagedCode),
#endif
    ]
    public static T Success<T>(string? message = null) => With<T>(message, 0);
    /// <typeparam name="T">Only used for type coercion.</typeparam>
    /// <inheritdoc cref="Failure"/>
    [ContractAnnotation("=> halt"),
     DoesNotReturn,
     SecuritySafeCritical,
#if NETFRAMEWORK || NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_0_OR_GREATER && !NET5_0_OR_GREATER
     SecurityPermission(Demand, Flags = UnmanagedCode),
#endif
    ]
    public static T Failure<T>(string? message = null) => With<T>(message, 1);
    /// <typeparam name="T">Only used for type coercion.</typeparam>
    /// <inheritdoc cref="Usage"/>
    [ContractAnnotation("=> halt"),
     DoesNotReturn,
     SecuritySafeCritical,
#if NETFRAMEWORK || NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_0_OR_GREATER && !NET5_0_OR_GREATER
     SecurityPermission(Demand, Flags = UnmanagedCode),
#endif
    ]
    public static T Usage<T>(string? message = null) => With<T>(message, 2);
    /// <summary>Terminates this process and returns the exit code to the operating system.</summary>
    /// <typeparam name="T">Only used for type coercion.</typeparam>
    /// <param name="message">The message to print into the standard output/error, if specified.</param>
    /// <param name="exitCode">The exit code.</param>
    /// <exception cref="SecurityException">
    /// The caller does not have sufficient security permission to perform this function.
    /// </exception>
    /// <returns>This method does not return. Specified to allow <see langword="throw"/> expressions.</returns>
    [ContractAnnotation("=> halt"), DoesNotReturn, SecuritySafeCritical,
#if NETFRAMEWORK || NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_0_OR_GREATER && !NET5_0_OR_GREATER
     SecurityPermission(Demand, Flags = UnmanagedCode),
#endif
    ]
    static T With<T>(string? message, byte exitCode)
    {
        if (message is not null)
            (exitCode is 0 ? Console.Out : Console.Error).WriteLine(message);
        Environment.Exit(exitCode);
        throw Unreachable;
    }
#endif
// SPDX-License-Identifier: MPL-2.0
#if XNA
/// <summary>The basic wrapper around <see cref="Game"/> that handles letterboxing for a 2D game.</summary>
// ReSharper disable NullableWarningSuppressionIsUsed
[CLSCompliant(false)]
public abstract partial class Letterboxed2DGame : Game
{
    /// <summary>Gets the target to draw to.</summary>
    RenderTarget2D? _target;
    /// <summary>Initializes a new instance of the <see cref="Letterboxed2DGame"/> class.</summary>
    /// <param name="width">The width of the world.</param>
    /// <param name="height">The height of the world.</param>
    /// <param name="scale">The scale relative to the native resolution to open the window to.</param>
    protected Letterboxed2DGame(int width, int height, float scale = 5 / 6f)
    {
        var ratio = (GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Width / (float)(Width = width))
           .Min(GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Height / (float)(Height = height));
        (GraphicsDeviceManager = new(this)
        {
            SynchronizeWithVerticalRetrace = false,
            PreferredBackBufferWidth = (int)(Width * ratio * scale),
            PreferredBackBufferHeight = (int)(Height * ratio * scale),
        }).ApplyChanges();
        IsMouseVisible = true;
        IsFixedTimeStep = false;
        Window.AllowUserResizing = true;
#if !ANDROID
        Window.KeyDown += CheckForBorderlessOrFullScreenBind;
#endif
        GraphicsDevice.BlendState = BlendState.NonPremultiplied;
    }
    /// <summary>Determines whether the game is being played in a desktop environment.</summary>
    [Pure, SupportedOSPlatformGuard("freebsd"), SupportedOSPlatformGuard("linux"), SupportedOSPlatformGuard("macos"),
     SupportedOSPlatformGuard("windows")]
    public static bool IsDesktop =>
        OperatingSystem.IsWindows() ||
        OperatingSystem.IsMacOS() ||
        OperatingSystem.IsLinux() ||
        OperatingSystem.IsFreeBSD();
    /// <summary>Gets the height of the native (world) resolution.</summary>
    [ValueRange(1, int.MaxValue), Pure]
    public int Height { get; }
    /// <summary>Gets the width of the native (world) resolution.</summary>
    [ValueRange(1, int.MaxValue), Pure]
    public int Width { get; }
    /// <summary>Gets the background, shown in letterboxing.</summary>
    [Pure]
    public Color Background { get; set; }
    /// <summary>Gets the default blend state.</summary>
    [Pure]
    public virtual BlendState BatchBlendState => BlendState.NonPremultiplied;
    /// <summary>Gets the device manager that contains this instance.</summary>
    [Pure]
    public GraphicsDeviceManager GraphicsDeviceManager { get; }
    /// <summary>Gets the batch to draw with.</summary>
    [Pure]
    public SpriteBatch Batch { get; private set; } = null!;
    /// <summary>Gets the texture containing a single white pixel.</summary>
    [Pure]
    public Texture2D WhitePixel { get; private set; } = null!;
    /// <summary>Converts the window coordinate to the world coordinate.</summary>
    /// <param name="x">The x coordinate.</param>
    /// <param name="y">The y coordinate.</param>
    /// <returns>The world coordinate of the parameters given.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public Vector2 World(float x, float y)
    {
        var bounds = Window.ClientBounds;
        float width = bounds.Width, height = bounds.Height;
        var world = Width / (float)Height;
        var window = width / height;
        var ratio = window < world ? width / Width : height / Height;
        return window < world
            ? new(x / ratio, (y - (height - ratio * Height) / 2) / ratio)
            : new((x - (width - ratio * Width) / 2) / ratio, y / ratio);
    }
    /// <inheritdoc cref="World(Vector2)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public Vector2 World(in MouseState v) => World(v.Position);
    /// <inheritdoc cref="World(Vector2)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public Vector2 World(Point v) => World(v.X, v.Y);
    /// <inheritdoc cref="World(Vector2)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public Vector2 World(in TouchLocation v) => World(v.Position);
    /// <summary>Converts the window coordinate to the world coordinate.</summary>
    /// <param name="v">The vector to convert.</param>
    /// <returns>The world coordinate of the vector.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public Vector2 World(Vector2 v) => World(v.X, v.Y);
    /// <inheritdoc />
    protected override void Dispose(bool disposing)
    {
        if (disposing)
            _target?.Dispose();
        base.Dispose(disposing);
    }
    /// <inheritdoc />
    protected override void EndDraw()
    {
        Debug.Assert(Batch is not null);
        Batch.End();
        GraphicsDevice.SetRenderTarget(null);
        GraphicsDevice.Clear(Background);
        Batch.Begin();
        var resolution = GraphicsDevice.Resolution(Width, Height);
        Batch.Draw(_target, resolution, Color.White);
        Batch.End();
        base.EndDraw();
    }
    /// <inheritdoc />
    [CLSCompliant(false), MemberNotNull(nameof(Batch), nameof(_target), nameof(WhitePixel))]
    protected override void Initialize()
    {
        base.Initialize();
        _target = new(GraphicsDevice, Width, Height);
        Services.AddService(Batch = new(GraphicsDevice));
        WhitePixel = new(GraphicsDevice, 1, 1);
        WhitePixel.SetData([Color.White]);
    }
    /// <inheritdoc />
    protected override bool BeginDraw()
    {
        Debug.Assert(Batch is not null);
        GraphicsDevice.SetRenderTarget(_target);
        GraphicsDevice.Clear(Background);
        Batch.Begin(blendState: BatchBlendState);
        return base.BeginDraw();
    }
#if !ANDROID
    /// <summary>Invoked when a keyboard button is pressed.</summary>
    /// <param name="_">The sender, ignored.</param>
    /// <param name="e">The event arguments containing the key that was pressed.</param>
    void CheckForBorderlessOrFullScreenBind([UsedImplicitly] object? _, InputKeyEventArgs e)
    {
        switch (e.Key)
        {
            case Keys.F9 when IsDesktop:
                Window.IsBorderless = !Window.IsBorderless;
                break;
            case Keys.F11:
                GraphicsDeviceManager.IsFullScreen = !GraphicsDeviceManager.IsFullScreen;
                GraphicsDeviceManager.ApplyChanges();
                break;
        }
    }
#endif
}
#endif
// SPDX-License-Identifier: MPL-2.0
#if IMGUI && XNA
// ReSharper disable RedundantNameQualifier
// ReSharper disable once CheckNamespace
#pragma warning disable CA1707, CA2213
/// <summary>ImGui renderer for use with MonoGame.</summary>
/// <param name="game">The game to use as reference.</param>
/// <param name="shared">Whether the <see cref="Context"/> is shared between instances of this type.</param>
[CLSCompliant(false)]
public sealed class ImGuiRenderer(Game game, bool shared = false) : IDisposable
{
    delegate (bool Return, string NewInput) TextInput(
        ReadOnlySpan<char> label,
        ReadOnlySpan<char> hint,
        string input,
        uint maxLength,
        System.Numerics.Vector2 size,
        ImGuiInputTextFlags flags
    );
    const float WheelDelta = 120;
    static readonly ImmutableArray<Keys> s_keys = ImmutableCollectionsMarshal.AsImmutableArray(Enum.GetValues<Keys>());
    static readonly List<(ReadOnlyMemory<char> Label, string Input)> s_queued = [];
    static readonly VertexDeclaration s_declaration = new(
        Unsafe.SizeOf<ImDrawVert>(),
        new VertexElement(0, VertexElementFormat.Vector2, VertexElementUsage.Position, 0),
        new VertexElement(8, VertexElementFormat.Vector2, VertexElementUsage.TextureCoordinate, 0),
        new VertexElement(16, VertexElementFormat.Color, VertexElementUsage.Color, 0)
    );
#if TEXTCOPY
    static nint s_clipboard;
#endif
    static nint s_sharedContext;
    readonly Dictionary<nint, Texture2D> _loadedTextures = [];
    readonly (Game Game, bool Shared, nint Context) _m = (game, shared, SetupInput(game, shared));
    readonly GraphicsDevice _graphicsDevice = game.GraphicsDevice;
    readonly RasterizerState _rasterizerState = new()
    {
        CullMode = CullMode.None,
        DepthBias = 0,
        FillMode = FillMode.Solid,
        MultiSampleAntiAlias = false,
        ScissorTestEnable = true,
        SlopeScaleDepthBias = 0,
    };
    byte[]? _indexData, _vertexData;
    int _horizontalScrollWheelValue, _indexBufferSize, _scrollWheelValue, _textureId, _vertexBufferSize;
    nint? _fontTextureId;
    BasicEffect? _effect;
    IndexBuffer? _indexBuffer;
    VertexBuffer? _vertexBuffer;
    /// <summary>Gets the value determining whether this instance is disposed.</summary>
    public bool IsDisposed { get; private set; }
    /// <summary>Gets the context.</summary>
    public nint Context => _m.Context;
    /// <summary>Shows the keyboard display for mobile. Does nothing on desktop builds.</summary>
    /// <param name="title">The title.</param>
    /// <param name="description">The description.</param>
    /// <param name="defaultText">The default text.</param>
    /// <param name="usePasswordMode">Whether to hide the characters.</param>
    public static void AddKeyboardInputToIO(
        string title,
        string description,
        string defaultText = "",
        bool usePasswordMode = false
    )
    {
        async Task ShowAsync()
        {
            var input = await KeyboardInput.Show(title, description, defaultText, usePasswordMode)
               .ConfigureAwait(false);
            var io = ImGui.GetIO();
            foreach (var c in input.AsSpan())
                if (c is not '\t')
                    io.AddInputCharacter(c);
        }
        if (OperatingSystem.IsAndroid() || OperatingSystem.IsIOS())
#pragma warning disable MA0134
            _ = Task.Run(ShowAsync);
#pragma warning restore MA0134
    }
    /// <inheritdoc cref="BeginTabItem(ReadOnlySpan{char}, ref bool, ImGuiTabItemFlags)"/>
    public static bool BeginTabItem(string label, ref bool p_open, ImGuiTabItemFlags flags) =>
        BeginTabItem(label.AsSpan(), ref p_open, flags);
    /// <inheritdoc cref="ImGui.BeginTabItem(string, ref bool, ImGuiTabItemFlags)"/>
    /// <remarks><para>
    /// The original binding doesn't work when <paramref name="p_open"/> is null reference.
    /// However, it being a null ref has significance to imgui, as it means
    /// the item is always shown and the selection is managed by imgui itself.
    /// So, we fix this ourselves and wait till it gets fixed upstream.
    /// </para></remarks>
    public static unsafe bool BeginTabItem(ReadOnlySpan<char> label, ref bool p_open, ImGuiTabItemFlags flags)
    {
        var nativeLabel = Encoding.UTF8.GetByteCount(label) + 1 is var length && length <= Span.MaxStackalloc
            ? stackalloc byte[length]
            : new byte[length];
        nativeLabel[Encoding.UTF8.GetBytes(label, nativeLabel)] = 0;
        fixed (byte* nativeLabelPtr = nativeLabel)
        fixed (bool* open = &p_open)
            return ImGuiNative.igBeginTabItem(nativeLabelPtr, (byte*)open, flags) is not 0;
    }
    /// <inheritdoc cref="InputText(ReadOnlyMemory{char}, ref string, uint, ImGuiInputTextFlags)"/>
    public static bool InputText(
        string label,
        ref string input,
        uint maxLength,
        ImGuiInputTextFlags flags = ImGuiInputTextFlags.None
    ) =>
        InputText(label.AsMemory(), ref input, maxLength, flags);
    /// <summary>
    /// Drop-in replacement for <see cref="ImGui.InputText(string, ref string, uint, ImGuiInputTextFlags)"/>
    /// that allows mobile devices to enter text fields explicitly.
    /// </summary>
    /// <param name="label">The label of the input text.</param>
    /// <param name="input">The current value of the input text.</param>
    /// <param name="maxLength">The maximum length for the parameter <paramref name="maxLength"/>.</param>
    /// <param name="flags">The flags of the input text.</param>
    public static bool InputText(
        ReadOnlyMemory<char> label,
        ref string input,
        uint maxLength,
        ImGuiInputTextFlags flags = ImGuiInputTextFlags.None
    ) =>
        Text(
            label,
            "",
            ref input,
            maxLength,
            default,
            flags,
            static (label, _, input, maxLength, _, flags) =>
                (ImGui.InputText(label, ref input, maxLength, flags), input)
        );
    /// <inheritdoc cref="InputText(ReadOnlyMemory{char}, ref string, uint, ImGuiInputTextFlags)"/>
    public static bool InputTextMultiline(
        string label,
        ReadOnlySpan<char> hint,
        ref string input,
        uint maxLength,
        System.Numerics.Vector2 size,
        ImGuiInputTextFlags flags = ImGuiInputTextFlags.None
    ) =>
        InputTextMultiline(label.AsMemory(), hint, ref input, maxLength, size, flags);
    /// <inheritdoc cref="InputText(ReadOnlyMemory{char}, ref string, uint, ImGuiInputTextFlags)"/>
    public static bool InputTextMultiline(
        ReadOnlyMemory<char> label,
        ReadOnlySpan<char> hint,
        ref string input,
        uint maxLength,
        System.Numerics.Vector2 size,
        ImGuiInputTextFlags flags = ImGuiInputTextFlags.None
    ) =>
        OperatingSystem.IsAndroid() || OperatingSystem.IsIOS()
            ? Text(
                label,
                hint,
                ref input,
                maxLength,
                size,
                flags,
                static (label, _, input, maxLength, size, flags) =>
                    (ImGui.InputTextMultiline(label, ref input, maxLength, size, flags), input)
            )
            : ImGui.InputTextMultiline(label.Span, ref input, maxLength, size, flags);
    /// <inheritdoc cref="InputText(ReadOnlyMemory{char}, ref string, uint, ImGuiInputTextFlags)"/>
    public static bool InputTextWithHint(
        string label,
        ReadOnlySpan<char> hint,
        ref string input,
        uint maxLength,
        ImGuiInputTextFlags flags = ImGuiInputTextFlags.None
    ) =>
        InputTextWithHint(label.AsMemory(), hint, ref input, maxLength, flags);
    /// <inheritdoc cref="InputText(ReadOnlyMemory{char}, ref string, uint, ImGuiInputTextFlags)"/>
    public static bool InputTextWithHint(
        ReadOnlyMemory<char> label,
        ReadOnlySpan<char> hint,
        ref string input,
        uint maxLength,
        ImGuiInputTextFlags flags = ImGuiInputTextFlags.None
    ) =>
        OperatingSystem.IsAndroid() || OperatingSystem.IsIOS()
            ? Text(
                label,
                hint,
                ref input,
                maxLength,
                default,
                flags,
                static (label, hint, input, maxLength, _, flags) =>
                    (ImGui.InputTextWithHint(label, hint, ref input, maxLength, flags), input)
            )
            : ImGui.InputTextWithHint(label.Span, hint, ref input, maxLength, flags);
    /// <summary>
    /// Creates a pointer to a texture, which can be passed through ImGui calls such a
    /// <see cref="ImGui.Image(System.IntPtr, System.Numerics.Vector2)" />.
    /// That pointer is then used by ImGui to let us know what texture to draw.
    /// </summary>
    public nint BindTexture(Texture2D texture)
    {
        var id = (nint)_textureId++;
        _loadedTextures.Add(id, texture);
        return id;
    }
    /// <summary>
    /// Asks ImGui for the generated geometry data and sends it to the graphics pipeline,
    /// should be called after the UIs drawn using ImGui.* calls.
    /// </summary>
    public void AfterLayout()
    {
        ImGui.Render();
        RenderDrawData(ImGui.GetDrawData());
    }
    /// <summary>Sets up ImGui for a new frame, should be called at frame start.</summary>
    public void BeforeLayout(GameTime gameTime)
    {
        ImGui.GetIO().DeltaTime = (float)gameTime.ElapsedGameTime.TotalSeconds;
        UpdateInput();
        ImGui.NewFrame();
    }
    /// <inheritdoc />
    public void Dispose()
    {
        if (IsDisposed)
            return;
#if TEXTCOPY
        FreeClipboard();
#endif
        IsDisposed = true;
        _effect?.Dispose();
        _indexBuffer?.Dispose();
        _vertexBuffer?.Dispose();
        if (!_m.Shared)
            ImGui.DestroyContext(_m.Context);
        (_effect, _indexBuffer, _vertexBuffer) = (null, null, null);
    }
    /// <summary>
    /// Creates a texture and loads the font data from ImGui. Should be called when the
    /// <see cref="GraphicsDevice" /> is initialized but before any rendering is done.
    /// </summary>
    public unsafe void RebuildFontAtlas()
    {
        var io = ImGui.GetIO();
        io.Fonts.GetTexDataAsRGBA32(out byte* pixelData, out var width, out var height, out var bytesPerPixel);
        Texture2D tex2d = new(_graphicsDevice, width, height, false, SurfaceFormat.Color);
        tex2d.SetData([..new ReadOnlySpan<byte>(pixelData, width * height * bytesPerPixel)]);
        if (_fontTextureId is { } id)
            UnbindTexture(id);
        var bind = BindTexture(tex2d);
        _fontTextureId = bind;
        io.Fonts.SetTexID(bind);
        io.Fonts.ClearTexData();
    }
#if TEXTCOPY
    /// <summary>Sets up the clipboard.</summary>
    static unsafe void SetupClipboard()
    {
        static nint Get(nint _)
        {
            FreeClipboard();
            return s_clipboard = Marshal.StringToHGlobalAnsi(ClipboardService.GetText());
        }
        static void Set(nint _, sbyte* text)
        {
            FreeClipboard();
            ClipboardService.SetText(new(text));
        }
        var platformIo = ImGui.GetPlatformIO();
        platformIo.Platform_GetClipboardTextFn = (nint)(delegate*<nint, nint>)&Get;
        platformIo.Platform_SetClipboardTextFn = (nint)(delegate*<nint, sbyte*, void>)&Set;
    }
    /// <summary>Frees the last recorded clipboard.</summary>
    static void FreeClipboard()
    {
        if (s_clipboard is 0)
            return;
        Marshal.FreeHGlobal(s_clipboard);
        s_clipboard = 0;
    }
#endif
    /// <summary>Sets up the IO.</summary>
    static void SetupIO()
    {
#if TEXTCOPY
        SetupClipboard();
#endif
        var io = ImGui.GetIO();
        io.ConfigErrorRecovery = true;
        io.ConfigErrorRecoveryEnableAssert = false;
        io.ConfigErrorRecoveryEnableTooltip = true;
        io.ConfigErrorRecoveryEnableDebugLog = false;
    }
    /// <summary>
    /// Removes a previously created texture pointer, releasing its reference and allowing it to be deallocated.
    /// </summary>
    public void UnbindTexture(nint textureId) => _loadedTextures.Remove(textureId);
    static bool TryMapKeys(Keys key, out ImGuiKey imGuiKey) =>
        (imGuiKey = key switch
        {
            Keys.Back => ImGuiKey.Backspace,
            Keys.Tab => ImGuiKey.Tab,
            Keys.Enter => ImGuiKey.Enter,
            Keys.CapsLock => ImGuiKey.CapsLock,
            Keys.Escape => ImGuiKey.Escape,
            Keys.Space => ImGuiKey.Space,
            Keys.PageUp => ImGuiKey.PageUp,
            Keys.PageDown => ImGuiKey.PageDown,
            Keys.End => ImGuiKey.End,
            Keys.Home => ImGuiKey.Home,
            Keys.Left => ImGuiKey.LeftArrow,
            Keys.Right => ImGuiKey.RightArrow,
            Keys.Up => ImGuiKey.UpArrow,
            Keys.Down => ImGuiKey.DownArrow,
            Keys.PrintScreen => ImGuiKey.PrintScreen,
            Keys.Insert => ImGuiKey.Insert,
            Keys.Delete => ImGuiKey.Delete,
            >= Keys.D0 and <= Keys.D9 => ImGuiKey._0 + (key - Keys.D0),
            >= Keys.A and <= Keys.Z => ImGuiKey.A + (key - Keys.A),
            >= Keys.NumPad0 and <= Keys.NumPad9 => ImGuiKey.Keypad0 + (key - Keys.NumPad0),
            Keys.Multiply => ImGuiKey.KeypadMultiply,
            Keys.Add => ImGuiKey.KeypadAdd,
            Keys.Subtract => ImGuiKey.KeypadSubtract,
            Keys.Decimal => ImGuiKey.KeypadDecimal,
            Keys.Divide => ImGuiKey.KeypadDivide,
            >= Keys.F1 and <= Keys.F24 => ImGuiKey.F1 + (key - Keys.F1),
            Keys.NumLock => ImGuiKey.NumLock,
            Keys.Scroll => ImGuiKey.ScrollLock,
            Keys.LeftShift => ImGuiKey.ModShift,
            Keys.LeftControl => ImGuiKey.ModCtrl,
            Keys.LeftAlt => ImGuiKey.ModAlt,
            Keys.OemSemicolon => ImGuiKey.Semicolon,
            Keys.OemPlus => ImGuiKey.Equal,
            Keys.OemComma => ImGuiKey.Comma,
            Keys.OemMinus => ImGuiKey.Minus,
            Keys.OemPeriod => ImGuiKey.Period,
            Keys.OemQuestion => ImGuiKey.Slash,
            Keys.OemTilde => ImGuiKey.GraveAccent,
            Keys.OemOpenBrackets => ImGuiKey.LeftBracket,
            Keys.OemCloseBrackets => ImGuiKey.RightBracket,
            Keys.OemPipe => ImGuiKey.Backslash,
            Keys.OemQuotes => ImGuiKey.Apostrophe,
            Keys.BrowserBack => ImGuiKey.AppBack,
            Keys.BrowserForward => ImGuiKey.AppForward,
            _ => ImGuiKey.None,
        }) is not ImGuiKey.None ||
        key is Keys.None;
    static bool Text(
        ReadOnlyMemory<char> label,
        ReadOnlySpan<char> hint,
        ref string input,
        uint maxLength,
        System.Numerics.Vector2 size,
        ImGuiInputTextFlags flags,
        [RequireStaticDelegate(IsError = true)] TextInput textInput
    )
    {
        var copy = input;
        async Task ShowAsync()
        {
            var display = label.SplitOn('#').First;
            var result = await KeyboardInput.Show(
                    display.ToString(),
                    $"Enter a value for {display}.",
                    copy,
                    flags.Has(ImGuiInputTextFlags.Password)
                )
               .ConfigureAwait(false);
            s_queued.Add((label, result));
        }
        var labelSpan = label.Span;
        if (OperatingSystem.IsAndroid() || OperatingSystem.IsIOS())
            for (var i = s_queued.Count - 1; i >= 0; i--)
                if (s_queued[i] is var (queuedLabel, queuedInput) &&
                    labelSpan.Equals(queuedLabel.Span, StringComparison.Ordinal))
                {
                    input = queuedInput.Length > maxLength ? queuedInput[..(int)maxLength] : queuedInput;
                    s_queued.RemoveAt(i);
                }
        (var ret, input) = textInput(labelSpan, hint, input, maxLength, size, flags);
        if ((OperatingSystem.IsAndroid() || OperatingSystem.IsIOS()) && ret)
#pragma warning disable MA0134
            _ = Task.Run(ShowAsync);
#pragma warning restore MA0134
        return ret;
    }
    static nint SetupInput([UsedImplicitly] Game game, bool shared)
    {
        Debug.Assert(game is not null);
        if (shared && s_sharedContext is not 0)
            return s_sharedContext;
        var context = ImGui.CreateContext();
        ImGui.SetCurrentContext(context);
        SetupIO();
        if (shared && s_sharedContext is 0)
            s_sharedContext = context;
#if !ANDROID && !IOS
        var io = ImGui.GetIO();
        game.Window.TextInput += (_, a) =>
        {
            if (a.Character is not '\t' and var c)
                io.AddInputCharacter(c);
        };
#endif
        return context;
    }
    void RenderCommandLists(ImDrawDataPtr drawData)
    {
        _graphicsDevice.SetVertexBuffer(_vertexBuffer);
        _graphicsDevice.Indices = _indexBuffer;
        for (int n = 0, idxOffset = 0, vtxOffset = 0;
            n < drawData.CmdListsCount && drawData.CmdLists[n] is var cmdList;
            n++, idxOffset += cmdList.IdxBuffer.Size, vtxOffset += cmdList.VtxBuffer.Size)
            for (var cmdI = 0; cmdI < cmdList.CmdBuffer.Size; cmdI++)
            {
                if (cmdList.CmdBuffer[cmdI] is not { ElemCount: not 0 } drawCmd)
                    continue;
                if (!_loadedTextures.TryGetValue(drawCmd.TextureId, out var value))
                    throw new InvalidOperationException(
                        $"Could not find a texture with id '{drawCmd.TextureId}', please check your bindings"
                    );
                _graphicsDevice.ScissorRectangle = new(
                    (int)drawCmd.ClipRect.X,
                    (int)drawCmd.ClipRect.Y,
                    (int)(drawCmd.ClipRect.Z - drawCmd.ClipRect.X),
                    (int)(drawCmd.ClipRect.W - drawCmd.ClipRect.Y)
                );
                foreach (var pass in UpdateEffect(value).CurrentTechnique.Passes)
                {
                    pass.Apply();
                    _graphicsDevice.DrawIndexedPrimitives(
                        PrimitiveType.TriangleList,
                        (int)drawCmd.VtxOffset + vtxOffset,
                        (int)drawCmd.IdxOffset + idxOffset,
                        (int)drawCmd.ElemCount / 3
                    );
                }
            }
    }
    /// <summary>Gets the geometry as set up by ImGui and sends it to the graphics device.</summary>
    void RenderDrawData(ImDrawDataPtr drawData)
    {
        var lastViewport = _graphicsDevice.Viewport;
        var lastScissorBox = _graphicsDevice.ScissorRectangle;
        var lastRasterizer = _graphicsDevice.RasterizerState;
        var lastDepthStencil = _graphicsDevice.DepthStencilState;
        var lastBlendFactor = _graphicsDevice.BlendFactor;
        var lastBlendState = _graphicsDevice.BlendState;
        _graphicsDevice.BlendFactor = Color.White;
        _graphicsDevice.BlendState = BlendState.NonPremultiplied;
        _graphicsDevice.RasterizerState = _rasterizerState;
        _graphicsDevice.DepthStencilState = DepthStencilState.DepthRead;
        drawData.ScaleClipRects(ImGui.GetIO().DisplayFramebufferScale);
        _graphicsDevice.Viewport = new(
            0,
            0,
            _graphicsDevice.PresentationParameters.BackBufferWidth,
            _graphicsDevice.PresentationParameters.BackBufferHeight
        );
        UpdateBuffers(drawData);
        RenderCommandLists(drawData);
        _graphicsDevice.Viewport = lastViewport;
        _graphicsDevice.ScissorRectangle = lastScissorBox;
        _graphicsDevice.RasterizerState = lastRasterizer;
        _graphicsDevice.DepthStencilState = lastDepthStencil;
        _graphicsDevice.BlendState = lastBlendState;
        _graphicsDevice.BlendFactor = lastBlendFactor;
    }
    unsafe void UpdateBuffers(ImDrawDataPtr drawData)
    {
        if (drawData.TotalVtxCount is 0)
            return;
        if (drawData.TotalVtxCount > _vertexBufferSize)
        {
            _vertexBuffer?.Dispose();
            _vertexBufferSize = (int)(drawData.TotalVtxCount * 1.5);
            _vertexBuffer = new(_graphicsDevice, s_declaration, _vertexBufferSize, BufferUsage.None);
            _vertexData = new byte[_vertexBufferSize * Unsafe.SizeOf<ImDrawVert>()];
        }
        if (drawData.TotalIdxCount > _indexBufferSize)
        {
            _indexBuffer?.Dispose();
            _indexBufferSize = (int)(drawData.TotalIdxCount * 1.5);
            _indexBuffer = new(_graphicsDevice, IndexElementSize.SixteenBits, _indexBufferSize, BufferUsage.None);
            _indexData = new byte[_indexBufferSize * sizeof(ushort)];
        }
        Debug.Assert(_indexData is not null);
        Debug.Assert(_vertexData is not null);
        Debug.Assert(_indexBuffer is not null);
        Debug.Assert(_vertexBuffer is not null);
        for (int n = 0, idxOffset = 0, vtxOffset = 0;
            n < drawData.CmdListsCount && drawData.CmdLists[n] is var cmdList;
            n++, idxOffset += cmdList.IdxBuffer.Size, vtxOffset += cmdList.VtxBuffer.Size)
            fixed (void* vtxDstPtr = &_vertexData[vtxOffset * Unsafe.SizeOf<ImDrawVert>()])
            fixed (void* idxDstPtr = &_indexData[idxOffset * sizeof(ushort)])
            {
                Buffer.MemoryCopy(
                    (void*)cmdList.VtxBuffer.Data,
                    vtxDstPtr,
                    _vertexData.Length,
                    cmdList.VtxBuffer.Size * Unsafe.SizeOf<ImDrawVert>()
                );
                Buffer.MemoryCopy(
                    (void*)cmdList.IdxBuffer.Data,
                    idxDstPtr,
                    _indexData.Length,
                    cmdList.IdxBuffer.Size * sizeof(ushort)
                );
            }
        _vertexBuffer.SetData(_vertexData, 0, drawData.TotalVtxCount * Unsafe.SizeOf<ImDrawVert>());
        _indexBuffer.SetData(_indexData, 0, drawData.TotalIdxCount * sizeof(ushort));
    }
    void UpdateInput()
    {
        if (!_m.Game.IsActive)
            return;
        var io = ImGui.GetIO();
        var mouse = Mouse.GetState();
        var keyboard = Keyboard.GetState();
        var touches = TouchPanel.GetState();
        if (touches.Count is not 0)
            foreach (var touch in touches)
            {
                io.AddMousePosEvent(touch.Position.X, touch.Position.Y);
                io.AddMouseButtonEvent(0, touch.State is TouchLocationState.Pressed);
            }
        else
            io.AddMousePosEvent(mouse.X, mouse.Y);
        io.AddMouseButtonEvent(0, mouse.LeftButton is ButtonState.Pressed);
        io.AddMouseButtonEvent(1, mouse.RightButton is ButtonState.Pressed);
        io.AddMouseButtonEvent(2, mouse.MiddleButton is ButtonState.Pressed);
        io.AddMouseButtonEvent(3, mouse.XButton1 is ButtonState.Pressed);
        io.AddMouseButtonEvent(4, mouse.XButton2 is ButtonState.Pressed);
        io.AddMouseWheelEvent(
            (mouse.HorizontalScrollWheelValue - _horizontalScrollWheelValue) / WheelDelta,
            (mouse.ScrollWheelValue - _scrollWheelValue) / WheelDelta
        );
        _scrollWheelValue = mouse.ScrollWheelValue;
        _horizontalScrollWheelValue = mouse.HorizontalScrollWheelValue;
        foreach (var key in s_keys)
            if (TryMapKeys(key, out var imGuiKey))
                io.AddKeyEvent(imGuiKey, keyboard.IsKeyDown(key));
        io.DisplaySize = new(
            _graphicsDevice.PresentationParameters.BackBufferWidth.Max(0),
            _graphicsDevice.PresentationParameters.BackBufferHeight.Max(0)
        );
        io.DisplayFramebufferScale = new(1, 1);
    }
    [MemberNotNull(nameof(_effect))]
    BasicEffect UpdateEffect(Texture2D texture)
    {
        _effect ??= new(_graphicsDevice);
        var io = ImGui.GetIO();
        _effect.World = Microsoft.Xna.Framework.Matrix.Identity;
        _effect.View = Microsoft.Xna.Framework.Matrix.Identity;
        _effect.Projection =
            Microsoft.Xna.Framework.Matrix.CreateOrthographicOffCenter(0, io.DisplaySize.X, io.DisplaySize.Y, 0, -1, 1);
        _effect.TextureEnabled = true;
        _effect.Texture = texture;
        _effect.VertexColorEnabled = true;
        return _effect;
    }
}
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable once CheckNamespace
/// <summary>Extension methods for nullable types and booleans.</summary>
#if NET7_0_OR_GREATER
    /// <summary>Converts <see cref="bool"/> to <typeparamref name="T"/>.</summary>
    /// <typeparam name="T">The type of number to convert to.</typeparam>
    /// <param name="that">Whether or not to return the one value, or zero.</param>
    /// <returns>
    /// The value <see cref="INumberBase{T}.One"/> or <see cref="INumberBase{T}.Zero"/>,
    /// based on the value of <paramref name="that"/>.
    /// </returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T As<T>(this bool that)
        where T : INumberBase<T> =>
        that ? T.One : T.Zero;
#endif
#if NETCOREAPP || ROSLYN
    /// <summary>Determines whether two sequences are equal.</summary>
    /// <typeparam name="TDerived">The type of element in the compared array.</typeparam>
    /// <typeparam name="TBase">The type of element contained by the collection.</typeparam>
    /// <param name="first">The first <see cref="ImmutableArray{TBase}"/> to compare.</param>
    /// <param name="second">The second <see cref="ImmutableArray{TDerived}"/> to compare.</param>
    /// <returns>
    /// The value <see langword="true"/> if both sequences have the same
    /// values, or are both default; otherwise, <see langword="false"/>.
    /// </returns>
    [MustUseReturnValue]
    public static bool GuardedSequenceEqual<TDerived, TBase>(
        this ImmutableArray<TBase> first,
        ImmutableArray<TDerived> second
    )
        where TDerived : TBase =>
        first.IsDefault || second.IsDefault ? first.IsDefault && second.IsDefault : first.SequenceEqual(second);
    /// <summary>Determines whether two sequences are equal according to an equality comparer.</summary>
    /// <typeparam name="TDerived">The type of element in the compared array.</typeparam>
    /// <typeparam name="TBase">The type of element contained by the collection.</typeparam>
    /// <param name="first">The first <see cref="ImmutableArray{TBase}"/> to compare.</param>
    /// <param name="second">The second <see cref="ImmutableArray{TDerived}"/> to compare.</param>
    /// <param name="comparer">The comparer to use to check for equality.</param>
    /// <returns>
    /// The value <see langword="true"/> if both sequences have the same
    /// values, or are both default; otherwise, <see langword="false"/>.
    /// </returns>
    [MustUseReturnValue]
    public static bool GuardedSequenceEqual<TDerived, TBase>(
        this ImmutableArray<TBase> first,
        ImmutableArray<TDerived> second,
        Func<TBase, TBase, bool>? comparer
    )
        where TDerived : TBase =>
        first.IsDefault || second.IsDefault ? first.IsDefault && second.IsDefault :
        comparer is null ? first.SequenceEqual(second) : first.SequenceEqual(second, comparer);
    /// <summary>Determines whether two sequences are equal according to an equality comparer.</summary>
    /// <typeparam name="TDerived">The type of element in the compared array.</typeparam>
    /// <typeparam name="TBase">The type of element contained by the collection.</typeparam>
    /// <param name="first">The first <see cref="ImmutableArray{TBase}"/> to compare.</param>
    /// <param name="second">The second <see cref="ImmutableArray{TDerived}"/> to compare.</param>
    /// <param name="comparer">The comparer to use to check for equality.</param>
    /// <returns>
    /// The value <see langword="true"/> if both sequences have the same
    /// values, or are both default; otherwise, <see langword="false"/>.
    /// </returns>
    [MustUseReturnValue]
    public static bool GuardedSequenceEqual<TDerived, TBase>(
        this ImmutableArray<TBase> first,
        ImmutableArray<TDerived> second,
        IEqualityComparer<TBase>? comparer
    )
        where TDerived : TBase =>
        first.IsDefault || second.IsDefault ? first.IsDefault && second.IsDefault :
        comparer is null ? first.SequenceEqual(second) : first.SequenceEqual(second, comparer);
#endif
#if !NET20 && !NET30
    /// <summary>Filters an <see cref="IEnumerable{T}"/> to only non-null values.</summary>
    /// <typeparam name="T">The type of value to filter.</typeparam>
    /// <param name="iterable">The <see cref="IEnumerable{T}"/> to filter.</param>
    /// <returns>A filtered <see cref="IEnumerable{T}"/> with strictly non-null values.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<T> Filter<T>([NoEnumeration] this IEnumerable<T?>? iterable) =>
#pragma warning disable CS8619
        iterable?.Where(x => x is not null) ?? [];
#pragma warning restore CS8619
    /// <summary>Filters an <see cref="IEnumerable{T}"/> to only non-null values.</summary>
    /// <typeparam name="T">The type of value to filter.</typeparam>
    /// <param name="iterable">The <see cref="IEnumerable{T}"/> to filter.</param>
    /// <returns>A filtered <see cref="IEnumerable{T}"/> with strictly non-null values.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<T> Filter<T>([NoEnumeration] this IEnumerable<T?>? iterable)
        where T : struct =>
#pragma warning disable CS8629
        iterable?.Where(x => x.HasValue).Select(x => x.Value) ?? [];
#pragma warning restore CS8629
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable once CheckNamespace
// ReSharper disable RedundantReadonlyModifier StructCanBeMadeReadOnly
/// <summary>Provides methods to calculate various binomial coefficients.</summary>
#if NET8_0_OR_GREATER
    /// <summary>Calculates the binomial coefficient (nCk) (N items, choose k).</summary>
    /// <remarks><para>
    /// Implementation based on <a href="https://stackoverflow.com/a/19125294/18052726">Moop's solution</a>.
    /// </para></remarks>
    /// <typeparam name="T">The type of the number.</typeparam>
    /// <param name="n">The number of items.</param>
    /// <param name="k">The number to choose.</param>
    /// <returns>
    /// <math><mrow><mo>(</mo><mfrac linethickness="0"><mi>n</mi><mi>k</mi></mfrac><mo>)</mo></mrow></math>
    /// </returns>
    [NonNegativeValue, Pure]
    public static T Choose<T>(this T n, T k)
        where T : INumberBase<T>
    {
        if (T.IsNegative(n))
            return checked(T.IsEvenInteger(k) ? Choose(-n + T.One, k) : -Choose(-n + T.One + T.One, k));
        if (T.IsZero(k) || T.IsNegative(k) || T.IsNegative(n - k))
            return T.Zero;
        if (n == k)
            return T.One;
        var c = T.One;
        for (var i = T.One; T.IsPositive(k - i); i++)
            c = checked(c * n-- / i);
        return c;
    }
#else
    /// <summary>Calculates the binomial coefficient (nCk) (N items, choose k).</summary>
    /// <remarks><para>
    /// Implementation based on <a href="https://stackoverflow.com/a/19125294/18052726">Moop's solution</a>.
    /// </para></remarks>
    /// <param name="n">The number of items.</param>
    /// <param name="k">The number to choose.</param>
    /// <returns>
    /// <math><mrow><mo>(</mo><mfrac linethickness="0"><mi>n</mi><mi>k</mi></mfrac><mo>)</mo></mrow></math>
    /// </returns>
    [NonNegativeValue, Pure]
    public static int Choose(this int n, int k)
    {
        if (n < 0)
            return checked((k & 1) is 0 ? Choose(-n + 1, k) : -Choose(-n + 2, k));
        if (n < k || k <= 0)
            return 0;
        if (n == k)
            return 1;
        var c = 1;
        for (var i = 1; i <= k; i++)
            c = checked(c * n-- / i);
        return c;
    }
    /// <inheritdoc cref="Choose(int, int)"/>
    [NonNegativeValue, Pure]
    public static long Choose(this long n, long k)
    {
        if (n < 0)
            return checked((k & 1) is 0 ? Choose(-n + 1, k) : -Choose(-n + 2, k));
        if (n < k || k <= 0)
            return 0;
        if (n == k)
            return 1;
        long c = 1;
        for (long i = 1; i <= k; i++)
            c = checked(c * n-- / i);
        return c;
    }
#endif
    /// <summary>Calculates the binomial coefficient (nCk) (N items, choose k).</summary>
    /// <typeparam name="T">The type of items to choose from.</typeparam>
    /// <param name="n">The items to choose from.</param>
    /// <param name="k">The amount of items to choose.</param>
    /// <returns>
    /// The <see cref="ICollection{T}"/> of <see cref="IList{T}"/> containing the binomial coefficients.
    /// </returns>
    [Pure]
#pragma warning disable IDE0305
    public static Choices<T> Choose<T>(this IEnumerable<T>? n, int k) => new(n.ToIList(), k);
#pragma warning restore IDE0305
/// <summary>Provides methods to calculate various binomial coefficients.</summary>
/// <typeparam name="T">The type of element.</typeparam>
/// <param name="n">The collection to choose from.</param>
/// <param name="k">The number to choose.</param>
[StructLayout(LayoutKind.Auto)]
#if CSHARPREPL
public
#endif
#if !NO_READONLY_STRUCTS
readonly
#endif
    struct Choices<T>(IList<T>? n, int k) : ICollection<IList<T>>, IEquatable<Choices<T>>
{
    /// <summary>Provides the enumerator for the <see cref="Choices{T}"/> struct.</summary>
    /// <param name="n">The collection to choose from.</param>
    /// <param name="k">The number to choose.</param>
    [StructLayout(LayoutKind.Auto)]
    public struct Enumerator(IList<T>? n, int k) : IEnumerator<IList<T>>
    {
        bool _hasDisposed, _hasMoved;
        int[] _values = Rent(n, k);
        /// <inheritdoc cref="Choices{T}.K"/>
        [NonNegativeValue, Pure]
        public int K { get; } = System.Math.Max(k, 0);
        /// <inheritdoc />
        [Pure]
        public IList<T> Current { get; private set; } = [];
        /// <inheritdoc cref="Choices{T}.N"/>
        [Pure]
        public readonly IList<T> N { get; } = n ?? [];
        /// <inheritdoc />
        [Pure]
        readonly object IEnumerator.Current => Current;
        /// <summary>Resets the provided array to the initial state.</summary>
        /// <param name="values">The array to fill.</param>
        /// <param name="k">
        /// The length of the area to fill, assumed to be at least
        /// the length of the parameter <paramref name="values"/>.
        /// </param>
        /// <returns>The parameter <paramref name="values"/>.</returns>
        public static int[] Reset(int[] values, int k)
        {
#if (NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) && !NO_SYSTEM_MEMORY
            values.AsSpan()[..k].Range();
#else
            for (var i = 0; i < k; i++)
                values[i] = i;
#endif
            return values;
        }
        /// <inheritdoc />
        public void Dispose()
        {
            if (_hasDisposed || _values is null or [])
                return;
            ArrayPool<int>.Shared.Return(_values);
            _hasDisposed = true;
            _values = [];
        }
        /// <inheritdoc />
        public void Reset()
        {
            _hasMoved = false;
            Reset(_values ??= new int[K], K);
        }
        /// <inheritdoc />
        public bool MoveNext()
        {
            if (EarlyReturn() is { } next)
                return next;
            for (var i = K - 1; i >= 0; i--)
                if (Found(i))
                    return true;
            return false;
        }
        [Pure]
        static int[] Rent(IList<T>? n, int k) =>
            n is not { Count: not 0 and var count } || count <= k
                ? []
                : Reset(ArrayPool<int>.Shared.Rent(k), k);
        void Copy()
        {
            Current = new T[K];
            for (var i = 0; i < K; i++)
                Current[i] = N[_values[i]];
        }
        [MustUseReturnValue]
        bool Found(int found)
        {
            if (_values[found] + 1 is var next && next >= N.Count - (K - found - 1))
                return false;
#if (NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) && !NO_SYSTEM_MEMORY
            _values.AsSpan()[found..].Range(next);
#else
            for (var i = found; i < K; i++)
                _values[i] = next + i - found;
#endif
            Copy();
            return true;
        }
        [MustUseReturnValue]
        bool? EarlyReturn()
        {
            if (K is 0 || N is not { Count: not 0 and var count } || count < K)
                return false;
            if (K == count)
                return (Current = N) is var _ && !_hasMoved && (_hasMoved = true);
            if (_hasMoved)
                return null;
            Copy();
            _hasMoved = true;
            return true;
        }
    }
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), Pure]
    readonly bool ICollection<IList<T>>.IsReadOnly => true;
    /// <inheritdoc cref="ICollection{T}.Count"/>
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), NonNegativeValue, Pure]
    public readonly int Count => N.Count.Choose(K);
    /// <summary>Gets the number of choices.</summary>
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), NonNegativeValue, Pure]
    public int K { get; } = System.Math.Max(k, 0);
    /// <summary>Gets the list of choices.</summary>
    [CollectionAccess(Read), Pure]
    public IList<T> N { get; } = n ?? [];
    /// <summary>Gets the first <see cref="K"/> choices.</summary>
    [CollectionAccess(Read), Pure]
    public readonly IEnumerable<T> First =>
        N.Count is var count && count < K ? [] :
        count == K ? N : N.Take(K);
    /// <summary>Gets the last <see cref="K"/> choices.</summary>
    [CollectionAccess(Read), Pure]
    public readonly IEnumerable<T> Last =>
        N.Count is var count && count < K ? [] :
        count == K ? N : N.Skip(N.Count - K);
    /// <summary>Determines whether the specified objects are equal.</summary>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>Whether the specified objects are equal.</returns>
    public static bool operator ==(Choices<T> left, Choices<T> right) => left.Equals(right);
    /// <summary>Determines whether the specified objects are unequal.</summary>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>Whether the specified objects are unequal.</returns>
    public static bool operator !=(Choices<T> left, Choices<T> right) => !(left == right);
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)]
    readonly void ICollection<IList<T>>.Add(IList<T> item) { }
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)]
    readonly void ICollection<IList<T>>.Clear() { }
    /// <inheritdoc />
    [CollectionAccess(Read)]
    public readonly void CopyTo(IList<T>[] array, int arrayIndex)
    {
        foreach (var next in this)
            array[arrayIndex++] = next;
    }
    /// <inheritdoc />
    [CollectionAccess(Read), Pure]
    public readonly bool Contains(IList<T> item) => IndexOf(item) is not -1;
    /// <inheritdoc />
    public readonly override bool Equals(object? obj) => obj is Choices<T> other && Equals(other);
    /// <inheritdoc />
    public readonly bool Equals(Choices<T> other) => K == other.K && N.Equals(other.N);
    /// <inheritdoc />
    [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), Pure]
    readonly bool ICollection<IList<T>>.Remove(IList<T> item) => false;
    /// <inheritdoc cref="IList{T}.IndexOf"/>
    [CollectionAccess(Read), Pure]
    public readonly int IndexOf(IList<T> item)
    {
        if (N.Count == K)
            return N.Equals(item) ? 0 : -1;
        var i = 0;
        foreach (var next in this)
            if (next.Equals(item))
                return i;
            else
                i++;
        return -1;
    }
    /// <inheritdoc />
    public readonly override int GetHashCode() => unchecked(K * 397 ^ N.GetHashCode());
    /// <inheritdoc />
    public readonly override string ToString()
    {
#if NET6_0_OR_GREATER
        var count = Count;
        DefaultInterpolatedStringHandler str = new(count is 0 ? 2 : count * 4, count);
        str.AppendLiteral("[");
#else
        StringBuilder str = new("[");
#endif
        using var e = GetEnumerator();
        if (!e.MoveNext())
            goto Done;
#if NET6_0_OR_GREATER
        str.AppendLiteral("[");
#else
        str.Append('[');
#endif
        str.AppendMany(e.Current);
#if NET6_0_OR_GREATER
        str.AppendLiteral("]");
#else
        str.Append(']');
#endif
        while (e.MoveNext())
        {
#if NET6_0_OR_GREATER
            str.AppendLiteral(", [");
#else
            str.Append(", [");
#endif
            str.AppendMany(e.Current);
#if NET6_0_OR_GREATER
            str.AppendLiteral("]");
#else
            str.Append(']');
#endif
        }
    Done:
#if NET6_0_OR_GREATER
        str.AppendLiteral("]");
        return str.ToStringAndClear();
#else
        return $"{str.Append(']')}";
#endif
    }
    /// <inheritdoc cref="IEnumerable{T}.GetEnumerator"/>
    [CollectionAccess(Read), Pure]
    public readonly Enumerator GetEnumerator() => new(N, K);
    /// <inheritdoc />
    [CollectionAccess(Read), Pure]
    readonly IEnumerator<IList<T>> IEnumerable<IList<T>>.GetEnumerator() => GetEnumerator();
    /// <inheritdoc />
    [CollectionAccess(Read), Pure]
    readonly IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable BadPreprocessorIndent CheckNamespace ConvertToAutoPropertyWhenPossible InvertIf RedundantNameQualifier RedundantReadonlyModifier RedundantUsingDirective StructCanBeMadeReadOnly UseSymbolAlias
#pragma warning disable CS8631, IDE0032
/// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}"/>
public partial struct SplitSpan<TBody, TSeparator, TStrategy>
{
    /// <inheritdoc cref="IEnumerable{T}.GetEnumerator"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly ReversedEnumerator GetReversedEnumerator() => new(this);
    /// <summary>
    /// Returns itself but with the number of elements from the end specified skipped. This is evaluated eagerly.
    /// </summary>
    /// <param name="count">The number of elements to skip from the end.</param>
    /// <returns>Itself but skipping from the end the parameter <paramref name="count"/> number of elements.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly SplitSpan<TBody, TSeparator, TStrategy> SkippedLast([NonNegativeValue] int count)
    {
        Enumerator e = this;
        for (; count > 0 && e.MoveNext(); count--) { }
        return e.SplitSpan;
    }
    /// <summary>
    /// Represents the backwards enumeration object that views <see cref="SplitSpan{T, TSeparator, TStrategy}"/>.
    /// </summary>
    [StructLayout(LayoutKind.Auto)]
    [method: MethodImpl(MethodImplOptions.AggressiveInlining)]
    public
#if !NO_REF_STRUCTS
        ref
#endif
        partial struct ReversedEnumerator(ReadOnlySpan<TBody> body, ReadOnlySpan<TSeparator> separator)
    {
        readonly ReadOnlySpan<TSeparator> _separator = separator;
        ReadOnlySpan<TBody> _body = body, _current;
        /// <summary>Initializes a new instance of the <see cref="ReversedEnumerator"/> struct.</summary>
        /// <param name="body">The body.</param>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public ReversedEnumerator(ReadOnlySpan<TBody> body)
            : this(body, default) { }
        /// <summary>Initializes a new instance of the <see cref="ReversedEnumerator"/> struct.</summary>
        /// <param name="split">The enumerable to enumerate.</param>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public ReversedEnumerator(SplitSpan<TBody, TSeparator, TStrategy> split)
            : this(split._body, split._separator) { }
        /// <inheritdoc cref="SplitSpan{T, TSeparator, TStrategy}.Body"/>
        public readonly ReadOnlySpan<TBody> Body
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => _body;
            [MethodImpl(MethodImplOptions.AggressiveInlining)] init => _body = value;
        }
        /// <inheritdoc cref="IEnumerator{T}.Current"/>
        public readonly ReadOnlySpan<TBody> Current
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => _current;
        }
        /// <inheritdoc cref="SplitSpan{T, TSeparator, TStrategy}.Separator"/>
        public readonly ReadOnlySpan<TSeparator> Separator
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => _separator;
            [MethodImpl(MethodImplOptions.AggressiveInlining)] init => _separator = value;
        }
        /// <summary>
        /// Reconstructs the <see cref="SplitSpan{TBody, TSeparator, TStrategy}"/> based on the current state.
        /// </summary>
        public readonly SplitSpan<TBody, TSeparator, TStrategy> SplitSpan
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
            get => new(_body, _separator);
        }
        /// <summary>
        /// Explicitly converts the parameter by creating the new instance
        /// of <see cref="ReversedEnumerator"/> by using the constructor
        /// <see cref="SplitSpan{TBody, TSeparator, TStrategy}.ReversedEnumerator(ReadOnlySpan{TBody})"/>.
        /// </summary>
        /// <param name="body">The parameter to pass onto the constructor.</param>
        /// <returns>
        /// The new instance of <see cref="ReversedEnumerator"/> by passing
        /// the parameter <paramref name="body"/> to the constructor
        /// <see cref="SplitSpan{TBody, TSeparator, TStrategy}.ReversedEnumerator(ReadOnlySpan{TBody})"/>.
        /// </returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        public static explicit operator SplitSpan<TBody, TSeparator, TStrategy>.ReversedEnumerator(
            ReadOnlySpan<TBody> body
        ) =>
            new(body);
        /// <summary>
        /// Implicitly converts the parameter by creating the new instance
        /// of <see cref="ReversedEnumerator"/> by using the constructor
        /// <see cref="SplitSpan{TBody, TSeparator, TStrategy}.ReversedEnumerator(SplitSpan{TBody, TSeparator, TStrategy})"/>.
        /// </summary>
        /// <param name="split">The parameter to pass onto the constructor.</param>
        /// <returns>
        /// The new instance of <see cref="ReversedEnumerator"/> by passing
        /// the parameter <paramref name="split"/> to the constructor
        /// <see cref="SplitSpan{TBody, TSeparator, TStrategy}.ReversedEnumerator(SplitSpan{TBody, TSeparator, TStrategy})"/>.
        /// </returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        public static implicit operator SplitSpan<TBody, TSeparator, TStrategy>.ReversedEnumerator(
            SplitSpan<TBody, TSeparator, TStrategy> split
        ) =>
            new(split);
        /// <summary>Performs one step of an enumeration over the provided spans.</summary>
        /// <param name="sep">The separator span.</param>
        /// <param name="body">The span that contains the current state of the enumeration.</param>
        /// <param name="current">The current span.</param>
        /// <returns>
        /// <see langword="true"/> if a step was performed successfully;
        /// <see langword="false"/> if the end of the collection is reached.
        /// </returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool Move(
            scoped ReadOnlySpan<TSeparator> sep,
            scoped ref ReadOnlySpan<TBody> body,
            out ReadOnlySpan<TBody> current
        ) =>
            0 switch
            {
                _ when body.IsEmpty && (current = default) is var _ => false,
                _ when sep.IsEmpty => (current = body) is var _ && (body = default) is var _,
                _ when typeof(TStrategy) == typeof(MatchAll) => MoveNextAll(To<TBody>.From(sep), ref body, out current),
#if NET8_0_OR_GREATER
                _ when typeof(TStrategy) == typeof(MatchAny) && typeof(TSeparator) == typeof(SearchValues<TBody>) =>
                    MoveNextAny(To<SearchValues<TBody>>.From(sep), ref body, out current),
#endif
                _ when typeof(TStrategy) == typeof(MatchAny) => MoveNextAny(To<TBody>.From(sep), ref body, out current),
                _ when typeof(TStrategy) == typeof(MatchOne) => MoveNextOne(To<TBody>.From(sep), ref body, out current),
                _ => throw Error,
            };
        /// <inheritdoc cref="System.Collections.IEnumerator.MoveNext"/>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public bool MoveNext() => Move(_separator, ref _body, out _current);
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        static bool MoveNextAll(
            scoped ReadOnlySpan<TBody> sep,
            scoped ref ReadOnlySpan<TBody> body,
            out ReadOnlySpan<TBody> current
        )
        {
            System.Diagnostics.Debug.Assert(typeof(TStrategy) == typeof(MatchAll), "TStrategy is MatchAll");
            System.Diagnostics.Debug.Assert(!sep.IsEmpty, "separator is non-empty");
            if (sep.Length < body.Length)
            {
                current = default;
                return false;
            }
        Retry:
            switch (body.LastIndexOf(sep))
            {
                case -1:
                    current = body;
                    body = default;
                    return true;
                case var i when i == body.Length - sep.Length:
                    if (body.Length != sep.Length)
                    {
                        body = body.UnsafelyTake(i);
                        goto Retry;
                    }
                    current = default;
                    return false;
                case var i:
                    current = body.UnsafelySkip(i + sep.Length);
                    body = body.UnsafelyTake(i);
                    return true;
            }
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        static bool MoveNextAny(
            scoped ReadOnlySpan<TBody> sep,
            scoped ref ReadOnlySpan<TBody> body,
            out ReadOnlySpan<TBody> current
        )
        {
            System.Diagnostics.Debug.Assert(typeof(TStrategy) == typeof(MatchAny), "TStrategy is MatchAny");
            System.Diagnostics.Debug.Assert(!sep.IsEmpty, "separator is non-empty");
#if NET7_0_OR_GREATER
            switch (body.LastIndexOfAnyExcept(sep))
            {
                case -1:
                    current = default;
                    return false;
                case var i when i == body.Length - 1: break;
                case var i:
                    body = body.UnsafelyTake(i + 1);
                    break;
            }
            if (body.LastIndexOfAny(sep) is not -1 and var length)
            {
                current = body.UnsafelySkip(length + 1);
                body = body.UnsafelyTake(length);
                return true;
            }
            current = body;
            body = default;
#else
        Retry:
            var max = -1;
            foreach (var next in sep)
                switch (body.LastIndexOf(next))
                {
                    case -1: continue;
                    case var i when i == body.Length - 1:
                        if (body.Length is not 1)
                        {
                            body = body.UnsafelyTake(body.Length - 1);
                            goto Retry;
                        }
                        current = default;
                        return false;
                    case var i when i > max:
                        max = i;
                        continue;
                }
            if (max is not -1)
            {
                current = body.UnsafelySkip(max + 1);
                body = body.UnsafelyTake(max);
                return true;
            }
            current = body;
            body = default;
#endif
            return true;
        }
#if NET8_0_OR_GREATER
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        static bool MoveNextAny(
            scoped ReadOnlySpan<SearchValues<TBody>> sep,
            scoped ref ReadOnlySpan<TBody> body,
            out ReadOnlySpan<TBody> current
        )
        {
            System.Diagnostics.Debug.Assert(typeof(TStrategy) == typeof(MatchAny), "TStrategy is MatchAny");
            System.Diagnostics.Debug.Assert(!sep.IsEmpty, "separator is non-empty");
            ref var single = ref MemoryMarshal.GetReference(sep);
            switch (body.LastIndexOfAnyExcept(single))
            {
                case -1:
                    current = default;
                    return false;
                case var i when i == body.Length - 1: break;
                case var i:
                    body = body.UnsafelyTake(i + 1);
                    break;
            }
            if (body.LastIndexOfAny(single) is not -1 and var length)
            {
                current = body.UnsafelySkip(length + 1);
                body = body.UnsafelyTake(length);
                return true;
            }
            current = body;
            body = default;
            return true;
        }
#endif
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        static bool MoveNextOne(
            scoped ReadOnlySpan<TBody> sep,
            scoped ref ReadOnlySpan<TBody> body,
            out ReadOnlySpan<TBody> current
        )
        {
            System.Diagnostics.Debug.Assert(typeof(TStrategy) == typeof(MatchOne), "TStrategy is MatchOne");
            System.Diagnostics.Debug.Assert(!sep.IsEmpty, "separator is non-empty");
            var single = sep.UnsafelyIndex(0);
#if NET7_0_OR_GREATER
            switch (body.LastIndexOfAnyExcept(single))
            {
                case -1:
                    current = default;
                    return false;
                case var i when i == body.Length - 1: break;
                case var offset:
                    body = body.UnsafelyTake(offset + 1);
                    break;
            }
            if (body.LastIndexOf(single) is not -1 and var length)
            {
                current = body.UnsafelySkip(length + 1);
                body = body.UnsafelyTake(length);
                return true;
            }
            current = body;
            body = default;
            return true;
#else
        Retry:
            switch (body.LastIndexOf(single))
            {
                case -1:
                    current = body;
                    body = default;
                    return true;
                case var i when i == body.Length - 1:
                    if (body.Length is not 1)
                    {
                        body = body.UnsafelyTake(1);
                        goto Retry;
                    }
                    current = default;
                    return false;
                case var i:
                    current = body.UnsafelySkip(i);
                    body = body.UnsafelyTake(i - 1);
                    return true;
            }
#endif
        }
    }
}
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable once CheckNamespace EmptyNamespace
#if (NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) && !NO_SYSTEM_MEMORY
// ReSharper disable once RedundantUsingDirective
/// <inheritdoc cref="SpanSimdQueries"/>
// ReSharper disable NullableWarningSuppressionIsUsed RedundantNameQualifier RedundantSuppressNullableWarningExpression UseSymbolAlias
    /// <inheritdoc cref="Average{T}(ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Average<T>(this scoped Span<T> span)
#if UNMANAGED_SPAN
        where T : unmanaged
#elif !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            span.ReadOnly().Average();
    /// <inheritdoc cref="Average{T}(ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Average<T>(this ReadOnlyMemory<T> span)
#if !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            span.Span.Average();
    /// <summary>Gets the average.</summary>
    /// <typeparam name="T">The type of <see cref="Span{T}"/>.</typeparam>
    /// <param name="span">The span to get the average of.</param>
    /// <returns>The average of <paramref name="span"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Average<T>(this scoped ReadOnlySpan<T> span)
#if UNMANAGED_SPAN
        where T : unmanaged
#elif !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            Divider(span.Sum(), span.Length);
    /// <inheritdoc cref="Sum{T}(ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Sum<T>(this scoped Span<T> span)
#if UNMANAGED_SPAN
        where T : unmanaged
#elif !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            span.ReadOnly().Sum();
    /// <inheritdoc cref="Sum{T}(ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Sum<T>(this ReadOnlyMemory<T> span)
#if !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            span.Span.Sum();
    /// <summary>Gets the sum.</summary>
    /// <typeparam name="T">The type of <see cref="Span{T}"/>.</typeparam>
    /// <param name="span">The span to get the sum of.</param>
    /// <returns>The sum of <paramref name="span"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Sum<T>(this scoped ReadOnlySpan<T> span)
#if UNMANAGED_SPAN
        where T : unmanaged
#elif !NET8_0_OR_GREATER
        where T : struct
#endif
    {
        if (IsNumericPrimitive<T>() &&
            System.Numerics.Vector.IsHardwareAccelerated &&
            System.Numerics.Vector<T>.Count > 2 &&
            span.Length >= System.Numerics.Vector<T>.Count * 4)
            return SumVectorized(span);
        if (typeof(T).IsEnum)
            return UnderlyingSum(span);
        T sum = default!;
        foreach (var value in span)
            checked
            {
                sum = Adder(sum, value);
            }
        return sum;
    }
    /// <inheritdoc cref="Average{T, TResult}(ReadOnlySpan{T}, Converter{T, TResult})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static TResult Average<T, TResult>(
        this scoped Span<T> span,
        [InstantHandle, RequireStaticDelegate] Converter<T, TResult> converter
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
#if !NET8_0_OR_GREATER
        where TResult : struct
#endif
        =>
            Average(span.ReadOnly(), converter);
#if (NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) && !NO_SYSTEM_MEMORY
    /// <inheritdoc cref="Average{T, TResult}(ReadOnlySpan{T}, Converter{T, TResult})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static TResult Average<T, TResult>(
        this ReadOnlyMemory<T> span,
        [InstantHandle, RequireStaticDelegate] Converter<T, TResult> converter
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
#if !NET8_0_OR_GREATER
        where TResult : struct
#endif
        =>
            Average(span.Span, converter);
#endif
    /// <summary>Gets the average.</summary>
    /// <typeparam name="T">The type of <see cref="Span{T}"/>.</typeparam>
    /// <typeparam name="TResult">The type of return.</typeparam>
    /// <param name="span">The span to get the average of.</param>
    /// <param name="converter">The mapping of each element.</param>
    /// <returns>The average of each mapping of <paramref name="span"/> by <paramref name="converter"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static TResult Average<T, TResult>(
        this scoped ReadOnlySpan<T> span,
        [InstantHandle, RequireStaticDelegate] Converter<T, TResult> converter
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
#if !NET8_0_OR_GREATER
        where TResult : struct
#endif
        =>
            Divider(span.Sum(converter), span.Length);
    /// <inheritdoc cref="Sum{T, TResult}(ReadOnlySpan{T}, Converter{T, TResult})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static TResult Sum<T, TResult>(
        this scoped Span<T> span,
        [InstantHandle, RequireStaticDelegate] Converter<T, TResult> converter
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
#if !NET8_0_OR_GREATER
        where TResult : struct
#endif
        =>
            span.ReadOnly().Sum(converter);
#if (NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) && !NO_SYSTEM_MEMORY
    /// <inheritdoc cref="Sum{T, TResult}(ReadOnlySpan{T}, Converter{T, TResult})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static TResult Sum<T, TResult>(
        this ReadOnlyMemory<T> span,
        [InstantHandle, RequireStaticDelegate] Converter<T, TResult> converter
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
#if !NET8_0_OR_GREATER
        where TResult : struct
#endif
        =>
            span.Span.Sum(converter);
#endif
    /// <summary>Gets the sum.</summary>
    /// <typeparam name="T">The type of <see cref="Span{T}"/>.</typeparam>
    /// <typeparam name="TResult">The type of return.</typeparam>
    /// <param name="span">The span to get the sum of.</param>
    /// <param name="converter">The mapping of each element.</param>
    /// <returns>The sum of each mapping of <paramref name="span"/> by <paramref name="converter"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static TResult Sum<T, TResult>(
        this scoped ReadOnlySpan<T> span,
        [InstantHandle, RequireStaticDelegate] Converter<T, TResult> converter
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
#if !NET8_0_OR_GREATER
        where TResult : struct
#endif
    {
        TResult sum = default!;
        foreach (var x in span)
            sum = Adder(sum, converter(x));
        return sum;
    }
    /// <inheritdoc cref="Average{T}(ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Average<T>(this IMemoryOwner<T> span)
#if !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            span.Memory.Span.ReadOnly().Average();
    /// <inheritdoc cref="Average{T}(ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Average<T>(this Memory<T> span)
#if !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            span.Span.ReadOnly().Average();
    /// <inheritdoc cref="Sum{T}(ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Sum<T>(this IMemoryOwner<T> span)
#if !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            span.Memory.Span.ReadOnly().Sum();
    /// <inheritdoc cref="Sum{T}(ReadOnlySpan{T})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Sum<T>(this Memory<T> span)
#if !NET8_0_OR_GREATER
        where T : struct
#endif
        =>
            span.Span.ReadOnly().Sum();
    /// <inheritdoc cref="Average{T, TResult}(ReadOnlySpan{T}, Converter{T, TResult})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static TResult Average<T, TResult>(
        this IMemoryOwner<T> span,
        [InstantHandle, RequireStaticDelegate] Converter<T, TResult> converter
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
#if !NET8_0_OR_GREATER
        where TResult : struct
#endif
        =>
            span.Memory.Span.ReadOnly().Average(converter);
    /// <inheritdoc cref="Average{T, TResult}(ReadOnlySpan{T}, Converter{T, TResult})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static TResult Average<T, TResult>(
        this Memory<T> span,
        [InstantHandle, RequireStaticDelegate] Converter<T, TResult> converter
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
#if !NET8_0_OR_GREATER
        where TResult : struct
#endif
        =>
            span.Span.ReadOnly().Average(converter);
    /// <inheritdoc cref="Sum{T, TResult}(ReadOnlySpan{T}, Converter{T, TResult})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static TResult Sum<T, TResult>(
        this IMemoryOwner<T> span,
        [InstantHandle, RequireStaticDelegate] Converter<T, TResult> converter
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
#if !NET8_0_OR_GREATER
        where TResult : struct
#endif
        =>
            span.Memory.Span.Sum(converter);
    /// <inheritdoc cref="Sum{T, TResult}(ReadOnlySpan{T}, Converter{T, TResult})"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static TResult Sum<T, TResult>(
        this Memory<T> span,
        [InstantHandle, RequireStaticDelegate] Converter<T, TResult> converter
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
#if !NET8_0_OR_GREATER
        where TResult : struct
#endif
        =>
            span.Span.ReadOnly().Sum(converter);
    [CLSCompliant(false), MethodImpl(MethodImplOptions.AggressiveInlining)]
    static System.Numerics.Vector<T> LoadUnsafe<T>(scoped ref T source, nuint elementOffset)
#if NET8_0_OR_GREATER
        =>
            System.Numerics.Vector.LoadUnsafe(ref source, elementOffset);
#else
        where T : struct
    {
        source = ref Unsafe.Add(ref source, (nint)elementOffset);
        return Unsafe.ReadUnaligned<Vector<T>>(ref Unsafe.As<T, byte>(ref source));
    }
#endif
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
#pragma warning disable MA0051
    static T SumVectorized<T>(scoped ReadOnlySpan<T> span)
#pragma warning restore MA0051
#if UNMANAGED_SPAN
        where T : unmanaged
#elif !NET8_0_OR_GREATER
        where T : struct
#endif
    {
        ref var ptr = ref MemoryMarshal.GetReference(span);
        var length = (nuint)span.Length;
        var accumulator = System.Numerics.Vector<T>.Zero;
        System.Numerics.Vector<T> overflowTestVector = new(MinValue<T>());
        nuint index = 0;
        var limit = length - (nuint)System.Numerics.Vector<T>.Count * 4;
        do
        {
            var data = LoadUnsafe(ref ptr, index);
            var accumulator2 = accumulator + data;
            var overflowTracking = (accumulator2 ^ accumulator) & (accumulator2 ^ data);
            data = LoadUnsafe(ref ptr, index + (nuint)System.Numerics.Vector<T>.Count);
            accumulator = accumulator2 + data;
            overflowTracking |= (accumulator ^ accumulator2) & (accumulator ^ data);
            data = LoadUnsafe(ref ptr, index + (nuint)System.Numerics.Vector<T>.Count * 2);
            accumulator2 = accumulator + data;
            overflowTracking |= (accumulator2 ^ accumulator) & (accumulator2 ^ data);
            data = LoadUnsafe(ref ptr, index + (nuint)System.Numerics.Vector<T>.Count * 3);
            accumulator = accumulator2 + data;
            overflowTracking |= (accumulator ^ accumulator2) & (accumulator ^ data);
            if ((overflowTracking & overflowTestVector) != System.Numerics.Vector<T>.Zero)
                throw new OverflowException();
            index += (nuint)System.Numerics.Vector<T>.Count * 4;
        } while (index < limit);
        limit = length - (nuint)System.Numerics.Vector<T>.Count;
        if (index < limit)
        {
            var overflowTracking = System.Numerics.Vector<T>.Zero;
            do
            {
                var data = LoadUnsafe(ref ptr, index);
                var accumulator2 = accumulator + data;
                overflowTracking |= (accumulator2 ^ accumulator) & (accumulator2 ^ data);
                accumulator = accumulator2;
                index += (nuint)System.Numerics.Vector<T>.Count;
            } while (index < limit);
            if ((overflowTracking & overflowTestVector) != System.Numerics.Vector<T>.Zero)
                throw new OverflowException();
        }
        T result = default!;
        for (var i = 0; i < System.Numerics.Vector<T>.Count; i++)
            checked
            {
                result = Adder(result, accumulator[i]);
            }
        while (index < length)
        {
            checked
            {
                result = Adder(result, Unsafe.Add(ref ptr, index));
            }
            index++;
        }
        return result;
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    static T UnderlyingSum<T>(scoped ReadOnlySpan<T> span) =>
        typeof(T).GetEnumUnderlyingType() switch
        {
            var x when x == typeof(sbyte) => (T)(object)To<sbyte>.From(span).Sum(),
            var x when x == typeof(byte) => (T)(object)To<byte>.From(span).Sum(),
            var x when x == typeof(short) => (T)(object)To<short>.From(span).Sum(),
            var x when x == typeof(ushort) => (T)(object)To<ushort>.From(span).Sum(),
            var x when x == typeof(int) => (T)(object)To<int>.From(span).Sum(),
            var x when x == typeof(uint) => (T)(object)To<uint>.From(span).Sum(),
            var x when x == typeof(long) => (T)(object)To<long>.From(span).Sum(),
            var x when x == typeof(ulong) => (T)(object)To<ulong>.From(span).Sum(),
            var x when x == typeof(nint) => (T)(object)To<nint>.From(span).Sum(),
            var x when x == typeof(nuint) => (T)(object)To<nuint>.From(span).Sum(),
            _ => throw Unreachable,
        };
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable UnusedMember.Local
// ReSharper disable once CheckNamespace
#pragma warning disable CS8619
/// <summary>Extension methods for improving nullability awareness for enumerables.</summary>
    /// <summary>Annotates <c>ItemCanBeNullAttribute</c>.</summary>
    /// <typeparam name="T">The type of item to adjust nullability.</typeparam>
    /// <param name="iterable">The item to return with adjusted nullability.</param>
    /// <returns>The parameter <paramref name="iterable"/>, with <c>ItemCanBeNullAttribute</c>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    [return: NotNullIfNotNull(nameof(iterable))]
    public static IEnumerable<T?>? ItemCanBeNull<T>(this IEnumerable<T>? iterable) => iterable;
    /// <summary>Annotates <c>ItemCanBeNullAttribute</c>.</summary>
    /// <typeparam name="T">The type of item to adjust nullability.</typeparam>
    /// <param name="iterator">The item to return with adjusted nullability.</param>
    /// <returns>The parameter <paramref name="iterator"/>, with <c>ItemCanBeNullAttribute</c>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    [return: NotNullIfNotNull(nameof(iterator))]
    public static IEnumerator<T?>? ItemCanBeNull<T>(this IEnumerator<T>? iterator) => iterator;
    /// <summary>Annotates <c>ItemCanBeNullAttribute</c>.</summary>
    /// <typeparam name="T">The type of item to adjust nullability.</typeparam>
    /// <param name="collection">The item to return with adjusted nullability.</param>
    /// <returns>The parameter <paramref name="collection"/>, with <c>ItemCanBeNullAttribute</c>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    [return: NotNullIfNotNull(nameof(collection))]
    public static IReadOnlyCollection<T?>? ItemCanBeNull<T>(this IReadOnlyCollection<T>? collection) => collection;
    /// <summary>Annotates <c>ItemCanBeNullAttribute</c>.</summary>
    /// <typeparam name="T">The type of item to adjust nullability.</typeparam>
    /// <param name="list">The item to return with adjusted nullability.</param>
    /// <returns>The parameter <paramref name="list"/>, with <c>ItemCanBeNullAttribute</c>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    [return: NotNullIfNotNull(nameof(list))]
    public static IReadOnlyList<T?>? ItemCanBeNull<T>(this IReadOnlyList<T>? list) => list;
    /// <summary>Annotates <c>ItemCanBeNullAttribute</c>.</summary>
    /// <typeparam name="T">The type of item to adjust nullability.</typeparam>
    /// <param name="set">The item to return with adjusted nullability.</param>
    /// <returns>The parameter <paramref name="set"/>, with <c>ItemCanBeNullAttribute</c>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    [return: NotNullIfNotNull(nameof(set))]
    public static IReadOnlySet<T?>? ItemCanBeNull<T>(this IReadOnlySet<T>? set) => set;
// SPDX-License-Identifier: MPL-2.0
#if ROSLYN
// ReSharper disable once CheckNamespace
/// <summary>Strict value-based equality for symbol comparison.</summary>
public sealed class RoslynComparer
    : IEqualityComparer<CustomModifier?>, IEqualityComparer<ISymbol?>, IEqualityComparer<SyntaxReference?>
{
    /// <summary>Provides the signature for value-based equality in comparisons.</summary>
    /// <typeparam name="TOutput">The type of comparison to get.</typeparam>
    /// <param name="that">The recursive function.</param>
    /// <returns>The comparison function.</returns>
    public delegate Func<TOutput, TOutput, bool> Equal<in TOutput>(RoslynComparer that);
    /// <summary>Provides the signature for recursive hashing.</summary>
    /// <typeparam name="T">The type to hash.</typeparam>
    /// <param name="that">The recursive function.</param>
    /// <returns>The hashing function.</returns>
    public delegate Converter<T, int> Hash<in T>(RoslynComparer that);
    readonly Func<ISymbol, ISymbol, bool> _onSymbol;
    readonly Func<IAliasSymbol, IAliasSymbol, bool> _onAliasSymbol;
    readonly Func<IAssemblySymbol, IAssemblySymbol, bool> _onAssemblySymbol;
    readonly Func<IDiscardSymbol, IDiscardSymbol, bool> _onDiscardSymbol;
    readonly Func<IEventSymbol, IEventSymbol, bool> _onEventSymbol;
    readonly Func<IFieldSymbol, IFieldSymbol, bool> _onFieldSymbol;
    readonly Func<ILabelSymbol, ILabelSymbol, bool> _onLabelSymbol;
    readonly Func<ILocalSymbol, ILocalSymbol, bool> _onLocalSymbol;
    readonly Func<IMethodSymbol, IMethodSymbol, bool> _onMethodSymbol;
    readonly Func<IModuleSymbol, IModuleSymbol, bool> _onModuleSymbol;
    readonly Func<INamespaceOrTypeSymbol, INamespaceOrTypeSymbol, bool> _onNamespaceOrTypeSymbol;
    readonly Func<IParameterSymbol, IParameterSymbol, bool> _onParameterSymbol;
    readonly Func<IPreprocessingSymbol, IPreprocessingSymbol, bool> _onPreprocessingSymbol;
    readonly Func<IPropertySymbol, IPropertySymbol, bool> _onPropertySymbol;
    readonly Func<IRangeVariableSymbol, IRangeVariableSymbol, bool> _onRangeVariableSymbol;
    readonly Func<ISourceAssemblySymbol, ISourceAssemblySymbol, bool> _onSourceAssemblySymbol;
    readonly Func<INamespaceSymbol, INamespaceSymbol, bool> _onNamespaceSymbol;
    readonly Func<ITypeSymbol, ITypeSymbol, bool> _onTypeSymbol;
    readonly Func<IArrayTypeSymbol, IArrayTypeSymbol, bool> _onArrayTypeSymbol;
    readonly Func<IDynamicTypeSymbol, IDynamicTypeSymbol, bool> _onDynamicTypeSymbol;
    readonly Func<IFunctionPointerTypeSymbol, IFunctionPointerTypeSymbol, bool> _onFunctionPointerTypeSymbol;
    readonly Func<INamedTypeSymbol, INamedTypeSymbol, bool> _onNamedTypeSymbol;
    readonly Func<IPointerTypeSymbol, IPointerTypeSymbol, bool> _onPointerTypeSymbol;
    readonly Func<ITypeParameterSymbol, ITypeParameterSymbol, bool> _onTypeParameterSymbol;
    readonly Func<IErrorTypeSymbol, IErrorTypeSymbol, bool> _onErrorTypeSymbol;
    readonly Func<CustomModifier, CustomModifier, bool> _onCustomModifier;
    readonly Func<SyntaxReference, SyntaxReference, bool> _onSyntaxReference;
    readonly Converter<ISymbol, int> _onSymbolHash;
    readonly Converter<CustomModifier, int> _onCustomModifierHash;
    readonly Converter<SyntaxReference, int> _onSyntaxReferenceHash;
    /// <summary>Strict value-based equality for symbol comparison.</summary>
    public RoslynComparer(
        Equal<ISymbol>? onSymbol = null,
        Equal<IAliasSymbol>? onAliasSymbol = null,
        Equal<IAssemblySymbol>? onAssemblySymbol = null,
        Equal<IDiscardSymbol>? onDiscardSymbol = null,
        Equal<IEventSymbol>? onEventSymbol = null,
        Equal<IFieldSymbol>? onFieldSymbol = null,
        Equal<ILabelSymbol>? onLabelSymbol = null,
        Equal<ILocalSymbol>? onLocalSymbol = null,
        Equal<IMethodSymbol>? onMethodSymbol = null,
        Equal<IModuleSymbol>? onModuleSymbol = null,
        Equal<INamespaceOrTypeSymbol>? onNamespaceOrTypeSymbol = null,
        Equal<IParameterSymbol>? onParameterSymbol = null,
        Equal<IPreprocessingSymbol>? onPreprocessingSymbol = null,
        Equal<IPropertySymbol>? onPropertySymbol = null,
        Equal<IRangeVariableSymbol>? onRangeVariableSymbol = null,
        Equal<ISourceAssemblySymbol>? onSourceAssemblySymbol = null,
        Equal<INamespaceSymbol>? onNamespaceSymbol = null,
        Equal<ITypeSymbol>? onTypeSymbol = null,
        Equal<IArrayTypeSymbol>? onArrayTypeSymbol = null,
        Equal<IDynamicTypeSymbol>? onDynamicTypeSymbol = null,
        Equal<IFunctionPointerTypeSymbol>? onFunctionPointerTypeSymbol = null,
        Equal<INamedTypeSymbol>? onNamedTypeSymbol = null,
        Equal<IPointerTypeSymbol>? onPointerTypeSymbol = null,
        Equal<ITypeParameterSymbol>? onTypeParameterSymbol = null,
        Equal<IErrorTypeSymbol>? onErrorTypeSymbol = null,
        Equal<CustomModifier>? onCustomModifier = null,
        Equal<SyntaxReference>? onSyntaxReference = null,
        Hash<ISymbol>? onSymbolHash = null,
        Hash<CustomModifier>? onCustomModifierHash = null,
        Hash<SyntaxReference>? onSyntaxReferenceHash = null
    )
    {
        _onSymbol = onSymbol?.Invoke(this) ?? True;
        _onAliasSymbol = onAliasSymbol?.Invoke(this) ?? True;
        _onAssemblySymbol = onAssemblySymbol?.Invoke(this) ?? True;
        _onDiscardSymbol = onDiscardSymbol?.Invoke(this) ?? True;
        _onEventSymbol = onEventSymbol?.Invoke(this) ?? True;
        _onFieldSymbol = onFieldSymbol?.Invoke(this) ?? True;
        _onLabelSymbol = onLabelSymbol?.Invoke(this) ?? True;
        _onLocalSymbol = onLocalSymbol?.Invoke(this) ?? True;
        _onMethodSymbol = onMethodSymbol?.Invoke(this) ?? True;
        _onModuleSymbol = onModuleSymbol?.Invoke(this) ?? True;
        _onNamespaceOrTypeSymbol = onNamespaceOrTypeSymbol?.Invoke(this) ?? True;
        _onParameterSymbol = onParameterSymbol?.Invoke(this) ?? True;
        _onPreprocessingSymbol = onPreprocessingSymbol?.Invoke(this) ?? True;
        _onPropertySymbol = onPropertySymbol?.Invoke(this) ?? True;
        _onRangeVariableSymbol = onRangeVariableSymbol?.Invoke(this) ?? True;
        _onSourceAssemblySymbol = onSourceAssemblySymbol?.Invoke(this) ?? True;
        _onNamespaceSymbol = onNamespaceSymbol?.Invoke(this) ?? True;
        _onTypeSymbol = onTypeSymbol?.Invoke(this) ?? True;
        _onArrayTypeSymbol = onArrayTypeSymbol?.Invoke(this) ?? True;
        _onDynamicTypeSymbol = onDynamicTypeSymbol?.Invoke(this) ?? True;
        _onFunctionPointerTypeSymbol = onFunctionPointerTypeSymbol?.Invoke(this) ?? True;
        _onNamedTypeSymbol = onNamedTypeSymbol?.Invoke(this) ?? True;
        _onPointerTypeSymbol = onPointerTypeSymbol?.Invoke(this) ?? True;
        _onTypeParameterSymbol = onTypeParameterSymbol?.Invoke(this) ?? True;
        _onErrorTypeSymbol = onErrorTypeSymbol?.Invoke(this) ?? True;
        _onCustomModifier = onCustomModifier?.Invoke(this) ?? True;
        _onSyntaxReference = onSyntaxReference?.Invoke(this) ?? True;
        _onSymbolHash = onSymbolHash?.Invoke(this) ?? Zero;
        _onCustomModifierHash = onCustomModifierHash?.Invoke(this) ?? Zero;
        _onSyntaxReferenceHash = onSyntaxReferenceHash?.Invoke(this) ?? Zero;
    }
    /// <summary>Gets the instance for a comparison behaving identically to <see cref="SymbolComparer"/>.</summary>
    [Pure]
    public static RoslynComparer Gu { get; } = new(
        _ => (x, y) => x.Kind == y.Kind,
        onAssemblySymbol: _ => (x, y) => x.Identity == y.Identity,
        onEventSymbol: r => (x, y) => x.MetadataName == y.MetadataName &&
            r.Equals(x.ContainingType, y.ContainingType) &&
            r.Equals(x.Type, y.Type),
        onFieldSymbol: r => (x, y) => x.MetadataName == y.MetadataName && r.Equals(x.ContainingType, y.ContainingType),
        onLocalSymbol: r => (x, y) =>
            x.MetadataName == y.MetadataName && r.Equals(x.ContainingSymbol, y.ContainingSymbol),
        onMethodSymbol: r => (x, y) => x.MetadataName == y.MetadataName &&
            r.Equals(x.ContainingType, y.ContainingType) &&
            x.Parameters.SequenceEqual(y.Parameters, r),
        onParameterSymbol: _ => (x, y) => x.MetadataName == y.MetadataName,
        onPropertySymbol: r => (x, y) => x.MetadataName == y.MetadataName &&
            r.Equals(x.ContainingType, y.ContainingType) &&
            r.Equals(x.Type, y.Type),
        onNamespaceSymbol: r => (x, y) =>
            x.MetadataName == y.MetadataName && r.Equals(x.ContainingNamespace, y.ContainingNamespace),
        onTypeSymbol: r => (x, y) => x.MetadataName == y.MetadataName &&
            r.Equals(x.ContainingNamespace, y.ContainingNamespace) &&
            (!x.IsReferenceType || x.MatchesNullableAnnotation(y)),
        onNamedTypeSymbol: r => (x, y) => x.TypeArguments.GuardedSequenceEqual(y.TypeArguments, r)
    );
    /// <summary>Gets the instance for comparing signatures.</summary>
    [Pure]
    public static RoslynComparer Signature { get; } = new(
        r => (x, y) => x.Kind == y.Kind &&
            x.MetadataName == y.MetadataName &&
            r.Equals(x.ContainingType, y.ContainingType) &&
            r.Equals(x.ContainingNamespace, y.ContainingNamespace) &&
            r.Equals(x.ToUnderlying(), y.ToUnderlying()),
        onMethodSymbol: r => (x, y) => x.Parameters.SequenceEqual(y.Parameters, r) &&
            x.TypeArguments.SequenceEqual(y.TypeArguments, r) &&
            x.TypeParameters.SequenceEqual(y.TypeParameters, r),
        onPropertySymbol: r => (x, y) => x.Parameters.SequenceEqual(y.Parameters, r),
        onTypeSymbol: _ => IncludedSyntaxNodeRegistrant.MatchesNullableAnnotation,
        onNamedTypeSymbol: r => (x, y) =>
            x.TypeArguments.SequenceEqual(y.TypeArguments, r) && x.TypeParameters.SequenceEqual(y.TypeParameters, r)
    );
    /// <summary>Gets the instance for comparing as strict as value-based comparisons go.</summary>
    [Pure]
    public static RoslynComparer Strict { get; } = new(
        r => (x, y) => x.Kind == y.Kind &&
            x.Name == y.Name &&
            x.IsExtern == y.IsExtern &&
            x.IsSealed == y.IsSealed &&
            x.IsStatic == y.IsStatic &&
            x.Language == y.Language &&
            x.IsVirtual == y.IsVirtual &&
            x.IsAbstract == y.IsAbstract &&
            x.IsOverride == y.IsOverride &&
            x.MetadataName == y.MetadataName &&
            x.IsDefinition == y.IsDefinition &&
            x.MetadataToken == y.MetadataToken &&
            x.IsImplicitlyDeclared == y.IsImplicitlyDeclared &&
            x.CanBeReferencedByName == y.CanBeReferencedByName &&
            x.DeclaredAccessibility == y.DeclaredAccessibility &&
            x.HasUnsupportedMetadata == y.HasUnsupportedMetadata &&
            r.Equals(x.ContainingType, y.ContainingType) &&
            r.Equals(x.ContainingModule, y.ContainingModule) &&
            r.Equals(x.ContainingAssembly, y.ContainingAssembly) &&
            r.Equals(x.ContainingNamespace, y.ContainingNamespace) &&
            x.Locations.GuardedSequenceEqual(y.Locations) &&
            x.DeclaringSyntaxReferences.GuardedSequenceEqual(y.DeclaringSyntaxReferences, r),
        r => (x, y) => r.Equals(x.Target, y.Target),
        r => (x, y) => x.IsInteractive == y.IsInteractive &&
            x.Identity == y.Identity &&
            r.Equals(x.GlobalNamespace, y.GlobalNamespace),
        r => (x, y) => x.NullableAnnotation == y.NullableAnnotation && r.Equals(x, y),
        r => (x, y) => x.NullableAnnotation == y.NullableAnnotation &&
            x.IsWindowsRuntimeEvent == y.IsWindowsRuntimeEvent &&
            r.Equals(x.Type, y.Type) &&
            r.Equals(x.AddMethod, y.AddMethod) &&
            r.Equals(x.RaiseMethod, y.RaiseMethod) &&
            r.Equals(x.RemoveMethod, y.RemoveMethod) &&
            r.Equals(x.OverriddenEvent, y.OverriddenEvent) &&
            x.ExplicitInterfaceImplementations.GuardedSequenceEqual(y.ExplicitInterfaceImplementations, r),
        r => (x, y) => x.IsConst == y.IsConst &&
            x.RefKind == y.RefKind &&
            x.FixedSize == y.FixedSize &&
            x.IsReadOnly == y.IsReadOnly &&
            x.IsRequired == y.IsRequired &&
            x.IsVolatile == y.IsVolatile &&
            x.HasConstantValue == y.HasConstantValue &&
            x.IsFixedSizeBuffer == y.IsFixedSizeBuffer &&
            x.NullableAnnotation == y.NullableAnnotation &&
            (x.ConstantValue?.Equals(y.ConstantValue) ?? y.ConstantValue is null) &&
            r.Equals(x.Type, y.Type) &&
            r.Equals(x.AssociatedSymbol, y.AssociatedSymbol) &&
            r.Equals(x.CorrespondingTupleField, y.CorrespondingTupleField) &&
            x.CustomModifiers.GuardedSequenceEqual(y.CustomModifiers, r) &&
            x.RefCustomModifiers.GuardedSequenceEqual(y.RefCustomModifiers, r),
        r => (x, y) => r.Equals(x.ContainingMethod, y.ContainingMethod),
        r => (x, y) => x.IsRef == y.IsRef &&
            x.IsConst == y.IsConst &&
            x.IsFixed == y.IsFixed &&
            x.IsUsing == y.IsUsing &&
            x.RefKind == y.RefKind &&
            x.IsForEach == y.IsForEach &&
            x.ScopedKind == y.ScopedKind &&
            x.IsFunctionValue == y.IsFunctionValue &&
            x.HasConstantValue == y.HasConstantValue &&
            x.NullableAnnotation == y.NullableAnnotation &&
            (x.ConstantValue?.Equals(y.ConstantValue) ?? y.ConstantValue is null) &&
            r.Equals(x.Type, y.Type),
        r => (x, y) => x.Arity == y.Arity &&
            x.IsAsync == y.IsAsync &&
            x.RefKind == y.RefKind &&
            x.IsVararg == y.IsVararg &&
            x.IsInitOnly == y.IsInitOnly &&
            x.IsReadOnly == y.IsReadOnly &&
            x.MethodKind == y.MethodKind &&
            x.ReturnsVoid == y.ReturnsVoid &&
            x.ReturnsByRef == y.ReturnsByRef &&
            x.IsConditional == y.IsConditional &&
            x.IsGenericMethod == y.IsGenericMethod &&
            x.IsCheckedBuiltin == y.IsCheckedBuiltin &&
            x.CallingConvention == y.CallingConvention &&
            x.IsExtensionMethod == y.IsExtensionMethod &&
            x.IsPartialDefinition == y.IsPartialDefinition &&
            x.ReturnsByRefReadonly == y.ReturnsByRefReadonly &&
            x.HidesBaseMethodsByName == y.HidesBaseMethodsByName &&
            x.ReturnNullableAnnotation == y.ReturnNullableAnnotation &&
            x.ReceiverNullableAnnotation == y.ReceiverNullableAnnotation &&
            x.MethodImplementationFlags == y.MethodImplementationFlags &&
            r.Equals(x.ReturnType, y.ReturnType) &&
            r.Equals(x.AssociatedSymbol, y.AssociatedSymbol) &&
            r.Equals(x.ReducedFrom, y.ReducedFrom) &&
            r.Equals(x.ReceiverType, y.ReceiverType) &&
            r.Equals(x.ConstructedFrom, y.ConstructedFrom) &&
            r.Equals(x.OverriddenMethod, y.OverriddenMethod) &&
            r.Equals(x.PartialDefinitionPart, y.PartialDefinitionPart) &&
            r.Equals(x.PartialImplementationPart, y.PartialImplementationPart) &&
            r.Equals(x.AssociatedAnonymousDelegate, y.AssociatedAnonymousDelegate) &&
            x.TypeArgumentNullableAnnotations.GuardedSequenceEqual(y.TypeArgumentNullableAnnotations) &&
            x.RefCustomModifiers.GuardedSequenceEqual(y.RefCustomModifiers, r) &&
            x.ReturnTypeCustomModifiers.GuardedSequenceEqual(y.ReturnTypeCustomModifiers, r) &&
            x.Parameters.GuardedSequenceEqual(y.Parameters, r) &&
            x.TypeArguments.GuardedSequenceEqual(y.TypeArguments, r) &&
            x.UnmanagedCallingConventionTypes.GuardedSequenceEqual(y.UnmanagedCallingConventionTypes, r) &&
            x.ExplicitInterfaceImplementations.GuardedSequenceEqual(y.ExplicitInterfaceImplementations, r),
        r => (x, y) => r.Equals(x.GlobalNamespace, y.GlobalNamespace) &&
            x.ReferencedAssemblies.GuardedSequenceEqual(y.ReferencedAssemblies) &&
            x.ReferencedAssemblySymbols.GuardedSequenceEqual(y.ReferencedAssemblySymbols, r),
        _ => (x, y) => x.IsNamespace == y.IsNamespace && x.IsType == y.IsType,
        r => (x, y) => x.IsThis == y.IsThis &&
            x.Ordinal == y.Ordinal &&
            x.RefKind == y.RefKind &&
            x.IsParams == y.IsParams &&
            x.IsDiscard == y.IsDiscard &&
            x.IsOptional == y.IsOptional &&
            x.ScopedKind == y.ScopedKind &&
            x.NullableAnnotation == y.NullableAnnotation &&
            x.HasExplicitDefaultValue == y.HasExplicitDefaultValue &&
            (x.ExplicitDefaultValue?.Equals(y.ExplicitDefaultValue) ?? y.ExplicitDefaultValue is null) &&
            r.Equals(x.Type, y.Type) &&
            x.CustomModifiers.GuardedSequenceEqual(y.CustomModifiers, r) &&
            x.RefCustomModifiers.GuardedSequenceEqual(y.RefCustomModifiers, r),
        null,
        r => (x, y) => x.RefKind == y.RefKind &&
            x.IsIndexer == y.IsIndexer &&
            x.IsReadOnly == y.IsReadOnly &&
            x.IsRequired == y.IsRequired &&
            x.IsWriteOnly == y.IsWriteOnly &&
            x.IsWithEvents == y.IsWithEvents &&
            x.ReturnsByRef == y.ReturnsByRef &&
            x.NullableAnnotation == y.NullableAnnotation &&
            x.ReturnsByRefReadonly == y.ReturnsByRefReadonly &&
            r.Equals(x.Type, y.Type) &&
            r.Equals(x.GetMethod, y.GetMethod) &&
            r.Equals(x.SetMethod, y.SetMethod) &&
            r.Equals(x.OverriddenProperty, y.OverriddenProperty) &&
            x.RefCustomModifiers.GuardedSequenceEqual(y.RefCustomModifiers, r) &&
            x.TypeCustomModifiers.GuardedSequenceEqual(y.TypeCustomModifiers, r) &&
            x.ExplicitInterfaceImplementations.GuardedSequenceEqual(y.ExplicitInterfaceImplementations, r) &&
            x.Parameters.GuardedSequenceEqual(y.Parameters, r),
        null,
        null,
        _ => (x, y) => x.IsGlobalNamespace == y.IsGlobalNamespace && x.NamespaceKind == y.NamespaceKind,
        r => (x, y) => x.Kind == y.Kind &&
            x.IsRecord == y.IsRecord &&
            x.TypeKind == y.TypeKind &&
            x.IsReadOnly == y.IsReadOnly &&
            x.IsTupleType == y.IsTupleType &&
            x.IsValueType == y.IsValueType &&
            x.SpecialType == y.SpecialType &&
            x.IsRefLikeType == y.IsRefLikeType &&
            x.IsAnonymousType == y.IsAnonymousType &&
            x.IsReferenceType == y.IsReferenceType &&
            x.IsUnmanagedType == y.IsUnmanagedType &&
            x.IsNativeIntegerType == y.IsNativeIntegerType &&
            r.Equals(x.BaseType, y.BaseType) &&
            x.Interfaces.GuardedSequenceEqual(y.Interfaces, r) &&
            x.AllInterfaces.GuardedSequenceEqual(y.AllInterfaces, r),
        r => (x, y) => x.IsSZArray == y.IsSZArray &&
            x.Rank == y.Rank &&
            x.ElementNullableAnnotation == y.ElementNullableAnnotation &&
            r.Equals(x.ElementType, y.ElementType) &&
            x.Sizes.GuardedSequenceEqual(y.Sizes) &&
            x.LowerBounds.GuardedSequenceEqual(y.LowerBounds) &&
            x.CustomModifiers.GuardedSequenceEqual(y.CustomModifiers, r),
        null,
        r => (x, y) => r.Equals(x.Signature, y.Signature),
        r => (x, y) => x.Arity == y.Arity &&
            x.IsComImport == y.IsComImport &&
            x.IsFileLocal == y.IsFileLocal &&
            x.IsGenericType == y.IsGenericType &&
            x.IsScriptClass == y.IsScriptClass &&
            x.IsSerializable == y.IsSerializable &&
            x.IsImplicitClass & y.IsImplicitClass &&
            x.IsUnboundGenericType == y.IsUnboundGenericType &&
            x.MightContainExtensionMethods == y.MightContainExtensionMethods &&
            r.Equals(x.AssociatedSymbol, y.AssociatedSymbol) &&
            r.Equals(x.EnumUnderlyingType, y.EnumUnderlyingType) &&
            r.Equals(x.TupleUnderlyingType, y.TupleUnderlyingType) &&
            r.Equals(x.DelegateInvokeMethod, y.DelegateInvokeMethod) &&
            r.Equals(x.NativeIntegerUnderlyingType, y.NativeIntegerUnderlyingType) &&
            x.TypeArgumentNullableAnnotations.GuardedSequenceEqual(y.TypeArgumentNullableAnnotations) &&
            x.TupleElements.GuardedSequenceEqual(y.TupleElements, r) &&
            x.TypeArguments.GuardedSequenceEqual(y.TypeArguments, r) &&
            x.TypeParameters.GuardedSequenceEqual(y.TypeParameters, r),
        r => (x, y) => r.Equals(x.PointedAtType, y.PointedAtType) &&
            x.CustomModifiers.GuardedSequenceEqual(y.CustomModifiers, r),
        r => (x, y) => x.Ordinal == y.Ordinal &&
            x.Variance == y.Variance &&
            x.TypeParameterKind == y.TypeParameterKind &&
            x.HasNotNullConstraint == y.HasNotNullConstraint &&
            x.HasValueTypeConstraint == y.HasValueTypeConstraint &&
            x.HasConstructorConstraint == y.HasConstructorConstraint &&
            x.HasReferenceTypeConstraint == y.HasReferenceTypeConstraint &&
            x.HasUnmanagedTypeConstraint == y.HasUnmanagedTypeConstraint &&
            x.ReferenceTypeConstraintNullableAnnotation == y.ReferenceTypeConstraintNullableAnnotation &&
            r.Equals(x.ReducedFrom, y.ReducedFrom) &&
            r.Equals(x.DeclaringType, y.DeclaringType) &&
            r.Equals(x.DeclaringMethod, y.DeclaringMethod) &&
            x.ConstraintNullableAnnotations.GuardedSequenceEqual(y.ConstraintNullableAnnotations) &&
            x.ConstraintTypes.GuardedSequenceEqual(y.ConstraintTypes, r),
        r => (x, y) => x.CandidateReason == y.CandidateReason &&
            x.CandidateSymbols.GuardedSequenceEqual(y.CandidateSymbols, r),
        r => (x, y) => x.IsOptional == y.IsOptional && r.Equals(x.Modifier, y.Modifier),
        _ => (x, y) => x.Span == y.Span && x.SyntaxTree.IsEquivalentTo(y.SyntaxTree),
        _ => BetterHashCode,
        r => x => x.IsOptional.ToByte() * Prime() ^ r.GetHashCode(x.Modifier),
        _ => x => x.Span.GetHashCode()
    );
    /// <summary>Determines whether the <see cref="ITypeSymbol"/> has the defined operator.</summary>
    /// <param name="type">The <see cref="ITypeSymbol"/>.</param>
    /// <param name="name">The operator to check for.</param>
    /// <param name="returnType">The expected return type of the operator.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="type"/>
    /// has the operator named after the parameter <paramref name="name"/>.
    /// </returns>
    [Pure]
    public bool ContainsOperator([NotNullWhen(true)] ITypeSymbol? type, string name, SpecialType? returnType = null) =>
        type is not null &&
        type.GetMembers(name).TryFirst(x => IsOperator(x, returnType), out var op) &&
        Equals(type, op.ContainingType);
    /// <inheritdoc />
    [Pure]
    public bool Equals(CustomModifier? x, CustomModifier? y) =>
        ReferenceEquals(x, y) || x is not null && y is not null && _onCustomModifier(x, y);
    /// <inheritdoc />
    [Pure]
    public bool Equals(ISymbol? x, ISymbol? y) =>
        ReferenceEquals(x, y) ||
        x is not null &&
        y is not null &&
        _onSymbol(x, y) &&
        Eq(x, y, _onAliasSymbol) &&
        Eq(x, y, _onAssemblySymbol) &&
        Eq(x, y, _onDiscardSymbol) &&
        Eq(x, y, _onEventSymbol) &&
        Eq(x, y, _onFieldSymbol) &&
        Eq(x, y, _onLabelSymbol) &&
        Eq(x, y, _onLocalSymbol) &&
        Eq(x, y, _onMethodSymbol) &&
        Eq(x, y, _onModuleSymbol) &&
        Eq(x, y, _onNamespaceOrTypeSymbol) &&
        Eq(x, y, _onParameterSymbol) &&
        Eq(x, y, _onPreprocessingSymbol) &&
        Eq(x, y, _onPropertySymbol) &&
        Eq(x, y, _onRangeVariableSymbol) &&
        Eq(x, y, _onSourceAssemblySymbol) &&
        Eq(x, y, _onNamespaceSymbol) &&
        Eq(x, y, _onTypeSymbol) &&
        Eq(x, y, _onArrayTypeSymbol) &&
        Eq(x, y, _onDynamicTypeSymbol) &&
        Eq(x, y, _onFunctionPointerTypeSymbol) &&
        Eq(x, y, _onNamedTypeSymbol) &&
        Eq(x, y, _onPointerTypeSymbol) &&
        Eq(x, y, _onTypeParameterSymbol) &&
        Eq(x, y, _onErrorTypeSymbol);
    /// <inheritdoc />
    public bool Equals(SyntaxReference? x, SyntaxReference? y) =>
        ReferenceEquals(x, y) || x is not null && y is not null && _onSyntaxReference(x, y);
    /// <inheritdoc />
    [Pure]
    public int GetHashCode(CustomModifier? obj) => obj is null ? 0 : _onCustomModifierHash(obj);
    /// <inheritdoc />
    [Pure]
    public int GetHashCode(ISymbol? obj) => obj is null ? 0 : _onSymbolHash.Invoke(obj);
    /// <inheritdoc />
    [Pure]
    public int GetHashCode(SyntaxReference? obj) => obj is null ? 0 : _onSyntaxReferenceHash(obj);
    [Pure]
    static bool Eq<T>(ISymbol x, ISymbol y, Func<T, T, bool> predicate)
        where T : ISymbol =>
        x is T tx && y is T ty && predicate(tx, ty) || x is not T && y is not T;
    /// <summary>Determines whether the symbol is an operator.</summary>
    /// <param name="symbol">The symbol to check.</param>
    /// <param name="returnType">The expected return type.</param>
    /// <returns>Whether the parameter <paramref name="symbol"/> is an operator.</returns>
    [Pure]
    static bool IsOperator(ISymbol symbol, SpecialType? returnType) =>
        symbol is IMethodSymbol
        {
            MethodKind: MethodKind.BuiltinOperator or MethodKind.UserDefinedOperator,
            ReturnType.SpecialType: var specialType,
        } &&
        (returnType is not { } type || specialType == type);
    [Pure]
    static bool True<T>(T _, T __) => true;
    [Pure]
    static int BetterHashCode(ISymbol x)
    {
        int hash = Prime();
        for (var obj = Unsafe.As<ISymbol?>(x); obj is not null; obj = obj.ContainingSymbol)
        {
            hash ^= unchecked(obj.Kind.AsInt() * Prime());
            hash ^= unchecked(obj.MetadataToken * Prime());
            hash ^= unchecked(obj.DeclaredAccessibility.AsInt() * Prime());
            hash ^= unchecked(StringComparer.Ordinal.GetHashCode(obj.Name) * Prime());
            hash ^= unchecked(StringComparer.Ordinal.GetHashCode(obj.Language) * Prime());
            hash ^= unchecked(StringComparer.Ordinal.GetHashCode(obj.MetadataName) * Prime());
        }
        return hash;
    }
    [Pure]
    static int Zero<T>(T _) => 0;
}
#endif
// SPDX-License-Identifier: MPL-2.0
#if ROSLYN
// ReSharper disable NullableWarningSuppressionIsUsed
// ReSharper disable once CheckNamespace
/// <summary>A helper type to build sequences of values with pooled buffers.</summary>
/// <typeparam name="T">The type of items to create sequences for.</typeparam>
[StructLayout(LayoutKind.Auto)]
public ref partial struct ImmutableArrayBuilder<T>
{
    /// <summary>The rented <see cref="Writer"/> instance to use.</summary>
    Writer? _writer;
    /// <summary>
    /// Initializes a new instance of the <see cref="ImmutableArrayBuilder{T}"/> struct with the specified parameters.
    /// </summary>
    /// <param name="writer">The target data writer to use.</param>
    ImmutableArrayBuilder(Writer writer) => _writer = writer;
    /// <inheritdoc cref="ImmutableArray{T}.Builder.Count"/>
    public readonly int Count
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)] get => _writer!.Count;
    }
    /// <summary>Gets the data written to the underlying buffer so far, as a <see cref="ReadOnlySpan{T}"/>.</summary>
    [UnscopedRef]
    public readonly ReadOnlySpan<T> WrittenSpan
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)] get => _writer!.WrittenSpan;
    }
    /// <summary>Creates a <see cref="ImmutableArrayBuilder{T}"/> value with a pooled underlying data writer.</summary>
    /// <returns>A <see cref="ImmutableArrayBuilder{T}"/> instance to write data to.</returns>
    public static ImmutableArrayBuilder<T> Rent() => new(new());
    /// <inheritdoc cref="ImmutableArray{T}.Builder.Add(T)"/>
    public readonly void Add(T item) => _writer!.Add(item);
    /// <summary>Adds the specified items to the end of the array.</summary>
    /// <param name="items">The items to add at the end of the array.</param>
    public readonly void AddRange(scoped ReadOnlySpan<T> items) => _writer!.AddRange(items);
    /// <inheritdoc cref="ImmutableArray{T}.Builder.ToImmutable"/>
    public readonly ImmutableArray<T> ToImmutable() => ImmutableCollectionsMarshal.AsImmutableArray(ToArray());
    /// <inheritdoc cref="ImmutableArray{T}.Builder.ToArray"/>
    public readonly T[] ToArray() => WrittenSpan.ToArray();
    /// <summary>Gets an <see cref="IEnumerable{T}"/> instance for the current builder.</summary>
    /// <remarks><para>The builder should not be mutated while an enumerator is in use.</para></remarks>
    /// <returns>An <see cref="IEnumerable{T}"/> instance for the current builder.</returns>
    public readonly IEnumerable<T> AsEnumerable() => _writer!;
    /// <inheritdoc/>
    public readonly override string ToString() => WrittenSpan.ToString();
    /// <inheritdoc cref="IDisposable.Dispose"/>
    public void Dispose()
    {
        var writer = _writer;
        _writer = null;
        writer?.Dispose();
    }
    /// <summary>A class handling the actual buffer writing.</summary>
    sealed class Writer : ICollection<T>, IDisposable
    {
        /// <summary>The underlying <typeparamref name="T"/> array.</summary>
        T?[]? _array = ArrayPool<T?>.Shared.Rent(typeof(T) == typeof(char) ? 1024 : 8);
        /// <inheritdoc/>
        bool ICollection<T>.IsReadOnly => true;
        /// <inheritdoc cref="ImmutableArrayBuilder{T}.Count"/>
        public int Count
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)] get;
            [MethodImpl(MethodImplOptions.AggressiveInlining)] private set;
        }
        /// <inheritdoc cref="ImmutableArrayBuilder{T}.WrittenSpan"/>
        public ReadOnlySpan<T> WrittenSpan
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)] get => new(_array!, 0, Count);
        }
        /// <inheritdoc cref="ImmutableArrayBuilder{T}.Add"/>
        public void Add(T item)
        {
            EnsureCapacity(1);
            _array![Count++] = item;
        }
        /// <inheritdoc cref="ImmutableArrayBuilder{T}.AddRange"/>
        public void AddRange(ReadOnlySpan<T> items)
        {
            EnsureCapacity(items.Length);
            items.CopyTo(_array.AsSpan(Count)!);
            Count += items.Length;
        }
        /// <inheritdoc/>
        public void Dispose()
        {
            var array = _array;
            _array = null;
            if (array is not null)
                ArrayPool<T?>.Shared.Return(array, typeof(T) != typeof(char));
        }
        /// <inheritdoc/>
        void ICollection<T>.Clear() => throw new NotSupportedException();
        /// <inheritdoc/>
        void ICollection<T>.CopyTo(T[] array, int arrayIndex) => Array.Copy(_array!, 0, array, arrayIndex, Count);
        /// <summary>
        /// Ensures that <see cref="_array"/> has enough free space to contain a given number of new items.
        /// </summary>
        /// <param name="requestedSize">The minimum number of items to ensure space for in <see cref="_array"/>.</param>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        void EnsureCapacity(int requestedSize)
        {
            if (requestedSize > _array!.Length - Count)
                ResizeBuffer(requestedSize);
        }
        /// <summary>Resizes <see cref="_array"/> to ensure it can fit the specified number of new items.</summary>
        /// <param name="sizeHint">The minimum number of items to ensure space for in <see cref="_array"/>.</param>
        [MethodImpl(MethodImplOptions.NoInlining)]
        void ResizeBuffer(int sizeHint)
        {
            var minimumSize = Count + sizeHint;
            var oldArray = _array!;
            var newArray = ArrayPool<T?>.Shared.Rent(minimumSize);
            Array.Copy(oldArray, newArray, Count);
            _array = newArray;
            ArrayPool<T?>.Shared.Return(oldArray, typeof(T) != typeof(char));
        }
        /// <inheritdoc/>
        bool ICollection<T>.Contains(T item) => throw new NotSupportedException();
        /// <inheritdoc/>
        bool ICollection<T>.Remove(T item) => throw new NotSupportedException();
        /// <inheritdoc/>
        IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable<T>)this).GetEnumerator();
        /// <inheritdoc/>
        IEnumerator<T> IEnumerable<T>.GetEnumerator()
        {
            var array = _array!;
            var length = Count;
            for (var i = 0; i < length; i++)
                yield return array[i]!;
        }
    }
}
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable once CheckNamespace
#if !NET20 && !NET30
/// <summary>Extension methods that act as factories for read-only lists.</summary>
    /// <summary>Encapsulates an <see cref="IList{T}"/> and make all mutating methods a no-op.</summary>
    /// <typeparam name="T">The type of element in the list.</typeparam>
    /// <param name="list">The list to encapsulate.</param>
    sealed partial class ReadOnlyList<T>([ProvidesContext] IList<T> list) : IList<T>, IReadOnlyList<T>
    {
        /// <inheritdoc />
        [Pure]
        public bool IsReadOnly => true;
        /// <inheritdoc cref="ICollection{T}.Count"/>
        [CollectionAccess(Read), Pure]
        public int Count => list.Count;
        /// <inheritdoc cref="IList{T}.this" />
        [Pure]
        public T this[int index]
        {
            [CollectionAccess(Read)] get => list[index];
            [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)] set { }
        }
        /// <inheritdoc />
        [CollectionAccess(Read)]
        public void CopyTo(T[] array, int arrayIndex) => list.CopyTo(array, arrayIndex);
        /// <inheritdoc />
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)]
        void ICollection<T>.Add(T? item) { }
        /// <inheritdoc />
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)]
        void ICollection<T>.Clear() { }
        /// <inheritdoc />
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)]
        void IList<T>.Insert(int index, T? item) { }
        /// <inheritdoc />
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None)]
        void IList<T>.RemoveAt(int index) { }
        /// <inheritdoc />
        [CollectionAccess(Read), Pure]
        public bool Contains(T item) => list.Contains(item);
        /// <inheritdoc />
        [CollectionAccess(JetBrains.Annotations.CollectionAccessType.None), Pure]
        bool ICollection<T>.Remove(T? item) => false;
        /// <inheritdoc />
        [CollectionAccess(Read), Pure]
        public int IndexOf(T item) => list.IndexOf(item);
        /// <inheritdoc />
        [CollectionAccess(Read), Pure]
        public IEnumerator<T> GetEnumerator() => list.GetEnumerator();
        /// <inheritdoc />
        [CollectionAccess(Read), Pure]
        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
        /// <inheritdoc />
        [CollectionAccess(Read), Pure]
        public override string ToString() => list.ToString() ?? "";
    }
    /// <summary>Wraps an <see cref="IList{T}"/> (upcasted/created) to a read-only list.</summary>
    /// <typeparam name="T">The type of the <paramref name="iterable"/> and the <see langword="return"/>.</typeparam>
    /// <param name="iterable">The collection to turn into a read-only list.</param>
    /// <returns>A read-only list of <paramref name="iterable"/>.</returns>
    [Pure]
    [return: NotNullIfNotNull(nameof(iterable))]
    public static IReadOnlyList<T>? ReadOnly<T>(this IEnumerable<T>? iterable) =>
        iterable is null
            ? null
#pragma warning disable IDE0028
            : iterable as IReadOnlyList<T> ?? new ReadOnlyList<T>(iterable as IList<T> ?? [.. iterable]);
#pragma warning restore IDE0028
#endif
// SPDX-License-Identifier: MPL-2.0
#if (NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) && !NO_SYSTEM_MEMORY
#pragma warning disable CS8500, IDE0004
// ReSharper disable BadPreprocessorIndent CheckNamespace RedundantUnsafeContext RedundantCast StructCanBeMadeReadOnly
/// <inheritdoc cref="Bits{T}"/>
#if CSHARPREPL
public
#endif
#if !NO_READONLY_STRUCTS
readonly
#endif
    partial struct Bits<T>
{
    /// <inheritdoc cref="IList{T}.this[int]"/>
    [CollectionAccess(CollectionAccessType.Read)]
    public T this[[NonNegativeValue] int index]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        get
        {
            foreach (var ret in this)
                if (index is 0)
                    return ret;
                else
                    index--;
            throw new ArgumentOutOfRangeException(nameof(index), index, null);
        }
    }
    /// <inheritdoc cref="IList{T}.this"/>
    T IList<T>.this[[NonNegativeValue] int index]
    {
        [CollectionAccess(CollectionAccessType.Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        get => this[index];
        [CollectionAccess(CollectionAccessType.None), MethodImpl(MethodImplOptions.AggressiveInlining)] set { }
    }
    /// <inheritdoc cref="ICollection{T}.Count"/>
    [CollectionAccess(CollectionAccessType.Read)]
    public int Count
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        get
        {
            ref var f = ref Unsafe.AsRef(bits);
            ref var l = ref Unsafe.Add(ref f, 1);
            var sum = 0;
            if (Unsafe.SizeOf<T>() >= Unsafe.SizeOf<nint>())
            {
                while (Unsafe.IsAddressLessThan(
                    ref f,
                    ref Unsafe.SubtractByteOffset(ref l, (nint)Unsafe.SizeOf<nint>() - 1)
                ))
                {
                    sum += BitOperations.PopCount(Unsafe.As<T, nuint>(ref f));
                    f = ref Unsafe.As<nint, T>(ref Unsafe.Add(ref Unsafe.As<T, nint>(ref f), 1));
                }
                if (Unsafe.SizeOf<T>() % Unsafe.SizeOf<nint>() is 0)
                    return sum;
            }
            while (Unsafe.IsAddressLessThan(
                ref f,
                ref Unsafe.SubtractByteOffset(ref l, (nint)Unsafe.SizeOf<ulong>() - 1)
            ))
            {
                sum += BitOperations.PopCount(Unsafe.As<T, ulong>(ref f));
                f = ref Unsafe.As<ulong, T>(ref Unsafe.Add(ref Unsafe.As<T, ulong>(ref f), 1));
            }
            if (Unsafe.SizeOf<T>() % Unsafe.SizeOf<ulong>() is 0)
                return sum;
            while (Unsafe.IsAddressLessThan(
                ref f,
                ref Unsafe.SubtractByteOffset(ref l, (nint)Unsafe.SizeOf<uint>() - 1)
            ))
            {
                sum += BitOperations.PopCount(Unsafe.As<T, uint>(ref f));
                f = ref Unsafe.As<uint, T>(ref Unsafe.Add(ref Unsafe.As<T, uint>(ref f), 1));
            }
            if (Unsafe.SizeOf<T>() % sizeof(uint) is not 0)
                sum += BitOperations.PopCount(
                    (Unsafe.SizeOf<T>() % sizeof(uint)) switch
                    {
                        1 => Unsafe.As<T, byte>(ref f),
                        2 => Unsafe.As<T, ushort>(ref f),
                        3 => Unsafe.As<T, ushort>(ref f) | (uint)Unsafe.Add(ref Unsafe.As<T, byte>(ref f), 2) << 16,
                        _ => throw new InvalidOperationException("Unsafe.SizeOf<T>() is assumed to be within [1, 3]."),
                    }
                );
            return sum;
        }
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    static int TrailingZeroCount(nuint value)
#if NET7_0_OR_GREATER
        =>
            BitOperations.TrailingZeroCount(value);
#else
    {
        const int BitsInUInt = BitsInByte * sizeof(uint);
        for (var i = 0; i < (Unsafe.SizeOf<nint>() + sizeof(uint) - 1) / sizeof(uint); i++)
            if (Map((uint)(value << i * BitsInUInt)) is var j and not 32)
                return j + i * BitsInUInt;
        return Unsafe.SizeOf<nint>() * BitsInByte;
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    static int Map([ValueRange(0, 1u << 31)] uint value) =>
        value switch
        {
            0 => 32,
            1 << 0 => 0,
            1 << 1 => 1,
            1 << 2 => 2,
            1 << 3 => 3,
            1 << 4 => 4,
            1 << 5 => 5,
            1 << 6 => 6,
            1 << 7 => 7,
            1 << 8 => 8,
            1 << 9 => 9,
            1 << 10 => 10,
            1 << 11 => 11,
            1 << 12 => 12,
            1 << 13 => 13,
            1 << 14 => 14,
            1 << 15 => 15,
            1 << 16 => 10,
            1 << 17 => 11,
            1 << 18 => 12,
            1 << 19 => 13,
            1 << 20 => 14,
            1 << 21 => 15,
            1 << 22 => 10,
            1 << 23 => 11,
            1 << 24 => 12,
            1 << 25 => 13,
            1 << 26 => 14,
            1 << 27 => 15,
            1 << 28 => 10,
            1 << 29 => 11,
            1 << 30 => 12,
            1u << 31 => 13,
            _ => throw new ArgumentOutOfRangeException(nameof(value), value, null),
        };
#endif
}
#endif
// SPDX-License-Identifier: MPL-2.0
#if !NETSTANDARD1_0
// ReSharper disable BadPreprocessorIndent CheckNamespace StructCanBeMadeReadOnly
#pragma warning disable CS8500
/// <summary>Provides methods for determining similarity between two sequences.</summary>
    const StringComparison DefaultCharComparer = StringComparison.Ordinal;
    /// <summary>Calculates the Jaro similarity between two strings.</summary>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double Jaro(this string? left, string? right) =>
        string.Equals(left, right, DefaultCharComparer) ? 1 : left.Jaro(right, EqualityComparer<char>.Default);
    /// <summary>Calculates the Jaro similarity between two strings.</summary>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="comparer">The comparer to determine equality.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double Jaro(this string? left, string? right, [InstantHandle] Func<char, char, bool>? comparer) =>
        ReferenceEquals(left, right) ? 1 :
        left is null || right is null ? 0 :
        Jaro(left, right, static x => x.Length, static (x, i) => x[i], comparer);
    /// <summary>Calculates the Jaro similarity between two strings.</summary>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="comparer">The comparer to determine equality.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double Jaro(this string? left, string? right, IEqualityComparer<char>? comparer) =>
        left.Jaro(right, comparer is null ? null : comparer.Equals);
    /// <summary>Calculates the Jaro-Emik similarity between two strings.</summary>
    /// <remarks><para>Like <see cref="Jaro(string, string)"/>, but with a bias to common sub-slices.</para></remarks>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double JaroEmik(this string? left, string? right) =>
        string.Equals(left, right, DefaultCharComparer) ? 1 : left.JaroEmik(right, EqualityComparer<char>.Default);
    /// <summary>Calculates the Jaro-Emik similarity between two strings.</summary>
    /// <remarks><para>
    /// Like <see cref="Jaro(string, string, Func{char, char, bool})"/>, but with a bias to common sub-slices.
    /// </para></remarks>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="comparer">The comparer to determine equality.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double JaroEmik(this string? left, string? right, [InstantHandle] Func<char, char, bool>? comparer) =>
        ReferenceEquals(left, right) ? 1 :
        left is null || right is null ? 0 :
        JaroEmik(left, right, static x => x.Length, static (x, i) => x[i], comparer);
    /// <summary>Calculates the Jaro-Emik similarity between two strings.</summary>
    /// <remarks><para>
    /// Like <see cref="Jaro(string, string, IEqualityComparer{char})"/>, but with a bias to common sub-slices.
    /// </para></remarks>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="comparer">The comparer to determine equality.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double JaroEmik(this string? left, string? right, IEqualityComparer<char>? comparer) =>
        left.JaroEmik(right, comparer is null ? null : comparer.Equals);
    /// <summary>Calculates the Jaro-Winkler similarity between two strings.</summary>
    /// <remarks><para>Like <see cref="Jaro(string, string)"/>, but with a bias to common prefixes.</para></remarks>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double JaroWinkler(this string? left, string? right) =>
        string.Equals(left, right, DefaultCharComparer) ? 1 : left.JaroWinkler(right, EqualityComparer<char>.Default);
    /// <summary>Calculates the Jaro-Winkler similarity between two strings.</summary>
    /// <remarks><para>
    /// Like <see cref="Jaro(string, string, Func{char, char, bool})"/>, but with a bias to common prefixes.
    /// </para></remarks>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double JaroWinkler(
        this string? left,
        string? right,
        [InstantHandle] Func<char, char, bool>? comparer
    ) =>
        ReferenceEquals(left, right) ? 1 :
        left is null || right is null ? 0 :
        JaroWinkler(left, right, static x => x.Length, static (x, i) => x[i], comparer);
    /// <summary>Calculates the Jaro-Winkler similarity between two strings.</summary>
    /// <remarks><para>
    /// Like <see cref="Jaro(string, string, IEqualityComparer{char})"/>, but with a bias to common prefixes.
    /// </para></remarks>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double JaroWinkler(
        this string? left,
        string? right,
        IEqualityComparer<char>? comparer
    ) =>
        left.JaroWinkler(right, comparer is null ? null : comparer.Equals);
    /// <summary>Calculates the Jaro similarity between two sequences.</summary>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double Jaro<T>(this IList<T>? left, IList<T>? right) => left.Jaro(right, EqualityComparer<T>.Default);
    /// <summary>Calculates the Jaro similarity between two sequences.</summary>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double Jaro<T>(this IList<T>? left, IList<T>? right, [InstantHandle] Func<T, T, bool>? comparer) =>
        ReferenceEquals(left, right) ? 1 :
        left is null || right is null ? 0 :
        Jaro(left, right, static x => x.Count, static (x, i) => x[i], comparer);
    /// <summary>Calculates the Jaro similarity between two sequences.</summary>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double Jaro<T>(this IList<T>? left, IList<T>? right, IEqualityComparer<T>? comparer) =>
        left.Jaro(right, comparer is null ? null : comparer.Equals);
    /// <summary>Calculates the Jaro-Emik similarity between two sequences.</summary>
    /// <remarks><para>
    /// Like <see cref="Jaro{T}(IList{T}, IList{T})"/>, but with a bias to common sub-slices.
    /// </para></remarks>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double JaroEmik<T>(this IList<T>? left, IList<T>? right) =>
        left.Jaro(right, EqualityComparer<T>.Default);
    /// <summary>Calculates the Jaro-Emik similarity between two sequences.</summary>
    /// <remarks><para>
    /// Like <see cref="Jaro{T}(IList{T}, IList{T}, Func{T, T, bool})"/>, but with a bias to common sub-slices.
    /// </para></remarks>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double JaroEmik<T>(
        this IList<T>? left,
        IList<T>? right,
        [InstantHandle] Func<T, T, bool>? comparer
    ) =>
        ReferenceEquals(left, right) ? 1 :
        left is null || right is null ? 0 :
        Jaro(left, right, static x => x.Count, static (x, i) => x[i], comparer);
    /// <summary>Calculates the Jaro-Emik similarity between two sequences.</summary>
    /// <remarks><para>
    /// Like <see cref="Jaro{T}(IList{T}, IList{T}, IEqualityComparer{T})"/>, but with a bias to common sub-slices.
    /// </para></remarks>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double JaroEmik<T>(this IList<T>? left, IList<T>? right, IEqualityComparer<T>? comparer) =>
        left.Jaro(right, comparer is null ? null : comparer.Equals);
    /// <summary>Calculates the Jaro-Winkler similarity between two sequences.</summary>
    /// <remarks><para>
    /// Like <see cref="Jaro{T}(IList{T}, IList{T})"/>, but with a bias to common prefixes.
    /// </para></remarks>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double JaroWinkler<T>(this IList<T>? left, IList<T>? right) =>
        left.JaroWinkler(right, EqualityComparer<T>.Default);
    /// <summary>Calculates the Jaro-Winkler similarity between two sequences.</summary>
    /// <remarks><para>
    /// Like <see cref="Jaro{T}(IList{T}, IList{T}, Func{T, T, bool})"/>, but with a bias to common prefixes.
    /// </para></remarks>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double JaroWinkler<T>(
        this IList<T>? left,
        IList<T>? right,
        [InstantHandle] Func<T, T, bool>? comparer
    ) =>
        ReferenceEquals(left, right) ? 1 :
        left is null || right is null ? 0 :
        JaroWinkler(left, right, static x => x.Count, static (x, i) => x[i], comparer);
    /// <summary>Calculates the Jaro-Winkler similarity between two sequences.</summary>
    /// <remarks><para>
    /// Like <see cref="Jaro{T}(IList{T}, IList{T}, IEqualityComparer{T})"/>, but with a bias to common prefixes.
    /// </para></remarks>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double JaroWinkler<T>(this IList<T>? left, IList<T>? right, IEqualityComparer<T>? comparer) =>
        left.JaroWinkler(right, comparer is null ? null : comparer.Equals);
    /// <summary>Calculates the Jaro similarity between two sequences.</summary>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double Jaro<T>(
        this scoped ReadOnlySpan<T> left,
        scoped ReadOnlySpan<T> right,
        IEqualityComparer<T>? comparer
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            left.Jaro(right, comparer is null ? null : comparer.Equals);
    /// <summary>Calculates the Jaro similarity between two sequences.</summary>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double Jaro<T>(this scoped Span<T> left, scoped ReadOnlySpan<T> right, IEqualityComparer<T>? comparer)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            left.ReadOnly().Jaro(right, comparer);
    /// <summary>Calculates the Jaro similarity between two sequences.</summary>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static unsafe double Jaro<T>(
        this scoped ReadOnlySpan<T> left,
        scoped ReadOnlySpan<T> right,
        [InstantHandle] Func<T, T, bool>? comparer = null
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
    {
        fixed (T* l = left)
        fixed (T* r = right)
            return Jaro(
                new Fat<T>(left.Align(l), left.Length),
                new(right.Align(r), right.Length),
                static x => x.Length,
                static (x, i) => x[i],
                comparer
            );
    }
    /// <summary>Calculates the Jaro similarity between two sequences.</summary>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double Jaro<T>(
        this scoped Span<T> left,
        scoped ReadOnlySpan<T> right,
        [InstantHandle] Func<T, T, bool>? comparer = null
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            left.ReadOnly().Jaro(right, comparer);
    /// <summary>Calculates the Jaro-Emik similarity between two sequences.</summary>
    /// <remarks><para>
    /// Like <see cref="Jaro{T}(ReadOnlySpan{T}, ReadOnlySpan{T}, IEqualityComparer{T})"/>,
    /// but with a bias to common sub-slices.
    /// </para></remarks>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double JaroEmik<T>(
        this scoped ReadOnlySpan<T> left,
        scoped ReadOnlySpan<T> right,
        IEqualityComparer<T>? comparer
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            left.JaroEmik(right, comparer is null ? null : comparer.Equals);
    /// <summary>Calculates the Jaro-Emik similarity between two sequences.</summary>
    /// <remarks><para>
    /// Like <see cref="Jaro{T}(Span{T}, ReadOnlySpan{T}, IEqualityComparer{T})"/>,
    /// but with a bias to common sub-slices.
    /// </para></remarks>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double JaroEmik<T>(
        this scoped Span<T> left,
        scoped ReadOnlySpan<T> right,
        IEqualityComparer<T>? comparer
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            left.ReadOnly().JaroEmik(right, comparer);
    /// <summary>Calculates the Jaro-Emik similarity between two sequences.</summary>
    /// <remarks><para>
    /// Like <see cref="Jaro{T}(ReadOnlySpan{T}, ReadOnlySpan{T}, Func{T, T, bool})"/>,
    /// but with a bias to common sub-slices.
    /// </para></remarks>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static unsafe double JaroEmik<T>(
        this scoped ReadOnlySpan<T> left,
        scoped ReadOnlySpan<T> right,
        [InstantHandle] Func<T, T, bool>? comparer = null
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
    {
        fixed (T* l = left)
        fixed (T* r = right)
            return JaroEmik(
                new Fat<T>(left.Align(l), left.Length),
                new(right.Align(r), right.Length),
                static x => x.Length,
                static (x, i) => x[i],
                comparer
            );
    }
    /// <summary>Calculates the Jaro-Emik similarity between two sequences.</summary>
    /// <remarks><para>
    /// Like <see cref="Jaro{T}(Span{T}, ReadOnlySpan{T}, Func{T, T, bool})"/>,
    /// but with a bias to common sub-slices.
    /// </para></remarks>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double JaroEmik<T>(
        this scoped Span<T> left,
        scoped ReadOnlySpan<T> right,
        [InstantHandle] Func<T, T, bool>? comparer = null
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            left.ReadOnly().JaroEmik(right, comparer);
    /// <summary>Calculates the Jaro-Winkler similarity between two sequences.</summary>
    /// <remarks><para>
    /// Like <see cref="Jaro{T}(ReadOnlySpan{T}, ReadOnlySpan{T}, IEqualityComparer{T})"/>,
    /// but with a bias to common prefixes.
    /// </para></remarks>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double JaroWinkler<T>(
        this scoped ReadOnlySpan<T> left,
        scoped ReadOnlySpan<T> right,
        IEqualityComparer<T>? comparer
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            left.JaroWinkler(right, comparer is null ? null : comparer.Equals);
    /// <summary>Calculates the Jaro-Winkler similarity between two sequences.</summary>
    /// <remarks><para>
    /// Like <see cref="Jaro{T}(Span{T}, ReadOnlySpan{T}, IEqualityComparer{T})"/>,
    /// but with a bias to common prefixes.
    /// </para></remarks>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double JaroWinkler<T>(
        this scoped Span<T> left,
        scoped ReadOnlySpan<T> right,
        IEqualityComparer<T>? comparer
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            left.ReadOnly().JaroWinkler(right, comparer);
    /// <summary>Calculates the Jaro-Winkler similarity between two sequences.</summary>
    /// <remarks><para>
    /// Like <see cref="Jaro{T}(ReadOnlySpan{T}, ReadOnlySpan{T}, Func{T, T, bool})"/>,
    /// but with a bias to common prefixes.
    /// </para></remarks>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static unsafe double JaroWinkler<T>(
        this scoped ReadOnlySpan<T> left,
        scoped ReadOnlySpan<T> right,
        [InstantHandle] Func<T, T, bool>? comparer = null
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
    {
        fixed (T* l = left)
        fixed (T* r = right)
            return JaroWinkler(
                new Fat<T>(left.Align(l), left.Length),
                new(right.Align(r), right.Length),
                static x => x.Length,
                static (x, i) => x[i],
                comparer
            );
    }
    /// <summary>Calculates the Jaro-Winkler similarity between two sequences.</summary>
    /// <remarks><para>
    /// Like <see cref="Jaro{T}(Span{T}, ReadOnlySpan{T}, Func{T, T, bool})"/>,
    /// but with a bias to common prefixes.
    /// </para></remarks>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [Pure, ValueRange(0, 1)]
    public static double JaroWinkler<T>(
        this scoped Span<T> left,
        scoped ReadOnlySpan<T> right,
        [InstantHandle] Func<T, T, bool>? comparer = null
    )
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
        =>
            left.ReadOnly().JaroWinkler(right, comparer);
    /// <summary>Calculates the Jaro similarity between two sequences.</summary>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <typeparam name="TItem">The type of item within the sequence.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="counter">The function that gets the count.</param>
    /// <param name="indexer">The function that acts as an indexer.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [MustUseReturnValue, ValueRange(0, 1)]
    public static double Jaro<T, TItem>(
        T left,
        T right,
        [InstantHandle, RequireStaticDelegate(IsError = true)] Func<T, int> counter,
        [InstantHandle, RequireStaticDelegate(IsError = true)] Func<T, int, TItem> indexer,
        [InstantHandle] Func<TItem, TItem, bool>? comparer = null
    ) =>
        Jaro(left, right, counter(left), counter(right), indexer, comparer);
    /// <summary>Calculates the Jaro similarity between two instances.</summary>
    /// <typeparam name="T">The type of instance.</typeparam>
    /// <typeparam name="TItem">The type of item within the instance.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="leftLength">The left-hand side's length.</param>
    /// <param name="rightLength">The right-hand side's length.</param>
    /// <param name="indexer">The function that acts as an indexer.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [MustUseReturnValue, ValueRange(0, 1)]
    public static double Jaro<T, TItem>(
        T left,
        T right,
        [NonNegativeValue] int leftLength,
        [NonNegativeValue] int rightLength,
        [InstantHandle, RequireStaticDelegate(IsError = true)] Func<T, int, TItem> indexer,
        [InstantHandle] Func<TItem, TItem, bool>? comparer = null
    ) =>
        JaroInner(left, right, leftLength, rightLength, indexer, comparer ?? EqualityComparer<TItem>.Default.Equals);
    /// <summary>Calculates the Jaro-Emik similarity between two sequences.</summary>
    /// <remarks><para>
    /// Like <see cref="Jaro{T, TItem}(T, T, Func{T, int}, Func{T, int, TItem}, Func{TItem, TItem, bool})"/>,
    /// but with a bias to common sub-slices.
    /// </para></remarks>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <typeparam name="TItem">The type of item within the sequence.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="counter">The function that gets the count.</param>
    /// <param name="indexer">The function that acts as an indexer.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [MustUseReturnValue, ValueRange(0, 1)]
    public static double JaroEmik<T, TItem>(
        T left,
        T right,
        [InstantHandle, RequireStaticDelegate(IsError = true)] Func<T, int> counter,
        [InstantHandle, RequireStaticDelegate(IsError = true)] Func<T, int, TItem> indexer,
        [InstantHandle] Func<TItem, TItem, bool>? comparer = null
    ) =>
        JaroEmik(left, right, counter(left), counter(right), indexer, comparer);
    /// <summary>Calculates the Jaro-Emik similarity between two instances.</summary>
    /// <remarks><para>
    /// Like <see cref="Jaro{T, TItem}(T, T, int, int, Func{T, int, TItem}, Func{TItem, TItem, bool})"/>,
    /// but with a bias to common sub-slices.
    /// </para></remarks>
    /// <typeparam name="T">The type of instance.</typeparam>
    /// <typeparam name="TItem">The type of item within the instance.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="leftLength">The left-hand side's length.</param>
    /// <param name="rightLength">The right-hand side's length.</param>
    /// <param name="indexer">The function that acts as an indexer.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [MustUseReturnValue, ValueRange(0, 1)]
    public static double JaroEmik<T, TItem>(
        T left,
        T right,
        [NonNegativeValue] int leftLength,
        [NonNegativeValue] int rightLength,
        [InstantHandle, RequireStaticDelegate(IsError = true)] Func<T, int, TItem> indexer,
        [InstantHandle] Func<TItem, TItem, bool>? comparer = null
    )
    {
        comparer ??= EqualityComparer<TItem>.Default.Equals;
        var jaro = JaroInner(left, right, leftLength, rightLength, indexer, comparer);
        if (leftLength is 0 || rightLength is 0)
            return jaro;
        var slice = Slice(left, right, leftLength, rightLength, indexer, comparer) * Grade(leftLength, rightLength);
        return System.Math.Max(jaro, slice);
    }
    /// <summary>Calculates the Jaro-Winkler similarity between two sequences.</summary>
    /// <remarks><para>
    /// Like <see cref="Jaro{T, TItem}(T, T, Func{T, int}, Func{T, int, TItem}, Func{TItem, TItem, bool})"/>,
    /// but with a bias to common prefixes.
    /// </para></remarks>
    /// <typeparam name="T">The type of sequence.</typeparam>
    /// <typeparam name="TItem">The type of item within the sequence.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="counter">The function that gets the count.</param>
    /// <param name="indexer">The function that acts as an indexer.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [MustUseReturnValue, ValueRange(0, 1)]
    public static double JaroWinkler<T, TItem>(
        T left,
        T right,
        [InstantHandle, RequireStaticDelegate(IsError = true)] Func<T, int> counter,
        [InstantHandle, RequireStaticDelegate(IsError = true)] Func<T, int, TItem> indexer,
        [InstantHandle] Func<TItem, TItem, bool>? comparer = null
    ) =>
        JaroWinkler(left, right, counter(left), counter(right), indexer, comparer);
    /// <summary>Calculates the Jaro-Winkler similarity between two instances.</summary>
    /// <remarks><para>
    /// Like <see cref="Jaro{T, TItem}(T, T, int, int, Func{T, int, TItem}, Func{TItem, TItem, bool})"/>,
    /// but with a bias to common prefixes.
    /// </para></remarks>
    /// <typeparam name="T">The type of instance.</typeparam>
    /// <typeparam name="TItem">The type of item within the instance.</typeparam>
    /// <param name="left">The left-hand side.</param>
    /// <param name="right">The right-hand side.</param>
    /// <param name="leftLength">The left-hand side's length.</param>
    /// <param name="rightLength">The right-hand side's length.</param>
    /// <param name="indexer">The function that acts as an indexer.</param>
    /// <param name="comparer">The comparer to determine equality, or <see cref="EqualityComparer{T}.Default"/>.</param>
    /// <returns>Between 0.0 and 1.0 (higher value means more similar).</returns>
    [MustUseReturnValue, ValueRange(0, 1)]
    public static double JaroWinkler<T, TItem>(
        T left,
        T right,
        [NonNegativeValue] int leftLength,
        [NonNegativeValue] int rightLength,
        [InstantHandle, RequireStaticDelegate(IsError = true)] Func<T, int, TItem> indexer,
        [InstantHandle] Func<TItem, TItem, bool>? comparer = null
    )
    {
        comparer ??= EqualityComparer<TItem>.Default.Equals;
        var jaroDistance = JaroInner(left, right, leftLength, rightLength, indexer, comparer);
        var prefixLength = NumberOfEquals(left, right, leftLength, rightLength, indexer, comparer);
        var distance = JaroWinklerDistance(jaroDistance, prefixLength);
        return System.Math.Min(distance, 1);
    }
    [MustUseReturnValue, ValueRange(0, 1)]
    static double JaroAllocated<T, TItem>(
        scoped Span<byte> visited,
        T left,
        T right,
        [NonNegativeValue] int leftLength,
        [NonNegativeValue] int rightLength,
        [InstantHandle, RequireStaticDelegate(IsError = true)] Func<T, int, TItem> indexer,
        [InstantHandle] Func<TItem, TItem, bool> comparer
    )
    {
        int rightPreviousIndex = 0, transpositionCount = 0;
        double matchCount = 0;
        visited.Clear();
        for (var i = 0; i < leftLength; i++)
            if (InBounds(leftLength, rightLength, i))
                rightPreviousIndex = Next(
                    visited,
                    left,
                    right,
                    leftLength,
                    rightLength,
                    i,
                    rightPreviousIndex,
                    comparer,
                    indexer,
                    ref matchCount,
                    ref transpositionCount
                );
        return matchCount is 0 ? 0 : JaroDistance(leftLength, rightLength, matchCount, transpositionCount);
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining), MustUseReturnValue, ValueRange(0, 1)]
    static double JaroInner<T, TItem>(
        T left,
        T right,
        [NonNegativeValue] int leftLength,
        [NonNegativeValue] int rightLength,
        [InstantHandle, RequireStaticDelegate(IsError = true)] Func<T, int, TItem> indexer,
        [InstantHandle] Func<TItem, TItem, bool> comparer
    ) =>
        leftLength is 0 || rightLength is 0 ? leftLength is 0 && rightLength is 0 ? 1 : 0 :
        leftLength is 1 && rightLength is 1 ? EqualsAt(left, right, 0, 0, comparer, indexer) ? 1 : 0 :
        JaroAllocated(
            rightLength <= MaxStackalloc ? stackalloc byte[rightLength] : new byte[rightLength],
            left,
            right,
            leftLength,
            rightLength,
            indexer,
            comparer
        );
    [MethodImpl(MethodImplOptions.AggressiveInlining), MustUseReturnValue, NonNegativeValue]
    static int Next<T, TItem>(
        scoped Span<byte> visited,
        T left,
        T right,
        [ValueRange(2, int.MaxValue)] int leftLength,
        [ValueRange(2, int.MaxValue)] int rightLength,
        [NonNegativeValue] int leftIndex,
        [NonNegativeValue] int rightPreviousIndex,
        [InstantHandle] Func<TItem, TItem, bool> comparer,
        [InstantHandle, RequireStaticDelegate(IsError = true)] Func<T, int, TItem> indexer,
        [NonNegativeValue] ref double matchCount,
        [NonNegativeValue] ref int transpositionCount
    )
    {
        for (var rightIndex = 0; rightIndex < rightLength; rightIndex++)
        {
            if (!ShouldProceed(visited, left, right, leftLength, rightLength, leftIndex, rightIndex, comparer, indexer))
                continue;
            visited[rightIndex]++;
            matchCount++;
            if (rightIndex < rightPreviousIndex)
                transpositionCount++;
            return rightIndex;
        }
        return rightPreviousIndex;
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining), MustUseReturnValue]
    static bool ShouldProceed<T, TItem>(
        Span<byte> visited,
        T leftLength,
        T rightLength,
        [ValueRange(2, int.MaxValue)] int aLen,
        [ValueRange(2, int.MaxValue)] int bLen,
        [NonNegativeValue] int leftIndex,
        [NonNegativeValue] int rightIndex,
        [InstantHandle] Func<TItem, TItem, bool> comparer,
        [InstantHandle, RequireStaticDelegate(IsError = true)] Func<T, int, TItem> indexer
    ) =>
        InBounds(aLen, bLen, leftIndex, rightIndex) &&
        visited[rightIndex] is 0 &&
        EqualsAt(leftLength, rightLength, leftIndex, rightIndex, comparer, indexer);
    [MethodImpl(MethodImplOptions.AggressiveInlining), MustUseReturnValue]
    static bool EqualsAt<T, TItem>(
        T left,
        T right,
        [NonNegativeValue] int leftIndex,
        [NonNegativeValue] int rightIndex,
        [InstantHandle] Func<TItem, TItem, bool> comparer,
        [InstantHandle, RequireStaticDelegate(IsError = true)] Func<T, int, TItem> indexer
    ) =>
        comparer(indexer(left, leftIndex), indexer(right, rightIndex));
    [MethodImpl(MethodImplOptions.AggressiveInlining), MustUseReturnValue, ValueRange(0, 1)]
    static double Slice<T, TItem>(
        T left,
        T right,
        [NonNegativeValue] int leftLength,
        [NonNegativeValue] int rightLength,
        [InstantHandle, RequireStaticDelegate(IsError = true)] Func<T, int, TItem> indexer,
        [InstantHandle] Func<TItem, TItem, bool> comparer
    )
    {
        var score = 0;
        var isLeftSmaller = leftLength < rightLength;
        var small = isLeftSmaller ? left : right;
        var smallLength = isLeftSmaller ? leftLength : rightLength;
        var big = isLeftSmaller ? right : left;
        var bigLength = isLeftSmaller ? rightLength : leftLength;
        for (var i = 0; i < bigLength; i++)
        {
            var highestPossibleScore = System.Math.Min(bigLength - i - 1, smallLength);
            if (score >= highestPossibleScore)
                break;
            score = SliceInner(big, small, bigLength, smallLength, indexer, comparer, i, score);
        }
        return (double)score / smallLength;
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining), MustUseReturnValue, NonNegativeValue]
    static int SliceInner<T, TItem>(
        T big,
        T small,
        [NonNegativeValue] int bigLength,
        [NonNegativeValue] int smallLength,
        [InstantHandle, RequireStaticDelegate(IsError = true)] Func<T, int, TItem> indexer,
        [InstantHandle] Func<TItem, TItem, bool> comparer,
        [NonNegativeValue] int i,
        [NonNegativeValue] int score
    )
    {
        var lower = -1;
        for (var j = 0; j < smallLength && i + j < bigLength; j++)
            if (EqualsAt(big, small, i + j, j, comparer, indexer))
                score = System.Math.Max(score, j - lower);
            else
                lower = j;
        return score;
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining), MustUseReturnValue, NonNegativeValue]
    static int NumberOfEquals<T, TItem>(
        T left,
        T right,
        [ValueRange(2, int.MaxValue)] int leftLength,
        [ValueRange(2, int.MaxValue)] int rightLength,
        [InstantHandle, RequireStaticDelegate(IsError = true)] Func<T, int, TItem> indexer,
        [InstantHandle] Func<TItem, TItem, bool> comparer
    )
    {
        var sharedLength = System.Math.Min(leftLength, rightLength);
        for (var sharedIndex = 0; sharedIndex < sharedLength; sharedIndex++)
            if (!EqualsAt(left, right, sharedIndex, sharedIndex, comparer, indexer))
                return sharedIndex;
        return sharedLength;
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    static bool InBounds(
        [ValueRange(2, int.MaxValue)] int leftLength,
        [ValueRange(2, int.MaxValue)] int rightLength,
        [NonNegativeValue] int leftIndex
    ) =>
        MinBound(leftLength, rightLength, leftIndex) <= MaxBound(leftLength, rightLength, leftIndex);
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    static bool InBounds(
        [ValueRange(2, int.MaxValue)] int leftLength,
        [ValueRange(2, int.MaxValue)] int rightLength,
        [NonNegativeValue] int leftIndex,
        [NonNegativeValue] int rightIndex
    ) =>
        MinBound(leftLength, rightLength, leftIndex) <= rightIndex &&
        rightIndex <= MaxBound(leftLength, rightLength, leftIndex);
    [MethodImpl(MethodImplOptions.AggressiveInlining), NonNegativeValue, Pure]
    static int MaxBound(
        [ValueRange(2, int.MaxValue)] int leftLength,
        [ValueRange(2, int.MaxValue)] int rightLength,
        [NonNegativeValue] int leftIndex
    ) =>
        System.Math.Min(SearchRange(leftLength, rightLength) + leftIndex, rightLength - 1);
    [MethodImpl(MethodImplOptions.AggressiveInlining), NonNegativeValue, Pure]
    static int MinBound(
        [ValueRange(2, int.MaxValue)] int leftLength,
        [ValueRange(2, int.MaxValue)] int rightLength,
        [NonNegativeValue] int leftIndex
    ) =>
        SearchRange(leftLength, rightLength) < leftIndex
            ? System.Math.Max(0, leftIndex - SearchRange(leftLength, rightLength))
            : 0;
    [MethodImpl(MethodImplOptions.AggressiveInlining), NonNegativeValue, Pure]
    static int SearchRange(
        [ValueRange(2, int.MaxValue)] int leftLength,
        [ValueRange(2, int.MaxValue)] int rightLength
    ) =>
        System.Math.Max(leftLength, rightLength) / 2 - 1;
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure, ValueRange(0, 1)]
    static double JaroDistance(
        [ValueRange(2, int.MaxValue)] int leftLength,
        [ValueRange(2, int.MaxValue)] int rightLength,
        [NonNegativeValue] double matchCount,
        [NonNegativeValue] int transpositionCount
    ) =>
        1 / 3.0 * (matchCount / leftLength + matchCount / rightLength + (matchCount - transpositionCount) / matchCount);
    [ValueRange(0, 1), Pure]
    static double Grade([NonNegativeValue] int leftLength, [NonNegativeValue] int rightLength) =>
        1 - 1.0 / System.Math.Min(leftLength + 1, rightLength + 1);
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure, ValueRange(0, 1)]
    static double JaroWinklerDistance([ValueRange(0, 1)] double jaroDistance, [NonNegativeValue] int prefixLength) =>
        jaroDistance + 0.1 * prefixLength * (1.0 - jaroDistance);
    /// <summary>Represents a pointer with a length.</summary>
    /// <remarks><para>The data is assumed to be already pinned.</para></remarks>
    /// <param name="pointer">The pointer to the first element of the buffer.</param>
    /// <param name="length">The number of elements in the buffer.</param>
    [StructLayout(LayoutKind.Auto)]
#if !NO_READONLY_STRUCTS
    readonly
#endif
        unsafe partial struct Fat<T>(void* pointer, [NonNegativeValue] int length)
#if UNMANAGED_SPAN
        where T : unmanaged
#endif
    {
        /// <summary>Takes the element corresponding to the passed in index.</summary>
        /// <remarks><para>No bounds check is performed. Going out of bounds is undefined behavior.</para></remarks>
        /// <param name="i">The index to take.</param>
        public T this[[NonNegativeValue] int i]
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
            get
            {
                System.Diagnostics.Debug.Assert((uint)i < (uint)length, "Index must be within bounds.");
                return ((T*)pointer)[i];
            }
        }
        /// <summary>Gets the length.</summary>
        public int Length
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), NonNegativeValue, Pure] get => length;
        }
    }
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable CheckNamespace EmptyNamespace InvalidXmlDocComment RedundantCallerArgumentExpressionDefaultValue RedundantNameQualifier SuggestBaseTypeForParameter UseSymbolAlias
#if NET35_OR_GREATER || NETSTANDARD2_0_OR_GREATER || NETCOREAPP2_0_OR_GREATER
/// <summary>Contains methods for deconstructing objects.</summary>
#pragma warning disable CA1031, CS9107
    [return: NotNullIfNotNull(nameof(it))]
    public static T Debug<T>(
        this T it,
        Predicate<T>? filter = null,
        Converter<T, object?>? map = null,
        int visitLength = DeconstructionCollection.DefaultVisitLength,
        int stringLength = DeconstructionCollection.DefaultStringLength,
        int recurseLength = DeconstructionCollection.DefaultRecurseLength,
        [CallerArgumentExpression(nameof(it))] string? expression = null,
        [CallerFilePath] string? path = null,
        [CallerMemberName] string? name = null,
        [CallerLineNumber] int line = 0
    )
    {
        if (filter?.Invoke(it) is false)
            return it;
        var text = $"[{DateTime.Now:HH:mm:ss}] [{path.FileName()}.{name}:{line} ({expression.CollapseToSingleLine()})] {
            (map is null ? it : map(it)).ToDeconstructed(visitLength, stringLength, recurseLength)}\n";
#if KTANE
        UnityEngine.Debug.Log(text);
#else
        Console.WriteLine(text);
#endif
        File.AppendAllText(Path.Combine(Path.GetTempPath(), "morsels.log"), text);
        return it;
    }
    /// <summary>Takes the complex object and turns it into a structure that is serializable.</summary>
    /// <param name="value">The complex object to convert.</param>
    /// <param name="visitLength">The maximum number of times to recurse through an enumeration.</param>
    /// <param name="stringLength">The maximum length of any given <see cref="string"/>.</param>
    /// <param name="recurseLength">The maximum number of times to recurse a nested object or dictionary.</param>
    /// <returns>
    /// The serializable object: any of <see cref="IntPtr"/>, <see cref="UIntPtr"/>,
    /// <see cref="ISerializable"/>, or <see cref="DeconstructionCollection"/>.
    /// </returns>
    [Pure]
    [return: NotNullIfNotNull(nameof(value))]
    public static object? ToDeconstructed(
        this object? value,
        int visitLength = DeconstructionCollection.DefaultVisitLength,
        int stringLength = DeconstructionCollection.DefaultStringLength,
        int recurseLength = DeconstructionCollection.DefaultRecurseLength
    )
    {
        if (value is DeconstructionCollection)
            return value;
        visitLength = visitLength >= 0 ? visitLength : int.MaxValue;
        stringLength = stringLength >= 0 ? stringLength : int.MaxValue;
        recurseLength = recurseLength >= 0 ? recurseLength : int.MaxValue;
        HashSet<object?> seen = new(DeconstructionCollection.Comparer) { value };
        var assertion = false;
        var next = DeconstructionCollection.CollectNext(value, stringLength, ref visitLength, ref assertion, seen);
        if (next is not DeconstructionCollection x)
        {
            System.Diagnostics.Debug.Assert(!assertion, "!assertion");
            return DeconstructionCollection.TryTruncate(next, stringLength, out var output) ? output : next;
        }
        System.Diagnostics.Debug.Assert(assertion, "assertion");
        for (var i = 0; recurseLength > 0 && i < recurseLength && x.TryRecurse(i, ref visitLength, seen); i++) { }
        return x.Simplify();
    }
/// <summary>Defines the collection responsible for deconstructing.</summary>
/// <param name="str">The maximum length of any given <see cref="string"/>.</param>
abstract partial class DeconstructionCollection([NonNegativeValue] int str) : ICollection
{
    /// <summary>Represents a comparer for <see cref="DeconstructionCollection"/> recursion checks.</summary>
    /// <remarks><para>
    /// All values considered to be scalar values are treated as being always unique even when the exact
    /// reference is the same. The point of the comparer is to avoid reference cycles, not for equality.
    /// </para></remarks>
    sealed partial class DeconstructionComparer : IEqualityComparer<object?>
    {
        int _unique = int.MaxValue;
        /// <inheritdoc />
        [Pure]
        public new bool Equals(object? x, object? y) => !IsScalar(x) && !IsScalar(y) && x == y;
        /// <inheritdoc />
        [Pure]
        public int GetHashCode(object? obj) =>
            IsScalar(obj)
                ? unchecked(_unique--)
#if NETFRAMEWORK && !NET35_OR_GREATER
                : RuntimeHelpers.GetHashCode(obj);
#else
                : 0;
#endif
        /// <summary>Determines whether the value is a scalar.</summary>
        /// <param name="value">The value to check.</param>
        /// <returns>
        /// The value <see langword="true"/> if the value is a scalar; otherwise, <see langword="false"/>.
        /// </returns>
        [Pure]
        static bool IsScalar([NotNullWhen(false)] object? value) =>
            value is nint or nuint or null or string or IConvertible or Pointer or Type or Version;
    }
    /// <summary>Represents a deep-cloned list.</summary>
    /// <param name="str">The maximum length of any given <see cref="string"/>.</param>
    sealed partial class DeconstructionList([NonNegativeValue] int str) : DeconstructionCollection(str), IList
    {
        readonly List<object?> _list = [];
        /// <inheritdoc />
        [Pure]
        public override IList Inner => _list;
        /// <inheritdoc />
        [Pure]
        public object? this[int index]
        {
            get => ((IList)_list)[index];
            set => ((IList)_list)[index] = value;
        }
        /// <inheritdoc />
        [Pure]
        bool IList.IsFixedSize => false;
        /// <inheritdoc />
        [Pure]
        bool IList.IsReadOnly => false;
        /// <summary>
        /// Implicitly converts the parameter by creating the new instance of
        /// <see cref="DeconstructionCollection.DeconstructionList"/> by using the constructor
        /// <see cref="DeconstructionCollection.DeconstructionList(int)"/>.
        /// </summary>
        /// <param name="str">The parameter to pass onto the constructor.</param>
        /// <returns>
        /// The new instance of <see cref="DeconstructionCollection.DeconstructionList"/>
        /// by passing the parameter <paramref name="str"/> to the constructor
        /// <see cref="DeconstructionCollection.DeconstructionList(int)"/>.
        /// </returns>
        [Pure]
        public static implicit operator DeconstructionList(int str) => new(str);
        /// <summary>Attempts to deconstruct an object by enumerating it.</summary>
        /// <param name="enumerator">The enumerator to collect. It will be disposed after the method halts.</param>
        /// <param name="str">The maximum length of any given <see cref="string"/>.</param>
        /// <param name="visit">The maximum number of times to recurse.</param>
        /// <param name="list">The resulting <see cref="DeconstructionCollection.DeconstructionList"/>.</param>
        /// <param name="seen">The set of seen values, which is used to avoid recursion.</param>
        /// <returns>
        /// Whether the parameter <paramref name="enumerator"/> was deconstructed fully and <paramref name="visit"/>
        /// altered. When this method returns <see langword="false"/>, the parameter <paramref name="list"/>
        /// will still contain the elements that were deconstructed, alongside an ellipsis.
        /// </returns>
        public static bool TryCollect(
            [HandlesResourceDisposal] IEnumerator enumerator,
            [NonNegativeValue] int str,
            ref int visit,
            out DeconstructionList list,
            HashSet<object?>? seen = null
        )
        {
            using var _ = enumerator as IDisposable;
            var copy = visit;
            list = new(str);
            try
            {
                while (enumerator.MoveNext())
                    if (seen?.Add(enumerator.Current) is false) { }
                    else if (--copy > 0)
                        list.Add(enumerator.Current);
                    else if (!enumerator.MoveNext())
                        break;
                    else
                        return list.Fail();
            }
            catch (Exception)
            {
                return list.Fail();
            }
            visit = copy;
            return true;
        }
        /// <summary>Attempts to deconstruct an object by enumerating it.</summary>
        /// <param name="enumerable">The enumerator to collect.</param>
        /// <param name="str">The maximum length of any given <see cref="string"/>.</param>
        /// <param name="visit">The maximum number of times to recurse.</param>
        /// <param name="list">The resulting <see cref="DeconstructionCollection.DeconstructionList"/>.</param>
        /// <param name="seen">The set of seen values, which is used to avoid recursion.</param>
        /// <returns>
        /// Whether the parameter <paramref name="enumerable"/> was deconstructed fully and <paramref name="visit"/>
        /// altered. When this method returns <see langword="false"/>, the parameter <paramref name="list"/>
        /// will still contain the elements that were deconstructed, alongside an ellipsis.
        /// </returns>
        public static bool TryCollect(
            [InstantHandle] IEnumerable enumerable,
            [NonNegativeValue] int str,
            ref int visit,
            out DeconstructionList list,
            HashSet<object?>? seen = null
        )
        {
            IEnumerator e;
            try
            {
                e = enumerable.GetEnumerator();
            }
            catch (Exception)
            {
                list = new(str);
                return list.Fail();
            }
            return TryCollect(e, str, ref visit, out list, seen);
        }
#if !NET20 && !NET30 && !NET35
        /// <summary>Attempts to deconstruct an object by enumerating it.</summary>
        /// <param name="comparable">The comparable to collect.</param>
        /// <param name="str">The maximum length of any given <see cref="string"/>.</param>
        /// <param name="visit">The maximum number of times to recurse.</param>
        /// <param name="list">The resulting <see cref="DeconstructionCollection.DeconstructionList"/>.</param>
        /// <param name="seen">The set of seen values, which is used to avoid recursion.</param>
        /// <returns>
        /// Whether the parameter <paramref name="comparable"/> was deconstructed fully and <paramref name="visit"/>
        /// altered. When this method returns <see langword="false"/>, the parameter <paramref name="list"/>
        /// will still contain the elements that were deconstructed, alongside an ellipsis.
        /// </returns>
        public static bool TryCollect(
            [InstantHandle] IStructuralComparable comparable,
            [NonNegativeValue] int str,
            ref int visit,
            out DeconstructionList list,
            HashSet<object?>? seen = null
        )
        {
            List<object?> e;
            try
            {
                e = comparable.ToList();
            }
            catch (Exception)
            {
                list = new(str);
                return list.Fail();
            }
            return TryCollect(e, str, ref visit, out list, seen);
        }
        /// <summary>Attempts to deconstruct an object by enumerating it.</summary>
        /// <param name="equatable">The equatable to collect.</param>
        /// <param name="str">The maximum length of any given <see cref="string"/>.</param>
        /// <param name="visit">The maximum number of times to recurse.</param>
        /// <param name="list">The resulting <see cref="DeconstructionCollection.DeconstructionList"/>.</param>
        /// <param name="seen">The set of seen values, which is used to avoid recursion.</param>
        /// <returns>
        /// Whether the parameter <paramref name="equatable"/> was deconstructed fully and <paramref name="visit"/>
        /// altered. When this method returns <see langword="false"/>, the parameter <paramref name="list"/>
        /// will still contain the elements that were deconstructed, alongside an ellipsis.
        /// </returns>
        public static bool TryCollect(
            [InstantHandle] IStructuralEquatable equatable,
            [NonNegativeValue] int str,
            ref int visit,
            out DeconstructionList list,
            HashSet<object?>? seen = null
        )
        {
            List<object?> e;
            try
            {
                e = equatable.ToList();
            }
            catch (Exception)
            {
                list = new(str);
                return list.Fail();
            }
            return TryCollect(e, str, ref visit, out list, seen);
        }
#endif
        public override bool Fail()
        {
            Add('…');
            return false;
        }
        /// <inheritdoc />
        public override bool TryRecurse(int layer, ref int visit, HashSet<object?>? seen = null)
        {
            if (layer < 0)
                return false;
            var any = false;
            if (layer is 0)
                for (var i = 0; i < Count; i++)
                    _list[i] = CollectNext(_list[i], str, ref visit, ref any, seen);
            else
                foreach (var next in _list)
                    RecurseNext(next, layer, ref visit, ref any, seen);
            return any;
        }
        /// <inheritdoc />
        [NonNegativeValue]
        public int Add(object? value) => ((IList)_list).Add(value);
        /// <inheritdoc />
        [Pure]
        public override string ToString() => $"[{_list.AsEnumerable().Select(ToString).Conjoin()}]";
        /// <inheritdoc />
        public override DeconstructionCollection Simplify()
        {
            for (var i = 0; i < Count; i++)
                _list[i] = SimplifyObject(_list[i]);
            return this;
        }
        /// <inheritdoc />
        void IList.Clear() => _list.Clear();
        /// <inheritdoc />
        void IList.Insert(int index, object? value) => _list.Insert(index, value);
        /// <inheritdoc />
        void IList.Remove(object? value) => _list.Remove(value);
        /// <inheritdoc />
        void IList.RemoveAt(int index) => _list.RemoveAt(index);
        /// <inheritdoc />
        [Pure]
        bool IList.Contains(object? value) => _list.Contains(value);
        /// <inheritdoc />
        [Pure]
        int IList.IndexOf(object? value) => _list.IndexOf(value);
        /// <inheritdoc />
        [Pure]
        public override IEnumerator GetEnumerator() => _list.GetEnumerator();
    }
    /// <summary>Represents either a complex object or a deep-cloned dictionary.</summary>
    /// <param name="str">The maximum length of any given <see cref="string"/>.</param>
    sealed partial class DeconstructionDictionary([NonNegativeValue] int str)
        : DeconstructionCollection(str), IDictionary
    {
        /// <summary>Handles enumeration of the <see cref="DeconstructionDictionary"/>.</summary>
        /// <param name="dictionary">The <see cref="DeconstructionDictionary"/> to enumerate.</param>
        sealed class Enumerator(DeconstructionDictionary dictionary) : IDictionaryEnumerator
        {
            int _index = -1;
            /// <inheritdoc />
            [Pure]
            public DictionaryEntry Entry =>
                _index >= 0 && _index < dictionary.Count ? dictionary._list[_index] : default;
            /// <inheritdoc />
            [Pure]
            object IEnumerator.Current => Entry;
            /// <inheritdoc />
            [Pure]
            object IDictionaryEnumerator.Key => Entry.Key;
            /// <inheritdoc />
            [Pure]
            object? IDictionaryEnumerator.Value => Entry.Value;
            /// <inheritdoc />
            bool IEnumerator.MoveNext() => ++_index < dictionary.Count;
            /// <inheritdoc />
            void IEnumerator.Reset() => _index = -1;
        }
        readonly List<DictionaryEntry> _list = [];
        /// <inheritdoc />
        [Pure]
        object? IDictionary.this[object key]
        {
            get => _list.Find(Eq(key)).Value;
            set => _ = _list.FindIndex(Eq(key)) is not -1 and var i ? _list[i] = new(key, value) : default;
        }
        /// <inheritdoc />
        [Pure]
        bool IDictionary.IsFixedSize => false;
        /// <inheritdoc />
        [Pure]
        bool IDictionary.IsReadOnly => false;
        /// <inheritdoc />
        [Pure]
        ICollection IDictionary.Keys => _list.ConvertAll(x => x.Key);
        /// <inheritdoc />
        [Pure]
        ICollection IDictionary.Values => _list.ConvertAll(x => x.Value);
        /// <inheritdoc />
        [Pure]
        public override IList Inner => _list;
        /// <inheritdoc />
        [Pure]
        public override ICollection Serialized =>
            _list.Aggregate(new Dictionary<string, object?>(StringComparer.Ordinal), AddUnique);
        /// <summary>
        /// Implicitly converts the parameter by creating the new instance of
        /// <see cref="DeconstructionCollection.DeconstructionDictionary"/>
        /// by using the constructor <see cref="DeconstructionCollection.DeconstructionDictionary(int)"/>.
        /// </summary>
        /// <param name="str">The parameter to pass onto the constructor.</param>
        /// <returns>
        /// The new instance of <see cref="DeconstructionCollection.DeconstructionDictionary"/>
        /// by passing the parameter <paramref name="str"/> to the constructor
        /// <see cref="DeconstructionCollection.DeconstructionDictionary(int)"/>.
        /// </returns>
        [Pure]
        public static implicit operator DeconstructionDictionary(int str) => new(str);
        /// <summary>Attempts to deconstruct an object by enumerating it.</summary>
        /// <param name="enumerator">The enumerator to collect. It will be disposed after the method halts.</param>
        /// <param name="str">The maximum length of any given <see cref="string"/>.</param>
        /// <param name="visit">The maximum number of times to recurse.</param>
        /// <param name="dictionary">
        /// The resulting <see cref="DeconstructionCollection.DeconstructionDictionary"/>.
        /// </param>
        /// <param name="seen">The set of seen values, which is used to avoid recursion.</param>
        /// <returns>
        /// Whether the parameter <paramref name="enumerator"/> was deconstructed fully and <paramref name="visit"/>
        /// altered. When this method returns <see langword="false"/>, the parameter <paramref name="dictionary"/>
        /// will still contain the elements that were deconstructed, alongside an ellipsis.
        /// </returns>
        public static bool TryCollect(
            [HandlesResourceDisposal] IDictionaryEnumerator enumerator,
            [NonNegativeValue] int str,
            ref int visit,
            out DeconstructionDictionary dictionary,
            HashSet<object?>? seen = null
        )
        {
            using var _ = enumerator as IDisposable;
            var copy = visit;
            dictionary = new(str);
            try
            {
                while (enumerator.MoveNext())
                    if (seen?.Contains(enumerator.Key) is true ||
                        seen?.Add(enumerator.Value) is false ||
                        seen?.Add(enumerator.Key) is false) { }
                    else if (--copy > 0)
                        dictionary.Add(enumerator.Key, enumerator.Value);
                    else if (enumerator.MoveNext())
                        return dictionary.Fail();
                    else
                        break;
            }
            catch (Exception)
            {
                return dictionary.Fail();
            }
            visit = copy;
            return true;
        }
        /// <summary>Attempts to deconstruct an object by enumerating it.</summary>
        /// <param name="dict">The dictionary to collect.</param>
        /// <param name="str">The maximum length of any given <see cref="string"/>.</param>
        /// <param name="visit">The maximum number of times to recurse.</param>
        /// <param name="dictionary">
        /// The resulting <see cref="DeconstructionCollection.DeconstructionDictionary"/>.
        /// </param>
        /// <param name="seen">The set of seen values, which is used to avoid recursion.</param>
        /// <returns>
        /// Whether the parameter <paramref name="dict"/> was deconstructed fully and <paramref name="visit"/>
        /// altered. When this method returns <see langword="false"/>, the parameter <paramref name="dictionary"/>
        /// will still contain the elements that were deconstructed, alongside an ellipsis.
        /// </returns>
        public static bool TryCollect(
            IDictionary dict,
            [NonNegativeValue] int str,
            ref int visit,
            out DeconstructionDictionary dictionary,
            HashSet<object?>? seen = null
        )
        {
            IDictionaryEnumerator e;
            try
            {
                e = dict.GetEnumerator();
            }
            catch (Exception)
            {
                dictionary = new(str);
                return dictionary.Fail();
            }
            return TryCollect(e, str, ref visit, out dictionary, seen);
        }
        /// <summary>Attempts to deconstruct an object by reflectively collecting its fields and properties.</summary>
        /// <param name="value">The complex object to convert.</param>
        /// <param name="str">The maximum length of any given <see cref="string"/>.</param>
        /// <param name="visit">The maximum number of times to recurse.</param>
        /// <param name="dictionary">
        /// The resulting <see cref="DeconstructionCollection.DeconstructionDictionary"/>.
        /// </param>
        /// <param name="seen">The set of seen values, which is used to avoid recursion.</param>
        /// <returns>
        /// Whether the parameter <paramref name="value"/> was deconstructed fully and <paramref name="visit"/>
        /// altered. When this method returns <see langword="false"/>, the parameter <paramref name="dictionary"/>
        /// will still contain the elements that were deconstructed, alongside an ellipsis.
        /// </returns>
        public static bool TryReflectivelyCollect(
            object value,
            [NonNegativeValue] int str,
            ref int visit,
            out DeconstructionDictionary dictionary,
            HashSet<object?>? seen = null
        )
        {
            var copy = visit;
            dictionary = new(str);
            var type = value.GetType();
#if !NETFRAMEWORK || NET45_OR_GREATER
            var fields = type.GetRuntimeFields().ToArray();
            var properties = type.GetRuntimeProperties().ToArray();
#else
            const BindingFlags Bindings = BindingFlags.Instance |
                BindingFlags.Static |
                BindingFlags.Public |
                BindingFlags.NonPublic |
                BindingFlags.FlattenHierarchy;
            var fields = type.GetFields(Bindings);
            var properties = type.GetProperties(Bindings);
#endif
            foreach (var next in fields)
            {
                if (next.IsStatic)
                    continue;
#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
                if (next.FieldType.IsByRefLike)
                    continue;
#endif
                if (next.GetValue(value) is var result && seen?.Add(result) is false)
                    continue;
                if (--copy <= 0)
                    return dictionary.Fail();
                var name = Name(next, fields, properties);
                dictionary.Add(name, result);
            }
            foreach (var next in properties)
            {
                if (next.GetGetMethod() is { } getter &&
                    (getter.IsStatic || next.GetGetMethod()?.GetParameters() is not []))
                    continue;
#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
                if (next.PropertyType.IsByRefLike)
                    continue;
#endif
                if (GetValueOrException(value, next, str, ref visit, seen) is var result && seen?.Add(result) is false)
                    continue;
                if (--copy <= 0)
                    return dictionary.Fail();
                var name = Name(next, fields, properties);
                dictionary.Add(name, result);
            }
            visit = copy;
            return true;
        }
        /// <inheritdoc cref="IDictionary.Add"/>
        public void Add(object? key, object? value) => _list.Add(new(key!, value));
        /// <inheritdoc cref="IDictionary.Clear"/>
        public void Clear() => _list.Clear();
        /// <inheritdoc />
        public override bool Fail()
        {
            Add('…', '…');
            return false;
        }
        /// <inheritdoc />
        public override bool TryRecurse(int layer, ref int visit, HashSet<object?>? seen = null)
        {
            if (layer < 0)
                return false;
            var any = false;
            if (layer is 0)
                for (var i = 0; i < Count; i++)
                    _list[i] = new(
                        CollectNext(_list[i].Key, str, ref visit, ref any, seen)!,
                        CollectNext(_list[i].Value, str, ref visit, ref any, seen)
                    );
            else
                foreach (var next in _list)
                {
                    RecurseNext(next.Key, layer, ref visit, ref any, seen);
                    RecurseNext(next.Value, layer, ref visit, ref any, seen);
                }
            return any;
        }
        /// <inheritdoc />
        [Pure]
        public override string ToString() =>
            _list is []
                ? "{ }"
                : $"{{ {_list.AsEnumerable().Select(x => $"{ToString(x.Key)}: {ToString(x.Value)}").Conjoin()} }}";
        /// <inheritdoc />
        public override DeconstructionCollection Simplify()
        {
            for (var i = 0; i < Count; i++)
                _list[i] = new(SimplifyObject(_list[i].Key), SimplifyObject(_list[i].Value));
            return this;
        }
        /// <inheritdoc />
        [MustUseReturnValue]
        public override IEnumerator GetEnumerator() => ((IDictionary)this).GetEnumerator();
        /// <inheritdoc />
        void IDictionary.Remove(object key) => _list.Remove(_list.Find(Eq(key)));
        /// <inheritdoc />
        [Pure]
        bool IDictionary.Contains(object key) => _list.FindIndex(Eq(key)) is not -1;
        /// <inheritdoc />
        [MustUseReturnValue]
        IDictionaryEnumerator IDictionary.GetEnumerator()
        {
            _list.Sort(ByKeyString);
            return new Enumerator(this);
        }
        [Pure]
        static string Name(MemberInfo next, FieldInfo[] fields, PropertyInfo[] properties)
        {
            static string QualifyTypeName(MemberInfo next) => $"{next.DeclaringType?.Name}.{next.Name}";
#pragma warning disable MA0169
            if (next.DeclaringType == next.ReflectedType)
                return next.Name;
#pragma warning restore MA0169
            foreach (var x in fields)
                if (x != next && x.Name == next.Name)
                    return QualifyTypeName(next);
            foreach (var x in properties)
                if (x != next && x.Name == next.Name)
                    return QualifyTypeName(next);
            return next.Name;
        }
        [Pure]
        static object? GetValueOrException(
            object value,
            PropertyInfo next,
            [NonNegativeValue] int str,
            ref int visit,
            HashSet<object?>? seen = null
        )
        {
            try
            {
                return next.GetValue(value, null);
            }
            catch (Exception ex)
            {
                return value is not Exception && TryReflectivelyCollect(ex, str, ref visit, out var x, seen) ? x : ex;
            }
        }
        [Pure]
        static Predicate<DictionaryEntry> Eq(object? key) => x => x.Key.Equals(key);
        [Pure]
        int ByKeyString(DictionaryEntry x, DictionaryEntry y) =>
            StringComparer.Ordinal.Compare(ToString(x.Key), ToString(y.Key));
        Dictionary<string, object?> AddUnique(Dictionary<string, object?> accumulator, DictionaryEntry next)
        {
            var key = ToString(next.Key);
            while (accumulator.ContainsKey(key))
                key = $"…{key}";
            accumulator[key] = next.Value is DeconstructionCollection { Serialized: var x } ? x : next.Value;
            return accumulator;
        }
    }
    /// <summary>The defaults used in <see cref="DeconstructionCollectionExtensions.ToDeconstructed"/>.</summary>
    public const int DefaultVisitLength = 500, DefaultStringLength = 5000, DefaultRecurseLength = 50;
    /// <summary>Gets the comparer used in <see cref="DeconstructionCollectionExtensions.ToDeconstructed"/>.</summary>
    [Pure]
    public static IEqualityComparer<object?> Comparer { get; } = new DeconstructionComparer();
    /// <inheritdoc />
    [Pure]
    public bool IsSynchronized => false;
    /// <inheritdoc />
    [NonNegativeValue, Pure]
    public int Count =>
        Inner is var inner && ReferenceEquals(this, inner) ? throw new InvalidOperationException() : inner.Count;
    /// <summary>Gets the maximum length of any given <see cref="string"/>.</summary>
    [NonNegativeValue, Pure]
    public int MaxStringLength => str;
    /// <inheritdoc />
    [Pure]
    public object SyncRoot => this;
    /// <summary>Gets the underlying collection.</summary>
    [Pure]
    public abstract IList Inner { get; }
    /// <summary>Gets the collection to a serializable collection.</summary>
    [Pure]
    public virtual ICollection Serialized => this;
    /// <summary>Attempts to truncate the <paramref name="v"/>.</summary>
    /// <param name="v">The <see cref="object"/> to truncate.</param>
    /// <param name="str">The maximum length of any given <see cref="string"/>.</param>
    /// <param name="o">The resulting truncation <see cref="string"/>.</param>
    /// <returns>Whether the <paramref name="v"/> was truncated.</returns>
    public static bool TryTruncate(object? v, [NonNegativeValue] int str, out string o) =>
        $"{v}" is var x &&
        (o = v is not DeconstructionCollection && str >= 1 && x.Length > str
            ? $"{x[..(str - 1)]}…"
            : x) is not null;
    /// <summary>Collects the value however applicable, reverting on failure.</summary>
    /// <param name="value">The complex object to convert.</param>
    /// <param name="str">The maximum length of any given <see cref="string"/>.</param>
    /// <param name="visit">The maximum number of times to recurse.</param>
    /// <param name="any">Whether any value was collected.</param>
    /// <param name="seen">The set of seen values, which is used to avoid recursion.</param>
    /// <returns>The replacement value.</returns>
    public static object? CollectNext(
        object? value,
        [NonNegativeValue] int str,
        ref int visit,
        ref bool any,
        HashSet<object?>? seen = null
    )
    {
        static bool IsChoiceAttribute(Attribute x) =>
            x.GetType() is { DeclaringType: null, FullName: "Emik.ChoiceAttribute" } ||
            (x.GetType().DeclaringType?.DeclaringType)
           .FindPathToNull(x => x.DeclaringType)
           .Any(x => x is { DeclaringType: not null, Name: "Choice" });
        static object? Ok(object? o, out bool any)
        {
            any = true;
            return o;
        }
        switch (value)
        {
            case not null when value.GetType().GetCustomAttributes().Any(IsChoiceAttribute): return value.ToString();
            case nint or nuint or null or DictionaryEntry or DeconstructionCollection or IConvertible: return value;
#if (NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) && !NO_SYSTEM_MEMORY
            case Memory<char> m: return m.ToString();
            case ReadOnlyMemory<char> m: return m.ToString();
#endif
            case Type x: return x.ToString();
            case Pointer x: return ToHexString(x);
            case Version x: return x.ToShortString();
            case IDictionary x when DeconstructionDictionary.TryCollect(x, str, ref visit, out var dictionary, seen):
                return Ok(dictionary, out any);
            case IDictionary: goto default;
            case IDictionaryEnumerator x
                when DeconstructionDictionary.TryCollect(x, str, ref visit, out var dictionaryEnumerator, seen):
                return Ok(dictionaryEnumerator, out any);
            case IDictionaryEnumerator: goto default;
            case IEnumerable x when DeconstructionList.TryCollect(x, str, ref visit, out var e, seen):
                return Ok(e, out any);
            case IEnumerable: goto default;
            case IEnumerator x when DeconstructionList.TryCollect(x, str, ref visit, out var e, seen):
                return Ok(e, out any);
            case IEnumerator: goto default;
#if !NET20 && !NET30 && !NET35
            case IStructuralComparable x when DeconstructionList.TryCollect(x, str, ref visit, out var cmp, seen):
                return Ok(cmp, out any);
            case IStructuralComparable: goto default;
            case IStructuralEquatable x when DeconstructionList.TryCollect(x, str, ref visit, out var eq, seen):
                return Ok(eq, out any);
            case IStructuralEquatable: goto default;
#endif
            default:
                return DeconstructionDictionary.TryReflectivelyCollect(value, str, ref visit, out var obj, seen)
                    ? Ok(obj, out any)
                    : value;
        }
    }
    /// <inheritdoc />
    public void CopyTo(Array array, int index) =>
        (Inner is var inner && ReferenceEquals(this, inner) ? throw new InvalidOperationException() : inner)
       .CopyTo(array, index);
    /// <summary>Adds a failure element, and returns <see langword="false"/>.</summary>
    /// <returns>The value <see langword="false"/>.</returns>
    public abstract bool Fail();
    /// <summary>Attempts to recurse into this instance's elements.</summary>
    /// <param name="layer">The amount of layers of recursion to apply.</param>
    /// <param name="visit">The maximum number of times to recurse.</param>
    /// <param name="seen">The set of seen values, which is used to avoid recursion.</param>
    /// <returns>Whether any mutation occured.</returns>
    public abstract bool TryRecurse(int layer, ref int visit, HashSet<object?>? seen = null);
    /// <inheritdoc />
    [Pure]
    public abstract override string ToString();
    /// <summary>Returns the <see cref="string"/> representation of this instance without newlines.</summary>
    /// <returns>The <see cref="string"/> representation of this instance.</returns>
    [Pure]
    public string ToStringWithoutNewLines() => ToString().SplitSpanLines().ToString();
    /// <summary>Recursively simplifies every value according to <see cref="Simplify"/>.</summary>
    /// <returns>Itself. The returned value is not a copy; mutation applies to the instance.</returns>
    public abstract DeconstructionCollection Simplify();
    /// <inheritdoc />
    [MustUseReturnValue]
    public abstract IEnumerator GetEnumerator();
    /// <summary>Starts recursion if the value is a collection.</summary>
    /// <param name="value">The complex object to convert.</param>
    /// <param name="layer">The amount of layers of recursion to apply.</param>
    /// <param name="visit">The maximum number of times to recurse.</param>
    /// <param name="any">Whether any value was collected.</param>
    /// <param name="seen">The set of seen values, which is used to avoid recursion.</param>
    protected static void RecurseNext(
        object? value,
        int layer,
        ref int visit,
        ref bool any,
        HashSet<object?>? seen = null
    )
    {
        if (value is DeconstructionCollection collection)
            any |= collection.TryRecurse(layer - 1, ref visit, seen);
    }
    /// <summary>Converts the <see cref="object"/> to a <see cref="string"/>.</summary>
    /// <param name="value">The <see cref="object"/> to convert.</param>
    /// <returns>The converted <see cref="string"/>.</returns>
    [Pure]
    protected string ToString(object? value)
    {
        TryTruncate(value, str, out var output);
        return output;
    }
    /// <summary>Simplifies the value to either a <see cref="IConvertible"/> or <see cref="string"/>.</summary>
    /// <param name="value">The value to simplify.</param>
    /// <returns>The simplified value.</returns>
    [Pure]
    [return: NotNullIfNotNull(nameof(value))]
    protected object? SimplifyObject(object? value) =>
        value switch
        {
            null => "null",
            true => "true",
            false => "false",
            DeconstructionCollection x => x.Simplify(),
            Version x => x.ToShortString(),
            Pointer x => ToHexString(x),
            Type x => x.ToString(),
            nuint x => x.ToHexString(),
            nint x => x.ToHexString(),
            string x => ToString(x),
            IConvertible => value,
            _ => ToString(value),
        };
    [Pure]
    static unsafe string ToHexString(Pointer x) => ((nint)Pointer.Unbox(x)).ToHexString();
}
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable CheckNamespace
/// <summary>Extension methods to attempt to grab the span from enumerables.</summary>
    /// <summary>Tries to extract a span from the source.</summary>
    /// <typeparam name="T">The type of element in the <see cref="IEnumerable{T}"/>.</typeparam>
    /// <param name="source">The source to extract the span from.</param>
    /// <param name="span">The resulting span.</param>
    /// <returns>Whether the span can be extracted from the parameter <paramref name="source"/>.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool TryGetSpan<T>(
        [NoEnumeration, NotNullWhen(true)] this IEnumerable<T>? source,
        out ReadOnlySpan<T> span
    ) =>
        source switch
        {
            T[] provider => (span = provider) is var _,
#if !NETFRAMEWORK || NET45_OR_GREATER
            ArraySegment<T> provider => (span = provider.AsSpan()) is var _,
#endif
#if NETCOREAPP || ROSLYN
            ImmutableArray<T> provider => (span = provider.AsSpan()) is var _,
#endif
            List<T> provider => (span = CollectionsMarshal.AsSpan(provider)) is var _,
            string provider => (span = To<T>.From(provider.AsSpan())) is var _,
            _ => !((span = default) is var _),
        };
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable InvertIf
// ReSharper disable once CheckNamespace
/// <summary>Extension methods to force full enumerations.</summary>
    /// <summary>Forces an enumeration, meant for enumerations that have side effects.</summary>
    /// <param name="iterable">The collection of items to go through one-by-one.</param>
    public static void Enumerate([InstantHandle] this IEnumerable? iterable)
    {
        if (iterable is not null)
            foreach (var _ in iterable) { }
    }
    /// <summary>Forces an enumeration, meant for enumerations that have side effects.</summary>
    /// <typeparam name="T">The type of iterator.</typeparam>
    /// <param name="iterable">The collection of items to go through one-by-one.</param>
    public static void Enumerate<T>([InstantHandle] this IEnumerable<T>? iterable)
    {
        if (iterable is not null)
            foreach (var _ in iterable) { }
    }
// SPDX-License-Identifier: MPL-2.0
#if !NETSTANDARD || NETSTANDARD2_0_OR_GREATER
#pragma warning disable GlobalUsingsAnalyzer
// ReSharper disable once CheckNamespace
/// <summary>Methods to read this assembly's manifest streams into common data structures.</summary>
// ReSharper disable RedundantNameQualifier
    /// <summary>Reads the manifest resource as a sequence of bytes.</summary>
    /// <param name="path">The path of the manifest resource.</param>
    /// <returns>The sequence of bytes of the resource <paramref name="path"/> contained in this assembly.</returns>
    [MustUseReturnValue]
    public static byte[]? GetManifestResourceBytes(
        [PathReference, StringSyntax(StringSyntaxAttribute.Uri), UriString] string? path
    )
    {
        using var stream = GetManifestResourceStream(path);
        if (stream is null)
            return null;
        using MemoryStream memory = new();
        stream.CopyTo(memory);
        return memory.ToArray();
    }
    /// <summary>Reads the manifest resource as a <see cref="string"/>.</summary>
    /// <param name="path">The path of the manifest resource.</param>
    /// <returns>The <see cref="string"/> of the resource <paramref name="path"/> contained in this assembly.</returns>
    [MustUseReturnValue]
    public static string? GetManifestResourceString(
        [PathReference, StringSyntax(StringSyntaxAttribute.Uri), UriString] string? path
    )
    {
        using var stream = GetManifestResourceStream(path);
        if (stream is null)
            return null;
        using StreamReader sr = new(stream);
        return sr.ReadToEnd();
    }
    /// <summary>Reads the manifest.</summary>
    /// <param name="path">The path of the manifest resource.</param>
    /// <returns>The <see cref="Stream"/> of the resource <paramref name="path"/> contained in this assembly.</returns>
    [MustDisposeResource]
    static Stream? GetManifestResourceStream(
        [PathReference, StringSyntax(StringSyntaxAttribute.Uri), UriString] string? path
    ) =>
        path is null or ""
            ? null
            : typeof(ManifestReader).Assembly.GetManifestResourceStream(
                $"{typeof(ManifestReader).Assembly.GetName().Name}.{path.Replace('/', '.').Replace('\\', '.')}"
            );
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable once CheckNamespace
/// <summary>Extension methods to clamp numbers.</summary>
    /// <summary>Evaluate whether a given integral value is a power of 2.</summary>
    /// <param name="value">The value.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="value"/>
    /// is a power of 2; otherwise, <see langword="false"/>.
    /// </returns>
    [CLSCompliant(false), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsPow2(this int value) =>
#if NET6_0_OR_GREATER
        BitOperations.IsPow2(value);
#else
        (value & value - 1) is 0 && value > 0;
#endif
    /// <summary>Evaluate whether a given integral value is a power of 2.</summary>
    /// <param name="value">The value.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="value"/>
    /// is a power of 2; otherwise, <see langword="false"/>.
    /// </returns>
    [CLSCompliant(false), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsPow2(this uint value) =>
#if NET6_0_OR_GREATER
        BitOperations.IsPow2(value);
#else
        (value & value - 1) is 0 && value > 0;
#endif
    /// <summary>Evaluate whether a given integral value is a power of 2.</summary>
    /// <param name="value">The value.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="value"/>
    /// is a power of 2; otherwise, <see langword="false"/>.
    /// </returns>
    [CLSCompliant(false), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsPow2(this long value) =>
#if NET6_0_OR_GREATER
        BitOperations.IsPow2(value);
#else
        (value & value - 1) is 0 && value > 0;
#endif
    /// <summary>Evaluate whether a given integral value is a power of 2.</summary>
    /// <param name="value">The value.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="value"/>
    /// is a power of 2; otherwise, <see langword="false"/>.
    /// </returns>
    [CLSCompliant(false), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsPow2(this ulong value) =>
#if NET6_0_OR_GREATER
        BitOperations.IsPow2(value);
#else
        (value & value - 1) is 0 && value > 0;
#endif
    /// <summary>Evaluate whether a given integral value is a power of 2.</summary>
    /// <param name="value">The value.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="value"/>
    /// is a power of 2; otherwise, <see langword="false"/>.
    /// </returns>
    [CLSCompliant(false), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsPow2(this nint value) =>
#if NET7_0_OR_GREATER
        BitOperations.IsPow2(value);
#else
        (value & value - 1) is 0 && value > 0;
#endif
    /// <summary>Evaluate whether a given integral value is a power of 2.</summary>
    /// <param name="value">The value.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="value"/>
    /// is a power of 2; otherwise, <see langword="false"/>.
    /// </returns>
    [CLSCompliant(false), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsPow2(this nuint value) =>
#if NET7_0_OR_GREATER
        BitOperations.IsPow2(value);
#else
        (value & value - 1) is 0 && value > 0;
#endif
    /// <inheritdoc cref="RoundUpToPowerOf2(uint)"/>
    [CLSCompliant(false), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static uint RoundUpToPowerOf2(this int value) => RoundUpToPowerOf2(unchecked((uint)value));
    /// <summary>Round the given integral value up to a power of 2.</summary>
    /// <remarks><para>
    /// The fallback implementation is based on
    /// <a href="https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2">
    /// Bit Twiddling Hacks by Sean Eron Anderson
    /// </a>.
    /// </para></remarks>
    /// <param name="value">The value.</param>
    /// <returns>
    /// The smallest power of 2 which is greater than or equal to <paramref name="value"/>.
    /// If <paramref name="value"/> is 0 or the result overflows, returns 0.
    /// </returns>
    [CLSCompliant(false), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static uint RoundUpToPowerOf2(this uint value)
#if NET6_0_OR_GREATER
        =>
            BitOperations.RoundUpToPowerOf2(value);
#else
    {
        --value;
        value |= value >> 1;
        value |= value >> 2;
        value |= value >> 4;
        value |= value >> 8;
        value |= value >> 16;
        return value + 1;
    }
#endif
    /// <inheritdoc cref="RoundUpToPowerOf2(uint)"/>
    [CLSCompliant(false), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ulong RoundUpToPowerOf2(this long value) => RoundUpToPowerOf2(unchecked((ulong)value));
    /// <inheritdoc cref="RoundUpToPowerOf2(uint)"/>
    [CLSCompliant(false), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static ulong RoundUpToPowerOf2(this ulong value)
#if NET6_0_OR_GREATER
        =>
            BitOperations.RoundUpToPowerOf2(value);
#else
    {
        --value;
        value |= value >> 1;
        value |= value >> 2;
        value |= value >> 4;
        value |= value >> 8;
        value |= value >> 16;
        value |= value >> 32;
        return value + 1;
    }
#endif
    /// <inheritdoc cref="RoundUpToPowerOf2(uint)"/>
    [CLSCompliant(false), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static nuint RoundUpToPowerOf2(this nint value) => RoundUpToPowerOf2(unchecked((nuint)value));
    /// <inheritdoc cref="RoundUpToPowerOf2(uint)"/>
    [CLSCompliant(false), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static nuint RoundUpToPowerOf2(this nuint value) =>
#if NET6_0_OR_GREATER
#pragma warning disable IDE0004
        (nuint)BitOperations.RoundUpToPowerOf2(value);
#pragma warning restore IDE0004
#else
        Unsafe.SizeOf<nuint>() is 4 ? RoundUpToPowerOf2((uint)value) : (nuint)RoundUpToPowerOf2((ulong)value);
#endif
#if NET7_0_OR_GREATER
    /// <summary>Clamps a value such that it is no smaller or larger than the defined amount.</summary>
    /// <typeparam name="T">The type of numeric value for comparisons.</typeparam>
    /// <param name="number">The number to clip.</param>
    /// <param name="min">If specified, the smallest number to return.</param>
    /// <param name="max">If specified, the greatest number to return.</param>
    /// <returns>
    /// The parameter <paramref name="min"/> if <paramref name="number"/> is smaller than <paramref name="min"/>,
    /// otherwise, the parameter <paramref name="max"/> if <paramref name="number"/> is greater than
    /// <paramref name="max"/>, otherwise the parameter <paramref name="number"/>.
    /// </returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T Clip<T>(this T number, T? min = null, T? max = null)
        where T : class, IComparisonOperators<T, T, bool> =>
        (min ?? number) is var small &&
        (max ?? number) is var big &&
        number <= small ? small :
        number >= big ? big : number;
    /// <inheritdoc cref="Clip{T}(T,T?,T?)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T Clip<T>(this T number, T? min = null, T? max = null)
        where T : struct, IComparisonOperators<T, T, bool> =>
        (min ?? number) is var small &&
        (max ?? number) is var big &&
        number <= small ? small :
        number >= big ? big : number;
    /// <summary>
    /// Calculates the least nonnegative remainder of <paramref name="number"/> <c>%</c> <paramref name="radix"/>.
    /// </summary>
    /// <remarks><para>
    /// Implementation based on <a href="https://doc.rust-lang.org/src/core/num/int_macros.rs.html#2190">
    /// Rust standard library (core)'s rem_euclid function
    /// </a>.
    /// </para></remarks>
    /// <typeparam name="T">The type of numeric value.</typeparam>
    /// <param name="number">The number to calculate the remainder of.</param>
    /// <param name="radix">The radix to use.</param>
    /// <returns>The result of the Euclidean division algorithm.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static T Mod<T>(this T number, T radix)
        where T : IComparisonOperators<T, T, bool>, IModulusOperators<T, T, T>, INumberBase<T> =>
        number % radix is var r && r < T.Zero ? unchecked(r + radix) : r;
#else
    /// <summary>Clamps a value such that it is no smaller or larger than the defined amount.</summary>
    /// <param name="number">The number to clip.</param>
    /// <param name="min">If specified, the smallest number to return.</param>
    /// <param name="max">If specified, the greatest number to return.</param>
    /// <returns>
    /// The parameter <paramref name="min"/> if <paramref name="number"/> is smaller than <paramref name="min"/>,
    /// otherwise, the parameter <paramref name="max"/> if <paramref name="number"/> is greater than
    /// <paramref name="max"/>, otherwise the parameter <paramref name="number"/>.
    /// </returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int Clamp(this int number, int? min = null, int? max = null) =>
        (min ?? number) is var small &&
        (max ?? number) is var big &&
        number <= small ? small :
        number >= big ? big : number;
    /// <inheritdoc cref="Clamp(int, int?, int?)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static float Clamp(this float number, float? min = null, float? max = null) =>
        (min ?? number) is var small &&
        (max ?? number) is var big &&
        number <= small ? small :
        number >= big ? big : number;
    /// <summary>
    /// Calculates the least nonnegative remainder of <paramref name="number"/> <c>%</c> <paramref name="radix"/>.
    /// </summary>
    /// <remarks><para>
    /// Implementation based on <a href="https://doc.rust-lang.org/src/core/num/int_macros.rs.html#2190">
    /// Rust standard library (core)'s rem_euclid function
    /// </a>.
    /// </para></remarks>
    /// <param name="number">The number to calculate the remainder of.</param>
    /// <param name="radix">The radix to use.</param>
    /// <returns>The result of the Euclidean division algorithm.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static int Mod(this int number, int radix) => number % radix is var r && r < 0 ? unchecked(r + radix) : r;
    /// <inheritdoc cref="Mod(int, int)"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static float Mod(this float number, float radix) => number % radix is var r && r < 0 ? r + radix : r;
#endif
// SPDX-License-Identifier: MPL-2.0
#if !NETSTANDARD || NETSTANDARD2_0_OR_GREATER
// ReSharper disable once CheckNamespace
/// <summary>Methods to provide coercions to <see cref="System.Linq.Expressions.Expression"/>.</summary>
// ReSharper disable RedundantNameQualifier
    /// <summary>Provides the verbose representation found in the debug view.</summary>
    /// <param name="x">The expression to get the <see langword="string"/> representation of.</param>
    /// <returns>The verbose representation of the parameter <paramref name="x"/>.</returns>
    public static string? ToVerboseString(this System.Linq.Expressions.Expression x) =>
        typeof(System.Linq.Expressions.Expression)
           .GetProperty("DebugView", BindingFlags.Instance | BindingFlags.NonPublic)
          ?.GetGetMethod(true)
          ?.Invoke(x, null) as string;
    /// <summary>Gets the field or property.</summary>
    /// <param name="expression">The expression to retrieve from.</param>
    /// <param name="member">The member to access.</param>
    /// <returns>The <see cref="BinaryExpression"/> representing <c>left.member = right</c>.</returns>
    public static MemberExpression FieldOrProperty(
        this System.Linq.Expressions.Expression expression,
        MemberInfo member
    ) =>
        member switch
        {
            PropertyInfo p => System.Linq.Expressions.Expression.Property(expression, p),
            FieldInfo f => System.Linq.Expressions.Expression.Field(expression, f),
            _ => throw Unreachable,
        };
#endif
// SPDX-License-Identifier: MPL-2.0
#if XNA
/// <summary>Provides the enumeration over <see cref="GamePad"/> instances.</summary>
[StructLayout(LayoutKind.Auto)]
public struct GamePads(PlayerIndex last = PlayerIndex.Four) : IEnumerable<GamePadState>, IEnumerator<GamePadState>
{
    readonly PlayerIndex _length = last + 1;
    PlayerIndex _index;
    /// <summary>Gets the first four <see cref="GamePadState"/> instances.</summary>
    public static (GamePadState First, GamePadState Second, GamePadState Third, GamePadState Fourth) Four =>
    (
        GamePad.GetState(PlayerIndex.One),
        GamePad.GetState(PlayerIndex.Two),
        GamePad.GetState(PlayerIndex.Three),
        GamePad.GetState(PlayerIndex.Four)
    );
    /// <inheritdoc />
    public GamePadState Current { get; private set; }
    /// <inheritdoc />
    readonly object IEnumerator.Current => Current;
    /// <inheritdoc />
    readonly void IDisposable.Dispose() { }
    /// <inheritdoc />
    public void Reset() => _index = PlayerIndex.One;
    /// <inheritdoc />
    public bool MoveNext() =>
#pragma warning disable MA0099
        _index < (_length is 0 ? PlayerIndex.Four + 1 : _length) && (Current = GamePad.GetState(_index++)) is var _;
#pragma warning restore MA0099
    /// <inheritdoc cref="IEnumerable{T}.GetEnumerator"/>
    public readonly GamePads GetEnumerator() => new(last);
    /// <inheritdoc />
    readonly IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
    /// <inheritdoc />
    readonly IEnumerator<GamePadState> IEnumerable<GamePadState>.GetEnumerator() => GetEnumerator();
}
/// <summary>Extensions for <see cref="GamePadState"/>.</summary>
#pragma warning disable MA0048
static class GamePadStateExtensions
#pragma warning restore MA0048
{
    /// <inheritdoc cref="GamePadState.IsConnected"/>
    public static bool IsConnected(this in (GamePadState, GamePadState, GamePadState, GamePadState) state) =>
        state.Item1.IsConnected || state.Item2.IsConnected || state.Item3.IsConnected || state.Item4.IsConnected;
    /// <inheritdoc cref="GamePadState.IsButtonDown"/>
    public static bool IsButtonDown(
        this in (GamePadState, GamePadState, GamePadState, GamePadState) state,
        Buttons buttons
    ) =>
        AsRef(state.Item1).IsButtonDown(buttons) ||
        AsRef(state.Item2).IsButtonDown(buttons) ||
        AsRef(state.Item3).IsButtonDown(buttons) ||
        AsRef(state.Item4).IsButtonDown(buttons);
    /// <inheritdoc cref="GamePadState.IsButtonUp"/>
    public static bool IsButtonUp(
        this in (GamePadState, GamePadState, GamePadState, GamePadState) state,
        Buttons buttons
    ) =>
        AsRef(state.Item1).IsButtonUp(buttons) ||
        AsRef(state.Item2).IsButtonUp(buttons) ||
        AsRef(state.Item3).IsButtonUp(buttons) ||
        AsRef(state.Item4).IsButtonUp(buttons);
}
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable CheckNamespace RedundantNameQualifier UseSymbolAlias
/// <summary>Provides methods to turn <see cref="Version"/> into a <see cref="string"/>.</summary>
    /// <summary>Gets the short display form of the version.</summary>
    /// <param name="version">The <see cref="Version"/> to convert.</param>
    /// <param name="prefix">The prefix to use.</param>
    /// <returns>The full name of the parameter <paramref name="version"/>.</returns>
    [Pure]
    public static string ToShortString(this Version? version, string? prefix = "v")
    {
        var (major, minor, build, revision) = version;
        var length = (prefix?.Length ?? 0) +
            major.DigitCount() +
            (revision > 0 ? minor.DigitCount() + build.DigitCount() + revision.DigitCount() + 3 :
                build > 0 ? minor.DigitCount() + build.DigitCount() + 2 :
                minor > 0 ? minor.DigitCount() + 1 : 0);
        Span<char> span = stackalloc char[length];
        Format(span, version, prefix);
        return span.ToString();
    }
    static void Format(scoped Span<char> span, Version? version, string? prefix)
    {
        static void PushLast([NonNegativeValue] int next, scoped ref Span<char> span)
        {
            if (!next.TryFormat(span, out var charsWritten))
                System.Diagnostics.Debug.Fail("TryFormat");
            span = span.UnsafelySkip(charsWritten);
        }
        static void Push([NonNegativeValue] int next, scoped ref Span<char> span)
        {
            PushLast(next, ref span);
            span[0] = '.';
            span = span.UnsafelySkip(1);
        }
        var length = prefix?.Length ?? 0;
        prefix.AsSpan().CopyTo(span);
        span = span.UnsafelySkip(length);
        switch (version)
        {
            case (var major, var minor, var build, > 0 and var revision):
                Push(major, ref span);
                Push(minor, ref span);
                Push(build, ref span);
                PushLast(revision, ref span);
                break;
            case (var major, var minor, > 0 and var build):
                Push(major, ref span);
                Push(minor, ref span);
                PushLast(build, ref span);
                break;
            case (var major, > 0 and var minor):
                Push(major, ref span);
                PushLast(minor, ref span);
                break;
            default:
                PushLast(version?.Major ?? 0, ref span);
                break;
        }
        System.Diagnostics.Debug.Assert(span.IsEmpty, $"span is drained and not {span.Length} characters long");
    }
// SPDX-License-Identifier: MPL-2.0
#if XNA
/// <summary>Provides methods to create <see cref="Texture2D"/> at runtime.</summary>
    /// <summary>The delegate responsible for painting the graphic.</summary>
    /// <param name="canvas">The eventual <see cref="Texture2D"/>.</param>
    public delegate void Painter(Span2D<Color> canvas);
    /// <summary>Creates the <see cref="Texture2D"/> at runtime.</summary>
    /// <param name="device">The device to associate the texture with.</param>
    /// <param name="width">The width of the texture.</param>
    /// <param name="height">The height of the texture.</param>
    /// <param name="painter">The callback for coloring the graphic.</param>
    /// <returns>The <see cref="Texture2D"/> containing the image painted by the <paramref name="painter"/>.</returns>
    [MustDisposeResource, MustUseReturnValue]
    public static Texture2D CreateTexture2D(
        this GraphicsDevice device,
        [NonNegativeValue] int width,
        [NonNegativeValue] int height,
        [InstantHandle] Painter painter
    )
    {
        Texture2D texture = new(device, width, height);
        var data = new Color[width * height];
        painter(new(data, height, width));
        texture.SetData(data);
        return texture;
    }
#endif
// SPDX-License-Identifier: MPL-2.0
#if ROSLYN
#pragma warning disable GlobalUsingsAnalyzer
// ReSharper disable once CheckNamespace
#pragma warning restore GlobalUsingsAnalyzer
/// <summary>Generates the attribute needed to use this analyzer.</summary>
/// <param name="hintName">The file name of the source.</param>
/// <param name="contents">The contents of the source.</param>
public abstract class FixedGenerator(
    [StringSyntax(StringSyntaxAttribute.Uri), UriString] string hintName,
    [StringSyntax("C#")] string contents
) : IIncrementalGenerator
{
    /// <summary>The header for generated files.</summary>
    [StringSyntax("C#")]
    public const string Header =
        """
        #nullable enable
        """;
    /// <summary>The extension of each generated file.</summary>
    const string Extension = ".g.cs";
    /// <summary>Gets the attribute that indicates source generation from this library.</summary>
    [Pure, StringSyntax("C#")]
    public static string Annotation { get; } =
#if GENERATED_CODE_ABSOLUTE_PATH
        $"[global::System.CodeDom.Compiler.GeneratedCodeAttribute(\"{
            typeof(FixedGenerator).Assembly.ManifestModule.FullyQualifiedName}\", \"{
                typeof(FixedGenerator).Assembly.ManifestModule.ModuleVersionId}\")]";
#else
        $"[global::System.CodeDom.Compiler.GeneratedCodeAttribute(\"{
            typeof(FixedGenerator).Assembly.GetName().Name}\", \"{
                typeof(FixedGenerator).Assembly.GetName().Version}\")]";
#endif
    /// <summary>Gets the name of the generated attribute.</summary>
    [Pure]
    public string Name => hintName;
    /// <summary>Gets the source.</summary>
    [Pure]
    public (string, SourceText) Source
    {
        get
        {
            var (name, text) = this;
            return ($"{GetType().Namespace}/{GetType()}/{name}",
                SourceText.From(text, Encoding.UTF8));
        }
    }
    /// <summary>Gets the name of the attribute generated specified by <typeparamref name="T"/>.</summary>
    /// <typeparam name="T">The kind of <see cref="FixedGenerator"/> to get the <see cref="Name"/> from.</typeparam>
    /// <returns>The <see cref="Name"/> of the <see cref="FixedGenerator"/> <typeparamref name="T"/>.</returns>
    [Pure]
    public static string Of<T>()
        where T : FixedGenerator, new() =>
        new T().Name;
    /// <summary>Deconstructs this instance to source code.</summary>
    /// <param name="name">The name of the generated file.</param>
    /// <param name="text">The contents of the generated file.</param>
    public void Deconstruct(out string name, out string text) =>
        (name, text) = ($"{hintName}{Extension}", $"{Header}{contents}\n");
    /// <inheritdoc />
#pragma warning disable CA1033
    void IIncrementalGenerator.Initialize(IncrementalGeneratorInitializationContext context) =>
        context.RegisterPostInitializationOutput(AddSource);
#pragma warning restore CA1033
    /// <summary>Adds source code to the context.</summary>
    /// <param name="context">The context to add source code to.</param>
    void AddSource(IncrementalGeneratorPostInitializationContext context)
    {
        var (name, text) = this;
        context.AddSource(name, text);
    }
}
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable once CheckNamespace
/// <summary>Provides methods to create views of <see cref="IEnumerable{T}"/> instances.</summary>
    /// <summary>
    /// Transforms the <see cref="IEnumerable{T}"/> into views of the current and next items.
    /// </summary>
    /// <typeparam name="T">The type of items in the collection.</typeparam>
    /// <param name="source">The collection to iterate over.</param>
    /// <returns>The <see cref="IEnumerable{T}"/> containing the current and next items.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<(T Left, T Right)> Pairs<T>(this IEnumerable<T> source) =>
        source.TryCount() is { } x ? Iterator(source).WithCount(x - 1) : Iterator(source);
    /// <summary>
    /// Transforms the <see cref="IEnumerable{T}"/> into views of the specified length.
    /// </summary>
    /// <typeparam name="T">The type of items in the collection.</typeparam>
    /// <param name="source">The collection to iterate over.</param>
    /// <param name="size">The size of the window.</param>
    /// <returns>An <see cref="IEnumerable{T}"/> of windows.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<T[]> Window<T>(this IEnumerable<T> source, int size) =>
        size <= 0
            ? []
            : source.TryCount() switch
            {
                0 => [],
                { } x when x < size => [],
                1 => source.Select(x => new[] { x }),
                { } x => Iterator(source, size).WithCount(x - size + 1),
                null => Iterator(source, size),
            };
    [Pure]
    static IEnumerable<(T Left, T Right)> Iterator<T>(IEnumerable<T> source)
    {
        using var e = source.GetEnumerator();
        if (!e.MoveNext())
            yield break;
        var previous = e.Current;
        while (e.MoveNext())
            yield return (previous, previous = e.Current);
    }
    [Pure]
    static IEnumerable<T[]> Iterator<T>(IEnumerable<T> source, int size)
    {
        using var e = source.GetEnumerator();
        var window = new T[size];
        for (var i = 0; i < size; i++)
            if (e.MoveNext())
                window[i] = e.Current;
            else
                yield break;
        yield return (T[])window.Clone();
        while (e.MoveNext())
        {
            for (var i = 1; i < window.Length; i++)
                window[i - 1] = window[i];
            window[^1] = e.Current;
            yield return (T[])window.Clone();
        }
    }
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable once CheckNamespace
/// <summary>Provides extension methods for <see cref="char"/>.</summary>
    /// <inheritdoc cref="char.IsControl(char)"/>
    [Pure]
    public static bool IsControl(this char c) => char.IsControl(c);
    /// <inheritdoc cref="char.IsDigit(char)"/>
    [Pure]
    public static bool IsDigit(this char c) => char.IsDigit(c);
    /// <inheritdoc cref="char.IsHighSurrogate(char)"/>
    [Pure]
    public static bool IsHighSurrogate(this char c) => char.IsHighSurrogate(c);
    /// <inheritdoc cref="char.IsLetter(char)"/>
    [Pure]
    public static bool IsLetter(this char c) => char.IsLetter(c);
    /// <inheritdoc cref="char.IsLetterOrDigit(char)"/>
    [Pure]
    public static bool IsLetterOrDigit(this char c) => char.IsLetterOrDigit(c);
    /// <inheritdoc cref="char.IsLower(char)"/>
    [Pure]
    public static bool IsLower(this char c) => char.IsLower(c);
    /// <inheritdoc cref="char.IsLowSurrogate(char)"/>
    [Pure]
    public static bool IsLowSurrogate(this char c) => char.IsLowSurrogate(c);
    /// <inheritdoc cref="string.IsNullOrEmpty(string)"/>
    [Pure]
    public static bool IsNullOrEmpty([NotNullWhen(false)] this string? value) => string.IsNullOrEmpty(value);
#if NET35
    /// <summary>
    /// Indicates whether a specified string is <see langword="null"/>,
    /// empty, or consists only of white-space characters.
    /// </summary>
    /// <param name="value">The string to test.</param>
    /// <returns>
    /// <see langword="true"/> if the <paramref name="value"/> parameter is <see langword="null"/>,
    /// or <see cref="string.Empty"/>, or if <paramref name="value"/> consists exclusively of white-space characters.
    /// </returns>
    [Pure]
    public static bool IsNullOrWhitespace([NotNullWhen(false)] this string? value) =>
        value?.All(char.IsWhiteSpace) != false;
#elif !NET20 && !NET30
    /// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/>
    [Pure]
    public static bool IsNullOrWhitespace([NotNullWhen(false)] this string? value) => string.IsNullOrWhiteSpace(value);
#endif
    /// <inheritdoc cref="char.IsNumber(char)"/>
    [Pure]
    public static bool IsNumber(this char c) => char.IsNumber(c);
    /// <inheritdoc cref="char.IsPunctuation(char)"/>
    [Pure]
    public static bool IsPunctuation(this char c) => char.IsPunctuation(c);
    /// <inheritdoc cref="char.IsSeparator(char)"/>
    [Pure]
    public static bool IsSeparator(this char c) => char.IsSeparator(c);
    /// <inheritdoc cref="char.IsSurrogate(char)"/>
    [Pure]
    public static bool IsSurrogate(this char c) => char.IsSurrogate(c);
    /// <inheritdoc cref="char.IsSymbol(char)"/>
    [Pure]
    public static bool IsSymbol(this char c) => char.IsSymbol(c);
    /// <inheritdoc cref="char.IsUpper(char)"/>
    public static bool IsUpper(this char c) => char.IsUpper(c);
    /// <inheritdoc cref="char.IsWhiteSpace(char)"/>
    [Pure]
    public static bool IsWhitespace(this char c) => char.IsWhiteSpace(c);
    /// <summary>Converts the character to the byte-equivalent, 0-9.</summary>
    /// <param name="c">The character to convert.</param>
    /// <exception cref="ArgumentOutOfRangeException">
    /// The parameter <paramref name="c"/> isn't between '0' and '9', inclusively on both ends.
    /// </exception>
    /// <returns>The number 0-9 representing the character.</returns>
    [Pure]
    public static byte AsDigit(this char c) =>
        c is >= '0' and <= '9'
            ? (byte)(c - '0')
            : throw new ArgumentOutOfRangeException(nameof(c), c, "Character must be 0-9.");
    /// <summary>Attempts to convert the character to the byte-equivalent, 0-9.</summary>
    /// <param name="c">The character to convert.</param>
    /// <returns>The number 0-9 representing the character, or <see langword="null"/>.</returns>
    [Pure]
    public static byte? TryAsDigit(this char c) => c is >= '0' and <= '9' ? (byte)(c - '0') : null;
    /// <inheritdoc cref="char.ToLower(char)"/>
    [Pure]
    public static char ToLower(this char c) => char.ToLowerInvariant(c);
    /// <inheritdoc cref="char.ToUpper(char)"/>
    [Pure]
    public static char ToUpper(this char c) => char.ToUpperInvariant(c);
    /// <inheritdoc cref="char.GetNumericValue(char)"/>
    [Pure]
    public static double GetNumericValue(this char c) => char.GetNumericValue(c);
    /// <inheritdoc cref="string.Trim(char[])"/>
    [Pure]
    public static string Trim(this string s, string trim)
    {
        int start = 0, end = 1;
        for (; start < s.Length; start++)
            if (start >= trim.Length || s[start] != trim[start])
                break;
        for (; end <= s.Length; end++)
            if (end > trim.Length || s[^end] != trim[^end])
                return s[..^(end - 1)];
        return s[start..^end];
    }
    /// <inheritdoc cref="string.TrimEnd(char[])"/>
    [Pure]
    public static string TrimEnd(this string s, string trim)
    {
        for (var i = 1; i <= s.Length; i++)
            if (i > trim.Length || s[^i] != trim[^i])
                return s[..^(i - 1)];
        return "";
    }
    /// <inheritdoc cref="string.TrimStart(char[])"/>
    [Pure]
    public static string TrimStart(this string s, string trim)
    {
        for (var i = 0; i < s.Length; i++)
            if (i >= trim.Length || s[i] != trim[i])
                return s[i..];
        return "";
    }
#if NETFRAMEWORK || NETSTANDARD2_0_OR_GREATER || NETCOREAPP2_0_OR_GREATER
    /// <inheritdoc cref="char.GetUnicodeCategory(char)"/>
    [Pure]
    public static UnicodeCategory GetUnicodeCategory(this char c) => char.GetUnicodeCategory(c);
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable CheckNamespace RedundantNameQualifier
/// <summary>Implements a <see cref="GetOffsetAndLength"/> overload that doesn't rely on tuples.</summary>
    /// <summary>Calculate the start offset and length of range object using a collection length.</summary>
    /// <remarks><para>
    /// For performance reasons, we don't validate the input length parameter against negative values.
    /// It is expected Range will be used with collections which always have non negative length/count.
    /// We validate the range is inside the length scope though.
    /// </para></remarks>
    /// <param name="range">The <see cref="Range"/> that contains the range of elements.</param>
    /// <param name="length">
    /// The length of the collection that the range will be used with.
    /// <paramref name="length"/> has to be a positive value.
    /// </param>
    /// <param name="outOffset">The resulting offset.</param>
    /// <param name="outLength">The resulting length.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void GetOffsetAndLength(this Range range, int length, out int outOffset, out int outLength)
    {
        if (!TryGetOffsetAndLength(range, length, out outOffset, out outLength))
            throw new ArgumentOutOfRangeException(nameof(length));
    }
    /// <summary>Calculate the start offset and length of range object using a collection length.</summary>
    /// <param name="range">The <see cref="Range"/> that contains the range of elements.</param>
    /// <param name="length">
    /// The length of the collection that the range will be used with.
    /// <paramref name="length"/> has to be a positive value.
    /// </param>
    /// <param name="outOffset">The resulting offset.</param>
    /// <param name="outLength">The resulting length.</param>
    /// <returns>Whether the values are set.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool TryGetOffsetAndLength(this Range range, int length, out int outOffset, out int outLength)
    {
        var startIndex = range.Start;
        var start = startIndex.IsFromEnd ? length - startIndex.Value : startIndex.Value;
        var endIndex = range.End;
        var end = endIndex.IsFromEnd ? length - endIndex.Value : endIndex.Value;
        outOffset = start;
        outLength = end - start;
        return unchecked((uint)end <= (uint)length && (uint)start <= (uint)end);
    }
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable once CheckNamespace
/// <summary>Provides methods to convert <see cref="IEnumerator{T}"/> to <see cref="IEnumerable{T}"/>.</summary>
    /// <summary>Collects <see cref="IComparer"/> and <see cref="IEqualityComparer"/> instances.</summary>
    sealed class ComparerCollector : IComparer, IEqualityComparer
    {
        /// <summary>The most common usage is with tuples, in which the maximum capacity is 8.</summary>
        const int Capacity = 8;
        public List<object?> List { get; } = new(Capacity);
        /// <inheritdoc />
        bool IEqualityComparer.Equals(object? x, object? y) => Append(x, true);
        /// <inheritdoc />
        int IComparer.Compare(object? x, object? y) => Append(x, 0);
        /// <inheritdoc />
        int IEqualityComparer.GetHashCode(object? obj) => Append(obj, 0);
        T Append<T>(object? obj, T ret)
        {
            List.Add(obj);
            return ret;
        }
    }
    /// <summary>
    /// Wraps an <see cref="IEnumerator{T}"/> and exposes it from an <see cref="IEnumerable{T}"/> context.
    /// </summary>
    /// <param name="enumerator">The <see cref="IEnumerator{T}"/> to encapsulate.</param>
    /// <typeparam name="T">The type of item to enumerate.</typeparam>
    public sealed partial class Enumerable<T>([HandlesResourceDisposal, ProvidesContext] IEnumerator<T> enumerator)
        : IDisposable, IEnumerable<T>
    {
        /// <inheritdoc />
        [CollectionAccess(CollectionAccessType.None)]
        public void Dispose() => enumerator.Dispose();
        /// <inheritdoc />
        [CollectionAccess(CollectionAccessType.Read), Pure]
        public IEnumerator<T> GetEnumerator() => enumerator;
        /// <inheritdoc />
        [CollectionAccess(CollectionAccessType.Read), Pure]
        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
    }
    /// <summary>
    /// Wraps an <see cref="IEnumerator{T}"/> and exposes it from an <see cref="IEnumerable{T}"/> context.
    /// </summary>
    /// <param name="enumerator">The enumerator to encapsulate.</param>
    sealed partial class Enumerator([HandlesResourceDisposal, ProvidesContext] IEnumerator enumerator)
        : IEnumerator<object?>
    {
        /// <inheritdoc cref="IEnumerator{T}.Current" />
        [Pure]
        public object? Current => enumerator.Current;
        /// <inheritdoc />
        public void Dispose() => (enumerator as IDisposable)?.Dispose();
        /// <inheritdoc />
        public void Reset() => enumerator.Reset();
        /// <inheritdoc />
        public bool MoveNext() => enumerator.MoveNext();
    }
    /// <summary>Wraps the enumerator inside an <see cref="IEnumerable{T}"/>.</summary>
    /// <param name="enumerator">The enumerator to encapsulate.</param>
    /// <returns>
    /// The <see cref="IEnumerator{T}"/> instance that returns the parameter <paramref name="enumerator"/>.
    /// </returns>
    [MustDisposeResource, Pure]
    public static IEnumerator<object?> AsGeneric([HandlesResourceDisposal] this IEnumerator enumerator) =>
        new Enumerator(enumerator);
    /// <summary>Wraps the enumerator inside an <see cref="IEnumerable{T}"/>.</summary>
    /// <param name="enumerator">The enumerator to encapsulate.</param>
    /// <returns>The <see cref="IEnumerator{T}"/> instance that wraps <paramref name="enumerator"/>.</returns>
    [MustDisposeResource, Pure]
    public static IEnumerable<object?> AsEnumerable([HandlesResourceDisposal] this IEnumerator enumerator) =>
        AsEnumerable(AsGeneric(enumerator));
    /// <summary>Wraps the array inside an <see cref="IEnumerable{T}"/>.</summary>
    /// <param name="array">The array to encapsulate.</param>
    /// <returns>The <see cref="IEnumerator{T}"/> instance that wraps <paramref name="array"/>.</returns>
    [MustDisposeResource, Pure]
    public static IEnumerable<object?> AsGenericEnumerable(this Array array) => AsEnumerable(array.GetEnumerator());
    /// <summary>Wraps the <see cref="IEnumerator{T}"/> inside an <see cref="IEnumerable{T}"/>.</summary>
    /// <typeparam name="T">The type of item to enumerate.</typeparam>
    /// <param name="enumerator">The <see cref="IEnumerator{T}"/> to encapsulate.</param>
    /// <returns>The <see cref="IEnumerator{T}"/> instance that wraps <paramref name="enumerator"/>.</returns>
    [MustDisposeResource, Pure]
    public static Enumerable<T> AsEnumerable<T>([HandlesResourceDisposal] this IEnumerator<T> enumerator) =>
        new(enumerator);
#if !NET20 && !NET30 && !NET35
    /// <summary>Converts an <see cref="IStructuralComparable"/> to a <see cref="List{T}"/>.</summary>
    /// <param name="structure">The <see cref="IStructuralComparable"/> to convert.</param>
    /// <returns>The <see cref="List{T}"/> that contains elements from <paramref name="structure"/>.</returns>
    [Pure]
    public static List<object?> ToList(this IStructuralComparable structure)
    {
        ComparerCollector collector = new();
        _ = structure.CompareTo(structure, collector);
        return collector.List;
    }
    /// <summary>Converts an <see cref="IStructuralEquatable"/> to a <see cref="List{T}"/>.</summary>
    /// <param name="structure">The <see cref="IStructuralEquatable"/> to convert.</param>
    /// <returns>The <see cref="List{T}"/> that contains elements from <paramref name="structure"/>.</returns>
    [Pure]
    public static List<object?> ToList(this IStructuralEquatable structure)
    {
        ComparerCollector collector = new();
        _ = structure.Equals(structure, collector);
        return collector.List;
    }
#endif
// SPDX-License-Identifier: MPL-2.0
#if (NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) && !NO_SYSTEM_MEMORY
#pragma warning disable CS8500
// ReSharper disable BadPreprocessorIndent CheckNamespace StructCanBeMadeReadOnly
/// <inheritdoc cref="Bits{T}"/>
#if CSHARPREPL
public
#endif
#if !NO_READONLY_STRUCTS
readonly
#endif
    partial struct Bits<T>
{
    /// <summary>Determines whether the item has only a single bit.</summary>
    /// <param name="item">The element to test.</param>
    /// <returns>
    /// The value <see langword="true"/> if the parameter <paramref name="item"/>
    /// has a single bit set; otherwise, <see langword="false"/>.
    /// </returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public static bool IsSingle(scoped in T item) =>
#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_0_OR_GREATER
        0 switch
        {
            _ when typeof(T) == typeof(sbyte) => unchecked((uint)(sbyte)(object)item).IsPow2(),
            _ when typeof(T) == typeof(byte) => ((uint)(byte)(object)item).IsPow2(),
            _ when typeof(T) == typeof(short) => unchecked((uint)(short)(object)item).IsPow2(),
            _ when typeof(T) == typeof(ushort) => ((uint)(ushort)(object)item).IsPow2(),
            _ when typeof(T) == typeof(int) => unchecked((uint)(int)(object)item).IsPow2(),
            _ when typeof(T) == typeof(uint) => ((uint)(object)item).IsPow2(),
            _ when typeof(T) == typeof(long) => unchecked((ulong)(long)(object)item).IsPow2(),
            _ when typeof(T) == typeof(ulong) => ((ulong)(object)item).IsPow2(),
            _ when typeof(T) == typeof(nint) => ((nuint)(nint)(object)item).IsPow2(),
            _ when typeof(T) == typeof(nuint) => ((nuint)(object)item).IsPow2(),
            _ when !typeof(T).IsEnum => (Enumerator)item is var e && e.MoveNext() && !e.MoveNext(),
            _ => (typeof(T) == typeof(Enum) ? item.GetType() : typeof(T)).GetEnumUnderlyingType() switch
            {
                var x when x == typeof(sbyte) => unchecked((uint)(sbyte)(object)item).IsPow2(),
                var x when x == typeof(byte) => ((uint)(byte)(object)item).IsPow2(),
                var x when x == typeof(short) => unchecked((uint)(short)(object)item).IsPow2(),
                var x when x == typeof(ushort) => ((uint)(ushort)(object)item).IsPow2(),
                var x when x == typeof(int) => unchecked((uint)(int)(object)item).IsPow2(),
                var x when x == typeof(uint) => ((uint)(object)item).IsPow2(),
                var x when x == typeof(long) => unchecked((ulong)(long)(object)item).IsPow2(),
                var x when x == typeof(ulong) => ((ulong)(object)item).IsPow2(),
                var x when x == typeof(nint) => ((nuint)(nint)(object)item).IsPow2(),
                var x when x == typeof(nuint) => ((nuint)(object)item).IsPow2(),
                _ => (Enumerator)item is var e && e.MoveNext() && !e.MoveNext(),
            },
        };
#else
        (Enumerator)item is var e && e.MoveNext() && !e.MoveNext();
#endif
    /// <inheritdoc cref="ICollection{T}.Contains"/>
    [CollectionAccess(CollectionAccessType.Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public bool Contains(T item)
    {
        if (!IsSingle(item))
            return false;
        And(bits, ref item);
        return !Eq0(item);
    }
    /// <inheritdoc cref="ISet{T}.IsProperSubsetOf" />
    [CollectionAccess(CollectionAccessType.Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public bool IsProperSubsetOf([InstantHandle] IEnumerable<T> other)
    {
        T t = default;
        var collection = other.ToICollection();
        foreach (var next in this)
            if (collection.Contains(next))
                Or(next, ref t);
            else
                return false;
        foreach (var next in collection)
            if (!Contains(next))
                return true;
        return false;
    }
    /// <inheritdoc cref="ISet{T}.IsProperSupersetOf" />
    [CollectionAccess(CollectionAccessType.Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public bool IsProperSupersetOf([InstantHandle] IEnumerable<T> other)
    {
        T t = default;
        foreach (var next in other)
            if (Contains(next))
                Or(next, ref t);
            else
                return false;
        return !Eq(bits, t);
    }
    /// <inheritdoc cref="ISet{T}.IsSubsetOf" />
    [CollectionAccess(CollectionAccessType.Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public bool IsSubsetOf([InstantHandle] IEnumerable<T> other)
    {
        var collection = other.ToICollection();
        return this.All(collection.Contains);
    }
    /// <inheritdoc cref="ISet{T}.IsSupersetOf" />
    [CollectionAccess(CollectionAccessType.Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public bool IsSupersetOf([InstantHandle] IEnumerable<T> other) => other.All(Contains);
    /// <inheritdoc cref="ISet{T}.Overlaps" />
    [CollectionAccess(CollectionAccessType.Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public bool Overlaps([InstantHandle] IEnumerable<T> other) => other.Any(Contains);
    /// <inheritdoc cref="ISet{T}.SetEquals" />
    [CollectionAccess(CollectionAccessType.Read), MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public bool SetEquals([InstantHandle] IEnumerable<T> other)
    {
        T t = default;
        foreach (var next in other)
            if (IsSingle(next))
                Or(next, ref t);
            else
                return false;
        return Eq(bits, t);
    }
}
#endif
// SPDX-License-Identifier: MPL-2.0
#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
// ReSharper disable once CheckNamespace
/// <summary>Extension methods to generate random numbers.</summary>
    /// <summary>Generates a random value of type <typeparamref name="T"/>.</summary>
    /// <typeparam name="T">The type of the random value.</typeparam>
    /// <param name="random">The random number generator.</param>
    /// <returns>The random value.</returns>
    public static T Next<T>(this System.Random random)
        where T : unmanaged
    {
        T output = default;
        random.NextBytes(MemoryMarshal.Cast<T, byte>(Ref(ref output)));
        return output;
    }
#endif
// SPDX-License-Identifier: MPL-2.0
#if !NET20 && !NET30
// ReSharper disable once CheckNamespace
/// <summary>Provides methods to flatten <see cref="IEnumerable{T}"/> instances.</summary>
    /// <summary>Flattens the nested collection.</summary>
    /// <typeparam name="T">The type of collection.</typeparam>
    /// <param name="enumerable">The collection to flatten.</param>
    /// <returns>The flattened collection of the parameter <paramref name="enumerable"/>.</returns>
    [LinqTunnel, Pure]
    public static IEnumerable<T> Flatten<T>(this IEnumerable<IEnumerable<T>> enumerable) =>
        enumerable.SelectMany(Enumerable.AsEnumerable);
    /// <inheritdoc cref="Flatten{T}"/>
    [LinqTunnel, Pure]
    public static IEnumerable<T> Flatten2<T>(this IEnumerable<IEnumerable<IEnumerable<T>>> enumerable) =>
        enumerable.Flatten().Flatten();
    /// <inheritdoc cref="Flatten{T}"/>
    [LinqTunnel, Pure]
    public static IEnumerable<T> Flatten3<T>(this IEnumerable<IEnumerable<IEnumerable<IEnumerable<T>>>> enumerable) =>
        enumerable.Flatten2().Flatten();
    /// <inheritdoc cref="Flatten{T}"/>
    [LinqTunnel, Pure]
    public static IEnumerable<T> Flatten4<T>(
        this IEnumerable<IEnumerable<IEnumerable<IEnumerable<IEnumerable<T>>>>> enumerable
    ) =>
        enumerable.Flatten2().Flatten2();
    /// <summary>
    /// Flattens the nested collection by taking all the first elements of the enumerations,
    /// then all the second elements of the enumerations, the third, and so on.
    /// When any enumeration runs out, it simply moves onto the next enumeration until all enumerations are finished.
    /// </summary>
    /// <typeparam name="T">The type of collection.</typeparam>
    /// <param name="enumerable">The collection to flatten.</param>
    /// <returns>
    /// The flattened collection by taking items in order of appearance of each individual enumerable,
    /// and only then by the outer enumerable.
    /// </returns>
    [Pure]
    public static IEnumerable<List<T>> Transpose<T>(this IEnumerable<IEnumerable<T>> enumerable)
    {
        var (truthy, falsy) = enumerable
           .Select([MustDisposeResource](x) => x.GetEnumerator())
           .SplitBy(x => x.MoveNext());
        falsy.For(x => x.Dispose());
        try
        {
            while (truthy is not [])
            {
#if NETFRAMEWORK || NETSTANDARD2_0_OR_GREATER || NETCOREAPP2_0_OR_GREATER
                yield return truthy.ConvertAll(x => x.Current);
#else
                yield return new(truthy.Select(x => x.Current));
#endif
                (truthy, falsy) = truthy.SplitBy(x => x.MoveNext());
                falsy.For(x => x.Dispose());
            }
        }
        finally
        {
            truthy.For(x => x.Dispose());
        }
    }
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable once CheckNamespace
/// <summary>Methods for draining collections.</summary>
    /// <summary>
    /// Removes all items from <paramref name="source"/> that do not satisfy <paramref name="predicate"/>.
    /// </summary>
    /// <typeparam name="T">The type of items in the collection.</typeparam>
    /// <param name="source">The collection to drain.</param>
    /// <param name="predicate">The predicate to apply.</param>
    public static void Retain<T>(this IList<T> source, [InstantHandle] Predicate<T> predicate)
    {
        int count = source.Count, i = 0;
        while (i < count)
        {
            if (predicate(source[i]))
            {
                i++;
                continue;
            }
            source.RemoveAt(i);
            count--;
        }
    }
    /// <summary>Removes all elements that match the conditions defined by the specified predicate.</summary>
    /// <typeparam name="T">The type of element in the collection to filter.</typeparam>
    /// <param name="collection">The collection to filter.</param>
    /// <param name="match">
    /// The <see cref="Predicate{T}"/> delegate that defines the conditions of the elements to remove.
    /// </param>
    /// <returns>The number of elements that were removed from the parameter <paramref name="collection"/>.</returns>
    public static int RemoveWhere<T>(this ICollection<T> collection, Func<T, bool> match) =>
        RemoveWhere<T, ICollection<T>>(collection, match);
    /// <summary>Removes all elements that match the conditions defined by the specified predicate.</summary>
    /// <typeparam name="TElement">The type of element in the collection to filter.</typeparam>
    /// <typeparam name="TCollection">The type of collection to filter.</typeparam>
    /// <param name="collection">The collection to filter.</param>
    /// <param name="match">
    /// The <see cref="Predicate{T}"/> delegate that defines the conditions of the elements to remove.
    /// </param>
    /// <returns>The number of elements that were removed from the parameter <paramref name="collection"/>.</returns>
    public static int RemoveWhere<TElement, TCollection>(this TCollection collection, Func<TElement, bool> match)
        where TCollection : ICollection<TElement>
    {
        List<TElement> matches = [..collection.Where(match)];
        var removed = 0;
        for (var i = matches.Count - 1; i >= 0 && matches[i] is var current; i--)
            _ = collection.Remove(current) ? removed++ : 0;
        return removed;
    }
// SPDX-License-Identifier: MPL-2.0
#if NETFRAMEWORK || NETSTANDARD2_0_OR_GREATER || NETCOREAPP2_0_OR_GREATER
// ReSharper disable CheckNamespace RedundantNameQualifier UseSymbolAlias
#if ROSLYN || NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
#else
#endif
/// <summary>Provides methods to convert instances to a <see cref="string"/>.</summary>
    const RegexOptions Options = RegexOptions.Multiline | RegexOptions.Compiled;
#if NET8_0_OR_GREATER
    static readonly OnceMemoryManager<SearchValues<char>> s_slashes = new(SearchValues.Create(@"/\"));
#endif
#pragma warning disable MA0110, SYSLIB1045
    static readonly Regex
        s_angles = new("<(?>(?:<(?<A>)|>(?<-A>)|[^<>]+){2,})>", Options),
        s_curlies = new("{(?>(?:{(?<A>)|}(?<-A>)|[^{}]+){2,})}", Options),
        s_singleQuotes = new(@"'(?>(?:{(?<A>)|}(?<-A>)|[^""]+){2,})'", Options),
        s_doubleQuotes = new(@"""(?>(?:{(?<A>)|}(?<-A>)|[^""]+){2,})""", Options),
        s_brackets = new(@"\[(?>(?:\[(?<A>)|\](?<-A>)|[^\[\]]+){2,})\]", Options),
        s_parentheses = new(@"\((?>(?:\((?<A>)|\)(?<-A>)|[^()]+){2,})\)", Options);
#pragma warning restore MA0110, SYSLIB1045
    /// <summary>Creates the collapsed form of the string.</summary>
    /// <param name="s">The string to collapse.</param>
    /// <returns>The collapsed string.</returns>
    public static string Collapse(this string s)
    {
        s = s_parentheses.Replace(s, "(…)");
        s = s_brackets.Replace(s, "[…]");
        s = s_curlies.Replace(s, "{…}");
        s = s_angles.Replace(s, "<…>");
        s = s_singleQuotes.Replace(s, "'…'");
        return s_doubleQuotes.Replace(s, "\"…\"");
    }
    /// <summary>Collapses the <see cref="string"/> to a single line.</summary>
    /// <param name="expression">The <see cref="string"/> to collapse.</param>
    /// <param name="prefix">The prefix to use.</param>
    /// <returns>The collapsed <see cref="string"/>.</returns>
    [Pure]
    [return: NotNullIfNotNull(nameof(expression))]
    public static string? CollapseToSingleLine(this string? expression, string? prefix = null)
    {
        static unsafe StringBuilder Accumulator(StringBuilder accumulator, scoped ReadOnlySpan<char> next)
#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
            =>
                accumulator.Append(next.Trim());
#else
        {
            var trimmed = next.Trim();
#if (NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) && !NO_SYSTEM_MEMORY
            fixed (char* ptr = trimmed)
                accumulator.Append(trimmed.Align(ptr), trimmed.Length);
#else
            foreach (var t in trimmed)
                accumulator.Append(t);
#endif
            return accumulator;
        }
#endif
        return expression?.Collapse().SplitSpanLines().Aggregate(prefix.ToBuilder(), Accumulator).Trim().ToString();
    }
    /// <summary>Converts a number to an ordinal.</summary>
    /// <param name="i">The number to convert.</param>
    /// <param name="one">The string for the value 1 or -1.</param>
    /// <param name="many">The string to concatenate. Use prefixed dashes to trim <paramref name="one"/>.</param>
    /// <returns>The conjugation of all the parameters.</returns>
    [Pure]
    public static string Conjugate(this int i, string one, string many = "s") =>
        i is not 1 and not -1 &&
#if NET7_0_OR_GREATER
        (many.AsSpan().IndexOfAnyExcept('-') is not -1 and var found ? found : 0)
#else
        System.Math.Min(many.TakeWhile(x => x is '-').Count(), one.Length)
#endif
        is var trim
            ? $"{i} {one[..^trim]}{many[trim..]}"
            : $"{i} {one}";
#if NET7_0_OR_GREATER
    /// <inheritdoc cref="Conjugate(int, string, string)"/>
    [Pure]
    public static string Conjugate<T>(this T i, string one, string many = "s")
        where T : INumberBase<T>, IComparisonOperators<T, T, bool> =>
        (T.IsZero(i) || T.Abs(i) > T.One) && (many.AsSpan().IndexOfAnyExcept('-') is not -1 and var f ? f : 0) is var tr
            ? $"{i} {one[..^tr]}{many[tr..]}"
            : $"{i} {one}";
#endif
    /// <summary>Extracts the file name from the path.</summary>
    /// <remarks><para>
    /// The return type depends on what framework is used. Ensure that the caller doesn't care about the return type.
    /// </para></remarks>
    /// <param name="path">The path to extract the file name from.</param>
    /// <returns>The file name.</returns>
    [Pure]
#if !ROSLYN && !NETSTANDARD2_1_OR_GREATER && !NETCOREAPP2_1_OR_GREATER
    [return: NotNullIfNotNull(nameof(path))]
#endif
    public static Substring FileName(this string? path) =>
        path is null
#if NET8_0_OR_GREATER
            ? default
            : path.SplitOn(s_slashes).Last.Trim();
#elif ROSLYN || NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
            ? default
            : path.SplitOnAny(@"/\".AsMemory()).Last.Trim();
#else
            ? ""
            : Path.GetFileName(path).Trim() ?? "";
#endif
    /// <summary>Creates the prettified form of the string.</summary>
    /// <param name="s">The string to prettify.</param>
    /// <returns>The prettified string.</returns>
    public static string Prettify(this string s) => Prettify(s, separator: ",;");
    /// <summary>Creates the prettified form of the string.</summary>
    /// <remarks><para>
    /// The functionality is based on
    /// <a href="https://gist.github.com/kodo-pp/89cefb17a8772cd9fd7b875d94fd29c7">this gist by kodo-pp</a>.
    /// </para></remarks>
    /// <param name="s">The string to prettify.</param>
    /// <param name="start">The characters considered to be starting blocks.</param>
    /// <param name="end">The characters considered to be ending blocks.</param>
    /// <param name="separator">The characters considered to be separators.</param>
    /// <param name="indent">The amount of spaces for indentation.</param>
    /// <returns>The prettified string.</returns>
    public static string Prettify(
        this string s,
        string start = "([{<",
        string end = ")]}>",
        string separator = ",;",
        string indent = "    "
    )
    {
        var seen = false;
        var nest = 0;
        StringBuilder sb = new();
        for (var i = 0; i < s.Length; i++)
            (seen, nest, sb) = s[i] switch
            {
                not ' ' when seen && sb.Indent(indent, nest) is var _ && (seen = false) => throw Unreachable,
                _ when start.Contains(s[i]) && (s.Nth(i + 1) is not { } next || !end.Contains(next)) =>
                    (seen, ++nest, sb.Append(s[i]).Indent(indent, nest)),
                _ when end.Contains(s[i]) && (s.Nth(i - 1) is not { } prev || !start.Contains(prev)) =>
                    (seen, --nest, sb.Indent(indent, nest).Append(s[i])),
                _ when separator.Contains(s[i]) => (true, nest, sb.Append(s[i])),
                ' ' when seen && nest > 0 ||
                    s.Nth(i - 1) is { } prev && start.Contains(prev) ||
                    s.Nth(i + 1) is { } next && end.Contains(next) => (seen, nest, sb),
                _ => (seen, nest, sb.Append(s[i])),
            };
        return $"{sb}";
    }
#if NET40_OR_GREATER || NETSTANDARD || NETCOREAPP
    /// <summary>Concatenates an enumeration of <see cref="char"/> into a <see cref="string"/>.</summary>
    /// <remarks><para>
    /// This method is more efficient than using <see cref="Conjoin{T}(IEnumerable{T}, string)"/>
    /// for <see cref="char"/> enumerations.
    /// </para></remarks>
    /// <param name="chars">The enumeration of characters.</param>
    /// <returns>A <see cref="string"/> built from concatenating <paramref name="chars"/>.</returns>
    [Pure]
    public static string Concat([InstantHandle] this IEnumerable<char> chars) => string.Concat(chars);
    /// <summary>Concatenates an enumeration of <see cref="string"/> into a <see cref="string"/>.</summary>
    /// <remarks><para>
    /// This method is more efficient than using <see cref="Conjoin{T}(IEnumerable{T}, string)"/> for empty separators.
    /// </para></remarks>
    /// <param name="strings">The enumeration of strings.</param>
    /// <returns>A <see cref="string"/> built from concatenating <paramref name="strings"/>.</returns>
    [Pure]
    public static string Concat([InstantHandle] this IEnumerable<string> strings) => string.Concat(strings);
#endif
    /// <summary>Joins a set of values into one long <see cref="string"/>.</summary>
    /// <remarks><para>
    /// This method is more efficient than using
    /// <see cref="Conjoin{T}(IEnumerable{T}, string)"/> for <see cref="char"/> separators.
    /// </para></remarks>
    /// <typeparam name="T">The type of each item in the collection.</typeparam>
    /// <param name="values">The values to join.</param>
    /// <param name="separator">The separator between each item.</param>
    /// <returns>One long <see cref="string"/>.</returns>
    [Pure]
    public static string Conjoin<T>([InstantHandle] this IEnumerable<T> values, char separator) =>
        $"{new StringBuilder().AppendMany(values, separator)}";
    /// <summary>Joins a set of values into one long <see cref="string"/>.</summary>
    /// <typeparam name="T">The type of each item in the collection.</typeparam>
    /// <param name="values">The values to join.</param>
    /// <param name="separator">The separator between each item.</param>
    /// <returns>One long <see cref="string"/>.</returns>
    [Pure]
    public static string Conjoin<T>([InstantHandle] this IEnumerable<T> values, string separator = ", ") =>
        $"{new StringBuilder().AppendMany(values, separator)}";
    /// <summary>Converts the <see cref="Stopwatch"/> to its concise <see cref="string"/> representation.</summary>
    /// <param name="stopwatch">The <see cref="Stopwatch"/> to convert.</param>
    /// <returns>The <see cref="string"/> representation of <paramref name="stopwatch"/>.</returns>
    [Pure]
    public static string ToConciseString(this Stopwatch? stopwatch) =>
        stopwatch is null ? "0" : ToConciseString(stopwatch.Elapsed);
    /// <summary>Converts the <see cref="TimeSpan"/> to its concise <see cref="string"/> representation.</summary>
    /// <param name="time">The <see cref="TimeSpan"/> to convert.</param>
    /// <returns>The <see cref="string"/> representation of <paramref name="time"/>.</returns>
    [Pure]
    public static string ToConciseString(this TimeSpan time)
    {
        var sign = time.Ticks < 0 ? "-" : "";
        var ticks = System.Math.Abs(time.Ticks);
        return ticks switch
        {
            0 => "0",
            >= TimeSpan.TicksPerDay * 7 => $"{sign}{ticks / TimeSpan.TicksPerDay}d",
            >= TimeSpan.TicksPerDay => $"{sign}{ticks / TimeSpan.TicksPerDay
            }d{ticks % TimeSpan.TicksPerDay / TimeSpan.TicksPerHour
            }h",
            >= TimeSpan.TicksPerHour => $"{sign}{ticks / TimeSpan.TicksPerHour
            }h{ticks % TimeSpan.TicksPerHour / TimeSpan.TicksPerMinute
            }m{ticks % TimeSpan.TicksPerMinute / TimeSpan.TicksPerSecond}s",
            >= TimeSpan.TicksPerMinute => $"{sign}{ticks / TimeSpan.TicksPerMinute
            }m{ticks % TimeSpan.TicksPerMinute / TimeSpan.TicksPerSecond}s",
            >= TimeSpan.TicksPerSecond => $"{sign}{System.Math.Round(ticks / (double)TimeSpan.TicksPerSecond, 1)}s",
            >= TimeSpan.TicksPerMillisecond =>
                $"{sign}{System.Math.Round(ticks / (double)TimeSpan.TicksPerMillisecond, 1)}ms",
            _ => $"{sign}{ticks / 10.0}µs",
        };
    }
    /// <summary>Converts the <see cref="Version"/> to its concise <see cref="string"/> representation.</summary>
    /// <param name="version">The <see cref="Version"/> to convert.</param>
    /// <returns>The <see cref="string"/> representation of <paramref name="version"/>.</returns>
    public static string ToConciseString(this Version version) =>
        version switch
        {
            { Minor: <= 0, Build: <= 0, Revision: <= 0 } => $"v{version.Major}",
            { Build: <= 0, Revision: <= 0 } => $"v{version.Major}.{version.Minor}",
            { Revision: <= 0 } => $"v{version.Major}.{version.Minor}.{version.Build}",
            _ => $"v{version.Major}.{version.Minor}.{version.Build}.{version.Revision}",
        };
#if !(NET45_OR_GREATER || NETSTANDARD1_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER) || NO_SYSTEM_MEMORY
    /// <summary>Converts the value to a hex <see cref="string"/>.</summary>
    /// <remarks><para>The implementation is based on
    /// <a href="https://github.com/CommunityToolkit/dotnet/blob/7b53ae23dfc6a7fb12d0fc058b89b6e948f48448/src/CommunityToolkit.Diagnostics/Extensions/ValueTypeExtensions.cs#L44">
    /// CommunityToolkit.Diagnostics.ValueTypeExtensions.ToHexString
    /// </a>.
    /// </para></remarks>
    /// <typeparam name="T">The type of the value.</typeparam>
    /// <param name="value">The value to convert.</param>
    /// <returns>The hex <see cref="string"/>.</returns>
    [Pure]
    public static unsafe string ToHexString<T>(this T value)
#if KTANE
        where T : struct
#else
        where T : unmanaged
#endif
#pragma warning disable CS8500
    {
        var p = stackalloc char[Unsafe.SizeOf<T>() * 2 + 2];
        p[0] = '0';
        p[1] = 'x';
        fixed (char* rh = "0123456789ABCDEF")
            for (int i = 0, j = Unsafe.SizeOf<T>() * 2; i < Unsafe.SizeOf<T>(); i++, j -= 2)
            {
                var b = ((byte*)&value)[i];
                var low = b & 0x0f;
                var high = (b & 0xf0) >> 4;
                p[j + 1] = *(rh + low);
                p[j] = *(rh + high);
            }
        return new(p, 0, Unsafe.SizeOf<T>() * 2 + 2);
    }
#pragma warning restore CS8500
#endif
#if NET6_0_OR_GREATER
    /// <summary>Appends an enumeration onto the <see cref="DefaultInterpolatedStringHandler"/>.</summary>
    /// <typeparam name="T">The type of each item in the collection.</typeparam>
    /// <param name="dish">
    /// The <see cref="DefaultInterpolatedStringHandler"/> to mutate and <see langword="return"/>.
    /// </param>
    /// <param name="values">The values to join.</param>
    /// <param name="separator">The separator between each item.</param>
    /// <returns>The parameter <paramref name="dish"/>.</returns>
    public static DefaultInterpolatedStringHandler AppendMany<T>(
        this ref DefaultInterpolatedStringHandler dish,
        [InstantHandle] IEnumerable<T> values,
        char separator
    )
    {
        using var enumerator = values.GetEnumerator();
        if (enumerator.MoveNext())
            dish.AppendFormatted(enumerator.Current);
        else
            return dish;
        while (enumerator.MoveNext())
        {
            dish.AppendFormatted(separator);
            dish.AppendFormatted(enumerator.Current);
        }
        return dish;
    }
    /// <summary>Appends an enumeration onto the <see cref="DefaultInterpolatedStringHandler"/>.</summary>
    /// <typeparam name="T">The type of each item in the collection.</typeparam>
    /// <param name="dish">
    /// The <see cref="DefaultInterpolatedStringHandler"/> to mutate and <see langword="return"/>.
    /// </param>
    /// <param name="values">The values to join.</param>
    /// <param name="separator">The separator between each item.</param>
    /// <returns>The parameter <paramref name="dish"/>.</returns>
    public static DefaultInterpolatedStringHandler AppendMany<T>(
        this ref DefaultInterpolatedStringHandler dish,
        [InstantHandle] IEnumerable<T> values,
        string separator = ", "
    )
    {
        if (separator is "")
            switch (values)
            {
                case char[] x:
                    dish.AppendFormatted(x);
                    return dish;
                case string x:
                    dish.AppendFormatted(x);
                    return dish;
            }
        using var enumerator = values.GetEnumerator();
        if (enumerator.MoveNext())
            dish.AppendFormatted(enumerator.Current);
        else
            return dish;
        while (enumerator.MoveNext())
        {
            dish.AppendLiteral(separator);
            dish.AppendFormatted(enumerator.Current);
        }
        return dish;
    }
#endif
    /// <summary>Appends an enumeration onto the <see cref="StringBuilder"/>.</summary>
    /// <typeparam name="T">The type of each item in the collection.</typeparam>
    /// <param name="builder">The <see cref="StringBuilder"/> to mutate and <see langword="return"/>.</param>
    /// <param name="values">The values to join.</param>
    /// <param name="separator">The separator between each item.</param>
    /// <returns>The parameter <paramref name="builder"/>.</returns>
    public static StringBuilder AppendMany<T>(
        this StringBuilder builder,
        [InstantHandle] IEnumerable<T> values,
        char separator
    )
    {
        using var enumerator = values.GetEnumerator();
        if (enumerator.MoveNext())
            builder.Append(enumerator.Current);
        else
            return builder;
        while (enumerator.MoveNext())
            builder.Append(separator).Append(enumerator.Current);
        return builder;
    }
    /// <summary>Appends an enumeration onto the <see cref="StringBuilder"/>.</summary>
    /// <typeparam name="T">The type of each item in the collection.</typeparam>
    /// <param name="builder">The <see cref="StringBuilder"/> to mutate and <see langword="return"/>.</param>
    /// <param name="values">The values to join.</param>
    /// <param name="separator">The separator between each item.</param>
    /// <returns>The parameter <paramref name="builder"/>.</returns>
    public static StringBuilder AppendMany<T>(
        this StringBuilder builder,
        [InstantHandle] IEnumerable<T> values,
        string separator = ", "
    )
    {
        if (separator is "")
            switch (values)
            {
                case char[] x: return builder.Append(x);
                case string x: return builder.Append(x);
            }
        using var enumerator = values.GetEnumerator();
        if (enumerator.MoveNext())
            builder.Append(enumerator.Current);
        else
            return builder;
        while (enumerator.MoveNext())
            builder.Append(separator).Append(enumerator.Current);
        return builder;
    }
    [MustUseReturnValue]
    static StringBuilder Indent(this StringBuilder sb, string indent, int nest)
    {
        sb.AppendLine();
        for (var i = 0; i < nest && nest >= 0; i++)
            sb.Append(indent);
        return sb;
    }
#endif
// SPDX-License-Identifier: MPL-2.0
// ReSharper disable BadPreprocessorIndent CheckNamespace ConvertToAutoPropertyWhenPossible InvertIf RedundantNameQualifier RedundantReadonlyModifier RedundantUsingDirective StructCanBeMadeReadOnly UseSymbolAlias
#pragma warning disable CS8631, IDE0032
/// <inheritdoc cref="SplitSpan{TBody, TSeparator, TStrategy}"/>
public partial struct SplitSpan<TBody, TSeparator, TStrategy>
{
    /// <inheritdoc cref="IEnumerable{T}.GetEnumerator"/>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly Enumerator GetEnumerator() => new(this);
    /// <summary>Returns itself but with the number of elements specified skipped. This is evaluated eagerly.</summary>
    /// <param name="count">The number of elements to skip.</param>
    /// <returns>Itself but skipping the parameter <paramref name="count"/> number of elements.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
    public readonly SplitSpan<TBody, TSeparator, TStrategy> Skipped([NonNegativeValue] int count)
    {
        Enumerator e = this;
        for (; count > 0 && e.MoveNext(); count--) { }
        return e.SplitSpan;
    }
    /// <summary>
    /// Represents the forwards enumeration object that views <see cref="SplitSpan{T, TSeparator, TStrategy}"/>.
    /// </summary>
    [StructLayout(LayoutKind.Auto)]
    [method: MethodImpl(MethodImplOptions.AggressiveInlining)]
    public
#if !NO_REF_STRUCTS
        ref
#endif
        partial struct Enumerator(ReadOnlySpan<TBody> body, ReadOnlySpan<TSeparator> separator)
    {
        readonly ReadOnlySpan<TSeparator> _separator = separator;
        ReadOnlySpan<TBody> _body = body, _current;
        /// <summary>Initializes a new instance of the <see cref="Enumerator"/> struct.</summary>
        /// <param name="body">The body.</param>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public Enumerator(ReadOnlySpan<TBody> body)
            : this(body, default) { }
        /// <summary>Initializes a new instance of the <see cref="Enumerator"/> struct.</summary>
        /// <param name="split">The enumerable to enumerate.</param>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public Enumerator(SplitSpan<TBody, TSeparator, TStrategy> split)
            : this(split._body, split._separator) { }
        /// <inheritdoc cref="SplitSpan{T, TSeparator, TStrategy}.Body"/>
        public readonly ReadOnlySpan<TBody> Body
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => _body;
            [MethodImpl(MethodImplOptions.AggressiveInlining)] init => _body = value;
        }
        /// <inheritdoc cref="IEnumerator{T}.Current"/>
        public readonly ReadOnlySpan<TBody> Current
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => _current;
        }
        /// <inheritdoc cref="SplitSpan{T, TSeparator, TStrategy}.Separator"/>
        public readonly ReadOnlySpan<TSeparator> Separator
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure] get => _separator;
            [MethodImpl(MethodImplOptions.AggressiveInlining)] init => _separator = value;
        }
        /// <summary>
        /// Reconstructs the <see cref="SplitSpan{TBody, TSeparator, TStrategy}"/> based on the current state.
        /// </summary>
        public readonly SplitSpan<TBody, TSeparator, TStrategy> SplitSpan
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
            get => new(_body, _separator);
        }
        /// <summary>
        /// Explicitly converts the parameter by creating the new instance
        /// of <see cref="Enumerator"/> by using the constructor
        /// <see cref="SplitSpan{TBody, TSeparator, TStrategy}.Enumerator(ReadOnlySpan{TBody})"/>.
        /// </summary>
        /// <param name="body">The parameter to pass onto the constructor.</param>
        /// <returns>
        /// The new instance of <see cref="Enumerator"/> by passing
        /// the parameter <paramref name="body"/> to the constructor
        /// <see cref="SplitSpan{TBody, TSeparator, TStrategy}.Enumerator(ReadOnlySpan{TBody})"/>.
        /// </returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        public static explicit operator SplitSpan<TBody, TSeparator, TStrategy>.Enumerator(ReadOnlySpan<TBody> body) =>
            new(body);
        /// <summary>
        /// Implicitly converts the parameter by creating the new instance
        /// of <see cref="Enumerator"/> by using the constructor
        /// <see cref="SplitSpan{TBody, TSeparator, TStrategy}.Enumerator(SplitSpan{TBody, TSeparator, TStrategy})"/>.
        /// </summary>
        /// <param name="split">The parameter to pass onto the constructor.</param>
        /// <returns>
        /// The new instance of <see cref="Enumerator"/> by passing
        /// the parameter <paramref name="split"/> to the constructor
        /// <see cref="SplitSpan{TBody, TSeparator, TStrategy}.Enumerator(SplitSpan{TBody, TSeparator, TStrategy})"/>.
        /// </returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining), Pure]
        public static implicit operator SplitSpan<TBody, TSeparator, TStrategy>
            .Enumerator(SplitSpan<TBody, TSeparator, TStrategy> split) =>
            new(split);
        /// <summary>Performs one step of an enumeration over the provided spans.</summary>
        /// <param name="sep">The separator span.</param>
        /// <param name="body">The span that contains the current state of the enumeration.</param>
        /// <param name="current">The current span.</param>
        /// <returns>
        /// <see langword="true"/> if a step was performed successfully;
        /// <see langword="false"/> if the end of the collection is reached.
        /// </returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool Move(
            scoped ReadOnlySpan<TSeparator> sep,
            scoped ref ReadOnlySpan<TBody> body,
            out ReadOnlySpan<TBody> current
        ) =>
            0 switch
            {
                _ when body.IsEmpty && (current = default) is var _ => false,
                _ when sep.IsEmpty => (current = body) is var _ && (body = default) is var _,
                _ when typeof(TStrategy) == typeof(MatchAll) => MoveNextAll(To<TBody>.From(sep), ref body, out current),
#if NET8_0_OR_GREATER
                _ when typeof(TStrategy) == typeof(MatchAny) && typeof(TSeparator) == typeof(SearchValues<TBody>) =>
                    MoveNextAny(To<SearchValues<TBody>>.From(sep), ref body, out current),
#endif
                _ when typeof(TStrategy) == typeof(MatchAny) => MoveNextAny(To<TBody>.From(sep), ref body, out current),
                _ when typeof(TStrategy) == typeof(MatchOne) => MoveNextOne(To<TBody>.From(sep), ref body, out current),
                _ => throw Error,
            };
        /// <inheritdoc cref="System.Collections.IEnumerator.MoveNext"/>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public bool MoveNext() => Move(_separator, ref _body, out _current);
        /// <summary>
        /// Checks if two sequences of type <see name="TBody"/> are equal while iterating through the next element.
        /// </summary>
        /// <typeparam name="TOtherSeparator">The type of separator used in the other sequence.</typeparam>
        /// <typeparam name="TOtherStrategy">The strategy used for splitting the other sequence.</typeparam>
        /// <param name="other">The enumerator for the other sequence.</param>
        /// <param name="reader">The <see cref="ReadOnlySpan{T}"/> representing this sequence.</param>
        /// <param name="otherReader">The <see cref="ReadOnlySpan{T}"/> representing the other sequence.</param>
        /// <param name="ret">
        /// Output parameter indicating if the sequences are equal.
        /// Note that this value is undefined if <see langword="false"/> is returned.
        /// </param>
        /// <returns>
        /// The value <see langword="true"/> if enumeration should be stopped; otherwise, <see langword="false"/>.
        /// </returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public bool EqualityMoveNext<TOtherSeparator, TOtherStrategy>(
            scoped ref SplitSpan<TBody, TOtherSeparator, TOtherStrategy>.Enumerator other,
            scoped ref ReadOnlySpan<TBody> reader,
            scoped ref ReadOnlySpan<TBody> otherReader,
            out bool ret
        )
#if !NET7_0_OR_GREATER
            where TOtherSeparator : IEquatable<TOtherSeparator>?
#endif
        {
            if (reader.Length is var length && otherReader.Length is var otherLength && length == otherLength)
                return SameLength(ref other, ref reader, ref otherReader, out ret);
            if (length < otherLength)
            {
                if (!reader.SequenceEqual(otherReader.UnsafelyTake(length)) || !MoveNext())
                {
                    ret = false;
                    return true;
                }
                reader = Current;
                otherReader = otherReader.UnsafelySkip(length);
                Unsafe.SkipInit(out ret);
                return false;
            }
            if (!reader.UnsafelyTake(otherLength).SequenceEqual(otherReader) || !other.MoveNext())
            {
                ret = false;
                return true;
            }
            reader = reader.UnsafelySkip(otherLength);
            otherReader = other.Current;
            Unsafe.SkipInit(out ret);
            return false;
        }
#if NET6_0_OR_GREATER
        /// <summary>
        /// Checks if two sequences of type <see name="TBody"/> are equal while iterating through the next element.
        /// </summary>
        /// <typeparam name="TOtherSeparator">The type of separator used in the other sequence.</typeparam>
        /// <typeparam name="TOtherStrategy">The strategy used for splitting the other sequence.</typeparam>
        /// <param name="other">The enumerator for the other sequence.</param>
        /// <param name="reader">The <see cref="ReadOnlySpan{T}"/> representing this sequence.</param>
        /// <param name="otherReader">The <see cref="ReadOnlySpan{T}"/> representing the other sequence.</param>
        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> to use.</param>
        /// <param name="ret">
        /// Output parameter indicating if the sequences are equal.
        /// Note that this value is undefined if <see langword="false"/> is returned.
        /// </param>
        /// <returns>
        /// The value <see langword="true"/> if enumeration should be stopped; otherwise, <see langword="false"/>.
        /// </returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public bool EqualityMoveNext<TOtherSeparator, TOtherStrategy>(
            scoped ref SplitSpan<TBody, TOtherSeparator, TOtherStrategy>.Enumerator other,
            scoped ref ReadOnlySpan<TBody> reader,
            scoped ref ReadOnlySpan<TBody> otherReader,
            IEqualityComparer<TBody> comparer,
            out bool ret
        )
#if !NET7_0_OR_GREATER
            where TOtherSeparator : IEquatable<TOtherSeparator>?
#endif
        {
            if (reader.Length is var length && otherReader.Length is var otherLength && length == otherLength)
                return SameLength(ref other, ref reader, ref otherReader, comparer, out ret);
            if (length < otherLength)
            {
                if (!reader.SequenceEqual(otherReader.UnsafelyTake(length), comparer) || !MoveNext())
                {
                    ret = false;
                    return true;
                }
                reader = Current;
                otherReader = otherReader.UnsafelySkip(length);
                Unsafe.SkipInit(out ret);
                return false;
            }
            if (!reader.UnsafelyTake(otherLength).SequenceEqual(otherReader, comparer) || !other.MoveNext())
            {
                ret = false;
                return true;
            }
            reader = reader.UnsafelySkip(otherLength);
            otherReader = other.Current;
            Unsafe.SkipInit(out ret);
            return false;
        }
#endif
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        static bool MoveNextAll(
            scoped ReadOnlySpan<TBody> sep,
            scoped ref ReadOnlySpan<TBody> body,
            out ReadOnlySpan<TBody> current
        )
        {
            System.Diagnostics.Debug.Assert(typeof(TStrategy) == typeof(MatchAll), "TStrategy is MatchAll");
            System.Diagnostics.Debug.Assert(!sep.IsEmpty, "separator is non-empty");
        Retry:
            switch (body.IndexOf(sep))
            {
                case -1:
                    current = body;
                    body = default;
                    return true;
                case 0:
                    if (body.Length != sep.Length)
                    {
                        body = body.UnsafelySkip(sep.Length);
                        goto Retry;
                    }
                    current = default;
                    return false;
                case var i:
                    current = body.UnsafelyTake(i);
                    body = body.UnsafelySkip(i + sep.Length);
                    return true;
            }
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        static bool MoveNextAny(
            scoped ReadOnlySpan<TBody> sep,
            scoped ref ReadOnlySpan<TBody> body,
            out ReadOnlySpan<TBody> current
        )
        {
            System.Diagnostics.Debug.Assert(typeof(TStrategy) == typeof(MatchAny), "TStrategy is MatchAny");
            System.Diagnostics.Debug.Assert(!sep.IsEmpty, "separator is non-empty");
#if NET7_0_OR_GREATER
            switch (body.IndexOfAnyExcept(sep))
            {
                case -1:
                    current = default;
                    return false;
                case 0: break;
                case var i:
                    body = body.UnsafelySkip(i);
                    break;
            }
            if (body.IndexOfAny(sep) is not -1 and var length)
            {
                current = body.UnsafelyTake(length);
                body = body.UnsafelySkip(length + 1);
                return true;
            }
            current = body;
            body = default;
#else
        Retry:
            var min = int.MaxValue;
            foreach (var next in sep)
                switch (body.IndexOf(next))
                {
                    case -1: continue;
                    case 0:
                        if (body.Length is not 1)
                        {
                            body = body.UnsafelySkip(1);
                            goto Retry;
                        }
                        current = default;
                        return false;
                    case var i when i < min:
                        min = i;
                        continue;
                }
            if (min is not int.MaxValue)
            {
                current = body.UnsafelyTake(min);
                body = body.UnsafelySkip(min + 1);
                return true;
            }
            current = body;
            body = default;
#endif
            return true;
        }
#if NET8_0_OR_GREATER
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        static bool MoveNextAny(
            scoped ReadOnlySpan<SearchValues<TBody>> sep,
            scoped ref ReadOnlySpan<TBody> body,
            out ReadOnlySpan<TBody> current
        )
        {
            System.Diagnostics.Debug.Assert(typeof(TStrategy) == typeof(MatchAny), "TStrategy is MatchAny");
            System.Diagnostics.Debug.Assert(!sep.IsEmpty, "separator is non-empty");
            var single = sep.UnsafelyIndex(0);
            switch (body.IndexOfAnyExcept(single))
            {
                case -1:
                    current = default;
                    return false;
                case 0: break;
                case var offset:
                    body = body.UnsafelySkip(offset);
                    break;
            }
            if (body.IndexOfAny(single) is not -1 and var length)
            {
                current = body.UnsafelyTake(length);
                body = body.UnsafelySkip(length + 1);
                return true;
            }
            current = body;
            body = default;
            return true;
        }
#endif
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        static bool MoveNextOne(
            scoped ReadOnlySpan<TBody> sep,
            scoped ref ReadOnlySpan<TBody> body,
            out ReadOnlySpan<TBody> current
        )
        {
            System.Diagnostics.Debug.Assert(typeof(TStrategy) == typeof(MatchOne), "TStrategy is MatchOne");
            System.Diagnostics.Debug.Assert(!sep.IsEmpty, "separator is non-empty");
            var single = sep.UnsafelyIndex(0);
#if NET7_0_OR_GREATER
            switch (body.IndexOfAnyExcept(single))
            {
                case -1:
                    current = default;
                    return false;
                case 0: break;
                case var offset:
                    body = body.UnsafelySkip(offset);
                    break;
            }
            if (body.IndexOf(single) is not -1 and var length)
            {
                current = body.UnsafelyTake(length);
                body = body.UnsafelySkip(length + 1);
                return true;
            }
            current = body;
            body = default;
            return true;
#else
        Retry:
            switch (body.IndexOf(single))
            {
                case -1:
                    current = body;
                    body = default;
                    return true;
                case 0:
                    if (body.Length is not 1)
                    {
                        body = body.UnsafelySkip(1);
                        goto Retry;
                    }
                    current = default;
                    return false;
                case var i:
                    current = body.UnsafelyTake(i);
                    body = body.UnsafelySkip(i + 1);
                    return true;
            }
#endif
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        bool SameLength<TOtherSeparator, TOtherStrategy>(
            scoped ref SplitSpan<TBody, TOtherSeparator, TOtherStrategy>.Enumerator other,
            scoped ref ReadOnlySpan<TBody> reader,
            scoped ref ReadOnlySpan<TBody> otherReader,
            out bool ret
        )
#if !NET7_0_OR_GREATER
            where TOtherSeparator : IEquatable<TOtherSeparator>?
#endif
        {
            if (!reader.SequenceEqual(otherReader))
            {
                ret = false;
                return true;
            }
            if (!MoveNext())
            {
                ret = !other.MoveNext();
                return true;
            }
            if (!other.MoveNext())
            {
                ret = false;
                return true;
            }
            reader = Current;
            otherReader = other.Current;
            Unsafe.SkipInit(out ret);
            return false;
        }
#if NET6_0_OR_GREATER
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        bool SameLength<TOtherSeparator, TOtherStrategy>(
            scoped ref SplitSpan<TBody, TOtherSeparator, TOtherStrategy>.Enumerator other,
            scoped ref ReadOnlySpan<TBody> reader,
            scoped ref ReadOnlySpan<TBody> otherReader,
            IEqualityComparer<TBody> comparer,
            out bool ret
        )
#if !NET7_0_OR_GREATER
            where TOtherSeparator : IEquatable<TOtherSeparator>?
#endif
        {
            if (!reader.SequenceEqual(otherReader, comparer))
            {
                ret = false;
                return true;
            }
            if (!MoveNext())
            {
                ret = !other.MoveNext();
                return true;
            }
            if (!other.MoveNext())
            {
                ret = false;
                return true;
            }
            reader = Current;
            otherReader = other.Current;
            Unsafe.SkipInit(out ret);
            return false;
        }
#endif
    }
}
// SPDX-License-Identifier: MPL-2.0
#if !NETSTANDARD || NETSTANDARD2_0_OR_GREATER
// ReSharper disable once CheckNamespace
/// <summary>Allows you to get an attribute on an enum field value.</summary>
    /// <summary>Gets the <typeparamref name="T"/> applied to the field of the enum.</summary>
    /// <typeparam name="T">The type of <see cref="Attribute"/> to get.</typeparam>
    /// <param name="value">The enum containing the <typeparamref name="T"/> instance in metadata.</param>
    /// <returns>
    /// The <typeparamref name="T"/> instance attached to the parameter <paramref name="value"/>'s field metadata.
    /// </returns>
    public static T? GetCustomAttribute<T>(this Enum value)
        where T : Attribute =>
        value.GetType().GetMember($"{value}", BindingFlags.Static | BindingFlags.Public)[0].GetCustomAttribute<T>();
#endif
// SPDX-License-Identifier: MPL-2.0
#if !NETSTANDARD || NETSTANDARD2_1_OR_GREATER
// ReSharper disable once CheckNamespace
/// <summary>Contains functions to create other functions that get or set fields and properties.</summary>
    /// <summary>The function containing the value to set.</summary>
    /// <typeparam name="T">The instance to mutate an inner value of.</typeparam>
    /// <typeparam name="TValue">The value to insert.</typeparam>
    public delegate void Setting<T, in TValue>(ref T obj, TValue value);
    /// <summary>Creates the getter function for the field.</summary>
    /// <param name="x">The field to generate the function for.</param>
    /// <returns>
    /// The function that get <paramref name="x"/>. The return type is <see cref="Converter{TInput, TOutput}"/>.
    /// </returns>
    public static Delegate Getter(this FieldInfo x)
    {
        DynamicMethod ret = new(x.Name, x.DeclaringType, [x.FieldType]);
        var il = ret.GetILGenerator();
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ldfld, x);
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ret);
        return ret.CreateDelegate(typeof(Converter<,>).MakeGenericType(x.DeclaringType!, x.FieldType));
    }
    /// <summary>Creates the setter function for the field.</summary>
    /// <param name="x">The field to generate the function for.</param>
    /// <returns>
    /// The function that sets <paramref name="x"/>. The return type is <see cref="Setting{T, Value}"/>.
    /// </returns>
    public static Delegate Setter(this FieldInfo x)
    {
        DynamicMethod ret = new(x.Name, typeof(void), [x.DeclaringType!.MakeByRefType(), x.FieldType]);
        var il = ret.GetILGenerator();
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ldarg_1);
        il.Emit(OpCodes.Stfld, x);
        il.Emit(OpCodes.Ret);
        return ret.CreateDelegate(typeof(Setting<,>).MakeGenericType(x.DeclaringType!, x.FieldType));
    }
    /// <summary>Creates the getter function for the field.</summary>
    /// <param name="x">The property to generate the function for.</param>
    /// <returns>
    /// The function that get <paramref name="x"/>. The return type is <see cref="Converter{TInput, TOutput}"/>.
    /// </returns>
    public static Delegate Getter(this PropertyInfo x)
    {
        DynamicMethod ret = new(x.Name, x.DeclaringType, [x.PropertyType]);
        var il = ret.GetILGenerator();
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Call, x.GetGetMethod(true)!);
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ret);
        return ret.CreateDelegate(typeof(Converter<,>).MakeGenericType(x.DeclaringType!, x.PropertyType));
    }
    /// <summary>Creates the setter function for the field.</summary>
    /// <param name="x">The property to generate the function for.</param>
    /// <returns>
    /// The function that sets <paramref name="x"/>. The return type is <see cref="Setting{T, TValue}"/>.
    /// </returns>
    public static Delegate Setter(this PropertyInfo x)
    {
        DynamicMethod ret = new(x.Name, typeof(void), [x.DeclaringType!.MakeByRefType(), x.PropertyType]);
        var il = ret.GetILGenerator();
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ldarg_1);
        il.Emit(OpCodes.Call, x.GetSetMethod(true)!);
        il.Emit(OpCodes.Ret);
        return ret.CreateDelegate(typeof(Setting<,>).MakeGenericType(x.DeclaringType!, x.PropertyType));
    }
#endif
// SPDX-License-Identifier: MPL-2.0
#pragma warning disable GlobalUsingsAnalyzer
#pragma warning restore GlobalUsingsAnalyzer
// ReSharper disable once CheckNamespace
#pragma warning disable CA1031
/// <summary>Provides methods to wrap delegates around try-catch blocks.</summary>
// ReSharper disable OutParameterValueIsAlwaysDiscarded.Global
    /// <summary>Attempts to execute the <paramref name="action"/>.</summary>
    /// <param name="action">The action to execute.</param>
    /// <param name="err">
    /// When this method returns <see langword="true"/>, contains the <see cref="Exception"/> that was thrown.
    /// </param>
    /// <returns>The value indicating whether <paramref name="action"/> threw an <see cref="Exception"/>.</returns>
    public static bool Go([InstantHandle] Action action, [NotNullWhen(true)] out Exception? err)
    {
        try
        {
            action();
            err = null;
            return false;
        }
        catch (Exception ex)
        {
            err = ex;
            return true;
        }
    }
    /// <summary>Attempts to execute the <paramref name="action"/>.</summary>
    /// <typeparam name="T">The type of parameter to pass to <paramref name="action"/>.</typeparam>
    /// <param name="action">The action to execute.</param>
    /// <param name="param">The parameter to pass to <paramref name="action"/>.</param>
    /// <param name="err">
    /// When this method returns <see langword="true"/>, contains the <see cref="Exception"/> that was thrown.
    /// </param>
    /// <returns>The value indicating whether <paramref name="action"/> threw an <see cref="Exception"/>.</returns>
    public static bool Go<T>([InstantHandle] Action<T> action, in T param, [NotNullWhen(true)] out Exception? err)
    {
        try
        {
            action(param);
            err = null;
            return false;
        }
        catch (Exception ex)
        {
            err = ex;
            return true;
        }
    }
    /// <summary>Attempts to execute the <paramref name="action"/>.</summary>
    /// <typeparam name="T1">The first type of parameter to pass to <paramref name="action"/>.</typeparam>
    /// <typeparam name="T2">The second type of parameter to pass to <paramref name="action"/>.</typeparam>
    /// <param name="action">The action to execute.</param>
    /// <param name="first">The first parameter to pass to <paramref name="action"/>.</param>
    /// <param name="second">The second parameter to pass to <paramref name="action"/>.</param>
    /// <param name="err">
    /// When this method returns <see langword="true"/>, contains the <see cref="Exception"/> that was thrown.
    /// </param>
    /// <returns>The value indicating whether <paramref name="action"/> threw an <see cref="Exception"/>.</returns>
    public static bool Go<T1, T2>(
        [InstantHandle] Action<T1, T2> action,
        in T1 first,
        in T2 second,
        [NotNullWhen(true)] out Exception? err
    )
    {
        try
        {
            action(first, second);
            err = null;
            return false;
        }
        catch (Exception ex)
        {
            err = ex;
            return true;
        }
    }
    /// <summary>Attempts to execute the <paramref name="action"/>.</summary>
    /// <typeparam name="T1">The first type of parameter to pass to <paramref name="action"/>.</typeparam>
    /// <typeparam name="T2">The second type of parameter to pass to <paramref name="action"/>.</typeparam>
    /// <typeparam name="T3">The third type of parameter to pass to <paramref name="action"/>.</typeparam>
    /// <param name="action">The action to execute.</param>
    /// <param name="first">The first parameter to pass to <paramref name="action"/>.</param>
    /// <param name="second">The second parameter to pass to <paramref name="action"/>.</param>
    /// <param name="third">The third parameter to pass to <paramref name="action"/>.</param>
    /// <param name="err">
    /// When this method returns <see langword="true"/>, contains the <see cref="Exception"/> that was thrown.
    /// </param>
    /// <returns>The value indicating whether <paramref name="action"/> threw an <see cref="Exception"/>.</returns>
    public static bool Go<T1, T2, T3>(
        [InstantHandle] Action<T1, T2, T3> action,
        in T1 first,
        in T2 second,
        in T3 third,
        [NotNullWhen(true)] out Exception? err
    )
    {
        try
        {
            action(first, second, third);
            err = null;
            return false;
        }
        catch (Exception ex)
        {
            err = ex;
            return true;
        }
    }
    /// <summary>Attempts to execute the <paramref name="action"/>.</summary>
    /// <typeparam name="T1">The first type of parameter to pass to <paramref name="action"/>.</typeparam>
    /// <typeparam name="T2">The second type of parameter to pass to <paramref name="action"/>.</typeparam>
    /// <typeparam name="T3">The third type of parameter to pass to <paramref name="action"/>.</typeparam>
    /// <typeparam name="T4">The fourth type of parameter to pass to <paramref name="action"/>.</typeparam>
    /// <param name="action">The action to execute.</param>
    /// <param name="first">The first parameter to pass to <paramref name="action"/>.</param>
    /// <param name="second">The second parameter to pass to <paramref name="action"/>.</param>
    /// <param name="third">The third parameter to pass to <paramref name="action"/>.</param>
    /// <param name="fourth">The fourth parameter to pass to <paramref name="action"/>.</param>
    /// <param name="err">
    /// When this method returns <see langword="true"/>, contains the <see cref="Exception"/> that was thrown.
    /// </param>
    /// <returns>The value indicating whether <paramref name="action"/> threw an <see cref="Exception"/>.</returns>
    public static bool Go<T1, T2, T3, T4>(
        [InstantHandle] Action<T1, T2, T3, T4> action,
        in T1 first,
        in T2 second,
        in T3 third,
        in T4 fourth,
        [NotNullWhen(true)] out Exception? err
    )
    {
        try
        {
            action(first, second, third, fourth);
            err = null;
            return false;
        }
        catch (Exception ex)
        {
            err = ex;
            return true;
        }
    }
    /// <summary>Attempts to execute the <paramref name="func"/>.</summary>
    /// <typeparam name="T">The return type of <paramref name="func"/>.</typeparam>
    /// <param name="func">The function to execute.</param>
    /// <param name="err">
    /// When this method returns <see langword="true"/>, contains the <see cref="Exception"/> that was thrown.
    /// </param>
    /// <param name="ok">
    /// When this method returns <see langword="false"/>, contains the <typeparamref name="T"/> that was returned.
    /// </param>
    /// <returns>
    /// The value indicating whether <paramref name="func"/> threw an
    /// <see cref="Exception"/> or returned a <typeparamref name="T"/>.
    /// </returns>
    public static bool Go<T>(
        [InstantHandle] Func<T> func,
        [NotNullWhen(true)] out Exception? err,
        [MaybeNullWhen(true)] out T ok
    )
    {
        try
        {
            ok = func();
            err = null;
            return false;
        }
        catch (Exception ex)
        {
            ok = default;
            err = ex;
            return true;
        }
    }
    /// <summary>Attempts to execute the <paramref name="func"/>.</summary>
    /// <typeparam name="T">The type of parameter to pass to <paramref name="func"/>.</typeparam>
    /// <typeparam name="TResult">The return type of <paramref name="func"/>.</typeparam>
    /// <param name="func">The function to execute.</param>
    /// <param name="param">The parameter to pass to <paramref name="func"/>.</param>
    /// <param name="err">
    /// When this method returns <see langword="true"/>, contains the <see cref="Exception"/> that was thrown.
    /// </param>
    /// <param name="ok">
    /// When this method returns <see langword="false"/>, contains the <typeparamref name="TResult"/> that was returned.
    /// </param>
    /// <returns>
    /// The value indicating whether <paramref name="func"/> threw an
    /// <see cref="Exception"/> or returned a <typeparamref name="TResult"/>.
    /// </returns>
    public static bool Go<T, TResult>(
        [InstantHandle] Func<T, TResult> func,
        in T param,
        [NotNullWhen(true)] out Exception? err,
        [MaybeNullWhen(true)] out TResult ok
    )
    {
        try
        {
            ok = func(param);
            err = null;
            return false;
        }
        catch (Exception ex)
        {
            ok = default;
            err = ex;
            return true;
        }
    }
    /// <summary>Attempts to execute the <paramref name="func"/>.</summary>
    /// <typeparam name="T1">The first type of parameter to pass to <paramref name="func"/>.</typeparam>
    /// <typeparam name="T2">The second type of parameter to pass to <paramref name="func"/>.</typeparam>
    /// <typeparam name="TResult">The return type of <paramref name="func"/>.</typeparam>
    /// <param name="func">The function to execute.</param>
    /// <param name="first">The first parameter to pass to <paramref name="func"/>.</param>
    /// <param name="second">The second parameter to pass to <paramref name="func"/>.</param>
    /// <param name="err">
    /// When this method returns <see langword="true"/>, contains the <see cref="Exception"/> that was thrown.
    /// </param>
    /// <param name="ok">
    /// When this method returns <see langword="false"/>, contains the <typeparamref name="TResult"/> that was returned.
    /// </param>
    /// <returns>
    /// The value indicating whether <paramref name="func"/> threw an
    /// <see cref="Exception"/> or returned a <typeparamref name="TResult"/>.
    /// </returns>
    public static bool Go<T1, T2, TResult>(
        [InstantHandle] Func<T1, T2, TResult> func,
        in T1 first,
        in T2 second,
        [NotNullWhen(true)] out Exception? err,
        [MaybeNullWhen(true)] out TResult ok
    )
    {
        try
        {
            ok = func(first, second);
            err = null;
            return false;
        }
        catch (Exception ex)
        {
            ok = default;
            err = ex;
            return true;
        }
    }
    /// <summary>Attempts to execute the <paramref name="func"/>.</summary>
    /// <typeparam name="T1">The first type of parameter to pass to <paramref name="func"/>.</typeparam>
    /// <typeparam name="T2">The second type of parameter to pass to <paramref name="func"/>.</typeparam>
    /// <typeparam name="T3">The third type of parameter to pass to <paramref name="func"/>.</typeparam>
    /// <typeparam name="TResult">The return type of <paramref name="func"/>.</typeparam>
    /// <param name="func">The function to execute.</param>
    /// <param name="first">The first parameter to pass to <paramref name="func"/>.</param>
    /// <param name="second">The second parameter to pass to <paramref name="func"/>.</param>
    /// <param name="third">The third parameter to pass to <paramref name="func"/>.</param>
    /// <param name="err">
    /// When this method returns <see langword="true"/>, contains the <see cref="Exception"/> that was thrown.
    /// </param>
    /// <param name="ok">
    /// When this method returns <see langword="false"/>, contains the <typeparamref name="TResult"/> that was returned.
    /// </param>
    /// <returns>
    /// The value indicating whether <paramref name="func"/> threw an
    /// <see cref="Exception"/> or returned a <typeparamref name="TResult"/>.
    /// </returns>
    public static bool Go<T1, T2, T3, TResult>(
        [InstantHandle] Func<T1, T2, T3, TResult> func,
        in T1 first,
        in T2 second,
        in T3 third,
        [NotNullWhen(true)] out Exception? err,
        [MaybeNullWhen(true)] out TResult ok
    )
    {
        try
        {
            ok = func(first, second, third);
            err = null;
            return false;
        }
        catch (Exception ex)
        {
            ok = default;
            err = ex;
            return true;
        }
    }
    /// <summary>Attempts to execute the <paramref name="func"/>.</summary>
    /// <typeparam name="T1">The first type of parameter to pass to <paramref name="func"/>.</typeparam>
    /// <typeparam name="T2">The second type of parameter to pass to <paramref name="func"/>.</typeparam>
    /// <typeparam name="T3">The third type of parameter to pass to <paramref name="func"/>.</typeparam>
    /// <typeparam name="T4">The fourth type of parameter to pass to <paramref name="func"/>.</typeparam>
    /// <typeparam name="TResult">The return type of <paramref name="func"/>.</typeparam>
    /// <param name="func">The function to execute.</param>
    /// <param name="first">The first parameter to pass to <paramref name="func"/>.</param>
    /// <param name="second">The second parameter to pass to <paramref name="func"/>.</param>
    /// <param name="third">The third parameter to pass to <paramref name="func"/>.</param>
    /// <param name="fourth">The fourth parameter to pass to <paramref name="func"/>.</param>
    /// <param name="err">
    /// When this method returns <see langword="true"/>, contains the <see cref="Exception"/> that was thrown.
    /// </param>
    /// <param name="ok">
    /// When this method returns <see langword="false"/>, contains the <typeparamref name="TResult"/> that was returned.
    /// </param>
    /// <returns>
    /// The value indicating whether <paramref name="func"/> threw an
    /// <see cref="Exception"/> or returned a <typeparamref name="TResult"/>.
    /// </returns>
    public static bool Go<T1, T2, T3, T4, TResult>(
        [InstantHandle] Func<T1, T2, T3, T4, TResult> func,
        in T1 first,
        in T2 second,
        in T3 third,
        in T4 fourth,
        [NotNullWhen(true)] out Exception? err,
        [MaybeNullWhen(true)] out TResult ok
    )
    {
        try
        {
            ok = func(first, second, third, fourth);
            err = null;
            return false;
        }
        catch (Exception ex)
        {
            ok = default;
            err = ex;
            return true;
        }
    }
/// <summary>Methods that creates enumerations from individual items.</summary>
static partial class ManyQueries
{
    /// <summary>Gets the types from an assembly even if type loads occur.</summary>
    /// <param name="assembly">The assembly to get the types from.</param>
    /// <returns>
    /// The enumeration of all successfully loaded types from the parameter <paramref name="assembly"/>.
    /// </returns>
    [MustUseReturnValue]
    public static IEnumerable<Type> TryGetTypes(Assembly? assembly) => assembly.TryGetTypes();
}
/// <summary>Methods to read this assembly's manifest streams into common data structures.</summary>
static partial class ManifestReader;
/// <summary>Method to inline.</summary>
[AttributeUsage(AttributeTargets.Method)]
partial class InlineAttribute : Attribute
{
    /// <summary>Initializes a new instance of the <see cref="InlineAttribute"/> class.</summary>
    /// <param name="behavior">Export attribute.</param>
    /// <param name="export">InlineMethod behavior.</param>
    public InlineAttribute(InlineBehavior behavior = InlineBehavior.RemovePrivate, bool export = false)
    {
        Behavior = behavior;
        Export = export;
    }
    /// <summary>Export attribute.</summary>
    public bool Export { get; }
    /// <summary>InlineMethod behavior.</summary>
    public InlineBehavior Behavior { get; }
}
/// <summary>InlineMethod behavior.</summary>
enum InlineBehavior
{
    /// <summary>Keep method after inline.</summary>
    Keep,
    /// <summary>Remove method after inline if private.</summary>
    RemovePrivate,
    /// <summary>Remove method after inline.</summary>
    Remove,
}
/// <summary>Resolve delegate parameter.</summary>
[AttributeUsage(AttributeTargets.Parameter)]
partial class ResolveDelegateAttribute : Attribute
{
    /// <summary>Initializes a new instance of the <see cref="ResolveDelegateAttribute"/> class.</summary>
    /// <param name="inline">Inline after resolve.</param>
    public ResolveDelegateAttribute(bool inline = true) => Inline = inline;
    /// <summary>Inline after resolve.</summary>
    public bool Inline { get; }
}
/// <summary>Declares a contract that the generic parameter must include the qualified member.</summary>
[global::System.AttributeUsage(global::System.AttributeTargets.Parameter)]
sealed partial class MatchAttribute : global::System.Attribute
{
    /// <summary>Initializes a new instance of the <see cref="Emik.MatchAttribute"/> class.</summary>
    /// <param name="pattern">The regular expression pattern to match.</param>
    public MatchAttribute([global::System.Diagnostics.CodeAnalysis.StringSyntax(global::System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.Regex)] string pattern)
    {
        Pattern = pattern;
    }

    /// <summary>Initializes a new instance of the <see cref="Emik.MatchAttribute"/> class.</summary>
    /// <param name="pattern">The regular expression pattern to match.</param>
    /// <param name="options">The bitwise combination of the enumeration values that modify the regular expression.</param>
    public MatchAttribute([global::System.Diagnostics.CodeAnalysis.StringSyntax(global::System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.Regex)] string pattern, global::System.Text.RegularExpressions.RegexOptions options)
    {
        Pattern = pattern;
        Options = options;
    }

    /// <summary>Initializes a new instance of the <see cref="Emik.MatchAttribute"/> class.</summary>
    /// <param name="pattern">The regular expression pattern to match.</param>
    /// <param name="allowRuntimeValues">The value determining whether to allow runtime values, instead of raising a warning.</param>
    public MatchAttribute([global::System.Diagnostics.CodeAnalysis.StringSyntax(global::System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.Regex)] string pattern, bool allowRuntimeValues)
    {
        Pattern = pattern;
        AllowRuntimeValues = allowRuntimeValues;
    }

    /// <summary>Initializes a new instance of the <see cref="Emik.MatchAttribute"/> class.</summary>
    /// <param name="pattern">The regular expression pattern to match.</param>
    /// <param name="allowRuntimeValues">The value determining whether to allow runtime values, instead of raising a warning.</param>
    /// <param name="options">The bitwise combination of the enumeration values that modify the regular expression.</param>
    public MatchAttribute([global::System.Diagnostics.CodeAnalysis.StringSyntax(global::System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.Regex)] string pattern, bool allowRuntimeValues, global::System.Text.RegularExpressions.RegexOptions options)
    {
        Pattern = pattern;
        Options = options;
        AllowRuntimeValues = allowRuntimeValues;
    }

    /// <summary>Initializes a new instance of the <see cref="Emik.MatchAttribute"/> class.</summary>
    /// <param name="pattern">The regular expression pattern to match.</param>
    /// <param name="options">The bitwise combination of the enumeration values that modify the regular expression.</param>
    /// <param name="allowRuntimeValues">The value determining whether to allow runtime values, instead of raising a warning.</param>
    public MatchAttribute([global::System.Diagnostics.CodeAnalysis.StringSyntax(global::System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.Regex)] string pattern, global::System.Text.RegularExpressions.RegexOptions options, bool allowRuntimeValues)
    {
        Pattern = pattern;
        Options = options;
        AllowRuntimeValues = allowRuntimeValues;
    }

    /// <summary>Gets the value determining whether to allow runtime values, instead of raising a warning.</summary>
    public bool AllowRuntimeValues { get; }

    /// <summary>Gets the regular expression to match.</summary>
    [global::System.Diagnostics.CodeAnalysis.StringSyntax(global::System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.Regex)]
    public string Pattern { get; }

    /// <summary>Gets the bitwise combination of the enumeration values that modify the regular expression.</summary>
    public global::System.Text.RegularExpressions.RegexOptions Options { get; }
}
/// <summary>Determines whether the specified <see langword="object"/> instances are the same instance.</summary>
/// <remarks><para>This method exists as a polyfill since not all REPLs provide this method.</para></remarks>
/// <param name="l">The first object to compare.</param>
/// <param name="r">The second object to compare.</param>
/// <returns>Whether the objects are equal.</returns>
static bool ReferenceEquals(object? l, object? r) => l == r;