using System;
using System.Buffers;
using System.CodeDom.Compiler;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Drawing;
using System.IO;
using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;
using Microsoft.Toolkit.HighPerformance.Buffers;
using Microsoft.Toolkit.HighPerformance.Buffers.Internals;
using Microsoft.Toolkit.HighPerformance.Buffers.Internals.Interfaces;
using Microsoft.Toolkit.HighPerformance.Buffers.Views;
using Microsoft.Toolkit.HighPerformance.Enumerables;
using Microsoft.Toolkit.HighPerformance.Helpers;
using Microsoft.Toolkit.HighPerformance.Helpers.Internals;
using Microsoft.Toolkit.HighPerformance.Memory.Internals;
using Microsoft.Toolkit.HighPerformance.Memory.Views;
using Microsoft.Toolkit.HighPerformance.Streams;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyFileVersion("7.1.2.1")]
[assembly: AssemblyInformationalVersion("7.1.2+da6d7d3f6c")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = "")]
[assembly: AssemblyMetadata("CommitHash", "da6d7d3f6ca9914dbe86d7d394e9a4abef25c9b6")]
[assembly: AssemblyCompany(".NET Foundation")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("(c) .NET Foundation and Contributors.  All rights reserved.")]
[assembly: AssemblyDescription("\r\n      This package includes high performance .NET Standard helpers such as:\r\n      - Memory2D<T> and Span2D<T>: two types providing fast and allocation-free abstraction over 2D memory areas.\r\n      - ArrayPoolBufferWriter<T>: an IBufferWriter<T> implementation using pooled arrays, which also supports IMemoryOwner<T>.\r\n      - MemoryBufferWriter<T>: an IBufferWriter<T>: implementation that can wrap external Memory<T>: instances.\r\n      - MemoryOwner<T>: an IMemoryOwner<T> implementation with an embedded length and a fast Span<T> accessor.\r\n      - SpanOwner<T>: a stack-only type with the ability to rent a buffer of a specified length and getting a Span<T> from it.\r\n      - StringPool: a configurable pool for string instances that be used to minimize allocations when creating multiple strings from char buffers.\r\n      - String, array, Memory<T>, Span<T> extensions and more, all focused on high performance.\r\n      - HashCode<T>: a SIMD-enabled extension of HashCode to quickly process sequences of values.\r\n      - BitHelper: a class with helper methods to perform bit operations on numeric types.\r\n      - ParallelHelper: helpers to work with parallel code in a highly optimized manner.\r\n      - Box<T>: a type mapping boxed value types and exposing some utility and high performance methods.\r\n      - Ref<T>: a stack-only struct that can store a reference to a value of a specified type.\r\n      - NullableRef<T>: a stack-only struct similar to Ref<T>, which also supports nullable references.\r\n  ")]
[assembly: AssemblyProduct("Windows Community Toolkit")]
[assembly: AssemblyTitle("Microsoft.Toolkit.HighPerformance")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/CommunityToolkit/WindowsCommunityToolkit")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("7.1.0.0")]
[module: UnverifiableCode]
[module: SkipLocalsInit]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsUnmanagedAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NativeIntegerAttribute : Attribute
	{
		public readonly bool[] TransformFlags;

		public NativeIntegerAttribute()
		{
			TransformFlags = new bool[1] { true };
		}

		public NativeIntegerAttribute(bool[] P_0)
		{
			TransformFlags = P_0;
		}
	}
}
[GeneratedCode("Nerdbank.GitVersioning.Tasks", "3.3.37.35081")]
[ExcludeFromCodeCoverage]
internal static class ThisAssembly
{
	internal const string AssemblyVersion = "7.1.0.0";

	internal const string AssemblyFileVersion = "7.1.2.1";

	internal const string AssemblyInformationalVersion = "7.1.2+da6d7d3f6c";

	internal const string AssemblyName = "Microsoft.Toolkit.HighPerformance";

	internal const string AssemblyTitle = "Microsoft.Toolkit.HighPerformance";

	internal const string AssemblyConfiguration = "Release";

	internal const string GitCommitId = "da6d7d3f6ca9914dbe86d7d394e9a4abef25c9b6";

	internal const string PublicKey = "002400000480000094000000060200000024000052534131000400000100010041753af735ae6140c9508567666c51c6ab929806adb0d210694b30ab142a060237bc741f9682e7d8d4310364b4bba4ee89cc9d3d5ce7e5583587e8ea44dca09977996582875e71fb54fa7b170798d853d5d8010b07219633bdb761d01ac924da44576d6180cdceae537973982bb461c541541d58417a3794e34f45e6f2d129e2";

	internal const string PublicKeyToken = "4aff67a105548ee2";

	internal const bool IsPublicRelease = true;

	internal const bool IsPrerelease = false;

	internal static readonly DateTime GitCommitDate = new DateTime(637728688180000000L, DateTimeKind.Utc);

	internal const string RootNamespace = "Microsoft.Toolkit.HighPerformance";
}
namespace Microsoft.Toolkit.HighPerformance
{
	[DebuggerDisplay("{ToString(),raw}")]
	public sealed class Box<T> where T : struct
	{
		private Box()
		{
			throw new InvalidOperationException("The Microsoft.Toolkit.HighPerformance.Box<T> constructor should never be used");
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Box<T> GetFrom(object obj)
		{
			if (obj.GetType() != typeof(T))
			{
				ThrowInvalidCastExceptionForGetFrom();
			}
			return Unsafe.As<Box<T>>(obj);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Box<T> DangerousGetFrom(object obj)
		{
			return Unsafe.As<Box<T>>(obj);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryGetFrom(object obj, [NotNullWhen(true)] out Box<T>? box)
		{
			if (obj.GetType() == typeof(T))
			{
				box = Unsafe.As<Box<T>>(obj);
				return true;
			}
			box = null;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static implicit operator T(Box<T> box)
		{
			return (T)box;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static implicit operator Box<T>(T value)
		{
			return Unsafe.As<Box<T>>(value);
		}

		public override string ToString()
		{
			return this.GetReference().ToString();
		}

		public override bool Equals(object? obj)
		{
			return object.Equals(this, obj);
		}

		public override int GetHashCode()
		{
			return this.GetReference().GetHashCode();
		}

		private static void ThrowInvalidCastExceptionForGetFrom()
		{
			throw new InvalidCastException($"Can't cast the input object to the type Box<{typeof(T)}>");
		}
	}
	public static class BoxExtensions
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ref T GetReference<T>(this Box<T> box) where T : struct
		{
			return ref Unsafe.Unbox<T>(box);
		}
	}
	public static class ArrayExtensions
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ref T DangerousGetReference<T>(this T[] array)
		{
			IntPtr arrayDataByteOffset = Microsoft.Toolkit.HighPerformance.Helpers.Internals.RuntimeHelpers.GetArrayDataByteOffset<T>();
			return ref ObjectMarshal.DangerousGetObjectDataReferenceAt<T>(array, arrayDataByteOffset);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ref T DangerousGetReferenceAt<T>(this T[] array, int i)
		{
			IntPtr arrayDataByteOffset = Microsoft.Toolkit.HighPerformance.Helpers.Internals.RuntimeHelpers.GetArrayDataByteOffset<T>();
			return ref Unsafe.Add(ref ObjectMarshal.DangerousGetObjectDataReferenceAt<T>(array, arrayDataByteOffset), (nint)(uint)i);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int Count<T>(this T[] array, T value) where T : IEquatable<T>
		{
			ref T r = ref array.DangerousGetReference();
			nint arrayNativeLength = Microsoft.Toolkit.HighPerformance.Helpers.Internals.RuntimeHelpers.GetArrayNativeLength(array);
			nint num = SpanHelper.Count(ref r, arrayNativeLength, value);
			if ((nuint)num > (nuint)2147483647u)
			{
				ThrowOverflowException();
			}
			return (int)num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static SpanEnumerable<T> Enumerate<T>(this T[] array)
		{
			return new SpanEnumerable<T>(array);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static SpanTokenizer<T> Tokenize<T>(this T[] array, T separator) where T : IEquatable<T>
		{
			return new SpanTokenizer<T>(array, separator);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int GetDjb2HashCode<T>(this T[] array) where T : notnull
		{
			ref T r = ref array.DangerousGetReference();
			nint arrayNativeLength = Microsoft.Toolkit.HighPerformance.Helpers.Internals.RuntimeHelpers.GetArrayNativeLength(array);
			return SpanHelper.GetDjb2HashCode(ref r, arrayNativeLength);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsCovariant<T>(this T[] array)
		{
			if (default(T) == null)
			{
				return array.GetType() != typeof(T[]);
			}
			return false;
		}

		private static void ThrowOverflowException()
		{
			throw new OverflowException();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ref T DangerousGetReference<T>(this T[,] array)
		{
			IntPtr array2DDataByteOffset = Microsoft.Toolkit.HighPerformance.Helpers.Internals.RuntimeHelpers.GetArray2DDataByteOffset<T>();
			return ref ObjectMarshal.DangerousGetObjectDataReferenceAt<T>(array, array2DDataByteOffset);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ref T DangerousGetReferenceAt<T>(this T[,] array, int i, int j)
		{
			int length = array.GetLength(1);
			nint elementOffset = (nint)(uint)i * (nint)(uint)length + (nint)(uint)j;
			IntPtr array2DDataByteOffset = Microsoft.Toolkit.HighPerformance.Helpers.Internals.RuntimeHelpers.GetArray2DDataByteOffset<T>();
			return ref Unsafe.Add(ref ObjectMarshal.DangerousGetObjectDataReferenceAt<T>(array, array2DDataByteOffset), elementOffset);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RefEnumerable<T> GetRow<T>(this T[,] array, int row)
		{
			if (array.IsCovariant())
			{
				ThrowArrayTypeMismatchException();
			}
			int length = array.GetLength(0);
			if ((uint)row >= (uint)length)
			{
				ThrowArgumentOutOfRangeExceptionForRow();
			}
			int length2 = array.GetLength(1);
			return new RefEnumerable<T>(ref array.DangerousGetReferenceAt(row, 0), length2, 1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RefEnumerable<T> GetColumn<T>(this T[,] array, int column)
		{
			if (array.IsCovariant())
			{
				ThrowArrayTypeMismatchException();
			}
			int length = array.GetLength(1);
			if ((uint)column >= (uint)length)
			{
				ThrowArgumentOutOfRangeExceptionForColumn();
			}
			int length2 = array.GetLength(0);
			return new RefEnumerable<T>(ref array.DangerousGetReferenceAt(0, column), length2, length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span2D<T> AsSpan2D<T>(this T[,]? array)
		{
			return new Span2D<T>(array);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span2D<T> AsSpan2D<T>(this T[,]? array, int row, int column, int height, int width)
		{
			return new Span2D<T>(array, row, column, height, width);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Memory2D<T> AsMemory2D<T>(this T[,]? array)
		{
			return new Memory2D<T>(array);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Memory2D<T> AsMemory2D<T>(this T[,]? array, int row, int column, int height, int width)
		{
			return new Memory2D<T>(array, row, column, height, width);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<T> GetRowSpan<T>(this T[,] array, int row)
		{
			if (array.IsCovariant())
			{
				ThrowArrayTypeMismatchException();
			}
			if ((uint)row >= (uint)array.GetLength(0))
			{
				ThrowArgumentOutOfRangeExceptionForRow();
			}
			return MemoryMarshal.CreateSpan(ref array.DangerousGetReferenceAt(row, 0), array.GetLength(1));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Memory<T> GetRowMemory<T>(this T[,] array, int row)
		{
			if (array.IsCovariant())
			{
				ThrowArrayTypeMismatchException();
			}
			if ((uint)row >= (uint)array.GetLength(0))
			{
				ThrowArgumentOutOfRangeExceptionForRow();
			}
			IntPtr offset = ObjectMarshal.DangerousGetObjectDataByteOffset(array, ref array.DangerousGetReferenceAt(row, 0));
			return new RawObjectMemoryManager<T>(array, offset, array.GetLength(1)).Memory;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Memory<T> AsMemory<T>(this T[,]? array)
		{
			if (array == null)
			{
				return default(Memory<T>);
			}
			if (array.IsCovariant())
			{
				ThrowArrayTypeMismatchException();
			}
			IntPtr array2DDataByteOffset = Microsoft.Toolkit.HighPerformance.Helpers.Internals.RuntimeHelpers.GetArray2DDataByteOffset<T>();
			int length = array.Length;
			return new RawObjectMemoryManager<T>(array, array2DDataByteOffset, length).Memory;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<T> AsSpan<T>(this T[,]? array)
		{
			if (array == null)
			{
				return default(Span<T>);
			}
			if (array.IsCovariant())
			{
				ThrowArrayTypeMismatchException();
			}
			ref T reference = ref array.DangerousGetReference();
			int length = array.Length;
			return MemoryMarshal.CreateSpan(ref reference, length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int Count<T>(this T[,] array, T value) where T : IEquatable<T>
		{
			ref T r = ref array.DangerousGetReference();
			nint arrayNativeLength = Microsoft.Toolkit.HighPerformance.Helpers.Internals.RuntimeHelpers.GetArrayNativeLength(array);
			nint num = SpanHelper.Count(ref r, arrayNativeLength, value);
			if ((nuint)num > (nuint)2147483647u)
			{
				ThrowOverflowException();
			}
			return (int)num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int GetDjb2HashCode<T>(this T[,] array) where T : notnull
		{
			ref T r = ref array.DangerousGetReference();
			nint arrayNativeLength = Microsoft.Toolkit.HighPerformance.Helpers.Internals.RuntimeHelpers.GetArrayNativeLength(array);
			return SpanHelper.GetDjb2HashCode(ref r, arrayNativeLength);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsCovariant<T>(this T[,] array)
		{
			if (default(T) == null)
			{
				return array.GetType() != typeof(T[,]);
			}
			return false;
		}

		private static void ThrowArrayTypeMismatchException()
		{
			throw new ArrayTypeMismatchException("The given array doesn't match the specified type T");
		}

		private static void ThrowArgumentOutOfRangeExceptionForRow()
		{
			throw new ArgumentOutOfRangeException("row");
		}

		private static void ThrowArgumentOutOfRangeExceptionForColumn()
		{
			throw new ArgumentOutOfRangeException("column");
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ref T DangerousGetReference<T>(this T[,,] array)
		{
			IntPtr array3DDataByteOffset = Microsoft.Toolkit.HighPerformance.Helpers.Internals.RuntimeHelpers.GetArray3DDataByteOffset<T>();
			return ref ObjectMarshal.DangerousGetObjectDataReferenceAt<T>(array, array3DDataByteOffset);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ref T DangerousGetReferenceAt<T>(this T[,,] array, int i, int j, int k)
		{
			int length = array.GetLength(1);
			int length2 = array.GetLength(2);
			nint elementOffset = (nint)(uint)i * (nint)(uint)length * (nint)(uint)length2 + (nint)(uint)j * (nint)(uint)length2 + (nint)(uint)k;
			IntPtr array3DDataByteOffset = Microsoft.Toolkit.HighPerformance.Helpers.Internals.RuntimeHelpers.GetArray3DDataByteOffset<T>();
			return ref Unsafe.Add(ref ObjectMarshal.DangerousGetObjectDataReferenceAt<T>(array, array3DDataByteOffset), elementOffset);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Memory<T> AsMemory<T>(this T[,,]? array)
		{
			if (array == null)
			{
				return default(Memory<T>);
			}
			if (array.IsCovariant())
			{
				ThrowArrayTypeMismatchException();
			}
			IntPtr array3DDataByteOffset = Microsoft.Toolkit.HighPerformance.Helpers.Internals.RuntimeHelpers.GetArray3DDataByteOffset<T>();
			int length = array.Length;
			return new RawObjectMemoryManager<T>(array, array3DDataByteOffset, length).Memory;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<T> AsSpan<T>(this T[,,]? array)
		{
			if (array == null)
			{
				return default(Span<T>);
			}
			if (array.IsCovariant())
			{
				ThrowArrayTypeMismatchException();
			}
			ref T reference = ref array.DangerousGetReference();
			int length = array.Length;
			return MemoryMarshal.CreateSpan(ref reference, length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<T> AsSpan<T>(this T[,,] array, int depth)
		{
			if (array.IsCovariant())
			{
				ThrowArrayTypeMismatchException();
			}
			if ((uint)depth >= (uint)array.GetLength(0))
			{
				ThrowArgumentOutOfRangeExceptionForDepth();
			}
			ref T reference = ref array.DangerousGetReferenceAt(depth, 0, 0);
			int length = checked(array.GetLength(1) * array.GetLength(2));
			return MemoryMarshal.CreateSpan(ref reference, length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Memory<T> AsMemory<T>(this T[,,] array, int depth)
		{
			if (array.IsCovariant())
			{
				ThrowArrayTypeMismatchException();
			}
			if ((uint)depth >= (uint)array.GetLength(0))
			{
				ThrowArgumentOutOfRangeExceptionForDepth();
			}
			IntPtr offset = ObjectMarshal.DangerousGetObjectDataByteOffset(array, ref array.DangerousGetReferenceAt(depth, 0, 0));
			int length = checked(array.GetLength(1) * array.GetLength(2));
			return new RawObjectMemoryManager<T>(array, offset, length).Memory;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span2D<T> AsSpan2D<T>(this T[,,] array, int depth)
		{
			return new Span2D<T>(array, depth);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Memory2D<T> AsMemory2D<T>(this T[,,] array, int depth)
		{
			return new Memory2D<T>(array, depth);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int Count<T>(this T[,,] array, T value) where T : IEquatable<T>
		{
			ref T r = ref array.DangerousGetReference();
			nint arrayNativeLength = Microsoft.Toolkit.HighPerformance.Helpers.Internals.RuntimeHelpers.GetArrayNativeLength(array);
			nint num = SpanHelper.Count(ref r, arrayNativeLength, value);
			if ((nuint)num > (nuint)2147483647u)
			{
				ThrowOverflowException();
			}
			return (int)num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int GetDjb2HashCode<T>(this T[,,] array) where T : notnull
		{
			ref T r = ref array.DangerousGetReference();
			nint arrayNativeLength = Microsoft.Toolkit.HighPerformance.Helpers.Internals.RuntimeHelpers.GetArrayNativeLength(array);
			return SpanHelper.GetDjb2HashCode(ref r, arrayNativeLength);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsCovariant<T>(this T[,,] array)
		{
			if (default(T) == null)
			{
				return array.GetType() != typeof(T[,,]);
			}
			return false;
		}

		private static void ThrowArgumentOutOfRangeExceptionForDepth()
		{
			throw new ArgumentOutOfRangeException("depth");
		}
	}
	public static class ArrayPoolBufferWriterExtensions
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Stream AsStream(this ArrayPoolBufferWriter<byte> writer)
		{
			return new IBufferWriterStream<ArrayBufferWriterOwner>(new ArrayBufferWriterOwner(writer));
		}
	}
	public static class ArrayPoolExtensions
	{
		public static void Resize<T>(this ArrayPool<T> pool, ref T[]? array, int newSize, bool clearArray = false)
		{
			if (array == null)
			{
				array = pool.Rent(newSize);
			}
			else if (array.Length != newSize)
			{
				T[] array2 = pool.Rent(newSize);
				int length = Math.Min(array.Length, newSize);
				Array.Copy(array, 0, array2, 0, length);
				pool.Return(array, clearArray);
				array = array2;
			}
		}
	}
	public static class BoolExtensions
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static byte ToByte(this bool flag)
		{
			bool flag2 = flag;
			return flag2 ? ((byte)1) : ((byte)0);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int ToBitwiseMask32(this bool flag)
		{
			bool flag2 = flag;
			return ~((flag2 ? 1 : 0) - 1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long ToBitwiseMask64(this bool flag)
		{
			bool flag2 = flag;
			return ~((flag2 ? 1L : 0L) - 1L);
		}
	}
	public static class HashCodeExtensions
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void Add<T>(this ref HashCode hashCode, ReadOnlySpan<T> span) where T : notnull
		{
			int value = HashCode<T>.CombineValues(span);
			hashCode.Add(value);
		}
	}
	public static class IBufferWriterExtensions
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Stream AsStream(this IBufferWriter<byte> writer)
		{
			if (writer.GetType() == typeof(ArrayPoolBufferWriter<byte>))
			{
				return new IBufferWriterStream<ArrayBufferWriterOwner>(new ArrayBufferWriterOwner(Unsafe.As<ArrayPoolBufferWriter<byte>>(writer)));
			}
			return new IBufferWriterStream<IBufferWriterOwner>(new IBufferWriterOwner(writer));
		}

		public static void Write<T>(this IBufferWriter<byte> writer, T value) where T : unmanaged
		{
			int num = Unsafe.SizeOf<T>();
			Span<byte> span = writer.GetSpan(1);
			if (span.Length < num)
			{
				ThrowArgumentExceptionForEndOfBuffer();
			}
			Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(span), value);
			writer.Advance(num);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void Write<T>(this IBufferWriter<T> writer, T value)
		{
			Span<T> span = writer.GetSpan(1);
			if (span.Length < 1)
			{
				ThrowArgumentExceptionForEndOfBuffer();
			}
			MemoryMarshal.GetReference(span) = value;
			writer.Advance(1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void Write<T>(this IBufferWriter<byte> writer, ReadOnlySpan<T> span) where T : unmanaged
		{
			ReadOnlySpan<byte> readOnlySpan = MemoryMarshal.AsBytes(span);
			Span<byte> span2 = writer.GetSpan(readOnlySpan.Length);
			readOnlySpan.CopyTo(span2);
			writer.Advance(readOnlySpan.Length);
		}

		private static void ThrowArgumentExceptionForEndOfBuffer()
		{
			throw new ArgumentException("The current buffer writer can't contain the requested input data.");
		}
	}
	public static class IMemoryOwnerExtensions
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Stream AsStream(this IMemoryOwner<byte> memoryOwner)
		{
			return Microsoft.Toolkit.HighPerformance.Streams.MemoryStream.Create(memoryOwner);
		}
	}
	public static class MemoryExtensions
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Memory2D<T> AsMemory2D<T>(this Memory<T> memory, int height, int width)
		{
			return new Memory2D<T>(memory, height, width);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Memory2D<T> AsMemory2D<T>(this Memory<T> memory, int offset, int height, int width, int pitch)
		{
			return new Memory2D<T>(memory, offset, height, width, pitch);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Memory<byte> AsBytes<T>(this Memory<T> memory) where T : unmanaged
		{
			return MemoryMarshal.AsMemory(ReadOnlyMemoryExtensions.Cast<T, byte>(memory));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Memory<TTo> Cast<TFrom, TTo>(this Memory<TFrom> memory) where TFrom : unmanaged where TTo : unmanaged
		{
			return MemoryMarshal.AsMemory(ReadOnlyMemoryExtensions.Cast<TFrom, TTo>(memory));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Stream AsStream(this Memory<byte> memory)
		{
			return Microsoft.Toolkit.HighPerformance.Streams.MemoryStream.Create(memory, isReadOnly: false);
		}
	}
	public static class ReadOnlyMemoryExtensions
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ReadOnlyMemory2D<T> AsMemory2D<T>(this ReadOnlyMemory<T> memory, int height, int width)
		{
			return new ReadOnlyMemory2D<T>(memory, height, width);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ReadOnlyMemory2D<T> AsMemory2D<T>(this ReadOnlyMemory<T> memory, int offset, int height, int width, int pitch)
		{
			return new ReadOnlyMemory2D<T>(memory, offset, height, width, pitch);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ReadOnlyMemory<byte> AsBytes<T>(this ReadOnlyMemory<T> memory) where T : unmanaged
		{
			return memory.Cast<T, byte>();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ReadOnlyMemory<TTo> Cast<TFrom, TTo>(this ReadOnlyMemory<TFrom> memory) where TFrom : unmanaged where TTo : unmanaged
		{
			if (memory.IsEmpty)
			{
				return default(ReadOnlyMemory<TTo>);
			}
			if (typeof(TFrom) == typeof(char) && MemoryMarshal.TryGetString((ReadOnlyMemory<char>)(object)memory, out string text, out int start, out int length))
			{
				return new StringMemoryManager<TTo>(text, start, length).Memory;
			}
			if (MemoryMarshal.TryGetArray(memory, out var segment))
			{
				return new ArrayMemoryManager<TFrom, TTo>(segment.Array, segment.Offset, segment.Count).Memory;
			}
			if (MemoryMarshal.TryGetMemoryManager<TFrom, MemoryManager<TFrom>>(memory, out MemoryManager<TFrom> manager, out start, out length))
			{
				if (manager is IMemoryManager memoryManager)
				{
					return memoryManager.GetMemory<TTo>(start, length);
				}
				return new ProxyMemoryManager<TFrom, TTo>(manager, start, length).Memory;
			}
			return ThrowArgumentExceptionForUnsupportedMemory();
			static ReadOnlyMemory<TTo> ThrowArgumentExceptionForUnsupportedMemory()
			{
				throw new ArgumentException("The input instance doesn't have a supported underlying data store.");
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Stream AsStream(this ReadOnlyMemory<byte> memory)
		{
			return Microsoft.Toolkit.HighPerformance.Streams.MemoryStream.Create(memory, isReadOnly: true);
		}
	}
	public static class ReadOnlySpanExtensions
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ref T DangerousGetReference<T>(this ReadOnlySpan<T> span)
		{
			return ref MemoryMarshal.GetReference(span);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ref T DangerousGetReferenceAt<T>(this ReadOnlySpan<T> span, int i)
		{
			return ref Unsafe.Add(ref MemoryMarshal.GetReference(span), (nint)(uint)i);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ref T DangerousGetReferenceAt<T>(this ReadOnlySpan<T> span, nint i)
		{
			return ref Unsafe.Add(ref MemoryMarshal.GetReference(span), i);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ref readonly T DangerousGetLookupReferenceAt<T>(this ReadOnlySpan<T> span, int i)
		{
			bool flag = (uint)i < (uint)span.Length;
			uint num = (uint)(~((flag ? 1 : 0) - 1));
			uint num2 = (uint)i & num;
			return ref Unsafe.Add(ref MemoryMarshal.GetReference(span), (nint)num2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ReadOnlySpan2D<T> AsSpan2D<T>(this ReadOnlySpan<T> span, int height, int width)
		{
			return new ReadOnlySpan2D<T>(span, height, width);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ReadOnlySpan2D<T> AsSpan2D<T>(this ReadOnlySpan<T> span, int offset, int height, int width, int pitch)
		{
			return new ReadOnlySpan2D<T>(span, offset, height, width, pitch);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int IndexOf<T>(this ReadOnlySpan<T> span, in T value)
		{
			nint num = (nint)Unsafe.ByteOffset(in MemoryMarshal.GetReference(span), in Unsafe.AsRef(in value)) / (nint)(uint)Unsafe.SizeOf<T>();
			if ((nuint)num >= (nuint)(uint)span.Length)
			{
				SpanExtensions.ThrowArgumentOutOfRangeExceptionForInvalidReference();
			}
			return (int)num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int Count<T>(this ReadOnlySpan<T> span, T value) where T : IEquatable<T>
		{
			ref T reference = ref MemoryMarshal.GetReference(span);
			nint length = (nint)(uint)span.Length;
			return (int)SpanHelper.Count(ref reference, length, value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ReadOnlySpan<byte> AsBytes<T>(this ReadOnlySpan<T> span) where T : unmanaged
		{
			return MemoryMarshal.AsBytes(span);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ReadOnlySpan<TTo> Cast<TFrom, TTo>(this ReadOnlySpan<TFrom> span) where TFrom : unmanaged where TTo : unmanaged
		{
			return MemoryMarshal.Cast<TFrom, TTo>(span);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ReadOnlySpanEnumerable<T> Enumerate<T>(this ReadOnlySpan<T> span)
		{
			return new ReadOnlySpanEnumerable<T>(span);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ReadOnlySpanTokenizer<T> Tokenize<T>(this ReadOnlySpan<T> span, T separator) where T : IEquatable<T>
		{
			return new ReadOnlySpanTokenizer<T>(span, separator);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int GetDjb2HashCode<T>(this ReadOnlySpan<T> span) where T : notnull
		{
			ref T reference = ref MemoryMarshal.GetReference(span);
			nint length = (nint)(uint)span.Length;
			return SpanHelper.GetDjb2HashCode(ref reference, length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void CopyTo<T>(this ReadOnlySpan<T> span, RefEnumerable<T> destination)
		{
			destination.CopyFrom(span);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryCopyTo<T>(this ReadOnlySpan<T> span, RefEnumerable<T> destination)
		{
			return destination.TryCopyFrom(span);
		}
	}
	public static class SpanExtensions
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ref T DangerousGetReference<T>(this Span<T> span)
		{
			return ref MemoryMarshal.GetReference(span);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ref T DangerousGetReferenceAt<T>(this Span<T> span, int i)
		{
			return ref Unsafe.Add(ref MemoryMarshal.GetReference(span), (nint)(uint)i);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ref T DangerousGetReferenceAt<T>(this Span<T> span, nint i)
		{
			return ref Unsafe.Add(ref MemoryMarshal.GetReference(span), i);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span2D<T> AsSpan2D<T>(this Span<T> span, int height, int width)
		{
			return new Span2D<T>(span, height, width);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span2D<T> AsSpan2D<T>(this Span<T> span, int offset, int height, int width, int pitch)
		{
			return new Span2D<T>(span, offset, height, width, pitch);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<byte> AsBytes<T>(this Span<T> span) where T : unmanaged
		{
			return MemoryMarshal.AsBytes(span);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<TTo> Cast<TFrom, TTo>(this Span<TFrom> span) where TFrom : unmanaged where TTo : unmanaged
		{
			return MemoryMarshal.Cast<TFrom, TTo>(span);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int IndexOf<T>(this Span<T> span, ref T value)
		{
			nint num = (nint)Unsafe.ByteOffset(in MemoryMarshal.GetReference(span), in value) / (nint)(uint)Unsafe.SizeOf<T>();
			if ((nuint)num >= (nuint)(uint)span.Length)
			{
				ThrowArgumentOutOfRangeExceptionForInvalidReference();
			}
			return (int)num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int Count<T>(this Span<T> span, T value) where T : IEquatable<T>
		{
			ref T reference = ref MemoryMarshal.GetReference(span);
			nint length = (nint)(uint)span.Length;
			return (int)SpanHelper.Count(ref reference, length, value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static SpanEnumerable<T> Enumerate<T>(this Span<T> span)
		{
			return new SpanEnumerable<T>(span);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static SpanTokenizer<T> Tokenize<T>(this Span<T> span, T separator) where T : IEquatable<T>
		{
			return new SpanTokenizer<T>(span, separator);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int GetDjb2HashCode<T>(this Span<T> span) where T : notnull
		{
			ref T reference = ref MemoryMarshal.GetReference(span);
			nint length = (nint)(uint)span.Length;
			return SpanHelper.GetDjb2HashCode(ref reference, length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void CopyTo<T>(this Span<T> span, RefEnumerable<T> destination)
		{
			destination.CopyFrom(span);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryCopyTo<T>(this Span<T> span, RefEnumerable<T> destination)
		{
			return destination.TryCopyFrom(span);
		}

		internal static void ThrowArgumentOutOfRangeExceptionForInvalidReference()
		{
			throw new ArgumentOutOfRangeException("value", "The input reference does not belong to an element of the input span");
		}
	}
	public static class SpinLockExtensions
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public readonly ref struct UnsafeLock
		{
			private unsafe readonly SpinLock* spinLock;

			private readonly bool lockTaken;

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public unsafe UnsafeLock(SpinLock* spinLock)
			{
				this.spinLock = spinLock;
				lockTaken = false;
				spinLock->Enter(ref lockTaken);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public unsafe void Dispose()
			{
				if (lockTaken)
				{
					spinLock->Exit();
				}
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public readonly ref struct Lock
		{
			private readonly Ref<SpinLock> spinLock;

			private readonly bool lockTaken;

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public Lock(ref SpinLock spinLock)
			{
				this.spinLock = new Ref<SpinLock>(ref spinLock);
				lockTaken = false;
				spinLock.Enter(ref lockTaken);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public void Dispose()
			{
				if (lockTaken)
				{
					spinLock.Value.Exit();
				}
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe static UnsafeLock Enter(SpinLock* spinLock)
		{
			return new UnsafeLock(spinLock);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Lock Enter(this ref SpinLock spinLock)
		{
			return new Lock(ref spinLock);
		}
	}
	public static class StreamExtensions
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe static T Read<T>(this Stream stream) where T : unmanaged
		{
			T result = default(T);
			int num = Unsafe.SizeOf<T>();
			if (stream.Read(new Span<byte>(&result, num)) != num)
			{
				ThrowInvalidOperationExceptionForEndOfStream();
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void Write<T>(this Stream stream, in T value) where T : unmanaged
		{
			ref byte reference = ref Unsafe.As<T, byte>(ref Unsafe.AsRef(in value));
			int length = Unsafe.SizeOf<T>();
			ReadOnlySpan<byte> buffer = MemoryMarshal.CreateReadOnlySpan(in reference, length);
			stream.Write(buffer);
		}

		private static void ThrowInvalidOperationExceptionForEndOfStream()
		{
			throw new InvalidOperationException("The stream didn't contain enough data to read the requested item");
		}
	}
	public static class StringExtensions
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ref char DangerousGetReference(this string text)
		{
			return ref MemoryMarshal.GetReference(text.AsSpan());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ref char DangerousGetReferenceAt(this string text, int i)
		{
			return ref Unsafe.Add(ref MemoryMarshal.GetReference(text.AsSpan()), (nint)(uint)i);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int Count(this string text, char c)
		{
			ref char r = ref text.DangerousGetReference();
			nint length = (nint)(uint)text.Length;
			return (int)SpanHelper.Count(ref r, length, c);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ReadOnlySpanEnumerable<char> Enumerate(this string text)
		{
			return new ReadOnlySpanEnumerable<char>(text.AsSpan());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ReadOnlySpanTokenizer<char> Tokenize(this string text, char separator)
		{
			return new ReadOnlySpanTokenizer<char>(text.AsSpan(), separator);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int GetDjb2HashCode(this string text)
		{
			ref char r = ref text.DangerousGetReference();
			nint length = (nint)(uint)text.Length;
			return SpanHelper.GetDjb2HashCode(ref r, length);
		}
	}
	[DebuggerTypeProxy(typeof(MemoryDebugView2D<>))]
	[DebuggerDisplay("{ToString(),raw}")]
	public readonly struct Memory2D<T> : IEquatable<Memory2D<T>>
	{
		private readonly object? instance;

		private readonly IntPtr offset;

		private readonly int height;

		private readonly int width;

		private readonly int pitch;

		public static Memory2D<T> Empty => default(Memory2D<T>);

		public bool IsEmpty
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if (height != 0)
				{
					return width == 0;
				}
				return true;
			}
		}

		public nint Length
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (nint)(uint)height * (nint)(uint)width;
			}
		}

		public int Height
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return height;
			}
		}

		public int Width
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return width;
			}
		}

		public Span2D<T> Span
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if (instance != null)
				{
					if (instance is MemoryManager<T> memoryManager)
					{
						return new Span2D<T>(ref Unsafe.Add(ref memoryManager.GetSpan().DangerousGetReference(), offset), height, width, pitch);
					}
					return new Span2D<T>(ref ObjectMarshal.DangerousGetObjectDataReferenceAt<T>(instance, offset), height, width, pitch);
				}
				return default(Span2D<T>);
			}
		}

		public Memory2D<T> this[Range rows, Range columns]
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				var (row, num) = rows.GetOffsetAndLength(height);
				var (column, num2) = columns.GetOffsetAndLength(width);
				return Slice(row, column, num, num2);
			}
		}

		public Memory2D(T[] array, int height, int width)
			: this(array, 0, height, width, 0)
		{
		}

		public Memory2D(T[] array, int offset, int height, int width, int pitch)
		{
			if (array.IsCovariant())
			{
				ThrowHelper.ThrowArrayTypeMismatchException();
			}
			if ((uint)offset > (uint)array.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForOffset();
			}
			if (height < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if (width < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			if (pitch < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForPitch();
			}
			int num = OverflowHelper.ComputeInt32Area(height, width, pitch);
			int num2 = array.Length - offset;
			if (num > num2)
			{
				ThrowHelper.ThrowArgumentException();
			}
			instance = array;
			this.offset = ObjectMarshal.DangerousGetObjectDataByteOffset(array, ref array.DangerousGetReferenceAt(offset));
			this.height = height;
			this.width = width;
			this.pitch = pitch;
		}

		public Memory2D(T[,]? array)
		{
			if (array == null)
			{
				this = default(Memory2D<T>);
				return;
			}
			if (array.IsCovariant())
			{
				ThrowHelper.ThrowArrayTypeMismatchException();
			}
			instance = array;
			offset = Microsoft.Toolkit.HighPerformance.Helpers.Internals.RuntimeHelpers.GetArray2DDataByteOffset<T>();
			height = array.GetLength(0);
			width = array.GetLength(1);
			pitch = 0;
		}

		public Memory2D(T[,]? array, int row, int column, int height, int width)
		{
			if (array == null)
			{
				if (row != 0 || column != 0 || height != 0 || width != 0)
				{
					ThrowHelper.ThrowArgumentException();
				}
				this = default(Memory2D<T>);
				return;
			}
			if (array.IsCovariant())
			{
				ThrowHelper.ThrowArrayTypeMismatchException();
			}
			int length = array.GetLength(0);
			int length2 = array.GetLength(1);
			if ((uint)row >= (uint)length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForRow();
			}
			if ((uint)column >= (uint)length2)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForColumn();
			}
			if ((uint)height > (uint)(length - row))
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if ((uint)width > (uint)(length2 - column))
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			instance = array;
			offset = ObjectMarshal.DangerousGetObjectDataByteOffset(array, ref array.DangerousGetReferenceAt(row, column));
			this.height = height;
			this.width = width;
			pitch = length2 - width;
		}

		public Memory2D(T[,,] array, int depth)
		{
			if (array.IsCovariant())
			{
				ThrowHelper.ThrowArrayTypeMismatchException();
			}
			if ((uint)depth >= (uint)array.GetLength(0))
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForDepth();
			}
			instance = array;
			offset = ObjectMarshal.DangerousGetObjectDataByteOffset(array, ref array.DangerousGetReferenceAt(depth, 0, 0));
			height = array.GetLength(1);
			width = array.GetLength(2);
			pitch = 0;
		}

		public Memory2D(T[,,] array, int depth, int row, int column, int height, int width)
		{
			if (array.IsCovariant())
			{
				ThrowHelper.ThrowArrayTypeMismatchException();
			}
			if ((uint)depth >= (uint)array.GetLength(0))
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForDepth();
			}
			int length = array.GetLength(1);
			int length2 = array.GetLength(2);
			if ((uint)row >= (uint)length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForRow();
			}
			if ((uint)column >= (uint)length2)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForColumn();
			}
			if ((uint)height > (uint)(length - row))
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if ((uint)width > (uint)(length2 - column))
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			instance = array;
			offset = ObjectMarshal.DangerousGetObjectDataByteOffset(array, ref array.DangerousGetReferenceAt(depth, row, column));
			this.height = height;
			this.width = width;
			pitch = length2 - width;
		}

		public Memory2D(MemoryManager<T> memoryManager, int height, int width)
			: this(memoryManager, 0, height, width, 0)
		{
		}

		public Memory2D(MemoryManager<T> memoryManager, int offset, int height, int width, int pitch)
		{
			int length = memoryManager.GetSpan().Length;
			if ((uint)offset > (uint)length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForOffset();
			}
			if (height < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if (width < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			if (pitch < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForPitch();
			}
			if (width == 0 || height == 0)
			{
				this = default(Memory2D<T>);
				return;
			}
			int num = OverflowHelper.ComputeInt32Area(height, width, pitch);
			int num2 = length - offset;
			if (num > num2)
			{
				ThrowHelper.ThrowArgumentException();
			}
			instance = memoryManager;
			this.offset = (nint)(uint)offset;
			this.height = height;
			this.width = width;
			this.pitch = pitch;
		}

		internal Memory2D(Memory<T> memory, int height, int width)
			: this(memory, 0, height, width, 0)
		{
		}

		internal Memory2D(Memory<T> memory, int offset, int height, int width, int pitch)
		{
			if ((uint)offset > (uint)memory.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForOffset();
			}
			if (height < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if (width < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			if (pitch < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForPitch();
			}
			if (width == 0 || height == 0)
			{
				this = default(Memory2D<T>);
				return;
			}
			int num = OverflowHelper.ComputeInt32Area(height, width, pitch);
			int num2 = memory.Length - offset;
			if (num > num2)
			{
				ThrowHelper.ThrowArgumentException();
			}
			ArraySegment<T> segment;
			MemoryManager<T> manager;
			int start2;
			if (typeof(T) == typeof(char) && MemoryMarshal.TryGetString(Unsafe.As<Memory<T>, Memory<char>>(ref memory), out string text, out int start, out int length))
			{
				ref char data = ref text.DangerousGetReferenceAt(start + offset);
				instance = text;
				this.offset = ObjectMarshal.DangerousGetObjectDataByteOffset(text, ref data);
			}
			else if (MemoryMarshal.TryGetArray((ReadOnlyMemory<T>)memory, out segment))
			{
				T[] array = (T[])(instance = segment.Array);
				this.offset = ObjectMarshal.DangerousGetObjectDataByteOffset(array, ref array.DangerousGetReferenceAt(segment.Offset + offset));
			}
			else if (MemoryMarshal.TryGetMemoryManager<T, MemoryManager<T>>(memory, out manager, out start2, out length))
			{
				instance = manager;
				this.offset = (nint)(uint)(start2 + offset);
			}
			else
			{
				ThrowHelper.ThrowArgumentExceptionForUnsupportedType();
				instance = null;
				this.offset = default(IntPtr);
			}
			this.height = height;
			this.width = width;
			this.pitch = pitch;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private Memory2D(object instance, IntPtr offset, int height, int width, int pitch)
		{
			this.instance = instance;
			this.offset = offset;
			this.height = height;
			this.width = width;
			this.pitch = pitch;
		}

		public static Memory2D<T> DangerousCreate(object instance, ref T value, int height, int width, int pitch)
		{
			if (height < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if (width < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			if (pitch < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForPitch();
			}
			OverflowHelper.EnsureIsInNativeIntRange(height, width, pitch);
			IntPtr intPtr = ObjectMarshal.DangerousGetObjectDataByteOffset(instance, ref value);
			return new Memory2D<T>(instance, intPtr, height, width, pitch);
		}

		public Memory2D<T> Slice(int row, int column, int height, int width)
		{
			if ((uint)row >= Height)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForRow();
			}
			if ((uint)column >= this.width)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForColumn();
			}
			if ((uint)height > Height - row)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if ((uint)width > this.width - column)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			int num = (this.width + pitch) * row + column;
			int num2 = pitch + (this.width - width);
			IntPtr intPtr = offset + num * Unsafe.SizeOf<T>();
			return new Memory2D<T>(instance, intPtr, height, width, num2);
		}

		public void CopyTo(Memory<T> destination)
		{
			Span.CopyTo(destination.Span);
		}

		public bool TryCopyTo(Memory<T> destination)
		{
			return Span.TryCopyTo(destination.Span);
		}

		public void CopyTo(Memory2D<T> destination)
		{
			Span.CopyTo(destination.Span);
		}

		public bool TryCopyTo(Memory2D<T> destination)
		{
			return Span.TryCopyTo(destination.Span);
		}

		public unsafe MemoryHandle Pin()
		{
			if (instance != null)
			{
				if (instance is MemoryManager<T> memoryManager)
				{
					return memoryManager.Pin();
				}
				GCHandle handle = GCHandle.Alloc(instance, GCHandleType.Pinned);
				return new MemoryHandle(Unsafe.AsPointer(ref ObjectMarshal.DangerousGetObjectDataReferenceAt<T>(instance, offset)), handle);
			}
			return default(MemoryHandle);
		}

		public bool TryGetMemory(out Memory<T> memory)
		{
			if (pitch == 0 && Length <= int.MaxValue)
			{
				if (instance == null)
				{
					memory = default(Memory<T>);
				}
				else if (typeof(T) == typeof(char) && instance.GetType() == typeof(string))
				{
					string text = Unsafe.As<string>(instance);
					int start = text.AsSpan().IndexOf(in ObjectMarshal.DangerousGetObjectDataReferenceAt<char>(text, offset));
					ReadOnlyMemory<char> source = text.AsMemory(start, (int)Length);
					memory = MemoryMarshal.AsMemory<T>(Unsafe.As<ReadOnlyMemory<char>, Memory<T>>(ref source));
				}
				else if (instance is MemoryManager<T> memoryManager)
				{
					memory = memoryManager.Memory.Slice((int)(nint)offset, height * width);
				}
				else if (instance.GetType() == typeof(T[]))
				{
					T[] array = Unsafe.As<T[]>(instance);
					int start2 = array.AsSpan().IndexOf(ref ObjectMarshal.DangerousGetObjectDataReferenceAt<T>(array, offset));
					memory = array.AsMemory(start2, height * width);
				}
				else
				{
					if (!(instance.GetType() == typeof(T[,])) && !(instance.GetType() == typeof(T[,,])))
					{
						goto IL_01bd;
					}
					memory = new RawObjectMemoryManager<T>(instance, offset, height * width).Memory;
				}
				return true;
			}
			goto IL_01bd;
			IL_01bd:
			memory = default(Memory<T>);
			return false;
		}

		public T[,] ToArray()
		{
			return Span.ToArray();
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public override bool Equals(object? obj)
		{
			if (obj is Memory2D<T> other)
			{
				return Equals(other);
			}
			if (obj is ReadOnlyMemory2D<T> readOnlyMemory2D)
			{
				return readOnlyMemory2D.Equals(this);
			}
			return false;
		}

		public bool Equals(Memory2D<T> other)
		{
			if (instance == other.instance && offset == other.offset && height == other.height && width == other.width)
			{
				return pitch == other.pitch;
			}
			return false;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public override int GetHashCode()
		{
			if (instance != null)
			{
				return HashCode.Combine(System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(instance), offset, height, width, pitch);
			}
			return 0;
		}

		public override string ToString()
		{
			return $"Microsoft.Toolkit.HighPerformance.Memory2D<{typeof(T)}>[{height}, {width}]";
		}

		public static implicit operator Memory2D<T>(T[,]? array)
		{
			return new Memory2D<T>(array);
		}
	}
	[DebuggerTypeProxy(typeof(MemoryDebugView2D<>))]
	[DebuggerDisplay("{ToString(),raw}")]
	public readonly struct ReadOnlyMemory2D<T> : IEquatable<ReadOnlyMemory2D<T>>
	{
		private readonly object? instance;

		private readonly IntPtr offset;

		private readonly int height;

		private readonly int width;

		private readonly int pitch;

		public static ReadOnlyMemory2D<T> Empty => default(ReadOnlyMemory2D<T>);

		public bool IsEmpty
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if (height != 0)
				{
					return width == 0;
				}
				return true;
			}
		}

		public nint Length
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (nint)(uint)height * (nint)(uint)width;
			}
		}

		public int Height
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return height;
			}
		}

		public int Width
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return width;
			}
		}

		public ReadOnlySpan2D<T> Span
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if (instance != null)
				{
					if (instance is MemoryManager<T> memoryManager)
					{
						return new ReadOnlySpan2D<T>(in Unsafe.Add(ref memoryManager.GetSpan().DangerousGetReference(), offset), height, width, pitch);
					}
					return new ReadOnlySpan2D<T>(in ObjectMarshal.DangerousGetObjectDataReferenceAt<T>(instance, offset), height, width, pitch);
				}
				return default(ReadOnlySpan2D<T>);
			}
		}

		public ReadOnlyMemory2D<T> this[Range rows, Range columns]
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				var (row, num) = rows.GetOffsetAndLength(height);
				var (column, num2) = columns.GetOffsetAndLength(width);
				return Slice(row, column, num, num2);
			}
		}

		public ReadOnlyMemory2D(string text, int height, int width)
			: this(text, 0, height, width, 0)
		{
		}

		public ReadOnlyMemory2D(string text, int offset, int height, int width, int pitch)
		{
			if ((uint)offset > (uint)text.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForOffset();
			}
			if (height < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if (width < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			if (pitch < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForPitch();
			}
			int num = OverflowHelper.ComputeInt32Area(height, width, pitch);
			int num2 = text.Length - offset;
			if (num > num2)
			{
				ThrowHelper.ThrowArgumentException();
			}
			instance = text;
			this.offset = ObjectMarshal.DangerousGetObjectDataByteOffset(text, ref text.DangerousGetReferenceAt(offset));
			this.height = height;
			this.width = width;
			this.pitch = pitch;
		}

		public ReadOnlyMemory2D(T[] array, int height, int width)
			: this(array, 0, height, width, 0)
		{
		}

		public ReadOnlyMemory2D(T[] array, int offset, int height, int width, int pitch)
		{
			if ((uint)offset > (uint)array.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForOffset();
			}
			if (height < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if (width < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			if (pitch < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForPitch();
			}
			int num = OverflowHelper.ComputeInt32Area(height, width, pitch);
			int num2 = array.Length - offset;
			if (num > num2)
			{
				ThrowHelper.ThrowArgumentException();
			}
			instance = array;
			this.offset = ObjectMarshal.DangerousGetObjectDataByteOffset(array, ref array.DangerousGetReferenceAt(offset));
			this.height = height;
			this.width = width;
			this.pitch = pitch;
		}

		public ReadOnlyMemory2D(T[,]? array)
		{
			if (array == null)
			{
				this = default(ReadOnlyMemory2D<T>);
				return;
			}
			instance = array;
			offset = Microsoft.Toolkit.HighPerformance.Helpers.Internals.RuntimeHelpers.GetArray2DDataByteOffset<T>();
			height = array.GetLength(0);
			width = array.GetLength(1);
			pitch = 0;
		}

		public ReadOnlyMemory2D(T[,]? array, int row, int column, int height, int width)
		{
			if (array == null)
			{
				if (row != 0 || column != 0 || height != 0 || width != 0)
				{
					ThrowHelper.ThrowArgumentException();
				}
				this = default(ReadOnlyMemory2D<T>);
				return;
			}
			int length = array.GetLength(0);
			int length2 = array.GetLength(1);
			if ((uint)row >= (uint)length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForRow();
			}
			if ((uint)column >= (uint)length2)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForColumn();
			}
			if ((uint)height > (uint)(length - row))
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if ((uint)width > (uint)(length2 - column))
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			instance = array;
			offset = ObjectMarshal.DangerousGetObjectDataByteOffset(array, ref array.DangerousGetReferenceAt(row, column));
			this.height = height;
			this.width = width;
			pitch = length2 - width;
		}

		public ReadOnlyMemory2D(T[,,] array, int depth)
		{
			if ((uint)depth >= (uint)array.GetLength(0))
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForDepth();
			}
			instance = array;
			offset = ObjectMarshal.DangerousGetObjectDataByteOffset(array, ref array.DangerousGetReferenceAt(depth, 0, 0));
			height = array.GetLength(1);
			width = array.GetLength(2);
			pitch = 0;
		}

		public ReadOnlyMemory2D(T[,,] array, int depth, int row, int column, int height, int width)
		{
			if ((uint)depth >= (uint)array.GetLength(0))
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForDepth();
			}
			int length = array.GetLength(1);
			int length2 = array.GetLength(2);
			if ((uint)row >= (uint)length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForRow();
			}
			if ((uint)column >= (uint)length2)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForColumn();
			}
			if ((uint)height > (uint)(length - row))
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if ((uint)width > (uint)(length2 - column))
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			instance = array;
			offset = ObjectMarshal.DangerousGetObjectDataByteOffset(array, ref array.DangerousGetReferenceAt(depth, row, column));
			this.height = height;
			this.width = width;
			pitch = length2 - width;
		}

		public ReadOnlyMemory2D(MemoryManager<T> memoryManager, int height, int width)
			: this(memoryManager, 0, height, width, 0)
		{
		}

		public ReadOnlyMemory2D(MemoryManager<T> memoryManager, int offset, int height, int width, int pitch)
		{
			int length = memoryManager.GetSpan().Length;
			if ((uint)offset > (uint)length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForOffset();
			}
			if (height < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if (width < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			if (pitch < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForPitch();
			}
			if (width == 0 || height == 0)
			{
				this = default(ReadOnlyMemory2D<T>);
				return;
			}
			int num = OverflowHelper.ComputeInt32Area(height, width, pitch);
			int num2 = length - offset;
			if (num > num2)
			{
				ThrowHelper.ThrowArgumentException();
			}
			instance = memoryManager;
			this.offset = (nint)(uint)offset;
			this.height = height;
			this.width = width;
			this.pitch = pitch;
		}

		internal ReadOnlyMemory2D(ReadOnlyMemory<T> memory, int height, int width)
			: this(memory, 0, height, width, 0)
		{
		}

		internal ReadOnlyMemory2D(ReadOnlyMemory<T> memory, int offset, int height, int width, int pitch)
		{
			if ((uint)offset > (uint)memory.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForOffset();
			}
			if (height < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if (width < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			if (pitch < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForPitch();
			}
			if (width == 0 || height == 0)
			{
				this = default(ReadOnlyMemory2D<T>);
				return;
			}
			int num = OverflowHelper.ComputeInt32Area(height, width, pitch);
			int num2 = memory.Length - offset;
			if (num > num2)
			{
				ThrowHelper.ThrowArgumentException();
			}
			ArraySegment<T> segment;
			MemoryManager<T> manager;
			int start2;
			if (typeof(T) == typeof(char) && MemoryMarshal.TryGetString(Unsafe.As<ReadOnlyMemory<T>, ReadOnlyMemory<char>>(ref memory), out string text, out int start, out int length))
			{
				ref char data = ref text.DangerousGetReferenceAt(start + offset);
				instance = text;
				this.offset = ObjectMarshal.DangerousGetObjectDataByteOffset(text, ref data);
			}
			else if (MemoryMarshal.TryGetArray(memory, out segment))
			{
				T[] array = (T[])(instance = segment.Array);
				this.offset = ObjectMarshal.DangerousGetObjectDataByteOffset(array, ref array.DangerousGetReferenceAt(segment.Offset + offset));
			}
			else if (MemoryMarshal.TryGetMemoryManager<T, MemoryManager<T>>(memory, out manager, out start2, out length))
			{
				instance = manager;
				this.offset = (nint)(uint)(start2 + offset);
			}
			else
			{
				ThrowHelper.ThrowArgumentExceptionForUnsupportedType();
				instance = null;
				this.offset = default(IntPtr);
			}
			this.height = height;
			this.width = width;
			this.pitch = pitch;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private ReadOnlyMemory2D(object instance, IntPtr offset, int height, int width, int pitch)
		{
			this.instance = instance;
			this.offset = offset;
			this.height = height;
			this.width = width;
			this.pitch = pitch;
		}

		public static ReadOnlyMemory2D<T> DangerousCreate(object instance, ref T value, int height, int width, int pitch)
		{
			if (height < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if (width < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			if (pitch < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForPitch();
			}
			OverflowHelper.EnsureIsInNativeIntRange(height, width, pitch);
			IntPtr intPtr = ObjectMarshal.DangerousGetObjectDataByteOffset(instance, ref value);
			return new ReadOnlyMemory2D<T>(instance, intPtr, height, width, pitch);
		}

		public ReadOnlyMemory2D<T> Slice(int row, int column, int height, int width)
		{
			if ((uint)row >= Height)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForRow();
			}
			if ((uint)column >= this.width)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForColumn();
			}
			if ((uint)height > Height - row)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if ((uint)width > this.width - column)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			int num = (this.width + pitch) * row + column;
			int num2 = pitch + (this.width - width);
			IntPtr intPtr = offset + num * Unsafe.SizeOf<T>();
			return new ReadOnlyMemory2D<T>(instance, intPtr, height, width, num2);
		}

		public void CopyTo(Memory<T> destination)
		{
			Span.CopyTo(destination.Span);
		}

		public bool TryCopyTo(Memory<T> destination)
		{
			return Span.TryCopyTo(destination.Span);
		}

		public void CopyTo(Memory2D<T> destination)
		{
			Span.CopyTo(destination.Span);
		}

		public bool TryCopyTo(Memory2D<T> destination)
		{
			return Span.TryCopyTo(destination.Span);
		}

		public unsafe MemoryHandle Pin()
		{
			if (instance != null)
			{
				if (instance is MemoryManager<T> memoryManager)
				{
					return memoryManager.Pin();
				}
				GCHandle handle = GCHandle.Alloc(instance, GCHandleType.Pinned);
				return new MemoryHandle(Unsafe.AsPointer(ref ObjectMarshal.DangerousGetObjectDataReferenceAt<T>(instance, offset)), handle);
			}
			return default(MemoryHandle);
		}

		public bool TryGetMemory(out ReadOnlyMemory<T> memory)
		{
			if (pitch == 0 && Length <= int.MaxValue)
			{
				if (instance == null)
				{
					memory = default(ReadOnlyMemory<T>);
				}
				else if (typeof(T) == typeof(char) && instance.GetType() == typeof(string))
				{
					string text = Unsafe.As<string>(instance);
					int start = text.AsSpan().IndexOf(in ObjectMarshal.DangerousGetObjectDataReferenceAt<char>(text, offset));
					ReadOnlyMemory<char> source = text.AsMemory(start, (int)Length);
					memory = Unsafe.As<ReadOnlyMemory<char>, ReadOnlyMemory<T>>(ref source);
				}
				else if (instance is MemoryManager<T> memoryManager)
				{
					memory = memoryManager.Memory.Slice((int)(nint)offset, height * width);
				}
				else if (instance.GetType() == typeof(T[]))
				{
					T[] array = Unsafe.As<T[]>(instance);
					int start2 = array.AsSpan().IndexOf(ref ObjectMarshal.DangerousGetObjectDataReferenceAt<T>(array, offset));
					memory = array.AsMemory(start2, height * width);
				}
				else
				{
					if (!(instance.GetType() == typeof(T[,])) && !(instance.GetType() == typeof(T[,,])))
					{
						goto IL_01c2;
					}
					memory = new RawObjectMemoryManager<T>(instance, offset, height * width).Memory;
				}
				return true;
			}
			goto IL_01c2;
			IL_01c2:
			memory = default(ReadOnlyMemory<T>);
			return false;
		}

		public T[,] ToArray()
		{
			return Span.ToArray();
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public override bool Equals(object? obj)
		{
			if (obj is ReadOnlyMemory2D<T> other)
			{
				return Equals(other);
			}
			if (obj is Memory2D<T> memory2D)
			{
				return Equals(memory2D);
			}
			return false;
		}

		public bool Equals(ReadOnlyMemory2D<T> other)
		{
			if (instance == other.instance && offset == other.offset && height == other.height && width == other.width)
			{
				return pitch == other.pitch;
			}
			return false;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public override int GetHashCode()
		{
			if (instance != null)
			{
				return HashCode.Combine(System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(instance), offset, height, width, pitch);
			}
			return 0;
		}

		public override string ToString()
		{
			return $"Microsoft.Toolkit.HighPerformance.ReadOnlyMemory2D<{typeof(T)}>[{height}, {width}]";
		}

		public static implicit operator ReadOnlyMemory2D<T>(T[,]? array)
		{
			return new ReadOnlyMemory2D<T>(array);
		}

		public static implicit operator ReadOnlyMemory2D<T>(Memory2D<T> memory)
		{
			return Unsafe.As<Memory2D<T>, ReadOnlyMemory2D<T>>(ref memory);
		}
	}
	[DebuggerTypeProxy(typeof(MemoryDebugView2D<>))]
	[DebuggerDisplay("{ToString(),raw}")]
	public readonly ref struct ReadOnlySpan2D<T>
	{
		public ref struct Enumerator
		{
			private readonly ReadOnlySpan<T> span;

			private readonly int width;

			private readonly int stride;

			private int x;

			private int y;

			public readonly ref readonly T Current
			{
				[MethodImpl(MethodImplOptions.AggressiveInlining)]
				get
				{
					ref T reference = ref MemoryMarshal.GetReference(span);
					nint elementOffset = (nint)(uint)y * (nint)(uint)stride + (nint)(uint)x;
					return ref Unsafe.Add(ref reference, elementOffset);
				}
			}

			internal Enumerator(ReadOnlySpan2D<T> span)
			{
				this.span = span.span;
				width = span.width;
				stride = span.stride;
				x = -1;
				y = 0;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public bool MoveNext()
			{
				int num = x + 1;
				if (num < width)
				{
					x = num;
					return true;
				}
				x = 0;
				return ++y < span.Length;
			}
		}

		private readonly ReadOnlySpan<T> span;

		private readonly int width;

		private readonly int stride;

		public static ReadOnlySpan2D<T> Empty => default(ReadOnlySpan2D<T>);

		public bool IsEmpty
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if (Height != 0)
				{
					return width == 0;
				}
				return true;
			}
		}

		public nint Length
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (nint)(uint)Height * (nint)(uint)width;
			}
		}

		public int Height
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return span.Length;
			}
		}

		public int Width
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return width;
			}
		}

		public ref readonly T this[int row, int column]
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if ((uint)row >= (uint)Height || (uint)column >= (uint)Width)
				{
					ThrowHelper.ThrowIndexOutOfRangeException();
				}
				return ref DangerousGetReferenceAt(row, column);
			}
		}

		public ref readonly T this[Index row, Index column]
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return ref this[row.GetOffset(Height), column.GetOffset(width)];
			}
		}

		public ReadOnlySpan2D<T> this[Range rows, Range columns]
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				var (row, height) = rows.GetOffsetAndLength(Height);
				var (column, num) = columns.GetOffsetAndLength(width);
				return Slice(row, column, height, num);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal ReadOnlySpan2D(in T value, int height, int width, int pitch)
		{
			span = MemoryMarshal.CreateReadOnlySpan(in Unsafe.AsRef(in value), height);
			this.width = width;
			stride = width + pitch;
		}

		public unsafe ReadOnlySpan2D(void* pointer, int height, int width, int pitch)
		{
			if (System.Runtime.CompilerServices.RuntimeHelpers.IsReferenceOrContainsReferences<T>())
			{
				ThrowHelper.ThrowArgumentExceptionForManagedType();
			}
			if (width < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			if (height < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if (pitch < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForPitch();
			}
			OverflowHelper.EnsureIsInNativeIntRange(height, width, pitch);
			span = new ReadOnlySpan<T>(pointer, height);
			this.width = width;
			stride = width + pitch;
		}

		public ReadOnlySpan2D(T[] array, int height, int width)
			: this(array, 0, height, width, 0)
		{
		}

		public ReadOnlySpan2D(T[] array, int offset, int height, int width, int pitch)
		{
			if ((uint)offset > (uint)array.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForOffset();
			}
			if (height < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if (width < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			if (pitch < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForPitch();
			}
			if (width == 0 || height == 0)
			{
				this = default(ReadOnlySpan2D<T>);
				return;
			}
			int num = OverflowHelper.ComputeInt32Area(height, width, pitch);
			int num2 = array.Length - offset;
			if (num > num2)
			{
				ThrowHelper.ThrowArgumentException();
			}
			span = MemoryMarshal.CreateReadOnlySpan(in array.DangerousGetReferenceAt(offset), height);
			this.width = width;
			stride = width + pitch;
		}

		public ReadOnlySpan2D(T[,]? array)
		{
			if (array == null)
			{
				this = default(ReadOnlySpan2D<T>);
				return;
			}
			span = MemoryMarshal.CreateReadOnlySpan(in array.DangerousGetReference(), array.GetLength(0));
			width = (stride = array.GetLength(1));
		}

		public ReadOnlySpan2D(T[,]? array, int row, int column, int height, int width)
		{
			if (array == null)
			{
				if (row != 0 || column != 0 || height != 0 || width != 0)
				{
					ThrowHelper.ThrowArgumentException();
				}
				this = default(ReadOnlySpan2D<T>);
				return;
			}
			int length = array.GetLength(0);
			int length2 = array.GetLength(1);
			if ((uint)row >= (uint)length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForRow();
			}
			if ((uint)column >= (uint)length2)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForColumn();
			}
			if ((uint)height > (uint)(length - row))
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if ((uint)width > (uint)(length2 - column))
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			span = MemoryMarshal.CreateReadOnlySpan(in array.DangerousGetReferenceAt(row, column), height);
			this.width = width;
			stride = length2;
		}

		public ReadOnlySpan2D(T[,,] array, int depth)
		{
			if ((uint)depth >= (uint)array.GetLength(0))
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForDepth();
			}
			span = MemoryMarshal.CreateReadOnlySpan(in array.DangerousGetReferenceAt(depth, 0, 0), array.GetLength(1));
			width = (stride = array.GetLength(2));
		}

		public ReadOnlySpan2D(T[,,] array, int depth, int row, int column, int height, int width)
		{
			if ((uint)depth >= (uint)array.GetLength(0))
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForDepth();
			}
			int length = array.GetLength(1);
			int length2 = array.GetLength(2);
			if ((uint)row >= (uint)length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForRow();
			}
			if ((uint)column >= (uint)length2)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForColumn();
			}
			if ((uint)height > (uint)(length - row))
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if ((uint)width > (uint)(length2 - column))
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			span = MemoryMarshal.CreateReadOnlySpan(in array.DangerousGetReferenceAt(depth, row, column), height);
			this.width = width;
			stride = length2;
		}

		internal ReadOnlySpan2D(ReadOnlySpan<T> span, int height, int width)
			: this(span, 0, height, width, 0)
		{
		}

		internal ReadOnlySpan2D(ReadOnlySpan<T> span, int offset, int height, int width, int pitch)
		{
			if ((uint)offset > (uint)span.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForOffset();
			}
			if (height < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if (width < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			if (pitch < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForPitch();
			}
			if (width == 0 || height == 0)
			{
				this = default(ReadOnlySpan2D<T>);
				return;
			}
			int num = OverflowHelper.ComputeInt32Area(height, width, pitch);
			int num2 = span.Length - offset;
			if (num > num2)
			{
				ThrowHelper.ThrowArgumentException();
			}
			this.span = MemoryMarshal.CreateSpan(ref span.DangerousGetReferenceAt(offset), height);
			this.width = width;
			stride = width + pitch;
		}

		public static ReadOnlySpan2D<T> DangerousCreate(in T value, int height, int width, int pitch)
		{
			if (width < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			if (height < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if (pitch < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForPitch();
			}
			OverflowHelper.EnsureIsInNativeIntRange(height, width, pitch);
			return new ReadOnlySpan2D<T>(in value, height, width, pitch);
		}

		public void CopyTo(Span<T> destination)
		{
			if (IsEmpty)
			{
				return;
			}
			if (TryGetSpan(out var readOnlySpan))
			{
				readOnlySpan.CopyTo(destination);
				return;
			}
			if (Length > destination.Length)
			{
				ThrowHelper.ThrowArgumentExceptionForDestinationTooShort();
			}
			int num = 0;
			int num2 = 0;
			while (num < Height)
			{
				GetRowSpan(num).CopyTo(destination.Slice(num2));
				num++;
				num2 += width;
			}
		}

		public void CopyTo(Span2D<T> destination)
		{
			if (destination.Height != Height || destination.Width != Width)
			{
				ThrowHelper.ThrowArgumentExceptionForDestinationWithNotSameShape();
			}
			if (IsEmpty)
			{
				return;
			}
			if (destination.TryGetSpan(out Span<T> destination2))
			{
				CopyTo(destination2);
				return;
			}
			for (int i = 0; i < Height; i++)
			{
				GetRowSpan(i).CopyTo(destination.GetRowSpan(i));
			}
		}

		public bool TryCopyTo(Span<T> destination)
		{
			if (destination.Length >= Length)
			{
				CopyTo(destination);
				return true;
			}
			return false;
		}

		public bool TryCopyTo(Span2D<T> destination)
		{
			if (destination.Height == Height && destination.Width == Width)
			{
				CopyTo(destination);
				return true;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public unsafe ref T GetPinnableReference()
		{
			ref T result = ref Unsafe.AsRef<T>(null);
			if (Length != 0)
			{
				result = ref MemoryMarshal.GetReference(span);
			}
			return ref result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ref T DangerousGetReference()
		{
			return ref MemoryMarshal.GetReference(span);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ref T DangerousGetReferenceAt(int i, int j)
		{
			ref T reference = ref MemoryMarshal.GetReference(span);
			nint elementOffset = (nint)(uint)i * (nint)(uint)stride + (nint)(uint)j;
			return ref Unsafe.Add(ref reference, elementOffset);
		}

		public ReadOnlySpan2D<T> Slice(int row, int column, int height, int width)
		{
			if ((uint)row >= Height)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForRow();
			}
			if ((uint)column >= this.width)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForColumn();
			}
			if ((uint)height > Height - row)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if ((uint)width > this.width - column)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			nint i = (nint)(uint)stride * (nint)(uint)row + (nint)(uint)column;
			int pitch = stride - width;
			return new ReadOnlySpan2D<T>(in span.DangerousGetReferenceAt(i), height, width, pitch);
		}

		public ReadOnlySpan<T> GetRowSpan(int row)
		{
			if ((uint)row >= (uint)Height)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForRow();
			}
			return MemoryMarshal.CreateReadOnlySpan(in DangerousGetReferenceAt(row, 0), width);
		}

		public bool TryGetSpan(out ReadOnlySpan<T> span)
		{
			if (stride == width && Length <= int.MaxValue)
			{
				span = MemoryMarshal.CreateReadOnlySpan(in MemoryMarshal.GetReference(this.span), (int)Length);
				return true;
			}
			span = default(ReadOnlySpan<T>);
			return false;
		}

		public T[,] ToArray()
		{
			T[,] array = new T[Height, width];
			CopyTo(array.AsSpan());
			return array;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		[Obsolete("Equals() on Span will always throw an exception. Use == instead.")]
		public override bool Equals(object? obj)
		{
			throw new NotSupportedException("Microsoft.Toolkit.HighPerformance.ReadOnlySpan2D<T>.Equals(object) is not supported");
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		[Obsolete("GetHashCode() on Span will always throw an exception.")]
		public override int GetHashCode()
		{
			throw new NotSupportedException("Microsoft.Toolkit.HighPerformance.ReadOnlySpan2D<T>.GetHashCode() is not supported");
		}

		public override string ToString()
		{
			return $"Microsoft.Toolkit.HighPerformance.ReadOnlySpan2D<{typeof(T)}>[{Height}, {width}]";
		}

		public static bool operator ==(ReadOnlySpan2D<T> left, ReadOnlySpan2D<T> right)
		{
			if (left.span == right.span && left.width == right.width)
			{
				return left.stride == right.stride;
			}
			return false;
		}

		public static bool operator !=(ReadOnlySpan2D<T> left, ReadOnlySpan2D<T> right)
		{
			return !(left == right);
		}

		public static implicit operator ReadOnlySpan2D<T>(T[,]? array)
		{
			return new ReadOnlySpan2D<T>(array);
		}

		public static implicit operator ReadOnlySpan2D<T>(Span2D<T> span)
		{
			return new ReadOnlySpan2D<T>(in span.DangerousGetReference(), span.Height, span.Width, span.Stride - span.Width);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlyRefEnumerable<T> GetRow(int row)
		{
			if ((uint)row >= Height)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForRow();
			}
			nint elementOffset = (nint)(uint)stride * (nint)(uint)row;
			return new ReadOnlyRefEnumerable<T>(in Unsafe.Add(ref DangerousGetReference(), elementOffset), Width, 1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlyRefEnumerable<T> GetColumn(int column)
		{
			if ((uint)column >= Width)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForColumn();
			}
			return new ReadOnlyRefEnumerable<T>(in Unsafe.Add(ref DangerousGetReference(), (nint)(uint)column), Height, stride);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Enumerator GetEnumerator()
		{
			return new Enumerator(this);
		}
	}
	[DebuggerTypeProxy(typeof(MemoryDebugView2D<>))]
	[DebuggerDisplay("{ToString(),raw}")]
	public readonly ref struct Span2D<T>
	{
		public ref struct Enumerator
		{
			private readonly Span<T> span;

			private readonly int width;

			private readonly int stride;

			private int x;

			private int y;

			public readonly ref T Current
			{
				[MethodImpl(MethodImplOptions.AggressiveInlining)]
				get
				{
					ref T reference = ref MemoryMarshal.GetReference(span);
					nint elementOffset = (nint)(uint)y * (nint)(uint)stride + (nint)(uint)x;
					return ref Unsafe.Add(ref reference, elementOffset);
				}
			}

			internal Enumerator(Span2D<T> span)
			{
				this.span = span.span;
				width = span.width;
				stride = span.Stride;
				x = -1;
				y = 0;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public bool MoveNext()
			{
				int num = x + 1;
				if (num < width)
				{
					x = num;
					return true;
				}
				x = 0;
				return ++y < span.Length;
			}
		}

		private readonly Span<T> span;

		private readonly int width;

		internal readonly int Stride;

		public static Span2D<T> Empty => default(Span2D<T>);

		public bool IsEmpty
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if (Height != 0)
				{
					return width == 0;
				}
				return true;
			}
		}

		public nint Length
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (nint)(uint)Height * (nint)(uint)width;
			}
		}

		public int Height
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return span.Length;
			}
		}

		public int Width
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return width;
			}
		}

		public ref T this[int row, int column]
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if ((uint)row >= (uint)Height || (uint)column >= (uint)width)
				{
					ThrowHelper.ThrowIndexOutOfRangeException();
				}
				return ref DangerousGetReferenceAt(row, column);
			}
		}

		public ref T this[Index row, Index column]
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return ref this[row.GetOffset(Height), column.GetOffset(width)];
			}
		}

		public Span2D<T> this[Range rows, Range columns]
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				var (row, height) = rows.GetOffsetAndLength(Height);
				var (column, num) = columns.GetOffsetAndLength(width);
				return Slice(row, column, height, num);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal Span2D(ref T value, int height, int width, int pitch)
		{
			span = MemoryMarshal.CreateSpan(ref value, height);
			this.width = width;
			Stride = width + pitch;
		}

		public unsafe Span2D(void* pointer, int height, int width, int pitch)
		{
			if (System.Runtime.CompilerServices.RuntimeHelpers.IsReferenceOrContainsReferences<T>())
			{
				ThrowHelper.ThrowArgumentExceptionForManagedType();
			}
			if (width < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			if (height < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if (pitch < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForPitch();
			}
			OverflowHelper.EnsureIsInNativeIntRange(height, width, pitch);
			span = new Span<T>(pointer, height);
			this.width = width;
			Stride = width + pitch;
		}

		public Span2D(T[] array, int height, int width)
			: this(array, 0, height, width, 0)
		{
		}

		public Span2D(T[] array, int offset, int height, int width, int pitch)
		{
			if (array.IsCovariant())
			{
				ThrowHelper.ThrowArrayTypeMismatchException();
			}
			if ((uint)offset > (uint)array.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForOffset();
			}
			if (height < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if (width < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			if (pitch < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForPitch();
			}
			int num = OverflowHelper.ComputeInt32Area(height, width, pitch);
			int num2 = array.Length - offset;
			if (num > num2)
			{
				ThrowHelper.ThrowArgumentException();
			}
			span = MemoryMarshal.CreateSpan(ref array.DangerousGetReferenceAt(offset), height);
			this.width = width;
			Stride = width + pitch;
		}

		public Span2D(T[,]? array)
		{
			if (array == null)
			{
				this = default(Span2D<T>);
				return;
			}
			if (array.IsCovariant())
			{
				ThrowHelper.ThrowArrayTypeMismatchException();
			}
			span = MemoryMarshal.CreateSpan(ref array.DangerousGetReference(), array.GetLength(0));
			width = (Stride = array.GetLength(1));
		}

		public Span2D(T[,]? array, int row, int column, int height, int width)
		{
			if (array == null)
			{
				if (row != 0 || column != 0 || height != 0 || width != 0)
				{
					ThrowHelper.ThrowArgumentException();
				}
				this = default(Span2D<T>);
				return;
			}
			if (array.IsCovariant())
			{
				ThrowHelper.ThrowArrayTypeMismatchException();
			}
			int length = array.GetLength(0);
			int length2 = array.GetLength(1);
			if ((uint)row >= (uint)length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForRow();
			}
			if ((uint)column >= (uint)length2)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForColumn();
			}
			if ((uint)height > (uint)(length - row))
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if ((uint)width > (uint)(length2 - column))
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			span = MemoryMarshal.CreateSpan(ref array.DangerousGetReferenceAt(row, column), height);
			this.width = width;
			Stride = length2;
		}

		public Span2D(T[,,] array, int depth)
		{
			if (array.IsCovariant())
			{
				ThrowHelper.ThrowArrayTypeMismatchException();
			}
			if ((uint)depth >= (uint)array.GetLength(0))
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForDepth();
			}
			span = MemoryMarshal.CreateSpan(ref array.DangerousGetReferenceAt(depth, 0, 0), array.GetLength(1));
			width = (Stride = array.GetLength(2));
		}

		public Span2D(T[,,] array, int depth, int row, int column, int height, int width)
		{
			if (array.IsCovariant())
			{
				ThrowHelper.ThrowArrayTypeMismatchException();
			}
			if ((uint)depth >= (uint)array.GetLength(0))
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForDepth();
			}
			int length = array.GetLength(1);
			int length2 = array.GetLength(2);
			if ((uint)row >= (uint)length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForRow();
			}
			if ((uint)column >= (uint)length2)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForColumn();
			}
			if ((uint)height > (uint)(length - row))
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if ((uint)width > (uint)(length2 - column))
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			span = MemoryMarshal.CreateSpan(ref array.DangerousGetReferenceAt(depth, row, column), height);
			this.width = width;
			Stride = length2;
		}

		internal Span2D(Span<T> span, int height, int width)
			: this(span, 0, height, width, 0)
		{
		}

		internal Span2D(Span<T> span, int offset, int height, int width, int pitch)
		{
			if ((uint)offset > (uint)span.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForOffset();
			}
			if (height < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if (width < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			if (pitch < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForPitch();
			}
			if (width == 0 || height == 0)
			{
				this = default(Span2D<T>);
				return;
			}
			int num = OverflowHelper.ComputeInt32Area(height, width, pitch);
			int num2 = span.Length - offset;
			if (num > num2)
			{
				ThrowHelper.ThrowArgumentException();
			}
			this.span = MemoryMarshal.CreateSpan(ref span.DangerousGetReferenceAt(offset), height);
			this.width = width;
			Stride = width + pitch;
		}

		public static Span2D<T> DangerousCreate(ref T value, int height, int width, int pitch)
		{
			if (width < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			if (height < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if (pitch < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForPitch();
			}
			OverflowHelper.EnsureIsInNativeIntRange(height, width, pitch);
			return new Span2D<T>(ref value, height, width, pitch);
		}

		public void Clear()
		{
			if (IsEmpty)
			{
				return;
			}
			if (TryGetSpan(out var span))
			{
				span.Clear();
				return;
			}
			for (int i = 0; i < Height; i++)
			{
				GetRowSpan(i).Clear();
			}
		}

		public void CopyTo(Span<T> destination)
		{
			if (IsEmpty)
			{
				return;
			}
			if (TryGetSpan(out var span))
			{
				span.CopyTo(destination);
				return;
			}
			if (Length > destination.Length)
			{
				ThrowHelper.ThrowArgumentExceptionForDestinationTooShort();
			}
			int num = 0;
			int num2 = 0;
			while (num < Height)
			{
				GetRowSpan(num).CopyTo(destination.Slice(num2));
				num++;
				num2 += width;
			}
		}

		public void CopyTo(Span2D<T> destination)
		{
			if (destination.Height != Height || destination.width != width)
			{
				ThrowHelper.ThrowArgumentExceptionForDestinationWithNotSameShape();
			}
			if (IsEmpty)
			{
				return;
			}
			if (destination.TryGetSpan(out Span<T> destination2))
			{
				CopyTo(destination2);
				return;
			}
			for (int i = 0; i < Height; i++)
			{
				GetRowSpan(i).CopyTo(destination.GetRowSpan(i));
			}
		}

		public bool TryCopyTo(Span<T> destination)
		{
			if (destination.Length >= Length)
			{
				CopyTo(destination);
				return true;
			}
			return false;
		}

		public bool TryCopyTo(Span2D<T> destination)
		{
			if (destination.Height == Height && destination.Width == width)
			{
				CopyTo(destination);
				return true;
			}
			return false;
		}

		public void Fill(T value)
		{
			if (IsEmpty)
			{
				return;
			}
			if (TryGetSpan(out var span))
			{
				span.Fill(value);
				return;
			}
			for (int i = 0; i < Height; i++)
			{
				GetRowSpan(i).Fill(value);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public unsafe ref T GetPinnableReference()
		{
			ref T result = ref Unsafe.AsRef<T>(null);
			if (Length != 0)
			{
				result = ref MemoryMarshal.GetReference(span);
			}
			return ref result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ref T DangerousGetReference()
		{
			return ref MemoryMarshal.GetReference(span);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ref T DangerousGetReferenceAt(int i, int j)
		{
			ref T reference = ref MemoryMarshal.GetReference(span);
			nint elementOffset = (nint)(uint)i * (nint)(uint)Stride + (nint)(uint)j;
			return ref Unsafe.Add(ref reference, elementOffset);
		}

		public Span2D<T> Slice(int row, int column, int height, int width)
		{
			if ((uint)row >= Height)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForRow();
			}
			if ((uint)column >= this.width)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForColumn();
			}
			if ((uint)height > Height - row)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForHeight();
			}
			if ((uint)width > this.width - column)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForWidth();
			}
			nint i = (nint)(uint)Stride * (nint)(uint)row + (nint)(uint)column;
			int pitch = Stride - width;
			return new Span2D<T>(ref span.DangerousGetReferenceAt(i), height, width, pitch);
		}

		public Span<T> GetRowSpan(int row)
		{
			if ((uint)row >= (uint)Height)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForRow();
			}
			return MemoryMarshal.CreateSpan(ref DangerousGetReferenceAt(row, 0), width);
		}

		public bool TryGetSpan(out Span<T> span)
		{
			if (Stride == width && Length <= int.MaxValue)
			{
				span = MemoryMarshal.CreateSpan(ref MemoryMarshal.GetReference(this.span), (int)Length);
				return true;
			}
			span = default(Span<T>);
			return false;
		}

		public T[,] ToArray()
		{
			T[,] array = new T[Height, width];
			CopyTo(array.AsSpan());
			return array;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		[Obsolete("Equals() on Span will always throw an exception. Use == instead.")]
		public override bool Equals(object? obj)
		{
			throw new NotSupportedException("Microsoft.Toolkit.HighPerformance.Span2D<T>.Equals(object) is not supported");
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		[Obsolete("GetHashCode() on Span will always throw an exception.")]
		public override int GetHashCode()
		{
			throw new NotSupportedException("Microsoft.Toolkit.HighPerformance.Span2D<T>.GetHashCode() is not supported");
		}

		public override string ToString()
		{
			return $"Microsoft.Toolkit.HighPerformance.Span2D<{typeof(T)}>[{Height}, {width}]";
		}

		public static bool operator ==(Span2D<T> left, Span2D<T> right)
		{
			if (left.span == right.span && left.width == right.width)
			{
				return left.Stride == right.Stride;
			}
			return false;
		}

		public static bool operator !=(Span2D<T> left, Span2D<T> right)
		{
			return !(left == right);
		}

		public static implicit operator Span2D<T>(T[,]? array)
		{
			return new Span2D<T>(array);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public RefEnumerable<T> GetRow(int row)
		{
			if ((uint)row >= Height)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForRow();
			}
			nint elementOffset = (nint)(uint)Stride * (nint)(uint)row;
			return new RefEnumerable<T>(ref Unsafe.Add(ref DangerousGetReference(), elementOffset), Width, 1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public RefEnumerable<T> GetColumn(int column)
		{
			if ((uint)column >= Width)
			{
				ThrowHelper.ThrowArgumentOutOfRangeExceptionForColumn();
			}
			return new RefEnumerable<T>(ref Unsafe.Add(ref DangerousGetReference(), (nint)(uint)column), Height, Stride);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Enumerator GetEnumerator()
		{
			return new Enumerator(this);
		}
	}
	public readonly ref struct NullableReadOnlyRef<T>
	{
		private readonly ReadOnlySpan<T> span;

		public static NullableReadOnlyRef<T> Null
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return default(NullableReadOnlyRef<T>);
			}
		}

		public bool HasValue
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				byte b = (byte)span.Length;
				return b != 0;
			}
		}

		public ref readonly T Value
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if (!HasValue)
				{
					ThrowInvalidOperationException();
				}
				return ref MemoryMarshal.GetReference(span);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public NullableReadOnlyRef(in T value)
		{
			span = MemoryMarshal.CreateReadOnlySpan(in Unsafe.AsRef(in value), 1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private NullableReadOnlyRef(ReadOnlySpan<T> span)
		{
			this.span = span;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static implicit operator NullableReadOnlyRef<T>(Ref<T> reference)
		{
			return new NullableReadOnlyRef<T>(reference.Span);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static implicit operator NullableReadOnlyRef<T>(ReadOnlyRef<T> reference)
		{
			return new NullableReadOnlyRef<T>(reference.Span);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static implicit operator NullableReadOnlyRef<T>(NullableRef<T> reference)
		{
			return new NullableReadOnlyRef<T>(reference.Span);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static explicit operator T(NullableReadOnlyRef<T> reference)
		{
			return reference.Value;
		}

		private static void ThrowInvalidOperationException()
		{
			throw new InvalidOperationException("The current instance doesn't have a value that can be accessed");
		}
	}
	public readonly ref struct NullableRef<T>
	{
		internal readonly Span<T> Span;

		public static NullableRef<T> Null
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return default(NullableRef<T>);
			}
		}

		public bool HasValue
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				byte b = (byte)Span.Length;
				return b != 0;
			}
		}

		public ref T Value
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if (!HasValue)
				{
					ThrowInvalidOperationException();
				}
				return ref MemoryMarshal.GetReference(Span);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public NullableRef(ref T value)
		{
			Span = MemoryMarshal.CreateSpan(ref value, 1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private NullableRef(Span<T> span)
		{
			Span = span;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static implicit operator NullableRef<T>(Ref<T> reference)
		{
			return new NullableRef<T>(reference.Span);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static explicit operator T(NullableRef<T> reference)
		{
			return reference.Value;
		}

		private static void ThrowInvalidOperationException()
		{
			throw new InvalidOperationException("The current instance doesn't have a value that can be accessed");
		}
	}
	public readonly ref struct ReadOnlyRef<T>
	{
		internal readonly ReadOnlySpan<T> Span;

		public ref readonly T Value
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return ref MemoryMarshal.GetReference(Span);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlyRef(in T value)
		{
			Span = MemoryMarshal.CreateReadOnlySpan(in Unsafe.AsRef(in value), 1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe ReadOnlyRef(void* pointer)
			: this(in Unsafe.AsRef<T>(pointer))
		{
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static implicit operator ReadOnlyRef<T>(Ref<T> reference)
		{
			return new ReadOnlyRef<T>(in reference.Value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static implicit operator T(ReadOnlyRef<T> reference)
		{
			return reference.Value;
		}
	}
	public readonly ref struct Ref<T>
	{
		internal readonly Span<T> Span;

		public ref T Value
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return ref MemoryMarshal.GetReference(Span);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Ref(ref T value)
		{
			Span = MemoryMarshal.CreateSpan(ref value, 1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe Ref(void* pointer)
			: this(ref Unsafe.AsRef<T>(pointer))
		{
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static implicit operator T(Ref<T> reference)
		{
			return reference.Value;
		}
	}
}
namespace Microsoft.Toolkit.HighPerformance.Streams
{
	internal sealed class IBufferWriterStream<TWriter> : Stream where TWriter : struct, IBufferWriter<byte>
	{
		private readonly TWriter bufferWriter;

		private bool disposed;

		public override bool CanRead => false;

		public override bool CanSeek => false;

		public override bool CanWrite
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return !disposed;
			}
		}

		public override long Length
		{
			get
			{
				throw MemoryStream.GetNotSupportedException();
			}
		}

		public override long Position
		{
			get
			{
				throw MemoryStream.GetNotSupportedException();
			}
			set
			{
				throw MemoryStream.GetNotSupportedException();
			}
		}

		public IBufferWriterStream(TWriter bufferWriter)
		{
			this.bufferWriter = bufferWriter;
		}

		public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
		{
			throw MemoryStream.GetNotSupportedException();
		}

		public override void Flush()
		{
		}

		public override Task FlushAsync(CancellationToken cancellationToken)
		{
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled(cancellationToken);
			}
			return Task.CompletedTask;
		}

		public override Task<int> ReadAsync(byte[]? buffer, int offset, int count, CancellationToken cancellationToken)
		{
			throw MemoryStream.GetNotSupportedException();
		}

		public override Task WriteAsync(byte[]? buffer, int offset, int count, CancellationToken cancellationToken)
		{
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled(cancellationToken);
			}
			try
			{
				Write(buffer, offset, count);
				return Task.CompletedTask;
			}
			catch (OperationCanceledException ex)
			{
				return Task.FromCanceled(ex.CancellationToken);
			}
			catch (Exception exception)
			{
				return Task.FromException(exception);
			}
		}

		public override long Seek(long offset, SeekOrigin origin)
		{
			throw MemoryStream.GetNotSupportedException();
		}

		public override void SetLength(long value)
		{
			throw MemoryStream.GetNotSupportedException();
		}

		public override int Read(byte[]? buffer, int offset, int count)
		{
			throw MemoryStream.GetNotSupportedException();
		}

		public override int ReadByte()
		{
			throw