@ai-dev-tools/csharp-copilot-core 0.0.19

package/out/atmpCache/deps/ToListCountAnalyzerTests_ToListinatorTests_test_AIUnitTestExample_code_d.deps

@@ -0,0 +1,4037 @@
+1c5ded8f87076b61c34d140f14727e1b3c711a455cf7cd7587bdd92caf60b28a
+
+#### Xunit.Assert
+```C#
+using System;
+using System.Collections;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.ExceptionServices;
+using System.Runtime.InteropServices;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using Xunit.Internal;
+using Xunit.Sdk;
+namespace Xunit;
+public class Assert
+{
+	public class RaisedEvent<T>
+	{
+		public object? Sender
+		{
+			[CompilerGenerated]
+			get;
+		}
+		public T Arguments
+		{
+			[CompilerGenerated]
+			get;
+		}
+		public RaisedEvent(T args)
+			: this((object?)null, args)
+		{
+		}
+		public RaisedEvent(object? sender, T args)
+		{
+			Sender = sender;
+			Arguments = args;
+		}
+	}
+	[CompilerGenerated]
+	private sealed class <>c__DisplayClass133_0
+	{
+		public bool result;
+		internal void <RaisesAsyncInternal>b__0()
+		{
+			result = true;
+		}
+	}
+	[CompilerGenerated]
+	private sealed class <>c__DisplayClass134_0
+	{
+		public RaisedEvent<EventArgs> raisedEvent;
+	}
+	[CompilerGenerated]
+	private sealed class <>c__DisplayClass135_0<T> where T : notnull
+	{
+		public RaisedEvent<T> raisedEvent;
+		internal void <RaisesAsyncInternal>b__0(T args)
+		{
+			raisedEvent = new RaisedEvent<T>(args);
+		}
+	}
+	[CompilerGenerated]
+	private sealed class <>c__DisplayClass136_0<T> where T : notnull
+	{
+		public RaisedEvent<T> raisedEvent;
+	}
+	[CompilerGenerated]
+	private sealed class <>c__DisplayClass179_0
+	{
+		public bool propertyChangeHappened;
+		public string propertyName;
+		internal void <PropertyChangedAsync>b__0(object? sender, PropertyChangedEventArgs args)
+		{
+			propertyChangeHappened = propertyChangeHappened || string.IsNullOrEmpty(args.PropertyName) || propertyName.Equals(args.PropertyName, (StringComparison)5);
+		}
+	}
+	[CompilerGenerated]
+	private sealed class <>c__DisplayClass44_0<T> where T : notnull
+	{
+		[StructLayout((LayoutKind)3)]
+		private struct <<AllAsync>b__0>d : IAsyncStateMachine
+		{
+			public int <>1__state;
+			public AsyncTaskMethodBuilder <>t__builder;
+			public <>c__DisplayClass44_0<T> <>4__this;
+			public T item;
+			private TaskAwaiter <>u__1;
+			private void MoveNext()
+			{
+				int num = <>1__state;
+				<>c__DisplayClass44_0<T> <>c__DisplayClass44_ = <>4__this;
+				try
+				{
+					TaskAwaiter val;
+					if (num != 0)
+					{
+						val = <>c__DisplayClass44_.action.Invoke(item).GetAwaiter();
+						if (!((TaskAwaiter)(ref val)).IsCompleted)
+						{
+							num = (<>1__state = 0);
+							<>u__1 = val;
+							((AsyncTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<TaskAwaiter, <<AllAsync>b__0>d>(ref val, ref this);
+							return;
+						}
+					}
+					else
+					{
+						val = <>u__1;
+						<>u__1 = default(TaskAwaiter);
+						num = (<>1__state = -1);
+					}
+					((TaskAwaiter)(ref val)).GetResult();
+				}
+				catch (System.Exception exception)
+				{
+					<>1__state = -2;
+					((AsyncTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
+					return;
+				}
+				<>1__state = -2;
+				((AsyncTaskMethodBuilder)(ref <>t__builder)).SetResult();
+			}
+			[DebuggerHidden]
+			private void SetStateMachine(IAsyncStateMachine stateMachine)
+			{
+				((AsyncTaskMethodBuilder)(ref <>t__builder)).SetStateMachine(stateMachine);
+			}
+		}
+		public Func<T, System.Threading.Tasks.Task> action;
+		[AsyncStateMachine(typeof(<>c__DisplayClass44_0<>.<<AllAsync>b__0>d))]
+		internal System.Threading.Tasks.Task <AllAsync>b__0(T item, int index)
+		{
+			<<AllAsync>b__0>d <<AllAsync>b__0>d = default(<<AllAsync>b__0>d);
+			<<AllAsync>b__0>d.<>t__builder = AsyncTaskMethodBuilder.Create();
+			<<AllAsync>b__0>d.<>4__this = this;
+			<<AllAsync>b__0>d.item = item;
+			<<AllAsync>b__0>d.<>1__state = -1;
+			((AsyncTaskMethodBuilder)(ref <<AllAsync>b__0>d.<>t__builder)).Start<<<AllAsync>b__0>d>(ref <<AllAsync>b__0>d);
+			return ((AsyncTaskMethodBuilder)(ref <<AllAsync>b__0>d.<>t__builder)).Task;
+		}
+	}
+	[StructLayout((LayoutKind)3)]
+	[CompilerGenerated]
+	private struct <AllAsync>d__44<T> : IAsyncStateMachine where T : notnull
+	{
+		public int <>1__state;
+		public AsyncTaskMethodBuilder <>t__builder;
+		public Func<T, System.Threading.Tasks.Task> action;
+		public System.Collections.Generic.IEnumerable<T> collection;
+		private TaskAwaiter <>u__1;
+		private void MoveNext()
+		{
+			int num = <>1__state;
+			try
+			{
+				TaskAwaiter val;
+				if (num != 0)
+				{
+					<>c__DisplayClass44_0<T> CS$<>8__locals2 = new <>c__DisplayClass44_0<T>
+					{
+						action = action
+					};
+					GuardArgumentNotNull("collection", collection);
+					GuardArgumentNotNull<Func<T, System.Threading.Tasks.Task>>("action", CS$<>8__locals2.action);
+					val = AllAsync(collection, (Func<T, int, System.Threading.Tasks.Task>)([AsyncStateMachine(typeof(<>c__DisplayClass44_0<>.<<AllAsync>b__0>d))] (T item, int index) =>
+					{
+						<>c__DisplayClass44_0<T>.<<AllAsync>b__0>d <<AllAsync>b__0>d = default(<>c__DisplayClass44_0<T>.<<AllAsync>b__0>d);
+						<<AllAsync>b__0>d.<>t__builder = AsyncTaskMethodBuilder.Create();
+						<<AllAsync>b__0>d.<>4__this = CS$<>8__locals2;
+						<<AllAsync>b__0>d.item = item;
+						<<AllAsync>b__0>d.<>1__state = -1;
+						((AsyncTaskMethodBuilder)(ref <<AllAsync>b__0>d.<>t__builder)).Start<<>c__DisplayClass44_0<T>.<<AllAsync>b__0>d>(ref <<AllAsync>b__0>d);
+						return ((AsyncTaskMethodBuilder)(ref <<AllAsync>b__0>d.<>t__builder)).Task;
+					})).GetAwaiter();
+					if (!((TaskAwaiter)(ref val)).IsCompleted)
+					{
+						num = (<>1__state = 0);
+						<>u__1 = val;
+						((AsyncTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<TaskAwaiter, <AllAsync>d__44<T>>(ref val, ref this);
+						return;
+					}
+				}
+				else
+				{
+					val = <>u__1;
+					<>u__1 = default(TaskAwaiter);
+					num = (<>1__state = -1);
+				}
+				((TaskAwaiter)(ref val)).GetResult();
+			}
+			catch (System.Exception exception)
+			{
+				<>1__state = -2;
+				((AsyncTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
+				return;
+			}
+			<>1__state = -2;
+			((AsyncTaskMethodBuilder)(ref <>t__builder)).SetResult();
+		}
+		[DebuggerHidden]
+		private void SetStateMachine(IAsyncStateMachine stateMachine)
+		{
+			((AsyncTaskMethodBuilder)(ref <>t__builder)).SetStateMachine(stateMachine);
+		}
+	}
+	[StructLayout((LayoutKind)3)]
+	[CompilerGenerated]
+	private struct <AllAsync>d__45<T> : IAsyncStateMachine where T : notnull
+	{
+		public int <>1__state;
+		public AsyncTaskMethodBuilder <>t__builder;
+		public System.Collections.Generic.IEnumerable<T> collection;
+		public Func<T, int, System.Threading.Tasks.Task> action;
+		private List<Tuple<int, string, System.Exception>> <errors>5__2;
+		private int <idx>5__3;
+		private System.Collections.Generic.IEnumerator<T> <>7__wrap3;
+		private T <item>5__5;
+		private TaskAwaiter <>u__1;
+		private void MoveNext()
+		{
+			int num = <>1__state;
+			try
+			{
+				if (num != 0)
+				{
+					GuardArgumentNotNull("collection", collection);
+					GuardArgumentNotNull<Func<T, int, System.Threading.Tasks.Task>>("action", action);
+					<errors>5__2 = new List<Tuple<int, string, System.Exception>>();
+					<idx>5__3 = 0;
+					<>7__wrap3 = collection.GetEnumerator();
+				}
+				try
+				{
+					if (num == 0)
+					{
+						goto IL_006a;
+					}
+					goto IL_0122;
+					IL_0122:
+					if (((System.Collections.IEnumerator)<>7__wrap3).MoveNext())
+					{
+						<item>5__5 = <>7__wrap3.Current;
+						goto IL_006a;
+					}
+					goto end_IL_0050;
+					IL_006a:
+					try
+					{
+						TaskAwaiter val;
+						if (num != 0)
+						{
+							val = action.Invoke(<item>5__5, <idx>5__3).GetAwaiter();
+							if (!((TaskAwaiter)(ref val)).IsCompleted)
+							{
+								num = (<>1__state = 0);
+								<>u__1 = val;
+								((AsyncTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<TaskAwaiter, <AllAsync>d__45<T>>(ref val, ref this);
+								return;
+							}
+						}
+						else
+						{
+							val = <>u__1;
+							<>u__1 = default(TaskAwaiter);
+							num = (<>1__state = -1);
+						}
+						((TaskAwaiter)(ref val)).GetResult();
+					}
+					catch (System.Exception ex)
+					{
+						<errors>5__2.Add(new Tuple<int, string, System.Exception>(<idx>5__3, ArgumentFormatter.Format(<item>5__5), ex));
+					}
+					int num2 = <idx>5__3 + 1;
+					<idx>5__3 = num2;
+					<item>5__5 = default(T);
+					goto IL_0122;
+					end_IL_0050:;
+				}
+				finally
+				{
+					if (num < 0 && <>7__wrap3 != null)
+					{
+						((System.IDisposable)<>7__wrap3).Dispose();
+					}
+				}
+				<>7__wrap3 = null;
+				if (<errors>5__2.Count > 0)
+				{
+					throw AllException.ForFailures(<idx>5__3, <errors>5__2.ToArray());
+				}
+			}
+			catch (System.Exception exception)
+			{
+				<>1__state = -2;
+				<errors>5__2 = null;
+				((AsyncTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
+				return;
+			}
+			<>1__state = -2;
+			<errors>5__2 = null;
+			((AsyncTaskMethodBuilder)(ref <>t__builder)).SetResult();
+		}
+		[DebuggerHidden]
+		private void SetStateMachine(IAsyncStateMachine stateMachine)
+		{
+			((AsyncTaskMethodBuilder)(ref <>t__builder)).SetStateMachine(stateMachine);
+		}
+	}
+	[StructLayout((LayoutKind)3)]
+	[CompilerGenerated]
+	private struct <CollectionAsync>d__47<T> : IAsyncStateMachine where T : notnull
+	{
+		public int <>1__state;
+		public AsyncTaskMethodBuilder <>t__builder;
+		public System.Collections.Generic.IEnumerable<T> collection;
+		public Func<T, System.Threading.Tasks.Task>[] elementInspectors;
+		private CollectionTracker<T> <tracker>5__2;
+		private int <index>5__3;
+		private System.Collections.Generic.IEnumerator<T> <>7__wrap3;
+		private TaskAwaiter <>u__1;
+		private void MoveNext()
+		{
+			int num = <>1__state;
+			try
+			{
+				if (num != 0)
+				{
+					GuardArgumentNotNull("collection", collection);
+					GuardArgumentNotNull("elementInspectors", elementInspectors);
+					<tracker>5__2 = collection.AsTracker();
+				}
+				try
+				{
+					if (num != 0)
+					{
+						<index>5__3 = 0;
+						<>7__wrap3 = <tracker>5__2.GetEnumerator();
+					}
+					try
+					{
+						if (num == 0)
+						{
+							goto IL_006f;
+						}
+						goto IL_0128;
+						IL_0128:
+						T current = default(T);
+						if (((System.Collections.IEnumerator)<>7__wrap3).MoveNext())
+						{
+							current = <>7__wrap3.Current;
+							goto IL_006f;
+						}
+						goto end_IL_005a;
+						IL_006f:
+						try
+						{
+							TaskAwaiter val;
+							if (num == 0)
+							{
+								val = <>u__1;
+								<>u__1 = default(TaskAwaiter);
+								num = (<>1__state = -1);
+								goto IL_00e3;
+							}
+							if (<index>5__3 < elementInspectors.Length)
+							{
+								val = elementInspectors[<index>5__3].Invoke(current).GetAwaiter();
+								if (!((TaskAwaiter)(ref val)).IsCompleted)
+								{
+									num = (<>1__state = 0);
+									<>u__1 = val;
+									((AsyncTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<TaskAwaiter, <CollectionAsync>d__47<T>>(ref val, ref this);
+									return;
+								}
+								goto IL_00e3;
+							}
+							goto end_IL_006f;
+							IL_00e3:
+							((TaskAwaiter)(ref val)).GetResult();
+							end_IL_006f:;
+						}
+						catch (System.Exception exception)
+						{
+							int? pointerIndent;
+							throw CollectionException.ForMismatchedItem(formattedCollection: <tracker>5__2.FormatIndexedMismatch(<index>5__3, out pointerIndent), exception: exception, indexFailurePoint: <index>5__3, failurePointerIndent: pointerIndent);
+						}
+						<index>5__3++;
+						goto IL_0128;
+						end_IL_005a:;
+					}
+					finally
+					{
+						if (num < 0 && <>7__wrap3 != null)
+						{
+							((System.IDisposable)<>7__wrap3).Dispose();
+						}
+					}
+					<>7__wrap3 = null;
+					if (<tracker>5__2.IterationCount != elementInspectors.Length)
+					{
+						throw CollectionException.ForMismatchedItemCount(elementInspectors.Length, <tracker>5__2.IterationCount, <tracker>5__2.FormatStart());
+					}
+				}
+				finally
+				{
+					if (num < 0 && <tracker>5__2 != null)
+					{
+						((System.IDisposable)<tracker>5__2).Dispose();
+					}
+				}
+				<tracker>5__2 = null;
+			}
+			catch (System.Exception exception2)
+			{
+				<>1__state = -2;
+				((AsyncTaskMethodBuilder)(ref <>t__builder)).SetException(exception2);
+				return;
+			}
+			<>1__state = -2;
+			((AsyncTaskMethodBuilder)(ref <>t__builder)).SetResult();
+		}
+		[DebuggerHidden]
+		private void SetStateMachine(IAsyncStateMachine stateMachine)
+		{
+			((AsyncTaskMethodBuilder)(ref <>t__builder)).SetStateMachine(stateMachine);
+		}
+	}
+	[StructLayout((LayoutKind)3)]
+	[CompilerGenerated]
+	private struct <PropertyChangedAsync>d__179 : IAsyncStateMachine
+	{
+		public int <>1__state;
+		public AsyncTaskMethodBuilder <>t__builder;
+		public string propertyName;
+		public INotifyPropertyChanged @object;
+		public Func<System.Threading.Tasks.Task> testCode;
+		private <>c__DisplayClass179_0 <>8__1;
+		private PropertyChangedEventHandler <handler>5__2;
+		private TaskAwaiter <>u__1;
+		private void MoveNext()
+		{
+			int num = <>1__state;
+			try
+			{
+				if (num != 0)
+				{
+					<>8__1 = new <>c__DisplayClass179_0();
+					<>8__1.propertyName = propertyName;
+					GuardArgumentNotNull<INotifyPropertyChanged>("object", @object);
+					GuardArgumentNotNull("propertyName", <>8__1.propertyName);
+					GuardArgumentNotNull<Func<System.Threading.Tasks.Task>>("testCode", testCode);
+					<>8__1.propertyChangeHappened = false;
+					<handler>5__2 = (PropertyChangedEventHandler)delegate(object? sender, PropertyChangedEventArgs args)
+					{
+						<>8__1.propertyChangeHappened = <>8__1.propertyChangeHappened || string.IsNullOrEmpty(args.PropertyName) || <>8__1.propertyName.Equals(args.PropertyName, (StringComparison)5);
+					};
+					@object.PropertyChanged += <handler>5__2;
+				}
+				try
+				{
+					TaskAwaiter val;
+					if (num != 0)
+					{
+						val = testCode.Invoke().GetAwaiter();
+						if (!((TaskAwaiter)(ref val)).IsCompleted)
+						{
+							num = (<>1__state = 0);
+							<>u__1 = val;
+							((AsyncTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<TaskAwaiter, <PropertyChangedAsync>d__179>(ref val, ref this);
+							return;
+						}
+					}
+					else
+					{
+						val = <>u__1;
+						<>u__1 = default(TaskAwaiter);
+						num = (<>1__state = -1);
+					}
+					((TaskAwaiter)(ref val)).GetResult();
+					if (!<>8__1.propertyChangeHappened)
+					{
+						throw PropertyChangedException.ForUnsetProperty(<>8__1.propertyName);
+					}
+				}
+				finally
+				{
+					if (num < 0)
+					{
+						@object.PropertyChanged -= <handler>5__2;
+					}
+				}
+			}
+			catch (System.Exception exception)
+			{
+				<>1__state = -2;
+				<>8__1 = null;
+				<handler>5__2 = null;
+				((AsyncTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
+				return;
+			}
+			<>1__state = -2;
+			<>8__1 = null;
+			<handler>5__2 = null;
+			((AsyncTaskMethodBuilder)(ref <>t__builder)).SetResult();
+		}
+		[DebuggerHidden]
+		private void SetStateMachine(IAsyncStateMachine stateMachine)
+		{
+			((AsyncTaskMethodBuilder)(ref <>t__builder)).SetStateMachine(stateMachine);
+		}
+	}
+	[StructLayout((LayoutKind)3)]
+	[CompilerGenerated]
+	private struct <RaisesAnyAsync>d__122 : IAsyncStateMachine
+	{
+		public int <>1__state;
+		public AsyncTaskMethodBuilder<RaisedEvent<EventArgs>> <>t__builder;
+		public Action<EventHandler> attach;
+		public Action<EventHandler> detach;
+		public Func<System.Threading.Tasks.Task> testCode;
+		private TaskAwaiter<RaisedEvent<EventArgs>?> <>u__1;
+		private void MoveNext()
+		{
+			int num = <>1__state;
+			RaisedEvent<EventArgs> result;
+			try
+			{
+				TaskAwaiter<RaisedEvent<EventArgs>> val;
+				if (num != 0)
+				{
+					val = RaisesAsyncInternal(attach, detach, testCode).GetAwaiter();
+					if (!val.IsCompleted)
+					{
+						num = (<>1__state = 0);
+						<>u__1 = val;
+						<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter<RaisedEvent<EventArgs>>, <RaisesAnyAsync>d__122>(ref val, ref this);
+						return;
+					}
+				}
+				else
+				{
+					val = <>u__1;
+					<>u__1 = default(TaskAwaiter<RaisedEvent<EventArgs>>);
+					num = (<>1__state = -1);
+				}
+				result = val.GetResult() ?? throw RaisesAnyException.ForNoEvent(typeof(EventArgs));
+			}
+			catch (System.Exception exception)
+			{
+				<>1__state = -2;
+				<>t__builder.SetException(exception);
+				return;
+			}
+			<>1__state = -2;
+			<>t__builder.SetResult(result);
+		}
+		[DebuggerHidden]
+		private void SetStateMachine(IAsyncStateMachine stateMachine)
+		{
+			<>t__builder.SetStateMachine(stateMachine);
+		}
+	}
+	[StructLayout((LayoutKind)3)]
+	[CompilerGenerated]
+	private struct <RaisesAnyAsync>d__123<T> : IAsyncStateMachine where T : notnull
+	{
+		public int <>1__state;
+		public AsyncTaskMethodBuilder<RaisedEvent<T>> <>t__builder;
+		public Action<Action<T>> attach;
+		public Action<Action<T>> detach;
+		public Func<System.Threading.Tasks.Task> testCode;
+		private TaskAwaiter<RaisedEvent<T>?> <>u__1;
+		private unsafe void MoveNext()
+		{
+			int num = <>1__state;
+			RaisedEvent<T> result;
+			try
+			{
+				TaskAwaiter<RaisedEvent<T>> val;
+				if (num != 0)
+				{
+					val = ((System.Threading.Tasks.Task<RaisedEvent<RaisedEvent<T>>>)(object)RaisesAsyncInternal<T>(attach, detach, testCode)).GetAwaiter();
+					if (!((TaskAwaiter<RaisedEvent<RaisedEvent<T>>>*)(&val))->IsCompleted)
+					{
+						num = (<>1__state = 0);
+						<>u__1 = val;
+						System.Runtime.CompilerServices.Unsafe.As<AsyncTaskMethodBuilder<RaisedEvent<T>>, AsyncTaskMethodBuilder<RaisedEvent<RaisedEvent<T>>>>(ref <>t__builder).AwaitUnsafeOnCompleted<TaskAwaiter<RaisedEvent<T>>, <RaisesAnyAsync>d__123<T>>(ref val, ref this);
+						return;
+					}
+				}
+				else
+				{
+					val = <>u__1;
+					<>u__1 = default(TaskAwaiter<RaisedEvent<T>>);
+					num = (<>1__state = -1);
+				}
+				result = ((TaskAwaiter<RaisedEvent<RaisedEvent<T>>>*)(&val))->GetResult() ?? throw RaisesAnyException.ForNoEvent(typeof(T));
+			}
+			catch (System.Exception exception)
+			{
+				<>1__state = -2;
+				System.Runtime.CompilerServices.Unsafe.As<AsyncTaskMethodBuilder<RaisedEvent<T>>, AsyncTaskMethodBuilder<RaisedEvent<RaisedEvent<T>>>>(ref <>t__builder).SetException(exception);
+				return;
+			}
+			<>1__state = -2;
+			System.Runtime.CompilerServices.Unsafe.As<AsyncTaskMethodBuilder<RaisedEvent<T>>, AsyncTaskMethodBuilder<RaisedEvent<RaisedEvent<T>>>>(ref <>t__builder).SetResult((RaisedEvent<RaisedEvent<T>>)(object)result);
+		}
+		[DebuggerHidden]
+		private void SetStateMachine(IAsyncStateMachine stateMachine)
+		{
+			System.Runtime.CompilerServices.Unsafe.As<AsyncTaskMethodBuilder<RaisedEvent<T>>, AsyncTaskMethodBuilder<RaisedEvent<RaisedEvent<T>>>>(ref <>t__builder).SetStateMachine(stateMachine);
+		}
+	}
+	[StructLayout((LayoutKind)3)]
+	[CompilerGenerated]
+	private struct <RaisesAnyAsync>d__124<T> : IAsyncStateMachine where T : notnull
+	{
+		public int <>1__state;
+		public AsyncTaskMethodBuilder<RaisedEvent<T>> <>t__builder;
+		public Action<EventHandler<T>> attach;
+		public Action<EventHandler<T>> detach;
+		public Func<System.Threading.Tasks.Task> testCode;
+		private TaskAwaiter<RaisedEvent<T>?> <>u__1;
+		private unsafe void MoveNext()
+		{
+			int num = <>1__state;
+			RaisedEvent<T> result;
+			try
+			{
+				TaskAwaiter<RaisedEvent<T>> val;
+				if (num != 0)
+				{
+					val = ((System.Threading.Tasks.Task<RaisedEvent<RaisedEvent<T>>>)(object)RaisesAsyncInternal<T>(attach, detach, testCode)).GetAwaiter();
+					if (!((TaskAwaiter<RaisedEvent<RaisedEvent<T>>>*)(&val))->IsCompleted)
+					{
+						num = (<>1__state = 0);
+						<>u__1 = val;
+						System.Runtime.CompilerServices.Unsafe.As<AsyncTaskMethodBuilder<RaisedEvent<T>>, AsyncTaskMethodBuilder<RaisedEvent<RaisedEvent<T>>>>(ref <>t__builder).AwaitUnsafeOnCompleted<TaskAwaiter<RaisedEvent<T>>, <RaisesAnyAsync>d__124<T>>(ref val, ref this);
+						return;
+					}
+				}
+				else
+				{
+					val = <>u__1;
+					<>u__1 = default(TaskAwaiter<RaisedEvent<T>>);
+					num = (<>1__state = -1);
+				}
+				result = ((TaskAwaiter<RaisedEvent<RaisedEvent<T>>>*)(&val))->GetResult() ?? throw RaisesAnyException.ForNoEvent(typeof(T));
+			}
+			catch (System.Exception exception)
+			{
+				<>1__state = -2;
+				System.Runtime.CompilerServices.Unsafe.As<AsyncTaskMethodBuilder<RaisedEvent<T>>, AsyncTaskMethodBuilder<RaisedEvent<RaisedEvent<T>>>>(ref <>t__builder).SetException(exception);
+				return;
+			}
+			<>1__state = -2;
+			System.Runtime.CompilerServices.Unsafe.As<AsyncTaskMethodBuilder<RaisedEvent<T>>, AsyncTaskMethodBuilder<RaisedEvent<RaisedEvent<T>>>>(ref <>t__builder).SetResult((RaisedEvent<RaisedEvent<T>>)(object)result);
+		}
+		[DebuggerHidden]
+		private void SetStateMachine(IAsyncStateMachine stateMachine)
+		{
+			System.Runtime.CompilerServices.Unsafe.As<AsyncTaskMethodBuilder<RaisedEvent<T>>, AsyncTaskMethodBuilder<RaisedEvent<RaisedEvent<T>>>>(ref <>t__builder).SetStateMachine(stateMachine);
+		}
+	}
+	[StructLayout((LayoutKind)3)]
+	[CompilerGenerated]
+	private struct <RaisesAsync>d__125 : IAsyncStateMachine
+	{
+		public int <>1__state;
+		public AsyncTaskMethodBuilder <>t__builder;
+		public Action<Action> attach;
+		public Action<Action> detach;
+		public Func<System.Threading.Tasks.Task> testCode;
+		private TaskAwaiter<bool> <>u__1;
+		private void MoveNext()
+		{
+			int num = <>1__state;
+			try
+			{
+				TaskAwaiter<bool> val;
+				if (num != 0)
+				{
+					val = RaisesAsyncInternal(attach, detach, testCode).GetAwaiter();
+					if (!val.IsCompleted)
+					{
+						num = (<>1__state = 0);
+						<>u__1 = val;
+						((AsyncTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<TaskAwaiter<bool>, <RaisesAsync>d__125>(ref val, ref this);
+						return;
+					}
+				}
+				else
+				{
+					val = <>u__1;
+					<>u__1 = default(TaskAwaiter<bool>);
+					num = (<>1__state = -1);
+				}
+				if (!val.GetResult())
+				{
+					throw RaisesException.ForNoEvent();
+				}
+			}
+			catch (System.Exception exception)
+			{
+				<>1__state = -2;
+				((AsyncTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
+				return;
+			}
+			<>1__state = -2;
+			((AsyncTaskMethodBuilder)(ref <>t__builder)).SetResult();
+		}
+		[DebuggerHidden]
+		private void SetStateMachine(IAsyncStateMachine stateMachine)
+		{
+			((AsyncTaskMethodBuilder)(ref <>t__builder)).SetStateMachine(stateMachine);
+		}
+	}
+	[StructLayout((LayoutKind)3)]
+	[CompilerGenerated]
+	private struct <RaisesAsync>d__126<T> : IAsyncStateMachine where T : notnull
+	{
+		public int <>1__state;
+		public AsyncTaskMethodBuilder<RaisedEvent<T>> <>t__builder;
+		public Action<Action<T>> attach;
+		public Action<Action<T>> detach;
+		public Func<System.Threading.Tasks.Task> testCode;
+		private TaskAwaiter<RaisedEvent<T>?> <>u__1;
+		private unsafe void MoveNext()
+		{
+			int num = <>1__state;
+			RaisedEvent<T> result2;
+			try
+			{
+				TaskAwaiter<RaisedEvent<T>> val;
+				if (num != 0)
+				{
+					val = ((System.Threading.Tasks.Task<RaisedEvent<RaisedEvent<T>>>)(object)RaisesAsyncInternal<T>(attach, detach, testCode)).GetAwaiter();
+					if (!((TaskAwaiter<RaisedEvent<RaisedEvent<T>>>*)(&val))->IsCompleted)
+					{
+						num = (<>1__state = 0);
+						<>u__1 = val;
+						System.Runtime.CompilerServices.Unsafe.As<AsyncTaskMethodBuilder<RaisedEvent<T>>, AsyncTaskMethodBuilder<RaisedEvent<RaisedEvent<T>>>>(ref <>t__builder).AwaitUnsafeOnCompleted<TaskAwaiter<RaisedEvent<T>>, <RaisesAsync>d__126<T>>(ref val, ref this);
+						return;
+					}
+				}
+				else
+				{
+					val = <>u__1;
+					<>u__1 = default(TaskAwaiter<RaisedEvent<T>>);
+					num = (<>1__state = -1);
+				}
+				RaisedEvent<T> result = ((TaskAwaiter<RaisedEvent<RaisedEvent<T>>>*)(&val))->GetResult();
+				if (result == null)
+				{
+					throw RaisesException.ForNoEvent(typeof(T));
+				}
+				if (result.Arguments != null && !((object)result.Arguments/*cast due to .constrained prefix*/).GetType().Equals(typeof(T)))
+				{
+					throw RaisesException.ForIncorrectType(typeof(T), ((object)result.Arguments/*cast due to .constrained prefix*/).GetType());
+				}
+				result2 = result;
+			}
+			catch (System.Exception exception)
+			{
+				<>1__state = -2;
+				System.Runtime.CompilerServices.Unsafe.As<AsyncTaskMethodBuilder<RaisedEvent<T>>, AsyncTaskMethodBuilder<RaisedEvent<RaisedEvent<T>>>>(ref <>t__builder).SetException(exception);
+				return;
+			}
+			<>1__state = -2;
+			System.Runtime.CompilerServices.Unsafe.As<AsyncTaskMethodBuilder<RaisedEvent<T>>, AsyncTaskMethodBuilder<RaisedEvent<RaisedEvent<T>>>>(ref <>t__builder).SetResult((RaisedEvent<RaisedEvent<T>>)(object)result2);
+		}
+		[DebuggerHidden]
+		private void SetStateMachine(IAsyncStateMachine stateMachine)
+		{
+			System.Runtime.CompilerServices.Unsafe.As<AsyncTaskMethodBuilder<RaisedEvent<T>>, AsyncTaskMethodBuilder<RaisedEvent<RaisedEvent<T>>>>(ref <>t__builder).SetStateMachine(stateMachine);
+		}
+	}
+	[StructLayout((LayoutKind)3)]
+	[CompilerGenerated]
+	private struct <RaisesAsync>d__127<T> : IAsyncStateMachine where T : notnull
+	{
+		public int <>1__state;
+		public AsyncTaskMethodBuilder<RaisedEvent<T>> <>t__builder;
+		public Action<EventHandler<T>> attach;
+		public Action<EventHandler<T>> detach;
+		public Func<System.Threading.Tasks.Task> testCode;
+		private TaskAwaiter<RaisedEvent<T>?> <>u__1;
+		private unsafe void MoveNext()
+		{
+			int num = <>1__state;
+			RaisedEvent<T> result2;
+			try
+			{
+				TaskAwaiter<RaisedEvent<T>> val;
+				if (num != 0)
+				{
+					val = ((System.Threading.Tasks.Task<RaisedEvent<RaisedEvent<T>>>)(object)RaisesAsyncInternal<T>(attach, detach, testCode)).GetAwaiter();
+					if (!((TaskAwaiter<RaisedEvent<RaisedEvent<T>>>*)(&val))->IsCompleted)
+					{
+						num = (<>1__state = 0);
+						<>u__1 = val;
+						System.Runtime.CompilerServices.Unsafe.As<AsyncTaskMethodBuilder<RaisedEvent<T>>, AsyncTaskMethodBuilder<RaisedEvent<RaisedEvent<T>>>>(ref <>t__builder).AwaitUnsafeOnCompleted<TaskAwaiter<RaisedEvent<T>>, <RaisesAsync>d__127<T>>(ref val, ref this);
+						return;
+					}
+				}
+				else
+				{
+					val = <>u__1;
+					<>u__1 = default(TaskAwaiter<RaisedEvent<T>>);
+					num = (<>1__state = -1);
+				}
+				RaisedEvent<T> result = ((TaskAwaiter<RaisedEvent<RaisedEvent<T>>>*)(&val))->GetResult();
+				if (result == null)
+				{
+					throw RaisesException.ForNoEvent(typeof(T));
+				}
+				if (result.Arguments != null && !((object)result.Arguments/*cast due to .constrained prefix*/).GetType().Equals(typeof(T)))
+				{
+					throw RaisesException.ForIncorrectType(typeof(T), ((object)result.Arguments/*cast due to .constrained prefix*/).GetType());
+				}
+				result2 = result;
+			}
+			catch (System.Exception exception)
+			{
+				<>1__state = -2;
+				System.Runtime.CompilerServices.Unsafe.As<AsyncTaskMethodBuilder<RaisedEvent<T>>, AsyncTaskMethodBuilder<RaisedEvent<RaisedEvent<T>>>>(ref <>t__builder).SetException(exception);
+				return;
+			}
+			<>1__state = -2;
+			System.Runtime.CompilerServices.Unsafe.As<AsyncTaskMethodBuilder<RaisedEvent<T>>, AsyncTaskMethodBuilder<RaisedEvent<RaisedEvent<T>>>>(ref <>t__builder).SetResult((RaisedEvent<RaisedEvent<T>>)(object)result2);
+		}
+		[DebuggerHidden]
+		private void SetStateMachine(IAsyncStateMachine stateMachine)
+		{
+			System.Runtime.CompilerServices.Unsafe.As<AsyncTaskMethodBuilder<RaisedEvent<T>>, AsyncTaskMethodBuilder<RaisedEvent<RaisedEvent<T>>>>(ref <>t__builder).SetStateMachine(stateMachine);
+		}
+	}
+	[StructLayout((LayoutKind)3)]
+	[CompilerGenerated]
+	private struct <RaisesAsyncInternal>d__133 : IAsyncStateMachine
+	{
+		public int <>1__state;
+		public AsyncTaskMethodBuilder<bool> <>t__builder;
+		public Action<Action> attach;
+		public Action<Action> detach;
+		public Func<System.Threading.Tasks.Task> testCode;
+		private <>c__DisplayClass133_0 <>8__1;
+		private Action <handler>5__2;
+		private TaskAwaiter <>u__1;
+		private void MoveNext()
+		{
+			int num = <>1__state;
+			bool result;
+			try
+			{
+				TaskAwaiter val;
+				if (num != 0)
+				{
+					<>8__1 = new <>c__DisplayClass133_0();
+					GuardArgumentNotNull<Action<Action>>("attach", attach);
+					GuardArgumentNotNull<Action<Action>>("detach", detach);
+					GuardArgumentNotNull<Func<System.Threading.Tasks.Task>>("testCode", testCode);
+					<>8__1.result = false;
+					<handler>5__2 = (Action)delegate
+					{
+						<>8__1.result = true;
+					};
+					attach.Invoke(<handler>5__2);
+					val = testCode.Invoke().GetAwaiter();
+					if (!((TaskAwaiter)(ref val)).IsCompleted)
+					{
+						num = (<>1__state = 0);
+						<>u__1 = val;
+						<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter, <RaisesAsyncInternal>d__133>(ref val, ref this);
+						return;
+					}
+				}
+				else
+				{
+					val = <>u__1;
+					<>u__1 = default(TaskAwaiter);
+					num = (<>1__state = -1);
+				}
+				((TaskAwaiter)(ref val)).GetResult();
+				detach.Invoke(<handler>5__2);
+				result = <>8__1.result;
+			}
+			catch (System.Exception exception)
+			{
+				<>1__state = -2;
+				<>8__1 = null;
+				<handler>5__2 = null;
+				<>t__builder.SetException(exception);
+				return;
+			}
+			<>1__state = -2;
+			<>8__1 = null;
+			<handler>5__2 = null;
+			<>t__builder.SetResult(result);
+		}
+		[DebuggerHidden]
+		private void SetStateMachine(IAsyncStateMachine stateMachine)
+		{
+			<>t__builder.SetStateMachine(stateMachine);
+		}
+	}
+	[StructLayout((LayoutKind)3)]
+	[CompilerGenerated]
+	private struct <RaisesAsyncInternal>d__134 : IAsyncStateMachine
+	{
+		public int <>1__state;
+		public AsyncTaskMethodBuilder<RaisedEvent<EventArgs>> <>t__builder;
+		public Action<EventHandler> attach;
+		public Action<EventHandler> detach;
+		public Func<System.Threading.Tasks.Task> testCode;
+		private <>c__DisplayClass134_0 <>8__1;
+		private TaskAwaiter <>u__1;
+		private void MoveNext()
+		{
+			int num = <>1__state;
+			RaisedEvent<EventArgs> result;
+			try
+			{
+				TaskAwaiter val;
+				if (num != 0)
+				{
+					<>8__1 = new <>c__DisplayClass134_0();
+					GuardArgumentNotNull<Action<EventHandler>>("attach", attach);
+					GuardArgumentNotNull<Action<EventHandler>>("detach", detach);
+					GuardArgumentNotNull<Func<System.Threading.Tasks.Task>>("testCode", testCode);
+					<>8__1.raisedEvent = null;
+					attach.Invoke(new EventHandler(handler));
+					val = testCode.Invoke().GetAwaiter();
+					if (!((TaskAwaiter)(ref val)).IsCompleted)
+					{
+						num = (<>1__state = 0);
+						<>u__1 = val;
+						<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter, <RaisesAsyncInternal>d__134>(ref val, ref this);
+						return;
+					}
+				}
+				else
+				{
+					val = <>u__1;
+					<>u__1 = default(TaskAwaiter);
+					num = (<>1__state = -1);
+				}
+				((TaskAwaiter)(ref val)).GetResult();
+				detach.Invoke(new EventHandler(handler));
+				result = <>8__1.raisedEvent;
+			}
+			catch (System.Exception exception)
+			{
+				<>1__state = -2;
+				<>8__1 = null;
+				<>t__builder.SetException(exception);
+				return;
+			}
+			<>1__state = -2;
+			<>8__1 = null;
+			<>t__builder.SetResult(result);
+			void handler(object? s, EventArgs args)
+			{
+				((<>c__DisplayClass134_0)(object)this).raisedEvent = new RaisedEvent<EventArgs>(s, args);
+			}
+		}
+		[DebuggerHidden]
+		private void SetStateMachine(IAsyncStateMachine stateMachine)
+		{
+			<>t__builder.SetStateMachine(stateMachine);
+		}
+	}
+	[StructLayout((LayoutKind)3)]
+	[CompilerGenerated]
+	private struct <RaisesAsyncInternal>d__135<T> : IAsyncStateMachine where T : notnull
+	{
+		public int <>1__state;
+		public AsyncTaskMethodBuilder<RaisedEvent<T>> <>t__builder;
+		public Action<Action<T>> attach;
+		public Action<Action<T>> detach;
+		public Func<System.Threading.Tasks.Task> testCode;
+		private <>c__DisplayClass135_0<T> <>8__1;
+		private Action<T> <handler>5__2;
+		private TaskAwaiter <>u__1;
+		private void MoveNext()
+		{
+			int num = <>1__state;
+			RaisedEvent<T> result;
+			try
+			{
+				TaskAwaiter val;
+				if (num != 0)
+				{
+					<>8__1 = new <>c__DisplayClass135_0<T>();
+					GuardArgumentNotNull<Action<Action<T>>>("attach", attach);
+					GuardArgumentNotNull<Action<Action<T>>>("detach", detach);
+					GuardArgumentNotNull<Func<System.Threading.Tasks.Task>>("testCode", testCode);
+					<>8__1.raisedEvent = null;
+					<handler>5__2 = delegate(T args)
+					{
+						<>8__1.raisedEvent = new RaisedEvent<T>(args);
+					};
+					((Action<Action<Action<T>>>)(object)attach).Invoke((Action<Action<T>>)(object)<handler>5__2);
+					val = testCode.Invoke().GetAwaiter();
+					if (!((TaskAwaiter)(ref val)).IsCompleted)
+					{
+						num = (<>1__state = 0);
+						<>u__1 = val;
+						System.Runtime.CompilerServices.Unsafe.As<AsyncTaskMethodBuilder<RaisedEvent<T>>, AsyncTaskMethodBuilder<RaisedEvent<RaisedEvent<T>>>>(ref <>t__builder).AwaitUnsafeOnCompleted<TaskAwaiter, <RaisesAsyncInternal>d__135<T>>(ref val, ref this);
+						return;
+					}
+				}
+				else
+				{
+					val = <>u__1;
+					<>u__1 = default(TaskAwaiter);
+					num = (<>1__state = -1);
+				}
+				((TaskAwaiter)(ref val)).GetResult();
+				((Action<Action<Action<T>>>)(object)detach).Invoke((Action<Action<T>>)(object)<handler>5__2);
+				result = <>8__1.raisedEvent;
+			}
+			catch (System.Exception exception)
+			{
+				<>1__state = -2;
+				<>8__1 = null;
+				<handler>5__2 = null;
+				System.Runtime.CompilerServices.Unsafe.As<AsyncTaskMethodBuilder<RaisedEvent<T>>, AsyncTaskMethodBuilder<RaisedEvent<RaisedEvent<T>>>>(ref <>t__builder).SetException(exception);
+				return;
+			}
+			<>1__state = -2;
+			<>8__1 = null;
+			<handler>5__2 = null;
+			System.Runtime.CompilerServices.Unsafe.As<AsyncTaskMethodBuilder<RaisedEvent<T>>, AsyncTaskMethodBuilder<RaisedEvent<RaisedEvent<T>>>>(ref <>t__builder).SetResult((RaisedEvent<RaisedEvent<T>>)(object)result);
+		}
+		[DebuggerHidden]
+		private void SetStateMachine(IAsyncStateMachine stateMachine)
+		{
+			System.Runtime.CompilerServices.Unsafe.As<AsyncTaskMethodBuilder<RaisedEvent<T>>, AsyncTaskMethodBuilder<RaisedEvent<RaisedEvent<T>>>>(ref <>t__builder).SetStateMachine(stateMachine);
+		}
+	}
+	[StructLayout((LayoutKind)3)]
+	[CompilerGenerated]
+	private struct <RaisesAsyncInternal>d__136<T> : IAsyncStateMachine where T : notnull
+	{
+		public int <>1__state;
+		public AsyncTaskMethodBuilder<RaisedEvent<T>> <>t__builder;
+		public Action<EventHandler<T>> attach;
+		public Action<EventHandler<T>> detach;
+		public Func<System.Threading.Tasks.Task> testCode;
+		private <>c__DisplayClass136_0<T> <>8__1;
+		private TaskAwaiter <>u__1;
+		private void MoveNext()
+		{
+			int num = <>1__state;
+			RaisedEvent<T> result;
+			try
+			{
+				TaskAwaiter val;
+				if (num != 0)
+				{
+					<>8__1 = new <>c__DisplayClass136_0<T>();
+					GuardArgumentNotNull<Action<EventHandler<T>>>("attach", attach);
+					GuardArgumentNotNull<Action<EventHandler<T>>>("detach", detach);
+					GuardArgumentNotNull<Func<System.Threading.Tasks.Task>>("testCode", testCode);
+					<>8__1.raisedEvent = null;
+					((Action<EventHandler<EventHandler<T>>>)(object)attach).Invoke((EventHandler<EventHandler<T>>)(object)new EventHandler<T>(handler));
+					val = testCode.Invoke().GetAwaiter();
+					if (!((TaskAwaiter)(ref val)).IsCompleted)
+					{
+						num = (<>1__state = 0);
+						<>u__1 = val;
+						System.Runtime.CompilerServices.Unsafe.As<AsyncTaskMethodBuilder<RaisedEvent<T>>, AsyncTaskMethodBuilder<RaisedEvent<RaisedEvent<T>>>>(ref <>t__builder).AwaitUnsafeOnCompleted<TaskAwaiter, <RaisesAsyncInternal>d__136<T>>(ref val, ref this);
+						return;
+					}
+				}
+				else
+				{
+					val = <>u__1;
+					<>u__1 = default(TaskAwaiter);
+					num = (<>1__state = -1);
+				}
+				((TaskAwaiter)(ref val)).GetResult();
+				((Action<EventHandler<EventHandler<T>>>)(object)detach).Invoke((EventHandler<EventHandler<T>>)(object)new EventHandler<T>(handler));
+				result = <>8__1.raisedEvent;
+			}
+			catch (System.Exception exception)
+			{
+				<>1__state = -2;
+				<>8__1 = null;
+				System.Runtime.CompilerServices.Unsafe.As<AsyncTaskMethodBuilder<RaisedEvent<T>>, AsyncTaskMethodBuilder<RaisedEvent<RaisedEvent<T>>>>(ref <>t__builder).SetException(exception);
+				return;
+			}
+			<>1__state = -2;
+			<>8__1 = null;
+			System.Runtime.CompilerServices.Unsafe.As<AsyncTaskMethodBuilder<RaisedEvent<T>>, AsyncTaskMethodBuilder<RaisedEvent<RaisedEvent<T>>>>(ref <>t__builder).SetResult((RaisedEvent<RaisedEvent<T>>)(object)result);
+			void handler(object? s, T args)
+			{
+				((<>c__DisplayClass136_0<T>)(object)this).raisedEvent = new RaisedEvent<T>(s, args);
+			}
+		}
+		[DebuggerHidden]
+		private void SetStateMachine(IAsyncStateMachine stateMachine)
+		{
+			System.Runtime.CompilerServices.Unsafe.As<AsyncTaskMethodBuilder<RaisedEvent<T>>, AsyncTaskMethodBuilder<RaisedEvent<RaisedEvent<T>>>>(ref <>t__builder).SetStateMachine(stateMachine);
+		}
+	}
+	[StructLayout((LayoutKind)3)]
+	[CompilerGenerated]
+	private struct <RecordExceptionAsync>d__187 : IAsyncStateMachine
+	{
+		public int <>1__state;
+		public AsyncTaskMethodBuilder<System.Exception> <>t__builder;
+		public Func<System.Threading.Tasks.Task> testCode;
+		private TaskAwaiter <>u__1;
+		private void MoveNext()
+		{
+			int num = <>1__state;
+			System.Exception result;
+			try
+			{
+				if (num != 0)
+				{
+					GuardArgumentNotNull<Func<System.Threading.Tasks.Task>>("testCode", testCode);
+				}
+				try
+				{
+					TaskAwaiter val;
+					if (num != 0)
+					{
+						val = testCode.Invoke().GetAwaiter();
+						if (!((TaskAwaiter)(ref val)).IsCompleted)
+						{
+							num = (<>1__state = 0);
+							<>u__1 = val;
+							<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter, <RecordExceptionAsync>d__187>(ref val, ref this);
+							return;
+						}
+					}
+					else
+					{
+						val = <>u__1;
+						<>u__1 = default(TaskAwaiter);
+						num = (<>1__state = -1);
+					}
+					((TaskAwaiter)(ref val)).GetResult();
+					result = null;
+				}
+				catch (System.Exception ex)
+				{
+					result = ex;
+				}
+			}
+			catch (System.Exception exception)
+			{
+				<>1__state = -2;
+				<>t__builder.SetException(exception);
+				return;
+			}
+			<>1__state = -2;
+			<>t__builder.SetResult(result);
+		}
+		[DebuggerHidden]
+		private void SetStateMachine(IAsyncStateMachine stateMachine)
+		{
+			<>t__builder.SetStateMachine(stateMachine);
+		}
+	}
+	[StructLayout((LayoutKind)3)]
+	[CompilerGenerated]
+	private struct <ThrowsAnyAsync>d__152<T> : IAsyncStateMachine where T : notnull, System.Exception
+	{
+		public int <>1__state;
+		public AsyncTaskMethodBuilder<T> <>t__builder;
+		public Func<System.Threading.Tasks.Task> testCode;
+		private System.Type <>7__wrap1;
+		private TaskAwaiter<System.Exception?> <>u__1;
+		private void MoveNext()
+		{
+			int num = <>1__state;
+			T result2;
+			try
+			{
+				TaskAwaiter<System.Exception> val;
+				if (num != 0)
+				{
+					<>7__wrap1 = typeof(T);
+					val = RecordExceptionAsync(testCode).GetAwaiter();
+					if (!val.IsCompleted)
+					{
+						num = (<>1__state = 0);
+						<>u__1 = val;
+						<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter<System.Exception>, <ThrowsAnyAsync>d__152<T>>(ref val, ref this);
+						return;
+					}
+				}
+				else
+				{
+					val = <>u__1;
+					<>u__1 = default(TaskAwaiter<System.Exception>);
+					num = (<>1__state = -1);
+				}
+				System.Exception result = val.GetResult();
+				result2 = (T)ThrowsAny(<>7__wrap1, result);
+			}
+			catch (System.Exception exception)
+			{
+				<>1__state = -2;
+				<>t__builder.SetException(exception);
+				return;
+			}
+			<>1__state = -2;
+			<>t__builder.SetResult(result2);
+		}
+		[DebuggerHidden]
+		private void SetStateMachine(IAsyncStateMachine stateMachine)
+		{
+			<>t__builder.SetStateMachine(stateMachine);
+		}
+	}
+	[StructLayout((LayoutKind)3)]
+	[CompilerGenerated]
+	private struct <ThrowsAsync>d__153 : IAsyncStateMachine
+	{
+		public int <>1__state;
+		public AsyncTaskMethodBuilder<System.Exception> <>t__builder;
+		public System.Type exceptionType;
+		public Func<System.Threading.Tasks.Task> testCode;
+		private System.Type <>7__wrap1;
+		private TaskAwaiter<System.Exception?> <>u__1;
+		private void MoveNext()
+		{
+			int num = <>1__state;
+			System.Exception result2;
+			try
+			{
+				TaskAwaiter<System.Exception> val;
+				if (num != 0)
+				{
+					<>7__wrap1 = exceptionType;
+					val = RecordExceptionAsync(testCode).GetAwaiter();
+					if (!val.IsCompleted)
+					{
+						num = (<>1__state = 0);
+						<>u__1 = val;
+						<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter<System.Exception>, <ThrowsAsync>d__153>(ref val, ref this);
+						return;
+					}
+				}
+				else
+				{
+					val = <>u__1;
+					<>u__1 = default(TaskAwaiter<System.Exception>);
+					num = (<>1__state = -1);
+				}
+				System.Exception result = val.GetResult();
+				result2 = Throws(<>7__wrap1, result);
+			}
+			catch (System.Exception exception)
+			{
+				<>1__state = -2;
+				<>t__builder.SetException(exception);
+				return;
+			}
+			<>1__state = -2;
+			<>t__builder.SetResult(result2);
+		}
+		[DebuggerHidden]
+		private void SetStateMachine(IAsyncStateMachine stateMachine)
+		{
+			<>t__builder.SetStateMachine(stateMachine);
+		}
+	}
+	[StructLayout((LayoutKind)3)]
+	[CompilerGenerated]
+	private struct <ThrowsAsync>d__154<T> : IAsyncStateMachine where T : notnull, System.Exception
+	{
+		public int <>1__state;
+		public AsyncTaskMethodBuilder<T> <>t__builder;
+		public Func<System.Threading.Tasks.Task> testCode;
+		private System.Type <>7__wrap1;
+		private TaskAwaiter<System.Exception?> <>u__1;
+		private void MoveNext()
+		{
+			int num = <>1__state;
+			T result2;
+			try
+			{
+				TaskAwaiter<System.Exception> val;
+				if (num != 0)
+				{
+					<>7__wrap1 = typeof(T);
+					val = RecordExceptionAsync(testCode).GetAwaiter();
+					if (!val.IsCompleted)
+					{
+						num = (<>1__state = 0);
+						<>u__1 = val;
+						<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter<System.Exception>, <ThrowsAsync>d__154<T>>(ref val, ref this);
+						return;
+					}
+				}
+				else
+				{
+					val = <>u__1;
+					<>u__1 = default(TaskAwaiter<System.Exception>);
+					num = (<>1__state = -1);
+				}
+				System.Exception result = val.GetResult();
+				result2 = (T)Throws(<>7__wrap1, result);
+			}
+			catch (System.Exception exception)
+			{
+				<>1__state = -2;
+				<>t__builder.SetException(exception);
+				return;
+			}
+			<>1__state = -2;
+			<>t__builder.SetResult(result2);
+		}
+		[DebuggerHidden]
+		private void SetStateMachine(IAsyncStateMachine stateMachine)
+		{
+			<>t__builder.SetStateMachine(stateMachine);
+		}
+	}
+	[StructLayout((LayoutKind)3)]
+	[CompilerGenerated]
+	private struct <ThrowsAsync>d__155<T> : IAsyncStateMachine where T : notnull, ArgumentException
+	{
+		public int <>1__state;
+		public AsyncTaskMethodBuilder<T> <>t__builder;
+		public Func<System.Threading.Tasks.Task> testCode;
+		public string paramName;
+		private TaskAwaiter<T> <>u__1;
+		private void MoveNext()
+		{
+			int num = <>1__state;
+			T result2;
+			try
+			{
+				TaskAwaiter<T> val;
+				if (num != 0)
+				{
+					val = Assert.ThrowsAsync<T>(testCode).GetAwaiter();
+					if (!val.IsCompleted)
+					{
+						num = (<>1__state = 0);
+						<>u__1 = val;
+						<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter<T>, <ThrowsAsync>d__155<T>>(ref val, ref this);
+						return;
+					}
+				}
+				else
+				{
+					val = <>u__1;
+					<>u__1 = default(TaskAwaiter<T>);
+					num = (<>1__state = -1);
+				}
+				T result = val.GetResult();
+				if (paramName != ((ArgumentException)result).ParamName)
+				{
+					throw ThrowsException.ForIncorrectParameterName(typeof(T), paramName, ((ArgumentException)result).ParamName);
+				}
+				result2 = result;
+			}
+			catch (System.Exception exception)
+			{
+				<>1__state = -2;
+				<>t__builder.SetException(exception);
+				return;
+			}
+			<>1__state = -2;
+			<>t__builder.SetResult(result2);
+		}
+		[DebuggerHidden]
+		private void SetStateMachine(IAsyncStateMachine stateMachine)
+		{
+			<>t__builder.SetStateMachine(stateMachine);
+		}
+	}
+	private static readonly System.Type typeofDictionary = typeof(Dictionary<, >);
+	private static readonly System.Type typeofHashSet = typeof(HashSet<>);
+	private static readonly System.Type typeofSet = typeof(ISet<>);
+	private static readonly HashSet<char> charsLineEndings;
+	private static readonly HashSet<char> charsWhitespace;
+	protected Assert()
+	{
+	}
+	[Obsolete("This is an override of Object.Equals(). Call Assert.Equal() instead.", true)]
+	[EditorBrowsable(/*Could not decode attribute arguments.*/)]
+	public static bool Equals(object a, object b)
+	{
+		throw new InvalidOperationException("Assert.Equals should not be used");
+	}
+	[Obsolete("This is an override of Object.ReferenceEquals(). Call Assert.Same() instead.", true)]
+	[EditorBrowsable(/*Could not decode attribute arguments.*/)]
+	public static bool ReferenceEquals(object a, object b)
+	{
+		throw new InvalidOperationException("Assert.ReferenceEquals should not be used");
+	}
+	private static System.Type? SafeGetGenericTypeDefinition(System.Type? type)
+	{
+		if (type == (System.Type)null)
+		{
+			return null;
+		}
+		if (!type.IsGenericType)
+		{
+			return null;
+		}
+		try
+		{
+			return type.GetGenericTypeDefinition();
+		}
+		catch (InvalidOperationException)
+		{
+			return null;
+		}
+	}
+	public static void All<T>(System.Collections.Generic.IAsyncEnumerable<T> collection, Action<T> action)
+	{
+		All(AssertHelper.ToEnumerable(collection), action);
+	}
+	public static void All<T>(System.Collections.Generic.IAsyncEnumerable<T> collection, Action<T, int> action)
+	{
+		All(AssertHelper.ToEnumerable(collection), action);
+	}
+	public static System.Threading.Tasks.Task AllAsync<T>(System.Collections.Generic.IAsyncEnumerable<T> collection, Func<T, System.Threading.Tasks.Task> action)
+	{
+		return AllAsync(AssertHelper.ToEnumerable(collection), action);
+	}
+	public static System.Threading.Tasks.Task AllAsync<T>(System.Collections.Generic.IAsyncEnumerable<T> collection, Func<T, int, System.Threading.Tasks.Task> action)
+	{
+		return AllAsync(AssertHelper.ToEnumerable(collection), action);
+	}
+	public static void Collection<T>(System.Collections.Generic.IAsyncEnumerable<T> collection, params Action<T>[] elementInspectors)
+	{
+		Collection(AssertHelper.ToEnumerable(collection), elementInspectors);
+	}
+	public static System.Threading.Tasks.Task CollectionAsync<T>(System.Collections.Generic.IAsyncEnumerable<T> collection, params Func<T, System.Threading.Tasks.Task>[] elementInspectors)
+	{
+		return CollectionAsync(AssertHelper.ToEnumerable(collection), elementInspectors);
+	}
+	public static void Contains<T>(T expected, System.Collections.Generic.IAsyncEnumerable<T> collection)
+	{
+		Contains(expected, AssertHelper.ToEnumerable(collection));
+	}
+	public static void Contains<T>(T expected, System.Collections.Generic.IAsyncEnumerable<T> collection, IEqualityComparer<T> comparer)
+	{
+		Contains(expected, AssertHelper.ToEnumerable(collection), comparer);
+	}
+	public static void Contains<T>(System.Collections.Generic.IAsyncEnumerable<T> collection, Predicate<T> filter)
+	{
+		Contains(AssertHelper.ToEnumerable(collection), filter);
+	}
+	public static void Distinct<T>(System.Collections.Generic.IAsyncEnumerable<T> collection)
+	{
+		Distinct(AssertHelper.ToEnumerable(collection), (IEqualityComparer<T>)(object)EqualityComparer<T>.Default);
+	}
+	public static void Distinct<T>(System.Collections.Generic.IAsyncEnumerable<T> collection, IEqualityComparer<T> comparer)
+	{
+		Distinct(AssertHelper.ToEnumerable(collection), comparer);
+	}
+	public static void DoesNotContain<T>(T expected, System.Collections.Generic.IAsyncEnumerable<T> collection)
+	{
+		DoesNotContain(expected, AssertHelper.ToEnumerable(collection));
+	}
+	public static void DoesNotContain<T>(T expected, System.Collections.Generic.IAsyncEnumerable<T> collection, IEqualityComparer<T> comparer)
+	{
+		DoesNotContain(expected, AssertHelper.ToEnumerable(collection), comparer);
+	}
+	public static void DoesNotContain<T>(System.Collections.Generic.IAsyncEnumerable<T> collection, Predicate<T> filter)
+	{
+		DoesNotContain(AssertHelper.ToEnumerable(collection), filter);
+	}
+	public static void Empty<T>(System.Collections.Generic.IAsyncEnumerable<T> collection)
+	{
+		Empty((System.Collections.IEnumerable)AssertHelper.ToEnumerable(collection));
+	}
+	public static void Equal<T>(System.Collections.Generic.IEnumerable<T>? expected, System.Collections.Generic.IAsyncEnumerable<T>? actual)
+	{
+		Equal(expected, AssertHelper.ToEnumerable(actual), GetEqualityComparer<T>());
+	}
+	public static void Equal<T>(System.Collections.Generic.IAsyncEnumerable<T>? expected, System.Collections.Generic.IAsyncEnumerable<T>? actual)
+	{
+		Equal(AssertHelper.ToEnumerable(expected), AssertHelper.ToEnumerable(actual), GetEqualityComparer<T>());
+	}
+	public static void Equal<T>(System.Collections.Generic.IEnumerable<T>? expected, System.Collections.Generic.IAsyncEnumerable<T>? actual, IEqualityComparer<T> comparer)
+	{
+		Assert.Equal<System.Collections.Generic.IEnumerable<T>>(expected, AssertHelper.ToEnumerable(actual), GetEqualityComparer<System.Collections.Generic.IEnumerable<T>>((IEqualityComparer?)(object)new AssertEqualityComparerAdapter<T>(comparer)));
+	}
+	public static void Equal<T>(System.Collections.Generic.IAsyncEnumerable<T>? expected, System.Collections.Generic.IAsyncEnumerable<T>? actual, IEqualityComparer<T> comparer)
+	{
+		Equal(AssertHelper.ToEnumerable(expected), AssertHelper.ToEnumerable(actual), GetEqualityComparer<System.Collections.Generic.IEnumerable<T>>((IEqualityComparer?)(object)new AssertEqualityComparerAdapter<T>(comparer)));
+	}
+	public static void Equal<T>(System.Collections.Generic.IEnumerable<T>? expected, System.Collections.Generic.IAsyncEnumerable<T>? actual, Func<T, T, bool> comparer)
+	{
+		Equal(expected, AssertHelper.ToEnumerable(actual), AssertEqualityComparer<T>.FromComparer(comparer));
+	}
+	public static void Equal<T>(System.Collections.Generic.IAsyncEnumerable<T>? expected, System.Collections.Generic.IAsyncEnumerable<T>? actual, Func<T, T, bool> comparer)
+	{
+		Equal(AssertHelper.ToEnumerable(expected), AssertHelper.ToEnumerable(actual), AssertEqualityComparer<T>.FromComparer(comparer));
+	}
+	public static void NotEmpty<T>(System.Collections.Generic.IAsyncEnumerable<T> collection)
+	{
+		NotEmpty((System.Collections.IEnumerable)AssertHelper.ToEnumerable(collection));
+	}
+	public static void NotEqual<T>(System.Collections.Generic.IEnumerable<T>? expected, System.Collections.Generic.IAsyncEnumerable<T>? actual)
+	{
+		NotEqual(expected, AssertHelper.ToEnumerable(actual), GetEqualityComparer<T>());
+	}
+	public static void NotEqual<T>(System.Collections.Generic.IAsyncEnumerable<T>? expected, System.Collections.Generic.IAsyncEnumerable<T>? actual)
+	{
+		NotEqual(AssertHelper.ToEnumerable(expected), AssertHelper.ToEnumerable(actual), GetEqualityComparer<T>());
+	}
+	public static void NotEqual<T>(System.Collections.Generic.IEnumerable<T>? expected, System.Collections.Generic.IAsyncEnumerable<T>? actual, IEqualityComparer<T> comparer)
+	{
+		Assert.NotEqual<System.Collections.Generic.IEnumerable<T>>(expected, AssertHelper.ToEnumerable(actual), GetEqualityComparer<System.Collections.Generic.IEnumerable<T>>((IEqualityComparer?)(object)new AssertEqualityComparerAdapter<T>(comparer)));
+	}
+	public static void NotEqual<T>(System.Collections.Generic.IAsyncEnumerable<T>? expected, System.Collections.Generic.IAsyncEnumerable<T>? actual, IEqualityComparer<T> comparer)
+	{
+		NotEqual(AssertHelper.ToEnumerable(expected), AssertHelper.ToEnumerable(actual), GetEqualityComparer<System.Collections.Generic.IEnumerable<T>>((IEqualityComparer?)(object)new AssertEqualityComparerAdapter<T>(comparer)));
+	}
+	public static void NotEqual<T>(System.Collections.Generic.IEnumerable<T>? expected, System.Collections.Generic.IAsyncEnumerable<T>? actual, Func<T, T, bool> comparer)
+	{
+		NotEqual(expected, AssertHelper.ToEnumerable(actual), AssertEqualityComparer<T>.FromComparer(comparer));
+	}
+	public static void NotEqual<T>(System.Collections.Generic.IAsyncEnumerable<T>? expected, System.Collections.Generic.IAsyncEnumerable<T>? actual, Func<T, T, bool> comparer)
+	{
+		NotEqual(AssertHelper.ToEnumerable(expected), AssertHelper.ToEnumerable(actual), AssertEqualityComparer<T>.FromComparer(comparer));
+	}
+	public static T Single<T>(System.Collections.Generic.IAsyncEnumerable<T> collection)
+	{
+		return Single(AssertHelper.ToEnumerable(collection));
+	}
+	public static T Single<T>(System.Collections.Generic.IAsyncEnumerable<T> collection, Predicate<T> predicate)
+	{
+		return Single(AssertHelper.ToEnumerable(collection), predicate);
+	}
+	public static void False([DoesNotReturnIf(true)] bool condition)
+	{
+		False((bool?)condition, (string?)null);
+	}
+	public static void False([DoesNotReturnIf(true)] bool? condition)
+	{
+		False(condition, null);
+	}
+	public static void False([DoesNotReturnIf(true)] bool condition, string? userMessage)
+	{
+		False((bool?)condition, userMessage);
+	}
+	public static void False([DoesNotReturnIf(true)] bool? condition, string? userMessage)
+	{
+		if (condition ?? true)
+		{
+			throw FalseException.ForNonFalseValue(userMessage, condition);
+		}
+	}
+	public static void True([DoesNotReturnIf(false)] bool condition)
+	{
+		True((bool?)condition, (string?)null);
+	}
+	public static void True([DoesNotReturnIf(false)] bool? condition)
+	{
+		True(condition, null);
+	}
+	public static void True([DoesNotReturnIf(false)] bool condition, string? userMessage)
+	{
+		True((bool?)condition, userMessage);
+	}
+	public static void True([DoesNotReturnIf(false)] bool? condition, string? userMessage)
+	{
+		if ((!condition) ?? true)
+		{
+			throw TrueException.ForNonTrueValue(userMessage, condition);
+		}
+	}
+	public static void All<T>(System.Collections.Generic.IEnumerable<T> collection, Action<T> action)
+	{
+		GuardArgumentNotNull("collection", collection);
+		GuardArgumentNotNull<Action<T>>("action", action);
+		All(collection, (Action<T, int>)delegate(T item, int index)
+		{
+			action.Invoke(item);
+		});
+	}
+	public static void All<T>(System.Collections.Generic.IEnumerable<T> collection, Action<T, int> action)
+	{
+		GuardArgumentNotNull("collection", collection);
+		GuardArgumentNotNull<Action<T, int>>("action", action);
+		List<Tuple<int, string, System.Exception>> val = new List<Tuple<int, string, System.Exception>>();
+		int num = 0;
+		System.Collections.Generic.IEnumerator<T> enumerator = collection.GetEnumerator();
+		try
+		{
+			while (((System.Collections.IEnumerator)enumerator).MoveNext())
+			{
+				T current = enumerator.Current;
+				try
+				{
+					action.Invoke(current, num);
+				}
+				catch (System.Exception ex)
+				{
+					val.Add(new Tuple<int, string, System.Exception>(num, ArgumentFormatter.Format(current), ex));
+				}
+				num++;
+			}
+		}
+		finally
+		{
+			((System.IDisposable)enumerator)?.Dispose();
+		}
+		if (val.Count > 0)
+		{
+			throw AllException.ForFailures(num, (System.Collections.Generic.IReadOnlyList<Tuple<int, string, System.Exception>>)val);
+		}
+	}
+	[AsyncStateMachine(typeof(<AllAsync>d__44<>))]
+	public static System.Threading.Tasks.Task AllAsync<T>(System.Collections.Generic.IEnumerable<T> collection, Func<T, System.Threading.Tasks.Task> action)
+	{
+		<AllAsync>d__44<T> <AllAsync>d__ = default(<AllAsync>d__44<T>);
+		<AllAsync>d__.<>t__builder = AsyncTaskMethodBuilder.Create();
+		<AllAsync>d__.collection = collection;
+		<AllAsync>d__.action = action;
+		<AllAsync>d__.<>1__state = -1;
+		((AsyncTaskMethodBuilder)(ref <AllAsync>d__.<>t__builder)).Start<<AllAsync>d__44<T>>(ref <AllAsync>d__);
+		return ((AsyncTaskMethodBuilder)(ref <AllAsync>d__.<>t__builder)).Task;
+	}
+	[AsyncStateMachine(typeof(<AllAsync>d__45<>))]
+	public static System.Threading.Tasks.Task AllAsync<T>(System.Collections.Generic.IEnumerable<T> collection, Func<T, int, System.Threading.Tasks.Task> action)
+	{
+		<AllAsync>d__45<T> <AllAsync>d__ = default(<AllAsync>d__45<T>);
+		<AllAsync>d__.<>t__builder = AsyncTaskMethodBuilder.Create();
+		<AllAsync>d__.collection = collection;
+		<AllAsync>d__.action = action;
+		<AllAsync>d__.<>1__state = -1;
+		((AsyncTaskMethodBuilder)(ref <AllAsync>d__.<>t__builder)).Start<<AllAsync>d__45<T>>(ref <AllAsync>d__);
+		return ((AsyncTaskMethodBuilder)(ref <AllAsync>d__.<>t__builder)).Task;
+	}
+	public static void Collection<T>(System.Collections.Generic.IEnumerable<T> collection, params Action<T>[] elementInspectors)
+	{
+		GuardArgumentNotNull("collection", collection);
+		GuardArgumentNotNull("elementInspectors", elementInspectors);
+		using CollectionTracker<T> collectionTracker = collection.AsTracker();
+		int num = 0;
+		System.Collections.Generic.IEnumerator<T> enumerator = collectionTracker.GetEnumerator();
+		try
+		{
+			while (((System.Collections.IEnumerator)enumerator).MoveNext())
+			{
+				T current = enumerator.Current;
+				try
+				{
+					if (num < elementInspectors.Length)
+					{
+						elementInspectors[num].Invoke(current);
+					}
+				}
+				catch (System.Exception exception)
+				{
+					int? pointerIndent;
+					throw CollectionException.ForMismatchedItem(formattedCollection: collectionTracker.FormatIndexedMismatch(num, out pointerIndent), exception: exception, indexFailurePoint: num, failurePointerIndent: pointerIndent);
+				}
+				num++;
+			}
+		}
+		finally
+		{
+			((System.IDisposable)enumerator)?.Dispose();
+		}
+		if (collectionTracker.IterationCount != elementInspectors.Length)
+		{
+			throw CollectionException.ForMismatchedItemCount(elementInspectors.Length, collectionTracker.IterationCount, collectionTracker.FormatStart());
+		}
+	}
+	[AsyncStateMachine(typeof(<CollectionAsync>d__47<>))]
+	public static System.Threading.Tasks.Task CollectionAsync<T>(System.Collections.Generic.IEnumerable<T> collection, params Func<T, System.Threading.Tasks.Task>[] elementInspectors)
+	{
+		<CollectionAsync>d__47<T> <CollectionAsync>d__ = default(<CollectionAsync>d__47<T>);
+		<CollectionAsync>d__.<>t__builder = AsyncTaskMethodBuilder.Create();
+		<CollectionAsync>d__.collection = collection;
+		<CollectionAsync>d__.elementInspectors = elementInspectors;
+		<CollectionAsync>d__.<>1__state = -1;
+		((AsyncTaskMethodBuilder)(ref <CollectionAsync>d__.<>t__builder)).Start<<CollectionAsync>d__47<T>>(ref <CollectionAsync>d__);
+		return ((AsyncTaskMethodBuilder)(ref <CollectionAsync>d__.<>t__builder)).Task;
+	}
+	public static void Contains<T>(T expected, System.Collections.Generic.IEnumerable<T> collection)
+	{
+		GuardArgumentNotNull("collection", collection);
+		if (collection is ISet<T> set)
+		{
+			Contains(expected, set);
+		}
+		else if (collection is IReadOnlySet<T> set2)
+		{
+			Contains(expected, set2);
+		}
+		else
+		{
+			Contains(expected, collection, GetEqualityComparer<T>());
+		}
+	}
+	public static void Contains<T>(T expected, System.Collections.Generic.IEnumerable<T> collection, IEqualityComparer<T> comparer)
+	{
+		GuardArgumentNotNull("collection", collection);
+		GuardArgumentNotNull<IEqualityComparer<T>>("comparer", comparer);
+		using CollectionTracker<T> collectionTracker = collection.AsTracker();
+		if (!Enumerable.Contains<T>((System.Collections.Generic.IEnumerable<T>)collectionTracker, expected, comparer))
+		{
+			throw ContainsException.ForCollectionItemNotFound(ArgumentFormatter.Format(expected), collectionTracker.FormatStart());
+		}
+	}
+	public static void Contains<T>(System.Collections.Generic.IEnumerable<T> collection, Predicate<T> filter)
+	{
+		GuardArgumentNotNull("collection", collection);
+		GuardArgumentNotNull<Predicate<T>>("filter", filter);
+		using CollectionTracker<T> collectionTracker = collection.AsTracker();
+		System.Collections.Generic.IEnumerator<T> enumerator = collectionTracker.GetEnumerator();
+		try
+		{
+			while (((System.Collections.IEnumerator)enumerator).MoveNext())
+			{
+				T current = enumerator.Current;
+				if (filter.Invoke(current))
+				{
+					return;
+				}
+			}
+		}
+		finally
+		{
+			((System.IDisposable)enumerator)?.Dispose();
+		}
+		throw ContainsException.ForCollectionFilterNotMatched(collectionTracker.FormatStart());
+	}
+	public static void Distinct<T>(System.Collections.Generic.IEnumerable<T> collection)
+	{
+		Distinct(collection, (IEqualityComparer<T>)(object)EqualityComparer<T>.Default);
+	}
+	public static void Distinct<T>(System.Collections.Generic.IEnumerable<T> collection, IEqualityComparer<T> comparer)
+	{
+		GuardArgumentNotNull("collection", collection);
+		GuardArgumentNotNull<IEqualityComparer<T>>("comparer", comparer);
+		using CollectionTracker<T> collectionTracker = collection.AsTracker();
+		HashSet<T> val = new HashSet<T>(comparer);
+		System.Collections.Generic.IEnumerator<T> enumerator = collectionTracker.GetEnumerator();
+		try
+		{
+			while (((System.Collections.IEnumerator)enumerator).MoveNext())
+			{
+				T current = enumerator.Current;
+				if (!val.Add(current))
+				{
+					throw DistinctException.ForDuplicateItem(ArgumentFormatter.Format(current), collectionTracker.FormatStart());
+				}
+			}
+		}
+		finally
+		{
+			((System.IDisposable)enumerator)?.Dispose();
+		}
+	}
+	public static void DoesNotContain<T>(T expected, System.Collections.Generic.IEnumerable<T> collection)
+	{
+		GuardArgumentNotNull("collection", collection);
+		if (collection is ISet<T> set)
+		{
+			DoesNotContain(expected, set);
+		}
+		else if (collection is IReadOnlySet<T> set2)
+		{
+			DoesNotContain(expected, set2);
+		}
+		else
+		{
+			DoesNotContain(expected, collection, GetEqualityComparer<T>());
+		}
+	}
+	public static void DoesNotContain<T>(T expected, System.Collections.Generic.IEnumerable<T> collection, IEqualityComparer<T> comparer)
+	{
+		GuardArgumentNotNull("collection", collection);
+		GuardArgumentNotNull<IEqualityComparer<T>>("comparer", comparer);
+		using CollectionTracker<T> collectionTracker = collection.AsTracker();
+		int num = 0;
+		System.Collections.Generic.IEnumerator<T> enumerator = collectionTracker.GetEnumerator();
+		try
+		{
+			while (((System.Collections.IEnumerator)enumerator).MoveNext())
+			{
+				T current = enumerator.Current;
+				if (comparer.Equals(current, expected))
+				{
+					int? pointerIndent;
+					string collection2 = collectionTracker.FormatIndexedMismatch(num, out pointerIndent);
+					throw DoesNotContainException.ForCollectionItemFound(ArgumentFormatter.Format(expected), num, pointerIndent, collection2);
+				}
+				num++;
+			}
+		}
+		finally
+		{
+			((System.IDisposable)enumerator)?.Dispose();
+		}
+	}
+	public static void DoesNotContain<T>(System.Collections.Generic.IEnumerable<T> collection, Predicate<T> filter)
+	{
+		GuardArgumentNotNull("collection", collection);
+		GuardArgumentNotNull<Predicate<T>>("filter", filter);
+		using CollectionTracker<T> collectionTracker = collection.AsTracker();
+		int num = 0;
+		System.Collections.Generic.IEnumerator<T> enumerator = collectionTracker.GetEnumerator();
+		try
+		{
+			while (((System.Collections.IEnumerator)enumerator).MoveNext())
+			{
+				T current = enumerator.Current;
+				if (filter.Invoke(current))
+				{
+					int? pointerIndent;
+					string collection2 = collectionTracker.FormatIndexedMismatch(num, out pointerIndent);
+					throw DoesNotContainException.ForCollectionFilterMatched(num, pointerIndent, collection2);
+				}
+				num++;
+			}
+		}
+		finally
+		{
+			((System.IDisposable)enumerator)?.Dispose();
+		}
+	}
+	public static void Empty(System.Collections.IEnumerable collection)
+	{
+		GuardArgumentNotNull("collection", collection);
+		using CollectionTracker collectionTracker = collection.AsTracker();
+		if (collectionTracker.GetEnumerator().MoveNext())
+		{
+			throw EmptyException.ForNonEmptyCollection(collectionTracker.FormatStart());
+		}
+	}
+	public static void Equal<T>(System.Collections.Generic.IEnumerable<T>? expected, System.Collections.Generic.IEnumerable<T>? actual)
+	{
+		Assert.Equal<System.Collections.Generic.IEnumerable<T>>(expected, actual, GetEqualityComparer<System.Collections.Generic.IEnumerable<T>>());
+	}
+	public static void Equal<T>(System.Collections.Generic.IEnumerable<T>? expected, System.Collections.Generic.IEnumerable<T>? actual, IEqualityComparer<T> comparer)
+	{
+		Assert.Equal<System.Collections.Generic.IEnumerable<T>>(expected, actual, GetEqualityComparer<System.Collections.Generic.IEnumerable<T>>((IEqualityComparer?)(object)new AssertEqualityComparerAdapter<T>(comparer)));
+	}
+	public static void Equal<T>(System.Collections.Generic.IEnumerable<T>? expected, System.Collections.Generic.IEnumerable<T>? actual, Func<T, T, bool> comparer)
+	{
+		Equal(expected, actual, AssertEqualityComparer<T>.FromComparer(comparer));
+	}
+	public static void NotEmpty(System.Collections.IEnumerable collection)
+	{
+		GuardArgumentNotNull("collection", collection);
+		System.Collections.IEnumerator enumerator = collection.GetEnumerator();
+		try
+		{
+			if (!enumerator.MoveNext())
+			{
+				throw NotEmptyException.ForNonEmptyCollection();
+			}
+		}
+		finally
+		{
+			System.IDisposable disposable = enumerator as System.IDisposable;
+			if (disposable != null)
+			{
+				disposable.Dispose();
+			}
+		}
+	}
+	public static void NotEqual<T>(System.Collections.Generic.IEnumerable<T>? expected, System.Collections.Generic.IEnumerable<T>? actual)
+	{
+		Assert.NotEqual<System.Collections.Generic.IEnumerable<T>>(expected, actual, GetEqualityComparer<System.Collections.Generic.IEnumerable<T>>());
+	}
+	public static void NotEqual<T>(System.Collections.Generic.IEnumerable<T>? expected, System.Collections.Generic.IEnumerable<T>? actual, IEqualityComparer<T> comparer)
+	{
+		Assert.NotEqual<System.Collections.Generic.IEnumerable<T>>(expected, actual, GetEqualityComparer<System.Collections.Generic.IEnumerable<T>>((IEqualityComparer?)(object)new AssertEqualityComparerAdapter<T>(comparer)));
+	}
+	public static void NotEqual<T>(System.Collections.Generic.IEnumerable<T>? expected, System.Collections.Generic.IEnumerable<T>? actual, Func<T, T, bool> comparer)
+	{
+		NotEqual(expected, actual, AssertEqualityComparer<T>.FromComparer(comparer));
+	}
+	public static object? Single(System.Collections.IEnumerable collection)
+	{
+		GuardArgumentNotNull("collection", collection);
+		return Single(Enumerable.Cast<object>(collection));
+	}
+	public static void Single(System.Collections.IEnumerable collection, object? expected)
+	{
+		GuardArgumentNotNull("collection", collection);
+		GetSingleResult(Enumerable.Cast<object>(collection), (object item) => object.Equals(item, expected), ArgumentFormatter.Format(expected));
+	}
+	public static T Single<T>(System.Collections.Generic.IEnumerable<T> collection)
+	{
+		GuardArgumentNotNull("collection", collection);
+		return GetSingleResult(collection, null, null);
+	}
+	public static T Single<T>(System.Collections.Generic.IEnumerable<T> collection, Predicate<T> predicate)
+	{
+		GuardArgumentNotNull("collection", collection);
+		GuardArgumentNotNull<Predicate<T>>("predicate", predicate);
+		return GetSingleResult(collection, predicate, "(predicate expression)");
+	}
+	private static T GetSingleResult<T>(System.Collections.Generic.IEnumerable<T> collection, Predicate<T>? predicate, string? expected)
+	{
+		int num = 0;
+		int num2 = 0;
+		List<int> val = new List<int>();
+		T val2 = default(T);
+		using CollectionTracker<T> collectionTracker = collection.AsTracker();
+		System.Collections.Generic.IEnumerator<T> enumerator = collectionTracker.GetEnumerator();
+		try
+		{
+			while (((System.Collections.IEnumerator)enumerator).MoveNext())
+			{
+				T current = enumerator.Current;
+				if (predicate == null || predicate.Invoke(current))
+				{
+					if (++num == 1)
+					{
+						val2 = current;
+					}
+					if (predicate != null)
+					{
+						val.Add(num2);
+					}
+				}
+				num2++;
+			}
+		}
+		finally
+		{
+			((System.IDisposable)enumerator)?.Dispose();
+		}
+		return num switch
+		{
+			0 => throw SingleException.Empty(expected, collectionTracker.FormatStart()), 
+			1 => val2, 
+			_ => throw SingleException.MoreThanOne(num, expected, collectionTracker.FormatStart(), (System.Collections.Generic.ICollection<int>)val), 
+		};
+	}
+	private static IEqualityComparer<T?> GetEqualityComparer<T>(IEqualityComparer? innerComparer = null)
+	{
+		return (IEqualityComparer<T?>)(object)new AssertEqualityComparer<T>(innerComparer);
+	}
+	private static IComparer<T> GetRangeComparer<T>() where T : IComparable
+	{
+		return (IComparer<T>)(object)new AssertRangeComparer<T>();
+	}
+	public static TValue Contains<TKey, TValue>(TKey expected, IDictionary<TKey, TValue> collection) where TKey : notnull
+	{
+		GuardArgumentNotNull("expected", expected);
+		GuardArgumentNotNull<IDictionary<TKey, TValue>>("collection", collection);
+		TValue result = default(TValue);
+		if (!collection.TryGetValue(expected, ref result))
+		{
+			throw ContainsException.ForKeyNotFound(ArgumentFormatter.Format(expected), CollectionTracker<TKey>.FormatStart((System.Collections.Generic.IEnumerable<TKey>)collection.Keys));
+		}
+		return result;
+	}
+	public static TValue Contains<TKey, TValue>(TKey expected, IReadOnlyDictionary<TKey, TValue> collection) where TKey : notnull
+	{
+		GuardArgumentNotNull("expected", expected);
+		GuardArgumentNotNull<IReadOnlyDictionary<TKey, TValue>>("collection", collection);
+		TValue result = default(TValue);
+		if (!collection.TryGetValue(expected, ref result))
+		{
+			throw ContainsException.ForKeyNotFound(ArgumentFormatter.Format(expected), CollectionTracker<TKey>.FormatStart(collection.Keys));
+		}
+		return result;
+	}
+	public static TValue Contains<TKey, TValue>(TKey expected, ConcurrentDictionary<TKey, TValue> collection) where TKey : notnull
+	{
+		return Contains<TKey, TValue>(expected, (IReadOnlyDictionary<TKey, TValue>)(object)collection);
+	}
+	public static TValue Contains<TKey, TValue>(TKey expected, Dictionary<TKey, TValue> collection) where TKey : notnull
+	{
+		return Contains<TKey, TValue>(expected, (IReadOnlyDictionary<TKey, TValue>)(object)collection);
+	}
+	public static TValue Contains<TKey, TValue>(TKey expected, ReadOnlyDictionary<TKey, TValue> collection) where TKey : notnull
+	{
+		return Contains<TKey, TValue>(expected, (IReadOnlyDictionary<TKey, TValue>)(object)collection);
+	}
+	public static TValue Contains<TKey, TValue>(TKey expected, ImmutableDictionary<TKey, TValue> collection) where TKey : notnull
+	{
+		return Contains<TKey, TValue>(expected, (IReadOnlyDictionary<TKey, TValue>)(object)collection);
+	}
+	public static void DoesNotContain<TKey, TValue>(TKey expected, IDictionary<TKey, TValue> collection) where TKey : notnull
+	{
+		GuardArgumentNotNull("expected", expected);
+		GuardArgumentNotNull<IDictionary<TKey, TValue>>("collection", collection);
+		if (collection.ContainsKey(expected))
+		{
+			throw DoesNotContainException.ForKeyFound(ArgumentFormatter.Format(expected), CollectionTracker<TKey>.FormatStart((System.Collections.Generic.IEnumerable<TKey>)collection.Keys));
+		}
+	}
+	public static void DoesNotContain<TKey, TValue>(TKey expected, IReadOnlyDictionary<TKey, TValue> collection) where TKey : notnull
+	{
+		GuardArgumentNotNull("expected", expected);
+		GuardArgumentNotNull<IReadOnlyDictionary<TKey, TValue>>("collection", collection);
+		if (collection.ContainsKey(expected))
+		{
+			throw DoesNotContainException.ForKeyFound(ArgumentFormatter.Format(expected), CollectionTracker<TKey>.FormatStart(collection.Keys));
+		}
+	}
+	public static void DoesNotContain<TKey, TValue>(TKey expected, ConcurrentDictionary<TKey, TValue> collection) where TKey : notnull
+	{
+		DoesNotContain<TKey, TValue>(expected, (IReadOnlyDictionary<TKey, TValue>)(object)collection);
+	}
+	public static void DoesNotContain<TKey, TValue>(TKey expected, Dictionary<TKey, TValue> collection) where TKey : notnull
+	{
+		DoesNotContain<TKey, TValue>(expected, (IReadOnlyDictionary<TKey, TValue>)(object)collection);
+	}
+	public static void DoesNotContain<TKey, TValue>(TKey expected, ReadOnlyDictionary<TKey, TValue> collection) where TKey : notnull
+	{
+		DoesNotContain<TKey, TValue>(expected, (IReadOnlyDictionary<TKey, TValue>)(object)collection);
+	}
+	public static void DoesNotContain<TKey, TValue>(TKey expected, ImmutableDictionary<TKey, TValue> collection) where TKey : notnull
+	{
+		DoesNotContain<TKey, TValue>(expected, (IReadOnlyDictionary<TKey, TValue>)(object)collection);
+	}
+	public static void Equal<T>([AllowNull] T[] expected, [AllowNull] T[] actual) where T : unmanaged, IEquatable<T>
+	{
+		if ((expected != null || actual != null) && (expected == null || actual == null || !MemoryExtensions.SequenceEqual<T>(MemoryExtensions.AsSpan<T>(expected), System.ReadOnlySpan<T>.op_Implicit(actual))))
+		{
+			Equal((object)expected, (object)actual);
+		}
+	}
+	public static void Equal<T>([AllowNull] T expected, [AllowNull] T actual)
+	{
+		Equal(expected, actual, GetEqualityComparer<T>());
+	}
+	public static void Equal<T>([AllowNull] T expected, [AllowNull] T actual, Func<T, T, bool> comparer)
+	{
+		Equal(expected, actual, AssertEqualityComparer<T>.FromComparer(comparer));
+	}
+	public static void Equal<T>([AllowNull] T expected, [AllowNull] T actual, IEqualityComparer<T> comparer)
+	{
+		GuardArgumentNotNull<IEqualityComparer<T>>("comparer", comparer);
+		if (expected == null && actual == null)
+		{
+			return;
+		}
+		CollectionTracker collectionTracker = expected.AsNonStringTracker();
+		CollectionTracker collectionTracker2 = actual.AsNonStringTracker();
+		System.Exception error = null;
+		try
+		{
+			if ((collectionTracker == null || collectionTracker2 == null) && (collectionTracker == null || actual != null) && (expected != null || collectionTracker2 == null))
+			{
+				try
+				{
+					if (comparer.Equals(expected, actual))
+					{
+						return;
+					}
+				}
+				catch (System.Exception ex)
+				{
+					error = ex;
+				}
+				throw EqualException.ForMismatchedValuesWithError(expected, actual, error);
+			}
+			int? mismatchedIndex = null;
+			IEqualityComparer val = null;
+			AssertEqualityComparer<T> assertEqualityComparer = comparer as AssertEqualityComparer<T>;
+			if (assertEqualityComparer != null)
+			{
+				val = assertEqualityComparer.InnerComparer;
+			}
+			else if ((object)comparer == EqualityComparer<T>.Default)
+			{
+				val = (IEqualityComparer)(object)EqualityComparer<object>.Default;
+			}
+			int? pointerIndent = null;
+			int? pointerIndent2 = null;
+			string expectedType = null;
+			string actualType = null;
+			string text;
+			string text2;
+			if (val != null)
+			{
+				try
+				{
+					if (assertEqualityComparer?.Equals(expected, collectionTracker, actual, collectionTracker2, out mismatchedIndex) ?? CollectionTracker.AreCollectionsEqual(collectionTracker, collectionTracker2, val, val == AssertEqualityComparer<T>.DefaultInnerComparer, out mismatchedIndex))
+					{
+						return;
+					}
+				}
+				catch (System.Exception ex2)
+				{
+					error = ex2;
+				}
+				int startIndex = -1;
+				int endIndex = -1;
+				collectionTracker?.GetMismatchExtents(mismatchedIndex, out startIndex, out endIndex);
+				int startIndex2 = -1;
+				int endIndex2 = -1;
+				collectionTracker2?.GetMismatchExtents(mismatchedIndex, out startIndex2, out endIndex2);
+				if (mismatchedIndex.HasValue)
+				{
+					if (startIndex > -1 && endIndex < mismatchedIndex.Value)
+					{
+						startIndex = startIndex2;
+					}
+					else if (startIndex2 > -1 && endIndex2 < mismatchedIndex.Value)
+					{
+						startIndex2 = startIndex;
+					}
+				}
+				pointerIndent = null;
+				text = collectionTracker?.FormatIndexedMismatch(startIndex, endIndex, mismatchedIndex, out pointerIndent) ?? ArgumentFormatter.Format(expected);
+				expectedType = collectionTracker?.TypeAt(mismatchedIndex);
+				pointerIndent2 = null;
+				text2 = collectionTracker2?.FormatIndexedMismatch(startIndex2, endIndex2, mismatchedIndex, out pointerIndent2) ?? ArgumentFormatter.Format(actual);
+				actualType = collectionTracker2?.TypeAt(mismatchedIndex);
+			}
+			else
+			{
+				try
+				{
+					if (comparer.Equals(expected, actual))
+					{
+						return;
+					}
+				}
+				catch (System.Exception ex3)
+				{
+					error = ex3;
+				}
+				text = ArgumentFormatter.Format(expected);
+				text2 = ArgumentFormatter.Format(actual);
+			}
+			string collectionDisplay = null;
+			ref T reference = ref expected;
+			T val2 = default(T);
+			object obj;
+			if (val2 == null)
+			{
+				val2 = reference;
+				reference = ref val2;
+				if (val2 == null)
+				{
+					obj = null;
+					goto IL_024a;
+				}
+			}
+			obj = ((object)reference/*cast due to .constrained prefix*/).GetType();
+			goto IL_024a;
+			IL_024a:
+			System.Type type = (System.Type)obj;
+			System.Type type2 = SafeGetGenericTypeDefinition(type);
+			System.Collections.Generic.IEnumerable<System.Type> enumerable = ((type != null) ? Enumerable.Select<System.Type, System.Type>(Enumerable.Where<System.Type>(IntrospectionExtensions.GetTypeInfo(type).ImplementedInterfaces, (Func<System.Type, bool>)((System.Type i) => ((System.Type)(object)IntrospectionExtensions.GetTypeInfo(i)).IsGenericType)), (Func<System.Type, System.Type>)((System.Type i) => i.GetGenericTypeDefinition())) : null);
+			ref T reference2 = ref actual;
+			val2 = default(T);
+			object obj2;
+			if (val2 == null)
+			{
+				val2 = reference2;
+				reference2 = ref val2;
+				if (val2 == null)
+				{
+					obj2 = null;
+					goto IL_02e6;
+				}
+			}
+			obj2 = ((object)reference2/*cast due to .constrained prefix*/).GetType();
+			goto IL_02e6;
+			IL_02e6:
+			System.Type type3 = (System.Type)obj2;
+			System.Type type4 = SafeGetGenericTypeDefinition(type3);
+			System.Collections.Generic.IEnumerable<System.Type> enumerable2 = ((type3 != null) ? Enumerable.Select<System.Type, System.Type>(Enumerable.Where<System.Type>(IntrospectionExtensions.GetTypeInfo(type3).ImplementedInterfaces, (Func<System.Type, bool>)((System.Type i) => ((System.Type)(object)IntrospectionExtensions.GetTypeInfo(i)).IsGenericType)), (Func<System.Type, System.Type>)((System.Type i) => i.GetGenericTypeDefinition())) : null);
+			if (type2 == typeofDictionary && type4 == typeofDictionary)
+			{
+				collectionDisplay = "Dictionaries";
+			}
+			else if (type2 == typeofHashSet && type4 == typeofHashSet)
+			{
+				collectionDisplay = "HashSets";
+			}
+			else if (enumerable != null && enumerable2 != null && Enumerable.Contains<System.Type>(enumerable, typeofSet) && Enumerable.Contains<System.Type>(enumerable2, typeofSet))
+			{
+				collectionDisplay = "Sets";
+			}
+			if (type != type3)
+			{
+				string obj3 = ((type == (System.Type)null) ? "" : (AssertHelper.IsCompilerGenerated(type) ? "<generated> " : (ArgumentFormatter.FormatTypeName(type) + " ")));
+				string text3 = ((type3 == (System.Type)null) ? "" : (AssertHelper.IsCompilerGenerated(type3) ? "<generated> " : (ArgumentFormatter.FormatTypeName(type3) + " ")));
+				int num = Math.Max(obj3.Length, text3.Length);
+				text = obj3.PadRight(num) + text;
+				text2 = text3.PadRight(num) + text2;
+				if (pointerIndent.HasValue)
+				{
+					pointerIndent += num;
+				}
+				if (pointerIndent2.HasValue)
+				{
+					pointerIndent2 += num;
+				}
+			}
+			throw EqualException.ForMismatchedCollectionsWithError(mismatchedIndex, text, pointerIndent, expectedType, text2, pointerIndent2, actualType, error, collectionDisplay);
+		}
+		finally
+		{
+			collectionTracker?.Dispose();
+			collectionTracker2?.Dispose();
+		}
+	}
+	public static void Equal(double expected, double actual, int precision)
+	{
+		double num = Math.Round(expected, precision);
+		double num2 = Math.Round(actual, precision);
+		if (!object.Equals((object)num, (object)num2))
+		{
+			throw EqualException.ForMismatchedValues(string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "{0:G17} (rounded from {1:G17})", (object)num, (object)expected), string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "{0:G17} (rounded from {1:G17})", (object)num2, (object)actual), string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "Values are not within {0} decimal place{1}", (object)precision, (object)((precision == 1) ? "" : "s")));
+		}
+	}
+	public static void Equal(double expected, double actual, int precision, MidpointRounding rounding)
+	{
+		double num = Math.Round(expected, precision, rounding);
+		double num2 = Math.Round(actual, precision, rounding);
+		if (!object.Equals((object)num, (object)num2))
+		{
+			throw EqualException.ForMismatchedValues(string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "{0:G17} (rounded from {1:G17})", (object)num, (object)expected), string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "{0:G17} (rounded from {1:G17})", (object)num2, (object)actual), string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "Values are not within {0} decimal place{1}", (object)precision, (object)((precision == 1) ? "" : "s")));
+		}
+	}
+	public static void Equal(double expected, double actual, double tolerance)
+	{
+		if (double.IsNaN(tolerance) || double.IsNegativeInfinity(tolerance) || tolerance < 0.0)
+		{
+			throw new ArgumentException("Tolerance must be greater than or equal to zero", "tolerance");
+		}
+		if (!object.Equals((object)expected, (object)actual) && !(Math.Abs(expected - actual) <= tolerance))
+		{
+			throw EqualException.ForMismatchedValues(expected.ToString("G17", (IFormatProvider)(object)CultureInfo.CurrentCulture), actual.ToString("G17", (IFormatProvider)(object)CultureInfo.CurrentCulture), string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "Values are not within tolerance {0:G17}", (object)tolerance));
+		}
+	}
+	public static void Equal(float expected, float actual, int precision)
+	{
+		double num = Math.Round((double)expected, precision);
+		double num2 = Math.Round((double)actual, precision);
+		if (!object.Equals((object)num, (object)num2))
+		{
+			throw EqualException.ForMismatchedValues(string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "{0:G9} (rounded from {1:G9})", (object)num, (object)expected), string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "{0:G9} (rounded from {1:G9})", (object)num2, (object)actual), string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "Values are not within {0} decimal place{1}", (object)precision, (object)((precision == 1) ? "" : "s")));
+		}
+	}
+	public static void Equal(float expected, float actual, int precision, MidpointRounding rounding)
+	{
+		double num = Math.Round((double)expected, precision, rounding);
+		double num2 = Math.Round((double)actual, precision, rounding);
+		if (!object.Equals((object)num, (object)num2))
+		{
+			throw EqualException.ForMismatchedValues(string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "{0:G9} (rounded from {1:G9})", (object)num, (object)expected), string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "{0:G9} (rounded from {1:G9})", (object)num2, (object)actual), string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "Values are not within {0} decimal place{1}", (object)precision, (object)((precision == 1) ? "" : "s")));
+		}
+	}
+	public static void Equal(float expected, float actual, float tolerance)
+	{
+		if (float.IsNaN(tolerance) || float.IsNegativeInfinity(tolerance) || (double)tolerance < 0.0)
+		{
+			throw new ArgumentException("Tolerance must be greater than or equal to zero", "tolerance");
+		}
+		if (!object.Equals((object)expected, (object)actual) && !(Math.Abs(expected - actual) <= tolerance))
+		{
+			throw EqualException.ForMismatchedValues(expected.ToString("G9", (IFormatProvider)(object)CultureInfo.CurrentCulture), actual.ToString("G9", (IFormatProvider)(object)CultureInfo.CurrentCulture), string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "Values are not within tolerance {0:G9}", (object)tolerance));
+		}
+	}
+	public static void Equal(decimal expected, decimal actual, int precision)
+	{
+		decimal num = Math.Round(expected, precision);
+		decimal num2 = Math.Round(actual, precision);
+		if (num != num2)
+		{
+			throw EqualException.ForMismatchedValues(string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "{0} (rounded from {1})", (object)num, (object)expected), string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "{0} (rounded from {1})", (object)num2, (object)actual));
+		}
+	}
+	public static void Equal(System.DateTime expected, System.DateTime actual)
+	{
+		Equal(expected, actual, TimeSpan.Zero);
+	}
+	public static void Equal(System.DateTime expected, System.DateTime actual, TimeSpan precision)
+	{
+		TimeSpan val = expected - actual;
+		TimeSpan val2 = ((TimeSpan)(ref val)).Duration();
+		if (val2 > precision)
+		{
+			string actual2 = ArgumentFormatter.Format(actual) + ((precision == TimeSpan.Zero) ? "" : string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, " (difference {0} is larger than {1})", (object)val2, (object)precision));
+			throw EqualException.ForMismatchedValues(expected, actual2);
+		}
+	}
+	public static void Equal(DateTimeOffset expected, DateTimeOffset actual)
+	{
+		Equal(expected, actual, TimeSpan.Zero);
+	}
+	public static void Equal(DateTimeOffset expected, DateTimeOffset actual, TimeSpan precision)
+	{
+		TimeSpan val = expected - actual;
+		TimeSpan val2 = ((TimeSpan)(ref val)).Duration();
+		if (val2 > precision)
+		{
+			string actual2 = ArgumentFormatter.Format(actual) + ((precision == TimeSpan.Zero) ? "" : string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, " (difference {0} is larger than {1})", (object)val2, (object)precision));
+			throw EqualException.ForMismatchedValues(expected, actual2);
+		}
+	}
+	public static void NotEqual<T>([AllowNull] T[] expected, [AllowNull] T[] actual) where T : unmanaged, IEquatable<T>
+	{
+		if (expected == null && actual == null)
+		{
+			NotEqual((object)expected, (object)actual);
+		}
+		if (expected != null && actual != null && MemoryExtensions.SequenceEqual<T>(MemoryExtensions.AsSpan<T>(expected), System.ReadOnlySpan<T>.op_Implicit(actual)))
+		{
+			NotEqual((object)expected, (object)actual);
+		}
+	}
+	public static void NotEqual<T>([AllowNull] T expected, [AllowNull] T actual)
+	{
+		NotEqual(expected, actual, GetEqualityComparer<T>());
+	}
+	public static void NotEqual<T>([AllowNull] T expected, [AllowNull] T actual, Func<T, T, bool> comparer)
+	{
+		NotEqual(expected, actual, AssertEqualityComparer<T>.FromComparer(comparer));
+	}
+	public static void NotEqual<T>([AllowNull] T expected, [AllowNull] T actual, IEqualityComparer<T> comparer)
+	{
+		GuardArgumentNotNull<IEqualityComparer<T>>("comparer", comparer);
+		CollectionTracker collectionTracker = expected.AsNonStringTracker();
+		CollectionTracker collectionTracker2 = actual.AsNonStringTracker();
+		System.Exception error = null;
+		try
+		{
+			if ((collectionTracker == null || collectionTracker2 == null) && (collectionTracker == null || actual != null) && (expected != null || collectionTracker2 == null))
+			{
+				try
+				{
+					if (!comparer.Equals(expected, actual))
+					{
+						return;
+					}
+				}
+				catch (System.Exception ex)
+				{
+					error = ex;
+				}
+				string expected2 = ArgumentFormatter.Format(expected);
+				string actual2 = ArgumentFormatter.Format(actual);
+				bool flag = expected is string;
+				bool flag2 = actual is string;
+				if ((flag && actual == null) || (flag2 && expected == null) || (flag && flag2))
+				{
+					throw NotEqualException.ForEqualCollectionsWithError(null, expected2, null, actual2, null, error, "Strings");
+				}
+				throw NotEqualException.ForEqualValuesWithError(expected2, actual2, error);
+			}
+			int? mismatchedIndex = null;
+			IEqualityComparer val = null;
+			AssertEqualityComparer<T> assertEqualityComparer = comparer as AssertEqualityComparer<T>;
+			if (assertEqualityComparer != null)
+			{
+				val = assertEqualityComparer.InnerComparer;
+			}
+			else if ((object)comparer == EqualityComparer<T>.Default)
+			{
+				val = (IEqualityComparer)(object)EqualityComparer<object>.Default;
+			}
+			int? pointerIndent = null;
+			int? pointerIndent2 = null;
+			string text;
+			string text2;
+			if (val != null)
+			{
+				try
+				{
+					if (!(assertEqualityComparer?.Equals(expected, collectionTracker, actual, collectionTracker2, out mismatchedIndex) ?? CollectionTracker.AreCollectionsEqual(collectionTracker, collectionTracker2, val, val == AssertEqualityComparer<T>.DefaultInnerComparer, out mismatchedIndex)))
+					{
+						return;
+					}
+					text = collectionTracker?.FormatStart() ?? "null";
+					text2 = collectionTracker2?.FormatStart() ?? "null";
+				}
+				catch (System.Exception ex2)
+				{
+					error = ex2;
+					int startIndex = -1;
+					int endIndex = -1;
+					collectionTracker?.GetMismatchExtents(mismatchedIndex, out startIndex, out endIndex);
+					int startIndex2 = -1;
+					int endIndex2 = -1;
+					collectionTracker2?.GetMismatchExtents(mismatchedIndex, out startIndex2, out endIndex2);
+					pointerIndent = null;
+					text = collectionTracker?.FormatIndexedMismatch(startIndex, endIndex, mismatchedIndex, out pointerIndent) ?? ArgumentFormatter.Format(expected);
+					pointerIndent2 = null;
+					text2 = collectionTracker2?.FormatIndexedMismatch(startIndex2, endIndex2, mismatchedIndex, out pointerIndent2) ?? ArgumentFormatter.Format(actual);
+				}
+			}
+			else
+			{
+				try
+				{
+					if (!comparer.Equals(expected, actual))
+					{
+						return;
+					}
+				}
+				catch (System.Exception ex3)
+				{
+					error = ex3;
+				}
+				text = ArgumentFormatter.Format(expected);
+				text2 = ArgumentFormatter.Format(actual);
+			}
+			string collectionDisplay = null;
+			ref T reference = ref expected;
+			T val2 = default(T);
+			object obj;
+			if (val2 == null)
+			{
+				val2 = reference;
+				reference = ref val2;
+				if (val2 == null)
+				{
+					obj = null;
+					goto IL_029b;
+				}
+			}
+			obj = ((object)reference/*cast due to .constrained prefix*/).GetType();
+			goto IL_029b;
+			IL_029b:
+			System.Type type = (System.Type)obj;
+			System.Type type2 = SafeGetGenericTypeDefinition(type);
+			System.Collections.Generic.IEnumerable<System.Type> enumerable = ((type != null) ? Enumerable.Select<System.Type, System.Type>(Enumerable.Where<System.Type>(IntrospectionExtensions.GetTypeInfo(type).ImplementedInterfaces, (Func<System.Type, bool>)((System.Type i) => ((System.Type)(object)IntrospectionExtensions.GetTypeInfo(i)).IsGenericType)), (Func<System.Type, System.Type>)((System.Type i) => i.GetGenericTypeDefinition())) : null);
+			ref T reference2 = ref actual;
+			val2 = default(T);
+			object obj2;
+			if (val2 == null)
+			{
+				val2 = reference2;
+				reference2 = ref val2;
+				if (val2 == null)
+				{
+					obj2 = null;
+					goto IL_0337;
+				}
+			}
+			obj2 = ((object)reference2/*cast due to .constrained prefix*/).GetType();
+			goto IL_0337;
+			IL_0337:
+			System.Type type3 = (System.Type)obj2;
+			System.Type type4 = SafeGetGenericTypeDefinition(type3);
+			System.Collections.Generic.IEnumerable<System.Type> enumerable2 = ((type3 != null) ? Enumerable.Select<System.Type, System.Type>(Enumerable.Where<System.Type>(IntrospectionExtensions.GetTypeInfo(type3).ImplementedInterfaces, (Func<System.Type, bool>)((System.Type i) => ((System.Type)(object)IntrospectionExtensions.GetTypeInfo(i)).IsGenericType)), (Func<System.Type, System.Type>)((System.Type i) => i.GetGenericTypeDefinition())) : null);
+			if (type2 == typeofDictionary && type4 == typeofDictionary)
+			{
+				collectionDisplay = "Dictionaries";
+			}
+			else if (type2 == typeofHashSet && type4 == typeofHashSet)
+			{
+				collectionDisplay = "HashSets";
+			}
+			else if (enumerable != null && enumerable2 != null && Enumerable.Contains<System.Type>(enumerable, typeofSet) && Enumerable.Contains<System.Type>(enumerable2, typeofSet))
+			{
+				collectionDisplay = "Sets";
+			}
+			if (type != type3)
+			{
+				string obj3 = ((type == (System.Type)null) ? "" : (AssertHelper.IsCompilerGenerated(type) ? "<generated> " : (ArgumentFormatter.FormatTypeName(type) + " ")));
+				string text3 = ((type3 == (System.Type)null) ? "" : (AssertHelper.IsCompilerGenerated(type3) ? "<generated> " : (ArgumentFormatter.FormatTypeName(type3) + " ")));
+				int num = Math.Max(obj3.Length, text3.Length);
+				text = obj3.PadRight(num) + text;
+				text2 = text3.PadRight(num) + text2;
+				if (pointerIndent.HasValue)
+				{
+					pointerIndent += num;
+				}
+				if (pointerIndent2.HasValue)
+				{
+					pointerIndent2 += num;
+				}
+			}
+			throw NotEqualException.ForEqualCollectionsWithError(mismatchedIndex, text, pointerIndent, text2, pointerIndent2, error, collectionDisplay);
+		}
+		finally
+		{
+			collectionTracker?.Dispose();
+			collectionTracker2?.Dispose();
+		}
+	}
+	public static void NotEqual(double expected, double actual, int precision)
+	{
+		double num = Math.Round(expected, precision);
+		double num2 = Math.Round(actual, precision);
+		if (object.Equals((object)num, (object)num2))
+		{
+			throw NotEqualException.ForEqualValues(string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "{0:G17} (rounded from {1:G17})", (object)num, (object)expected), string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "{0:G17} (rounded from {1:G17})", (object)num2, (object)actual), string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "Values are within {0} decimal places", (object)precision));
+		}
+	}
+	public static void NotEqual(double expected, double actual, int precision, MidpointRounding rounding)
+	{
+		double num = Math.Round(expected, precision, rounding);
+		double num2 = Math.Round(actual, precision, rounding);
+		if (object.Equals((object)num, (object)num2))
+		{
+			throw NotEqualException.ForEqualValues(string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "{0:G17} (rounded from {1:G17})", (object)num, (object)expected), string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "{0:G17} (rounded from {1:G17})", (object)num2, (object)actual), string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "Values are within {0} decimal places", (object)precision));
+		}
+	}
+	public static void NotEqual(double expected, double actual, double tolerance)
+	{
+		if (double.IsNaN(tolerance) || double.IsNegativeInfinity(tolerance) || tolerance < 0.0)
+		{
+			throw new ArgumentException("Tolerance must be greater than or equal to zero", "tolerance");
+		}
+		if (object.Equals((object)expected, (object)actual) || Math.Abs(expected - actual) <= tolerance)
+		{
+			throw NotEqualException.ForEqualValues(expected.ToString("G17", (IFormatProvider)(object)CultureInfo.CurrentCulture), actual.ToString("G17", (IFormatProvider)(object)CultureInfo.CurrentCulture), string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "Values are within tolerance {0:G17}", (object)tolerance));
+		}
+	}
+	public static void NotEqual(float expected, float actual, int precision)
+	{
+		double num = Math.Round((double)expected, precision);
+		double num2 = Math.Round((double)actual, precision);
+		if (object.Equals((object)num, (object)num2))
+		{
+			throw NotEqualException.ForEqualValues(string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "{0:G9} (rounded from {1:G9})", (object)num, (object)expected), string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "{0:G9} (rounded from {1:G9})", (object)num2, (object)actual), string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "Values are within {0} decimal places", (object)precision));
+		}
+	}
+	public static void NotEqual(float expected, float actual, int precision, MidpointRounding rounding)
+	{
+		double num = Math.Round((double)expected, precision, rounding);
+		double num2 = Math.Round((double)actual, precision, rounding);
+		if (object.Equals((object)num, (object)num2))
+		{
+			throw NotEqualException.ForEqualValues(string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "{0:G9} (rounded from {1:G9})", (object)num, (object)expected), string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "{0:G9} (rounded from {1:G9})", (object)num2, (object)actual), string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "Values are within {0} decimal places", (object)precision));
+		}
+	}
+	public static void NotEqual(float expected, float actual, float tolerance)
+	{
+		if (float.IsNaN(tolerance) || float.IsNegativeInfinity(tolerance) || (double)tolerance < 0.0)
+		{
+			throw new ArgumentException("Tolerance must be greater than or equal to zero", "tolerance");
+		}
+		if (object.Equals((object)expected, (object)actual) || Math.Abs(expected - actual) <= tolerance)
+		{
+			throw NotEqualException.ForEqualValues(expected.ToString("G9", (IFormatProvider)(object)CultureInfo.CurrentCulture), actual.ToString("G9", (IFormatProvider)(object)CultureInfo.CurrentCulture), string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "Values are within tolerance {0:G9}", (object)tolerance));
+		}
+	}
+	public static void NotEqual(decimal expected, decimal actual, int precision)
+	{
+		decimal num = Math.Round(expected, precision);
+		decimal num2 = Math.Round(actual, precision);
+		if (num == num2)
+		{
+			throw NotEqualException.ForEqualValues(string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "{0} (rounded from {1})", (object)num, (object)expected), string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "{0} (rounded from {1})", (object)num2, (object)actual));
+		}
+	}
+	public static void NotStrictEqual<T>([AllowNull] T expected, [AllowNull] T actual)
+	{
+		if (!EqualityComparer<T>.Default.Equals(expected, actual))
+		{
+			return;
+		}
+		throw NotStrictEqualException.ForEqualValues(ArgumentFormatter.Format(expected), ArgumentFormatter.Format(actual));
+	}
+	public static void StrictEqual<T>([AllowNull] T expected, [AllowNull] T actual)
+	{
+		if (EqualityComparer<T>.Default.Equals(expected, actual))
+		{
+			return;
+		}
+		throw StrictEqualException.ForEqualValues(ArgumentFormatter.Format(expected), ArgumentFormatter.Format(actual));
+	}
+	public static void Equivalent(object? expected, object? actual, bool strict = false)
+	{
+		EquivalentException ex = AssertHelper.VerifyEquivalence(expected, actual, strict);
+		if (ex != null)
+		{
+			throw ex;
+		}
+	}
+	public static void Raises(Action<Action> attach, Action<Action> detach, Action testCode)
+	{
+		if (!RaisesInternal(attach, detach, testCode))
+		{
+			throw RaisesException.ForNoEvent();
+		}
+	}
+	public static RaisedEvent<T> Raises<T>(Action<Action<T>> attach, Action<Action<T>> detach, Action testCode)
+	{
+		RaisedEvent<T> raisedEvent = RaisesInternal<T>(attach, detach, testCode);
+		if (raisedEvent == null)
+		{
+			throw RaisesException.ForNoEvent(typeof(T));
+		}
+		if (raisedEvent.Arguments != null && !((object)raisedEvent.Arguments/*cast due to .constrained prefix*/).GetType().Equals(typeof(T)))
+		{
+			throw RaisesException.ForIncorrectType(typeof(T), ((object)raisedEvent.Arguments/*cast due to .constrained prefix*/).GetType());
+		}
+		return raisedEvent;
+	}
+	public static RaisedEvent<T> Raises<T>(Action<EventHandler<T>> attach, Action<EventHandler<T>> detach, Action testCode)
+	{
+		RaisedEvent<T> raisedEvent = RaisesInternal<T>(attach, detach, testCode);
+		if (raisedEvent == null)
+		{
+			throw RaisesException.ForNoEvent(typeof(T));
+		}
+		if (raisedEvent.Arguments != null && !((object)raisedEvent.Arguments/*cast due to .constrained prefix*/).GetType().Equals(typeof(T)))
+		{
+			throw RaisesException.ForIncorrectType(typeof(T), ((object)raisedEvent.Arguments/*cast due to .constrained prefix*/).GetType());
+		}
+		return raisedEvent;
+	}
+	public static RaisedEvent<T> Raises<T>(Func<RaisedEvent<T>?> handler, Action attach, Action detach, Action testCode)
+	{
+		RaisedEvent<T> raisedEvent = RaisesInternal<T>(handler, attach, detach, testCode);
+		if (raisedEvent == null)
+		{
+			throw RaisesException.ForNoEvent(typeof(T));
+		}
+		if (raisedEvent.Arguments != null && !((object)raisedEvent.Arguments/*cast due to .constrained prefix*/).GetType().Equals(typeof(T)))
+		{
+			throw RaisesException.ForIncorrectType(typeof(T), ((object)raisedEvent.Arguments/*cast due to .constrained prefix*/).GetType());
+		}
+		return raisedEvent;
+	}
+	public static RaisedEvent<EventArgs> RaisesAny(Action<EventHandler> attach, Action<EventHandler> detach, Action testCode)
+	{
+		return RaisesInternal(attach, detach, testCode) ?? throw RaisesAnyException.ForNoEvent(typeof(EventArgs));
+	}
+	public static RaisedEvent<T> RaisesAny<T>(Action<Action<T>> attach, Action<Action<T>> detach, Action testCode)
+	{
+		return RaisesInternal<T>(attach, detach, testCode) ?? throw RaisesAnyException.ForNoEvent(typeof(T));
+	}
+	public static RaisedEvent<T> RaisesAny<T>(Action<EventHandler<T>> attach, Action<EventHandler<T>> detach, Action testCode)
+	{
+		return RaisesInternal<T>(attach, detach, testCode) ?? throw RaisesAnyException.ForNoEvent(typeof(T));
+	}
+	[AsyncStateMachine(typeof(<RaisesAnyAsync>d__122))]
+	public static async System.Threading.Tasks.Task<RaisedEvent<EventArgs>> RaisesAnyAsync(Action<EventHandler> attach, Action<EventHandler> detach, Func<System.Threading.Tasks.Task> testCode)
+	{
+		return (await RaisesAsyncInternal(attach, detach, testCode)) ?? throw RaisesAnyException.ForNoEvent(typeof(EventArgs));
+	}
+	[AsyncStateMachine(typeof(<RaisesAnyAsync>d__123<>))]
+	public static async System.Threading.Tasks.Task<RaisedEvent<T>> RaisesAnyAsync<T>(Action<Action<T>> attach, Action<Action<T>> detach, Func<System.Threading.Tasks.Task> testCode)
+	{
+		return (await RaisesAsyncInternal<T>(attach, detach, testCode)) ?? throw RaisesAnyException.ForNoEvent(typeof(T));
+	}
+	[AsyncStateMachine(typeof(<RaisesAnyAsync>d__124<>))]
+	public static async System.Threading.Tasks.Task<RaisedEvent<T>> RaisesAnyAsync<T>(Action<EventHandler<T>> attach, Action<EventHandler<T>> detach, Func<System.Threading.Tasks.Task> testCode)
+	{
+		return (await RaisesAsyncInternal<T>(attach, detach, testCode)) ?? throw RaisesAnyException.ForNoEvent(typeof(T));
+	}
+	[AsyncStateMachine(typeof(<RaisesAsync>d__125))]
+	public static System.Threading.Tasks.Task RaisesAsync(Action<Action> attach, Action<Action> detach, Func<System.Threading.Tasks.Task> testCode)
+	{
+		<RaisesAsync>d__125 <RaisesAsync>d__ = default(<RaisesAsync>d__125);
+		<RaisesAsync>d__.<>t__builder = AsyncTaskMethodBuilder.Create();
+		<RaisesAsync>d__.attach = attach;
+		<RaisesAsync>d__.detach = detach;
+		<RaisesAsync>d__.testCode = testCode;
+		<RaisesAsync>d__.<>1__state = -1;
+		((AsyncTaskMethodBuilder)(ref <RaisesAsync>d__.<>t__builder)).Start<<RaisesAsync>d__125>(ref <RaisesAsync>d__);
+		return ((AsyncTaskMethodBuilder)(ref <RaisesAsync>d__.<>t__builder)).Task;
+	}
+	[AsyncStateMachine(typeof(<RaisesAsync>d__126<>))]
+	public static async System.Threading.Tasks.Task<RaisedEvent<T>> RaisesAsync<T>(Action<Action<T>> attach, Action<Action<T>> detach, Func<System.Threading.Tasks.Task> testCode)
+	{
+		RaisedEvent<T> raisedEvent = await RaisesAsyncInternal<T>(attach, detach, testCode);
+		if (raisedEvent == null)
+		{
+			throw RaisesException.ForNoEvent(typeof(T));
+		}
+		if (raisedEvent.Arguments != null && !((object)raisedEvent.Arguments/*cast due to .constrained prefix*/).GetType().Equals(typeof(T)))
+		{
+			throw RaisesException.ForIncorrectType(typeof(T), ((object)raisedEvent.Arguments/*cast due to .constrained prefix*/).GetType());
+		}
+		return raisedEvent;
+	}
+	[AsyncStateMachine(typeof(<RaisesAsync>d__127<>))]
+	public static async System.Threading.Tasks.Task<RaisedEvent<T>> RaisesAsync<T>(Action<EventHandler<T>> attach, Action<EventHandler<T>> detach, Func<System.Threading.Tasks.Task> testCode)
+	{
+		RaisedEvent<T> raisedEvent = await RaisesAsyncInternal<T>(attach, detach, testCode);
+		if (raisedEvent == null)
+		{
+			throw RaisesException.ForNoEvent(typeof(T));
+		}
+		if (raisedEvent.Arguments != null && !((object)raisedEvent.Arguments/*cast due to .constrained prefix*/).GetType().Equals(typeof(T)))
+		{
+			throw RaisesException.ForIncorrectType(typeof(T), ((object)raisedEvent.Arguments/*cast due to .constrained prefix*/).GetType());
+		}
+		return raisedEvent;
+	}
+	private static bool RaisesInternal(Action<Action> attach, Action<Action> detach, Action testCode)
+	{
+		GuardArgumentNotNull<Action<Action>>("attach", attach);
+		GuardArgumentNotNull<Action<Action>>("detach", detach);
+		GuardArgumentNotNull<Action>("testCode", testCode);
+		bool result = false;
+		Action val = (Action)delegate
+		{
+			result = true;
+		};
+		attach.Invoke(val);
+		testCode.Invoke();
+		detach.Invoke(val);
+		return result;
+	}
+	private static RaisedEvent<EventArgs>? RaisesInternal(Action<EventHandler> attach, Action<EventHandler> detach, Action testCode)
+	{
+		GuardArgumentNotNull<Action<EventHandler>>("attach", attach);
+		GuardArgumentNotNull<Action<EventHandler>>("detach", detach);
+		GuardArgumentNotNull<Action>("testCode", testCode);
+		RaisedEvent<EventArgs> raisedEvent = null;
+		attach.Invoke(new EventHandler(handler));
+		testCode.Invoke();
+		detach.Invoke(new EventHandler(handler));
+		return raisedEvent;
+		void handler(object? s, EventArgs args)
+		{
+			raisedEvent = new RaisedEvent<EventArgs>(s, args);
+		}
+	}
+	private static RaisedEvent<T>? RaisesInternal<T>(Action<Action<T>> attach, Action<Action<T>> detach, Action testCode)
+	{
+		RaisedEvent<T> raisedEvent = null;
+		Action<T> handler = delegate(T args)
+		{
+			raisedEvent = new RaisedEvent<T>(args);
+		};
+		return RaisesInternal<T>(() => raisedEvent, (Action)delegate
+		{
+			attach.Invoke(handler);
+		}, (Action)delegate
+		{
+			detach.Invoke(handler);
+		}, testCode);
+	}
+	private static RaisedEvent<T>? RaisesInternal<T>(Action<EventHandler<T>> attach, Action<EventHandler<T>> detach, Action testCode)
+	{
+		RaisedEvent<T> raisedEvent = null;
+		return RaisesInternal<T>(() => raisedEvent, (Action)delegate
+		{
+			attach.Invoke((EventHandler<T>)handler);
+		}, (Action)delegate
+		{
+			detach.Invoke((EventHandler<T>)handler);
+		}, testCode);
+		void handler(object? s, T args)
+		{
+			raisedEvent = new RaisedEvent<T>(s, args);
+		}
+	}
+	private static RaisedEvent<T>? RaisesInternal<T>(Func<RaisedEvent<T>?> handler, Action attach, Action detach, Action testCode)
+	{
+		GuardArgumentNotNull<Func<RaisedEvent<T>>>("handler", handler);
+		GuardArgumentNotNull<Action>("attach", attach);
+		GuardArgumentNotNull<Action>("detach", detach);
+		GuardArgumentNotNull<Action>("testCode", testCode);
+		attach.Invoke();
+		testCode.Invoke();
+		detach.Invoke();
+		return handler.Invoke();
+	}
+	[AsyncStateMachine(typeof(<RaisesAsyncInternal>d__133))]
+	private static async System.Threading.Tasks.Task<bool> RaisesAsyncInternal(Action<Action> attach, Action<Action> detach, Func<System.Threading.Tasks.Task> testCode)
+	{
+		GuardArgumentNotNull<Action<Action>>("attach", attach);
+		GuardArgumentNotNull<Action<Action>>("detach", detach);
+		GuardArgumentNotNull<Func<System.Threading.Tasks.Task>>("testCode", testCode);
+		bool result = false;
+		Action handler = (Action)delegate
+		{
+			result = true;
+		};
+		attach.Invoke(handler);
+		await testCode.Invoke();
+		detach.Invoke(handler);
+		return result;
+	}
+	[AsyncStateMachine(typeof(<RaisesAsyncInternal>d__134))]
+	private static async System.Threading.Tasks.Task<RaisedEvent<EventArgs>?> RaisesAsyncInternal(Action<EventHandler> attach, Action<EventHandler> detach, Func<System.Threading.Tasks.Task> testCode)
+	{
+		GuardArgumentNotNull<Action<EventHandler>>("attach", attach);
+		GuardArgumentNotNull<Action<EventHandler>>("detach", detach);
+		GuardArgumentNotNull<Func<System.Threading.Tasks.Task>>("testCode", testCode);
+		RaisedEvent<EventArgs> raisedEvent = null;
+		attach.Invoke(new EventHandler(handler));
+		await testCode.Invoke();
+		detach.Invoke(new EventHandler(handler));
+		return raisedEvent;
+		void handler(object? s, EventArgs args)
+		{
+			raisedEvent = new RaisedEvent<EventArgs>(s, args);
+		}
+	}
+	[AsyncStateMachine(typeof(<RaisesAsyncInternal>d__135<>))]
+	private static async System.Threading.Tasks.Task<RaisedEvent<T>?> RaisesAsyncInternal<T>(Action<Action<T>> attach, Action<Action<T>> detach, Func<System.Threading.Tasks.Task> testCode)
+	{
+		GuardArgumentNotNull<Action<Action<T>>>("attach", attach);
+		GuardArgumentNotNull<Action<Action<T>>>("detach", detach);
+		GuardArgumentNotNull<Func<System.Threading.Tasks.Task>>("testCode", testCode);
+		RaisedEvent<T> raisedEvent = null;
+		Action<T> handler = delegate(T args)
+		{
+			raisedEvent = new RaisedEvent<T>(args);
+		};
+		attach.Invoke(handler);
+		await testCode.Invoke();
+		detach.Invoke(handler);
+		return raisedEvent;
+	}
+	[AsyncStateMachine(typeof(<RaisesAsyncInternal>d__136<>))]
+	private static async System.Threading.Tasks.Task<RaisedEvent<T>?> RaisesAsyncInternal<T>(Action<EventHandler<T>> attach, Action<EventHandler<T>> detach, Func<System.Threading.Tasks.Task> testCode)
+	{
+		GuardArgumentNotNull<Action<EventHandler<T>>>("attach", attach);
+		GuardArgumentNotNull<Action<EventHandler<T>>>("detach", detach);
+		GuardArgumentNotNull<Func<System.Threading.Tasks.Task>>("testCode", testCode);
+		RaisedEvent<T> raisedEvent = null;
+		attach.Invoke((EventHandler<T>)handler);
+		await testCode.Invoke();
+		detach.Invoke((EventHandler<T>)handler);
+		return raisedEvent;
+		void handler(object? s, T args)
+		{
+			raisedEvent = new RaisedEvent<T>(s, args);
+		}
+	}
+	private static System.Exception Throws(System.Type exceptionType, System.Exception? exception)
+	{
+		GuardArgumentNotNull("exceptionType", exceptionType);
+		if (exception == null)
+		{
+			throw ThrowsException.ForNoException(exceptionType);
+		}
+		if (!exceptionType.Equals(exception.GetType()))
+		{
+			throw ThrowsException.ForIncorrectExceptionType(exceptionType, exception);
+		}
+		return exception;
+	}
+	public static System.Exception Throws(System.Type exceptionType, Action testCode)
+	{
+		return Throws(exceptionType, RecordException(testCode));
+	}
+	public static System.Exception Throws(System.Type exceptionType, Func<object?> testCode)
+	{
+		return Throws(exceptionType, RecordException(testCode, "ThrowsAsync"));
+	}
+	[EditorBrowsable(/*Could not decode attribute arguments.*/)]
+	[Obsolete("You must call Assert.ThrowsAsync (and await the result) when testing async code.", true)]
+	public static System.Exception Throws(System.Type exceptionType, Func<System.Threading.Tasks.Task> testCode)
+	{
+		throw new NotImplementedException("You must call Assert.ThrowsAsync (and await the result) when testing async code.");
+	}
+	public static T Throws<T>(Action testCode) where T : System.Exception
+	{
+		return (T)Throws(typeof(T), RecordException(testCode));
+	}
+	public static T Throws<T>(Func<object?> testCode) where T : System.Exception
+	{
+		return (T)Throws(typeof(T), RecordException(testCode, "ThrowsAsync"));
+	}
+	[EditorBrowsable(/*Could not decode attribute arguments.*/)]
+	[Obsolete("You must call Assert.ThrowsAsync<T> (and await the result) when testing async code.", true)]
+	public static T Throws<T>(Func<System.Threading.Tasks.Task> testCode) where T : System.Exception
+	{
+		throw new NotImplementedException("You must call Assert.ThrowsAsync<T> (and await the result) when testing async code.");
+	}
+	public static T Throws<T>(string? paramName, Action testCode) where T : ArgumentException
+	{
+		T val = Assert.Throws<T>(testCode);
+		if (paramName != ((ArgumentException)val).ParamName)
+		{
+			throw ThrowsException.ForIncorrectParameterName(typeof(T), paramName, ((ArgumentException)val).ParamName);
+		}
+		return val;
+	}
+	public static T Throws<T>(string? paramName, Func<object?> testCode) where T : ArgumentException
+	{
+		T val = Assert.Throws<T>(testCode);
+		if (paramName != ((ArgumentException)val).ParamName)
+		{
+			throw ThrowsException.ForIncorrectParameterName(typeof(T), paramName, ((ArgumentException)val).ParamName);
+		}
+		return val;
+	}
+	[EditorBrowsable(/*Could not decode attribute arguments.*/)]
+	[Obsolete("You must call Assert.ThrowsAsync<T> (and await the result) when testing async code.", true)]
+	public static T Throws<T>(string? paramName, Func<System.Threading.Tasks.Task> testCode) where T : ArgumentException
+	{
+		throw new NotImplementedException("You must call Assert.ThrowsAsync<T> (and await the result) when testing async code.");
+	}
+	private static System.Exception ThrowsAny(System.Type exceptionType, System.Exception? exception)
+	{
+		GuardArgumentNotNull("exceptionType", exceptionType);
+		if (exception == null)
+		{
+			throw ThrowsAnyException.ForNoException(exceptionType);
+		}
+		if (!IntrospectionExtensions.GetTypeInfo(exceptionType).IsAssignableFrom(IntrospectionExtensions.GetTypeInfo(exception.GetType())))
+		{
+			throw ThrowsAnyException.ForIncorrectExceptionType(exceptionType, exception);
+		}
+		return exception;
+	}
+	public static T ThrowsAny<T>(Action testCode) where T : System.Exception
+	{
+		return (T)ThrowsAny(typeof(T), RecordException(testCode));
+	}
+	public static T ThrowsAny<T>(Func<object?> testCode) where T : System.Exception
+	{
+		return (T)ThrowsAny(typeof(T), RecordException(testCode, "ThrowsAnyAsync"));
+	}
+	[EditorBrowsable(/*Could not decode attribute arguments.*/)]
+	[Obsolete("You must call Assert.ThrowsAnyAsync<T> (and await the result) when testing async code.", true)]
+	public static T ThrowsAny<T>(Func<System.Threading.Tasks.Task> testCode) where T : System.Exception
+	{
+		throw new NotImplementedException("You must call Assert.ThrowsAnyAsync<T> (and await the result) when testing async code.");
+	}
+	[AsyncStateMachine(typeof(<ThrowsAnyAsync>d__152<>))]
+	public static async System.Threading.Tasks.Task<T> ThrowsAnyAsync<T>(Func<System.Threading.Tasks.Task> testCode) where T : System.Exception
+	{
+		System.Type typeFromHandle = typeof(T);
+		return (T)ThrowsAny(typeFromHandle, await RecordExceptionAsync(testCode));
+	}
+	[AsyncStateMachine(typeof(<ThrowsAsync>d__153))]
+	public static async System.Threading.Tasks.Task<System.Exception> ThrowsAsync(System.Type exceptionType, Func<System.Threading.Tasks.Task> testCode)
+	{
+		return Throws(exceptionType, await RecordExceptionAsync(testCode));
+	}
+	[AsyncStateMachine(typeof(<ThrowsAsync>d__154<>))]
+	public static async System.Threading.Tasks.Task<T> ThrowsAsync<T>(Func<System.Threading.Tasks.Task> testCode) where T : System.Exception
+	{
+		System.Type typeFromHandle = typeof(T);
+		return (T)Throws(typeFromHandle, await RecordExceptionAsync(testCode));
+	}
+	[AsyncStateMachine(typeof(<ThrowsAsync>d__155<>))]
+	public static async System.Threading.Tasks.Task<T> ThrowsAsync<T>(string? paramName, Func<System.Threading.Tasks.Task> testCode) where T : ArgumentException
+	{
+		T val = await Assert.ThrowsAsync<T>(testCode);
+		if (paramName != ((ArgumentException)val).ParamName)
+		{
+			throw ThrowsException.ForIncorrectParameterName(typeof(T), paramName, ((ArgumentException)val).ParamName);
+		}
+		return val;
+	}
+	[DoesNotReturn]
+	public static void Fail(string? message = null)
+	{
+		throw FailException.ForFailure(message);
+	}
+	[return: NotNull]
+	internal static T GuardArgumentNotNull<T>(string argName, [NotNull] T? argValue)
+	{
+		if (argValue == null)
+		{
+			throw new ArgumentNullException(argName.TrimStart('@'));
+		}
+		return argValue;
+	}
+	public static void NotSame(object? expected, object? actual)
+	{
+		if (expected == actual)
+		{
+			throw NotSameException.ForSameValues();
+		}
+	}
+	public static void Same(object? expected, object? actual)
+	{
+		if (expected != actual)
+		{
+			throw SameException.ForFailure(ArgumentFormatter.Format(expected), ArgumentFormatter.Format(actual));
+		}
+	}
+	public static void Contains<T>(System.Memory<T> expectedSubMemory, System.Memory<T> actualMemory) where T : IEquatable<T>
+	{
+		Assert.Contains<T>(System.Memory<T>.op_Implicit(expectedSubMemory), System.Memory<T>.op_Implicit(actualMemory));
+	}
+	public static void Contains<T>(System.Memory<T> expectedSubMemory, ReadOnlyMemory<T> actualMemory) where T : IEquatable<T>
+	{
+		Assert.Contains<T>(System.Memory<T>.op_Implicit(expectedSubMemory), actualMemory);
+	}
+	public static void Contains<T>(ReadOnlyMemory<T> expectedSubMemory, System.Memory<T> actualMemory) where T : IEquatable<T>
+	{
+		Assert.Contains<T>(expectedSubMemory, System.Memory<T>.op_Implicit(actualMemory));
+	}
+	public static void Contains<T>(ReadOnlyMemory<T> expectedSubMemory, ReadOnlyMemory<T> actualMemory) where T : IEquatable<T>
+	{
+		GuardArgumentNotNull<ReadOnlyMemory<T>>("expectedSubMemory", expectedSubMemory);
+		if (MemoryExtensions.IndexOf<T>(actualMemory.Span, expectedSubMemory.Span) < 0)
+		{
+			throw ContainsException.ForSubMemoryNotFound(CollectionTracker<T>.FormatStart(expectedSubMemory.Span), CollectionTracker<T>.FormatStart(actualMemory.Span));
+		}
+	}
+	public static void DoesNotContain<T>(System.Memory<T> expectedSubMemory, System.Memory<T> actualMemory) where T : IEquatable<T>
+	{
+		Assert.DoesNotContain<T>(System.Memory<T>.op_Implicit(expectedSubMemory), System.Memory<T>.op_Implicit(actualMemory));
+	}
+	public static void DoesNotContain<T>(System.Memory<T> expectedSubMemory, ReadOnlyMemory<T> actualMemory) where T : IEquatable<T>
+	{
+		Assert.DoesNotContain<T>(System.Memory<T>.op_Implicit(expectedSubMemory), actualMemory);
+	}
+	public static void DoesNotContain<T>(ReadOnlyMemory<T> expectedSubMemory, System.Memory<T> actualMemory) where T : IEquatable<T>
+	{
+		Assert.DoesNotContain<T>(expectedSubMemory, System.Memory<T>.op_Implicit(actualMemory));
+	}
+	public static void DoesNotContain<T>(ReadOnlyMemory<T> expectedSubMemory, ReadOnlyMemory<T> actualMemory) where T : IEquatable<T>
+	{
+		GuardArgumentNotNull<ReadOnlyMemory<T>>("expectedSubMemory", expectedSubMemory);
+		System.ReadOnlySpan<T> span = expectedSubMemory.Span;
+		System.ReadOnlySpan<T> span2 = actualMemory.Span;
+		int num = MemoryExtensions.IndexOf<T>(span2, span);
+		int? pointerIndent;
+		if (num > -1)
+		{
+			throw DoesNotContainException.ForSubMemoryFound(CollectionTracker<T>.FormatStart(span), memory: CollectionTracker<T>.FormatIndexedMismatch(span2, num, out pointerIndent), indexFailurePoint: num, failurePointerIndent: pointerIndent);
+		}
+	}
+	public static void Equal<T>(System.Memory<T> expectedMemory, System.Memory<T> actualMemory) where T : IEquatable<T>
+	{
+		Assert.Equal<T>(System.Memory<T>.op_Implicit(expectedMemory), System.Memory<T>.op_Implicit(actualMemory));
+	}
+	public static void Equal<T>(System.Memory<T> expectedMemory, ReadOnlyMemory<T> actualMemory) where T : IEquatable<T>
+	{
+		Assert.Equal<T>(System.Memory<T>.op_Implicit(expectedMemory), actualMemory);
+	}
+	public static void Equal<T>(ReadOnlyMemory<T> expectedMemory, System.Memory<T> actualMemory) where T : IEquatable<T>
+	{
+		Assert.Equal<T>(expectedMemory, System.Memory<T>.op_Implicit(actualMemory));
+	}
+	public static void Equal<T>(ReadOnlyMemory<T> expectedMemory, ReadOnlyMemory<T> actualMemory) where T : IEquatable<T>
+	{
+		GuardArgumentNotNull<ReadOnlyMemory<T>>("expectedMemory", expectedMemory);
+		if (!MemoryExtensions.SequenceEqual<T>(expectedMemory.Span, actualMemory.Span))
+		{
+			Equal((object)expectedMemory.Span.ToArray(), (object)actualMemory.Span.ToArray());
+		}
+	}
+	public static void Multiple(params Action[] checks)
+	{
+		if (checks == null || checks.Length == 0)
+		{
+			return;
+		}
+		List<System.Exception> val = new List<System.Exception>();
+		foreach (Action val2 in checks)
+		{
+			try
+			{
+				val2.Invoke();
+			}
+			catch (System.Exception ex)
+			{
+				val.Add(ex);
+			}
+		}
+		if (val.Count == 0)
+		{
+			return;
+		}
+		if (val.Count == 1)
+		{
+			ExceptionDispatchInfo.Capture(val[0]).Throw();
+		}
+		throw MultipleException.ForFailures((System.Collections.Generic.IReadOnlyCollection<System.Exception>)val);
+	}
+	public static void NotNull([NotNull] object? @object)
+	{
+		if (@object == null)
+		{
+			throw NotNullException.ForNullValue();
+		}
+	}
+	public static T NotNull<T>([NotNull] T? value) where T : struct
+	{
+		if (!value.HasValue)
+		{
+			throw NotNullException.ForNullStruct(typeof(T));
+		}
+		return value.Value;
+	}
+	public static void Null([MaybeNull] object? @object)
+	{
+		if (@object != null)
+		{
+			throw NullException.ForNonNullValue(@object);
+		}
+	}
+	public static void Null<T>(T? value) where T : struct
+	{
+		if (value.HasValue)
+		{
+			throw NullException.ForNonNullStruct(typeof(T), value);
+		}
+	}
+	public static void PropertyChanged(INotifyPropertyChanged @object, string propertyName, Action testCode)
+	{
+		GuardArgumentNotNull<INotifyPropertyChanged>("object", @object);
+		GuardArgumentNotNull("propertyName", propertyName);
+		GuardArgumentNotNull<Action>("testCode", testCode);
+		bool propertyChangeHappened = false;
+		PropertyChangedEventHandler val = (PropertyChangedEventHandler)delegate(object? sender, PropertyChangedEventArgs args)
+		{
+			propertyChangeHappened = propertyChangeHappened || string.IsNullOrEmpty(args.PropertyName) || propertyName.Equals(args.PropertyName, (StringComparison)5);
+		};
+		@object.PropertyChanged += val;
+		try
+		{
+			testCode.Invoke();
+			if (!propertyChangeHappened)
+			{
+				throw PropertyChangedException.ForUnsetProperty(propertyName);
+			}
+		}
+		finally
+		{
+			@object.PropertyChanged -= val;
+		}
+	}
+	[EditorBrowsable(/*Could not decode attribute arguments.*/)]
+	[Obsolete("You must call Assert.PropertyChangedAsync (and await the result) when testing async code.", true)]
+	public static void PropertyChanged(INotifyPropertyChanged @object, string propertyName, Func<System.Threading.Tasks.Task> testCode)
+	{
+		throw new NotImplementedException("You must call Assert.PropertyChangedAsync (and await the result) when testing async code.");
+	}
+	[AsyncStateMachine(typeof(<PropertyChangedAsync>d__179))]
+	public static System.Threading.Tasks.Task PropertyChangedAsync(INotifyPropertyChanged @object, string propertyName, Func<System.Threading.Tasks.Task> testCode)
+	{
+		<PropertyChangedAsync>d__179 <PropertyChangedAsync>d__ = default(<PropertyChangedAsync>d__179);
+		<PropertyChangedAsync>d__.<>t__builder = AsyncTaskMethodBuilder.Create();
+		<PropertyChangedAsync>d__.@object = @object;
+		<PropertyChangedAsync>d__.propertyName = propertyName;
+		<PropertyChangedAsync>d__.testCode = testCode;
+		<PropertyChangedAsync>d__.<>1__state = -1;
+		((AsyncTaskMethodBuilder)(ref <PropertyChangedAsync>d__.<>t__builder)).Start<<PropertyChangedAsync>d__179>(ref <PropertyChangedAsync>d__);
+		return ((AsyncTaskMethodBuilder)(ref <PropertyChangedAsync>d__.<>t__builder)).Task;
+	}
+	public static void InRange<T>(T actual, T low, T high) where T : IComparable
+	{
+		InRange(actual, low, high, GetRangeComparer<T>());
+	}
+	public static void InRange<T>(T actual, T low, T high, IComparer<T> comparer)
+	{
+		GuardArgumentNotNull("actual", actual);
+		GuardArgumentNotNull("low", low);
+		GuardArgumentNotNull("high", high);
+		GuardArgumentNotNull<IComparer<T>>("comparer", comparer);
+		if (comparer.Compare(low, actual) > 0 || comparer.Compare(actual, high) > 0)
+		{
+			throw InRangeException.ForValueNotInRange(actual, low, high);
+		}
+	}
+	public static void NotInRange<T>(T actual, T low, T high) where T : IComparable
+	{
+		NotInRange(actual, low, high, GetRangeComparer<T>());
+	}
+	public static void NotInRange<T>(T actual, T low, T high, IComparer<T> comparer)
+	{
+		GuardArgumentNotNull("actual", actual);
+		GuardArgumentNotNull("low", low);
+		GuardArgumentNotNull("high", high);
+		GuardArgumentNotNull<IComparer<T>>("comparer", comparer);
+		if (comparer.Compare(low, actual) <= 0 && comparer.Compare(actual, high) <= 0)
+		{
+			throw NotInRangeException.ForValueInRange(actual, low, high);
+		}
+	}
+	protected static System.Exception? RecordException(Action testCode)
+	{
+		GuardArgumentNotNull<Action>("testCode", testCode);
+		try
+		{
+			testCode.Invoke();
+			return null;
+		}
+		catch (System.Exception result)
+		{
+			return result;
+		}
+	}
+	protected static System.Exception? RecordException(Func<object?> testCode, string asyncMethodName)
+	{
+		GuardArgumentNotNull<Func<object>>("testCode", testCode);
+		object obj = null;
+		try
+		{
+			obj = testCode.Invoke();
+		}
+		catch (System.Exception result)
+		{
+			return result;
+		}
+		if (obj is System.Threading.Tasks.Task)
+		{
+			throw new InvalidOperationException(string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, "You must call Assert.{0} when testing async code", (object)asyncMethodName));
+		}
+		return null;
+	}
+	[EditorBrowsable(/*Could not decode attribute arguments.*/)]
+	[Obsolete("You must call Assert.RecordExceptionAsync (and await the result) when testing async code.", true)]
+	protected static System.Exception RecordException(Func<System.Threading.Tasks.Task> testCode)
+	{
+		throw new NotImplementedException("You must call Assert.RecordExceptionAsync (and await the result) when testing async code.");
+	}
+	[AsyncStateMachine(typeof(<RecordExceptionAsync>d__187))]
+	protected static async System.Threading.Tasks.Task<System.Exception?> RecordExceptionAsync(Func<System.Threading.Tasks.Task> testCode)
+	{
+		GuardArgumentNotNull<Func<System.Threading.Tasks.Task>>("testCode", testCode);
+		try
+		{
+			await testCode.Invoke();
+			return null;
+		}
+		catch (System.Exception result)
+		{
+			return result;
+		}
+	}
+	public static void Contains<T>(T expected, ISet<T> set)
+	{
+		GuardArgumentNotNull<ISet<T>>("set", set);
+		if (!((System.Collections.Generic.ICollection<T>)set).Contains(expected))
+		{
+			throw ContainsException.ForSetItemNotFound(ArgumentFormatter.Format(expected), CollectionTracker<T>.FormatStart((System.Collections.Generic.IEnumerable<T>)set));
+		}
+	}
+	public static void Contains<T>(T expected, IReadOnlySet<T> set)
+	{
+		GuardArgumentNotNull<IReadOnlySet<T>>("set", set);
+		if (!set.Contains(expected))
+		{
+			throw ContainsException.ForSetItemNotFound(ArgumentFormatter.Format(expected), CollectionTracker<T>.FormatStart((System.Collections.Generic.IEnumerable<T>)set));
+		}
+	}
+	public static void Contains<T>(T expected, HashSet<T> set)
+	{
+		Contains(expected, (ISet<T>)(object)set);
+	}
+	public static void Contains<T>(T expected, SortedSet<T> set)
+	{
+		Contains(expected, (ISet<T>)(object)set);
+	}
+	public static void Contains<T>(T expected, ImmutableHashSet<T> set)
+	{
+		Contains(expected, (ISet<T>)(object)set);
+	}
+	public static void Contains<T>(T expected, ImmutableSortedSet<T> set)
+	{
+		Contains(expected, (ISet<T>)(object)set);
+	}
+	public static void DoesNotContain<T>(T expected, ISet<T> set)
+	{
+		GuardArgumentNotNull<ISet<T>>("set", set);
+		if (((System.Collections.Generic.ICollection<T>)set).Contains(expected))
+		{
+			throw DoesNotContainException.ForSetItemFound(ArgumentFormatter.Format(expected), CollectionTracker<T>.FormatStart((System.Collections.Generic.IEnumerable<T>)set));
+		}
+	}
+	public static void DoesNotContain<T>(T expected, IReadOnlySet<T> set)
+	{
+		GuardArgumentNotNull<IReadOnlySet<T>>("set", set);
+		if (set.Contains(expected))
+		{
+			throw DoesNotContainException.ForSetItemFound(ArgumentFormatter.Format(expected), CollectionTracker<T>.FormatStart((System.Collections.Generic.IEnumerable<T>)set));
+		}
+	}
+	public static void DoesNotContain<T>(T expected, HashSet<T> set)
+	{
+		DoesNotContain(expected, (ISet<T>)(object)set);
+	}
+	public static void DoesNotContain<T>(T expected, SortedSet<T> set)
+	{
+		DoesNotContain(expected, (ISet<T>)(object)set);
+	}
+	public static void DoesNotContain<T>(T expected, ImmutableHashSet<T> set)
+	{
+		DoesNotContain(expected, (ISet<T>)(object)set);
+	}
+	public static void DoesNotContain<T>(T expected, ImmutableSortedSet<T> set)
+	{
+		DoesNotContain(expected, (ISet<T>)(object)set);
+	}
+	public static void ProperSubset<T>(ISet<T> expectedSubset, ISet<T>? actual)
+	{
+		GuardArgumentNotNull<ISet<T>>("expectedSubset", expectedSubset);
+		if (actual == null || !actual.IsProperSubsetOf((System.Collections.Generic.IEnumerable<T>)expectedSubset))
+		{
+			throw ProperSubsetException.ForFailure(CollectionTracker<T>.FormatStart((System.Collections.Generic.IEnumerable<T>)expectedSubset), (actual == null) ? "null" : CollectionTracker<T>.FormatStart((System.Collections.Generic.IEnumerable<T>)actual));
+		}
+	}
+	public static void ProperSuperset<T>(ISet<T> expectedSuperset, ISet<T>? actual)
+	{
+		GuardArgumentNotNull<ISet<T>>("expectedSuperset", expectedSuperset);
+		if (actual == null || !actual.IsProperSupersetOf((System.Collections.Generic.IEnumerable<T>)expectedSuperset))
+		{
+			throw ProperSupersetException.ForFailure(CollectionTracker<T>.FormatStart((System.Collections.Generic.IEnumerable<T>)expectedSuperset), (actual == null) ? "null" : CollectionTracker<T>.FormatStart((System.Collections.Generic.IEnumerable<T>)actual));
+		}
+	}
+	public static void Subset<T>(ISet<T> expectedSubset, ISet<T>? actual)
+	{
+		GuardArgumentNotNull<ISet<T>>("expectedSubset", expectedSubset);
+		if (actual == null || !actual.IsSubsetOf((System.Collections.Generic.IEnumerable<T>)expectedSubset))
+		{
+			throw SubsetException.ForFailure(CollectionTracker<T>.FormatStart((System.Collections.Generic.IEnumerable<T>)expectedSubset), (actual == null) ? "null" : CollectionTracker<T>.FormatStart((System.Collections.Generic.IEnumerable<T>)actual));
+		}
+	}
+	public static void Superset<T>(ISet<T> expectedSuperset, ISet<T>? actual)
+	{
+		GuardArgumentNotNull<ISet<T>>("expectedSuperset", expectedSuperset);
+		if (actual == null || !actual.IsSupersetOf((System.Collections.Generic.IEnumerable<T>)expectedSuperset))
+		{
+			throw SupersetException.ForFailure(CollectionTracker<T>.FormatStart((System.Collections.Generic.IEnumerable<T>)expectedSuperset), (actual == null) ? "null" : CollectionTracker<T>.FormatStart((System.Collections.Generic.IEnumerable<T>)actual));
+		}
+	}
+	public static void Contains<T>(System.Span<T> expectedSubSpan, System.Span<T> actualSpan) where T : IEquatable<T>
+	{
+		Assert.Contains<T>(System.Span<T>.op_Implicit(expectedSubSpan), System.Span<T>.op_Implicit(actualSpan));
+	}
+	public static void Contains<T>(System.Span<T> expectedSubSpan, System.ReadOnlySpan<T> actualSpan) where T : IEquatable<T>
+	{
+		Assert.Contains<T>(System.Span<T>.op_Implicit(expectedSubSpan), actualSpan);
+	}
+	public static void Contains<T>(System.ReadOnlySpan<T> expectedSubSpan, System.Span<T> actualSpan) where T : IEquatable<T>
+	{
+		Assert.Contains<T>(expectedSubSpan, System.Span<T>.op_Implicit(actualSpan));
+	}
+	public static void Contains<T>(System.ReadOnlySpan<T> expectedSubSpan, System.ReadOnlySpan<T> actualSpan) where T : IEquatable<T>
+	{
+		if (MemoryExtensions.IndexOf<T>(actualSpan, expectedSubSpan) < 0)
+		{
+			throw ContainsException.ForSubSpanNotFound(CollectionTracker<T>.FormatStart(expectedSubSpan), CollectionTracker<T>.FormatStart(actualSpan));
+		}
+	}
+	public static void DoesNotContain<T>(System.Span<T> expectedSubSpan, System.Span<T> actualSpan) where T : IEquatable<T>
+	{
+		Assert.DoesNotContain<T>(System.Span<T>.op_Implicit(expectedSubSpan), System.Span<T>.op_Implicit(actualSpan));
+	}
+	public static void DoesNotContain<T>(System.Span<T> expectedSubSpan, System.ReadOnlySpan<T> actualSpan) where T : IEquatable<T>
+	{
+		Assert.DoesNotContain<T>(System.Span<T>.op_Implicit(expectedSubSpan), actualSpan);
+	}
+	public static void DoesNotContain<T>(System.ReadOnlySpan<T> expectedSubSpan, System.Span<T> actualSpan) where T : IEquatable<T>
+	{
+		Assert.DoesNotContain<T>(expectedSubSpan, System.Span<T>.op_Implicit(actualSpan));
+	}
+	public static void DoesNotContain<T>(System.ReadOnlySpan<T> expectedSubSpan, System.ReadOnlySpan<T> actualSpan) where T : IEquatable<T>
+	{
+		int num = MemoryExtensions.IndexOf<T>(actualSpan, expectedSubSpan);
+		int? pointerIndent;
+		if (num > -1)
+		{
+			throw DoesNotContainException.ForSubSpanFound(CollectionTracker<T>.FormatStart(expectedSubSpan), span: CollectionTracker<T>.FormatIndexedMismatch(actualSpan, num, out pointerIndent), indexFailurePoint: num, failurePointerIndent: pointerIndent);
+		}
+	}
+	public static void Equal<T>(System.ReadOnlySpan<T> expectedSpan, T[] actualArray) where T : IEquatable<T>
+	{
+		Assert.Equal<T>(expectedSpan, MemoryExtensions.AsSpan<T>(actualArray));
+	}
+	public static void Equal<T>(System.Span<T> expectedSpan, System.Span<T> actualSpan) where T : IEquatable<T>
+	{
+		Assert.Equal<T>(System.Span<T>.op_Implicit(expectedSpan), System.Span<T>.op_Implicit(actualSpan));
+	}
+	public static void Equal<T>(System.Span<T> expectedSpan, System.ReadOnlySpan<T> actualSpan) where T : IEquatable<T>
+	{
+		Assert.Equal<T>(System.Span<T>.op_Implicit(expectedSpan), actualSpan);
+	}
+	public static void Equal<T>(System.ReadOnlySpan<T> expectedSpan, System.Span<T> actualSpan) where T : IEquatable<T>
+	{
+		Assert.Equal<T>(expectedSpan, System.Span<T>.op_Implicit(actualSpan));
+	}
+	public static void Equal<T>(System.ReadOnlySpan<T> expectedSpan, System.ReadOnlySpan<T> actualSpan) where T : IEquatable<T>
+	{
+		if (!MemoryExtensions.SequenceEqual<T>(expectedSpan, actualSpan))
+		{
+			Equal((object)expectedSpan.ToArray(), (object)actualSpan.ToArray());
+		}
+	}
+	public static void Contains(string expectedSubstring, string? actualString)
+	{
+		Contains(expectedSubstring, actualString, (StringComparison)0);
+	}
+	public static void Contains(string expectedSubstring, string? actualString, StringComparison comparisonType)
+	{
+		GuardArgumentNotNull("expectedSubstring", expectedSubstring);
+		if (actualString == null || actualString.IndexOf(expectedSubstring, comparisonType) < 0)
+		{
+			throw ContainsException.ForSubStringNotFound(expectedSubstring, actualString);
+		}
+	}
+	public static void Contains(System.Memory<char> expectedSubstring, System.Memory<char> actualString)
+	{
+		Contains(System.Memory<char>.op_Implicit(expectedSubstring), System.Memory<char>.op_Implicit(actualString), (StringComparison)0);
+	}
+	public static void Contains(System.Memory<char> expectedSubstring, ReadOnlyMemory<char> actualString)
+	{
+		Contains(System.Memory<char>.op_Implicit(expectedSubstring), actualString, (StringComparison)0);
+	}
+	public static void Contains(ReadOnlyMemory<char> expectedSubstring, System.Memory<char> actualString)
+	{
+		Contains(expectedSubstring, System.Memory<char>.op_Implicit(actualString), (StringComparison)0);
+	}
+	public static void Contains(ReadOnlyMemory<char> expectedSubstring, ReadOnlyMemory<char> actualString)
+	{
+		Contains(expectedSubstring, actualString, (StringComparison)0);
+	}
+	public static void Contains(System.Memory<char> expectedSubstring, System.Memory<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		Contains(System.Memory<char>.op_Implicit(expectedSubstring), System.Memory<char>.op_Implicit(actualString), comparisonType);
+	}
+	public static void Contains(System.Memory<char> expectedSubstring, ReadOnlyMemory<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		Contains(System.Memory<char>.op_Implicit(expectedSubstring), actualString, comparisonType);
+	}
+	public static void Contains(ReadOnlyMemory<char> expectedSubstring, System.Memory<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		Contains(expectedSubstring, System.Memory<char>.op_Implicit(actualString), comparisonType);
+	}
+	public static void Contains(ReadOnlyMemory<char> expectedSubstring, ReadOnlyMemory<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		GuardArgumentNotNull<ReadOnlyMemory<char>>("expectedSubstring", expectedSubstring);
+		Contains(expectedSubstring.Span, actualString.Span, comparisonType);
+	}
+	public static void Contains(System.Span<char> expectedSubstring, System.Span<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		Contains(System.Span<char>.op_Implicit(expectedSubstring), System.Span<char>.op_Implicit(actualString), comparisonType);
+	}
+	public static void Contains(System.Span<char> expectedSubstring, System.ReadOnlySpan<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		Contains(System.Span<char>.op_Implicit(expectedSubstring), actualString, comparisonType);
+	}
+	public static void Contains(System.ReadOnlySpan<char> expectedSubstring, System.Span<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		Contains(expectedSubstring, System.Span<char>.op_Implicit(actualString), comparisonType);
+	}
+	public static void Contains(System.ReadOnlySpan<char> expectedSubstring, System.ReadOnlySpan<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		if (MemoryExtensions.IndexOf(actualString, expectedSubstring, comparisonType) < 0)
+		{
+			throw ContainsException.ForSubStringNotFound(((object)expectedSubstring/*cast due to .constrained prefix*/).ToString(), ((object)actualString/*cast due to .constrained prefix*/).ToString());
+		}
+	}
+	public static void Contains(System.Span<char> expectedSubstring, System.Span<char> actualString)
+	{
+		Contains(System.Span<char>.op_Implicit(expectedSubstring), System.Span<char>.op_Implicit(actualString), (StringComparison)0);
+	}
+	public static void Contains(System.Span<char> expectedSubstring, System.ReadOnlySpan<char> actualString)
+	{
+		Contains(System.Span<char>.op_Implicit(expectedSubstring), actualString, (StringComparison)0);
+	}
+	public static void Contains(System.ReadOnlySpan<char> expectedSubstring, System.Span<char> actualString)
+	{
+		Contains(expectedSubstring, System.Span<char>.op_Implicit(actualString), (StringComparison)0);
+	}
+	public static void Contains(System.ReadOnlySpan<char> expectedSubstring, System.ReadOnlySpan<char> actualString)
+	{
+		Contains(expectedSubstring, actualString, (StringComparison)0);
+	}
+	public static void DoesNotContain(string expectedSubstring, string? actualString)
+	{
+		DoesNotContain(expectedSubstring, actualString, (StringComparison)0);
+	}
+	public static void DoesNotContain(string expectedSubstring, string? actualString, StringComparison comparisonType)
+	{
+		GuardArgumentNotNull("expectedSubstring", expectedSubstring);
+		if (actualString != null)
+		{
+			int num = actualString.IndexOf(expectedSubstring, comparisonType);
+			if (num >= 0)
+			{
+				throw DoesNotContainException.ForSubStringFound(expectedSubstring, num, actualString);
+			}
+		}
+	}
+	public static void DoesNotContain(System.Memory<char> expectedSubstring, System.Memory<char> actualString)
+	{
+		DoesNotContain(System.Memory<char>.op_Implicit(expectedSubstring), System.Memory<char>.op_Implicit(actualString), (StringComparison)0);
+	}
+	public static void DoesNotContain(System.Memory<char> expectedSubstring, ReadOnlyMemory<char> actualString)
+	{
+		DoesNotContain(System.Memory<char>.op_Implicit(expectedSubstring), actualString, (StringComparison)0);
+	}
+	public static void DoesNotContain(ReadOnlyMemory<char> expectedSubstring, System.Memory<char> actualString)
+	{
+		DoesNotContain(expectedSubstring, System.Memory<char>.op_Implicit(actualString), (StringComparison)0);
+	}
+	public static void DoesNotContain(ReadOnlyMemory<char> expectedSubstring, ReadOnlyMemory<char> actualString)
+	{
+		DoesNotContain(expectedSubstring, actualString, (StringComparison)0);
+	}
+	public static void DoesNotContain(System.Memory<char> expectedSubstring, System.Memory<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		DoesNotContain(System.Memory<char>.op_Implicit(expectedSubstring), System.Memory<char>.op_Implicit(actualString), comparisonType);
+	}
+	public static void DoesNotContain(System.Memory<char> expectedSubstring, ReadOnlyMemory<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		DoesNotContain(System.Memory<char>.op_Implicit(expectedSubstring), actualString, comparisonType);
+	}
+	public static void DoesNotContain(ReadOnlyMemory<char> expectedSubstring, System.Memory<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		DoesNotContain(expectedSubstring, System.Memory<char>.op_Implicit(actualString), comparisonType);
+	}
+	public static void DoesNotContain(ReadOnlyMemory<char> expectedSubstring, ReadOnlyMemory<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		GuardArgumentNotNull<ReadOnlyMemory<char>>("expectedSubstring", expectedSubstring);
+		DoesNotContain(expectedSubstring.Span, actualString.Span, comparisonType);
+	}
+	public static void DoesNotContain(System.Span<char> expectedSubstring, System.Span<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		DoesNotContain(System.Span<char>.op_Implicit(expectedSubstring), System.Span<char>.op_Implicit(actualString), comparisonType);
+	}
+	public static void DoesNotContain(System.Span<char> expectedSubstring, System.ReadOnlySpan<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		DoesNotContain(System.Span<char>.op_Implicit(expectedSubstring), actualString, comparisonType);
+	}
+	public static void DoesNotContain(System.ReadOnlySpan<char> expectedSubstring, System.Span<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		DoesNotContain(expectedSubstring, System.Span<char>.op_Implicit(actualString), comparisonType);
+	}
+	public static void DoesNotContain(System.ReadOnlySpan<char> expectedSubstring, System.ReadOnlySpan<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		int num = MemoryExtensions.IndexOf(actualString, expectedSubstring, comparisonType);
+		if (num > -1)
+		{
+			throw DoesNotContainException.ForSubStringFound(((object)expectedSubstring/*cast due to .constrained prefix*/).ToString(), num, ((object)actualString/*cast due to .constrained prefix*/).ToString());
+		}
+	}
+	public static void DoesNotContain(System.Span<char> expectedSubstring, System.Span<char> actualString)
+	{
+		DoesNotContain(System.Span<char>.op_Implicit(expectedSubstring), System.Span<char>.op_Implicit(actualString), (StringComparison)0);
+	}
+	public static void DoesNotContain(System.Span<char> expectedSubstring, System.ReadOnlySpan<char> actualString)
+	{
+		DoesNotContain(System.Span<char>.op_Implicit(expectedSubstring), actualString, (StringComparison)0);
+	}
+	public static void DoesNotContain(System.ReadOnlySpan<char> expectedSubstring, System.Span<char> actualString)
+	{
+		DoesNotContain(expectedSubstring, System.Span<char>.op_Implicit(actualString), (StringComparison)0);
+	}
+	public static void DoesNotContain(System.ReadOnlySpan<char> expectedSubstring, System.ReadOnlySpan<char> actualString)
+	{
+		DoesNotContain(expectedSubstring, actualString, (StringComparison)0);
+	}
+	public static void DoesNotMatch([StringSyntax("Regex")] string expectedRegexPattern, string? actualString)
+	{
+		GuardArgumentNotNull("expectedRegexPattern", expectedRegexPattern);
+		if (actualString != null)
+		{
+			Match val = Regex.Match(actualString, expectedRegexPattern);
+			int pointerIndent;
+			if (((Group)val).Success)
+			{
+				throw DoesNotMatchException.ForMatch(AssertHelper.ShortenAndEncodeString(expectedRegexPattern), @string: AssertHelper.ShortenAndEncodeString(actualString, ((Capture)val).Index, out pointerIndent), indexFailurePoint: ((Capture)val).Index, failurePointerIndent: pointerIndent);
+			}
+		}
+	}
+	public static void DoesNotMatch(Regex expectedRegex, string? actualString)
+	{
+		GuardArgumentNotNull<Regex>("expectedRegex", expectedRegex);
+		if (actualString != null)
+		{
+			Match val = expectedRegex.Match(actualString);
+			int pointerIndent;
+			if (((Group)val).Success)
+			{
+				throw DoesNotMatchException.ForMatch(AssertHelper.ShortenAndEncodeString(((object)expectedRegex).ToString()), @string: AssertHelper.ShortenAndEncodeString(actualString, ((Capture)val).Index, out pointerIndent), indexFailurePoint: ((Capture)val).Index, failurePointerIndent: pointerIndent);
+			}
+		}
+	}
+	public static void Empty(string value)
+	{
+		GuardArgumentNotNull("value", value);
+		if (value.Length != 0)
+		{
+			throw EmptyException.ForNonEmptyString(value);
+		}
+	}
+	public static void EndsWith(string? expectedEndString, string? actualString)
+	{
+		EndsWith(expectedEndString, actualString, (StringComparison)0);
+	}
+	public static void EndsWith(string? expectedEndString, string? actualString, StringComparison comparisonType)
+	{
+		if (expectedEndString == null || actualString == null || !actualString.EndsWith(expectedEndString, comparisonType))
+		{
+			throw EndsWithException.ForStringNotFound(expectedEndString, actualString);
+		}
+	}
+	public static void EndsWith(System.Memory<char> expectedEndString, System.Memory<char> actualString)
+	{
+		EndsWith(System.Memory<char>.op_Implicit(expectedEndString), System.Memory<char>.op_Implicit(actualString), (StringComparison)0);
+	}
+	public static void EndsWith(System.Memory<char> expectedEndString, ReadOnlyMemory<char> actualString)
+	{
+		EndsWith(System.Memory<char>.op_Implicit(expectedEndString), actualString, (StringComparison)0);
+	}
+	public static void EndsWith(ReadOnlyMemory<char> expectedEndString, System.Memory<char> actualString)
+	{
+		EndsWith(expectedEndString, System.Memory<char>.op_Implicit(actualString), (StringComparison)0);
+	}
+	public static void EndsWith(ReadOnlyMemory<char> expectedEndString, ReadOnlyMemory<char> actualString)
+	{
+		EndsWith(expectedEndString, actualString, (StringComparison)0);
+	}
+	public static void EndsWith(System.Memory<char> expectedEndString, System.Memory<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		EndsWith(System.Memory<char>.op_Implicit(expectedEndString), System.Memory<char>.op_Implicit(actualString), comparisonType);
+	}
+	public static void EndsWith(System.Memory<char> expectedEndString, ReadOnlyMemory<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		EndsWith(System.Memory<char>.op_Implicit(expectedEndString), actualString, comparisonType);
+	}
+	public static void EndsWith(ReadOnlyMemory<char> expectedEndString, System.Memory<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		EndsWith(expectedEndString, System.Memory<char>.op_Implicit(actualString), comparisonType);
+	}
+	public static void EndsWith(ReadOnlyMemory<char> expectedEndString, ReadOnlyMemory<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		GuardArgumentNotNull<ReadOnlyMemory<char>>("expectedEndString", expectedEndString);
+		EndsWith(expectedEndString.Span, actualString.Span, comparisonType);
+	}
+	public static void EndsWith(System.Span<char> expectedEndString, System.Span<char> actualString)
+	{
+		EndsWith(System.Span<char>.op_Implicit(expectedEndString), System.Span<char>.op_Implicit(actualString), (StringComparison)0);
+	}
+	public static void EndsWith(System.Span<char> expectedEndString, System.ReadOnlySpan<char> actualString)
+	{
+		EndsWith(System.Span<char>.op_Implicit(expectedEndString), actualString, (StringComparison)0);
+	}
+	public static void EndsWith(System.ReadOnlySpan<char> expectedEndString, System.Span<char> actualString)
+	{
+		EndsWith(expectedEndString, System.Span<char>.op_Implicit(actualString), (StringComparison)0);
+	}
+	public static void EndsWith(System.ReadOnlySpan<char> expectedEndString, System.ReadOnlySpan<char> actualString)
+	{
+		EndsWith(expectedEndString, actualString, (StringComparison)0);
+	}
+	public static void EndsWith(System.Span<char> expectedEndString, System.Span<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		EndsWith(System.Span<char>.op_Implicit(expectedEndString), System.Span<char>.op_Implicit(actualString), comparisonType);
+	}
+	public static void EndsWith(System.Span<char> expectedEndString, System.ReadOnlySpan<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		EndsWith(System.Span<char>.op_Implicit(expectedEndString), actualString, comparisonType);
+	}
+	public static void EndsWith(System.ReadOnlySpan<char> expectedEndString, System.Span<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		EndsWith(expectedEndString, System.Span<char>.op_Implicit(actualString), comparisonType);
+	}
+	public static void EndsWith(System.ReadOnlySpan<char> expectedEndString, System.ReadOnlySpan<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		if (!MemoryExtensions.EndsWith(actualString, expectedEndString, comparisonType))
+		{
+			throw EndsWithException.ForStringNotFound(((object)expectedEndString/*cast due to .constrained prefix*/).ToString(), ((object)actualString/*cast due to .constrained prefix*/).ToString());
+		}
+	}
+	public static void Equal(string? expected, string? actual)
+	{
+		Equal(expected, actual, ignoreCase: false, ignoreLineEndingDifferences: false, ignoreWhiteSpaceDifferences: false, ignoreAllWhiteSpace: false);
+	}
+	public unsafe static void Equal(System.ReadOnlySpan<char> expected, System.ReadOnlySpan<char> actual, bool ignoreCase = false, bool ignoreLineEndingDifferences = false, bool ignoreWhiteSpaceDifferences = false, bool ignoreAllWhiteSpace = false)
+	{
+		int num = 0;
+		int num2 = 0;
+		int length = expected.Length;
+		int length2 = actual.Length;
+		if (ignoreAllWhiteSpace && ((length == 0 && SkipWhitespace(actual, 0) == length2) || (length2 == 0 && SkipWhitespace(expected, 0) == length)))
+		{
+			return;
+		}
+		while (num < length && num2 < length2)
+		{
+			char c = *(char*)expected[num];
+			char c2 = *(char*)actual[num2];
+			if (ignoreLineEndingDifferences && charsLineEndings.Contains(c) && charsLineEndings.Contains(c2))
+			{
+				num = SkipLineEnding(expected, num);
+				num2 = SkipLineEnding(actual, num2);
+				continue;
+			}
+			if (ignoreAllWhiteSpace && (charsWhitespace.Contains(c) || charsWhitespace.Contains(c2)))
+			{
+				num = SkipWhitespace(expected, num);
+				num2 = SkipWhitespace(actual, num2);
+				continue;
+			}
+			if (ignoreWhiteSpaceDifferences && charsWhitespace.Contains(c) && charsWhitespace.Contains(c2))
+			{
+				num = SkipWhitespace(expected, num);
+				num2 = SkipWhitespace(actual, num2);
+				continue;
+			}
+			if (ignoreCase)
+			{
+				c = char.ToUpperInvariant(c);
+				c2 = char.ToUpperInvariant(c2);
+			}
+			if (c != c2)
+			{
+				break;
+			}
+			num++;
+			num2++;
+		}
+		if (num < length || num2 < length2)
+		{
+			throw EqualException.ForMismatchedStrings(((object)expected/*cast due to .constrained prefix*/).ToString(), ((object)actual/*cast due to .constrained prefix*/).ToString(), num, num2);
+		}
+	}
+	public static void Equal(System.Memory<char> expected, System.Memory<char> actual)
+	{
+		Equal(System.Memory<char>.op_Implicit(expected), System.Memory<char>.op_Implicit(actual), ignoreCase: false, ignoreLineEndingDifferences: false, ignoreWhiteSpaceDifferences: false, ignoreAllWhiteSpace: false);
+	}
+	public static void Equal(System.Memory<char> expected, ReadOnlyMemory<char> actual)
+	{
+		Equal(System.Memory<char>.op_Implicit(expected), actual, ignoreCase: false, ignoreLineEndingDifferences: false, ignoreWhiteSpaceDifferences: false, ignoreAllWhiteSpace: false);
+	}
+	public static void Equal(ReadOnlyMemory<char> expected, System.Memory<char> actual)
+	{
+		Equal(expected, System.Memory<char>.op_Implicit(actual), ignoreCase: false, ignoreLineEndingDifferences: false, ignoreWhiteSpaceDifferences: false, ignoreAllWhiteSpace: false);
+	}
+	public static void Equal(ReadOnlyMemory<char> expected, ReadOnlyMemory<char> actual)
+	{
+		Equal(expected, actual, ignoreCase: false, ignoreLineEndingDifferences: false, ignoreWhiteSpaceDifferences: false, ignoreAllWhiteSpace: false);
+	}
+	public static void Equal(System.Memory<char> expected, System.Memory<char> actual, bool ignoreCase = false, bool ignoreLineEndingDifferences = false, bool ignoreWhiteSpaceDifferences = false, bool ignoreAllWhiteSpace = false)
+	{
+		Equal(System.Memory<char>.op_Implicit(expected), System.Memory<char>.op_Implicit(actual), ignoreCase, ignoreLineEndingDifferences, ignoreWhiteSpaceDifferences, ignoreAllWhiteSpace);
+	}
+	public static void Equal(System.Memory<char> expected, ReadOnlyMemory<char> actual, bool ignoreCase = false, bool ignoreLineEndingDifferences = false, bool ignoreWhiteSpaceDifferences = false, bool ignoreAllWhiteSpace = false)
+	{
+		Equal(System.Memory<char>.op_Implicit(expected), actual, ignoreCase, ignoreLineEndingDifferences, ignoreWhiteSpaceDifferences, ignoreAllWhiteSpace);
+	}
+	public static void Equal(ReadOnlyMemory<char> expected, System.Memory<char> actual, bool ignoreCase = false, bool ignoreLineEndingDifferences = false, bool ignoreWhiteSpaceDifferences = false, bool ignoreAllWhiteSpace = false)
+	{
+		Equal(expected, System.Memory<char>.op_Implicit(actual), ignoreCase, ignoreLineEndingDifferences, ignoreWhiteSpaceDifferences, ignoreAllWhiteSpace);
+	}
+	public static void Equal(ReadOnlyMemory<char> expected, ReadOnlyMemory<char> actual, bool ignoreCase = false, bool ignoreLineEndingDifferences = false, bool ignoreWhiteSpaceDifferences = false, bool ignoreAllWhiteSpace = false)
+	{
+		GuardArgumentNotNull<ReadOnlyMemory<char>>("expected", expected);
+		Equal(expected.Span, actual.Span, ignoreCase, ignoreLineEndingDifferences, ignoreWhiteSpaceDifferences, ignoreAllWhiteSpace);
+	}
+	public static void Equal(System.Span<char> expected, System.Span<char> actual)
+	{
+		Equal(System.Span<char>.op_Implicit(expected), System.Span<char>.op_Implicit(actual), ignoreCase: false, ignoreLineEndingDifferences: false, ignoreWhiteSpaceDifferences: false, ignoreAllWhiteSpace: false);
+	}
+	public static void Equal(System.Span<char> expected, System.ReadOnlySpan<char> actual)
+	{
+		Equal(System.Span<char>.op_Implicit(expected), actual, ignoreCase: false, ignoreLineEndingDifferences: false, ignoreWhiteSpaceDifferences: false, ignoreAllWhiteSpace: false);
+	}
+	public static void Equal(System.ReadOnlySpan<char> expected, System.Span<char> actual)
+	{
+		Equal(expected, System.Span<char>.op_Implicit(actual), ignoreCase: false, ignoreLineEndingDifferences: false, ignoreWhiteSpaceDifferences: false, ignoreAllWhiteSpace: false);
+	}
+	public static void Equal(System.ReadOnlySpan<char> expected, System.ReadOnlySpan<char> actual)
+	{
+		Equal(expected, actual, ignoreCase: false, ignoreLineEndingDifferences: false, ignoreWhiteSpaceDifferences: false, ignoreAllWhiteSpace: false);
+	}
+	public static void Equal(System.Span<char> expected, System.Span<char> actual, bool ignoreCase = false, bool ignoreLineEndingDifferences = false, bool ignoreWhiteSpaceDifferences = false, bool ignoreAllWhiteSpace = false)
+	{
+		Equal(System.Span<char>.op_Implicit(expected), System.Span<char>.op_Implicit(actual), ignoreCase, ignoreLineEndingDifferences, ignoreWhiteSpaceDifferences, ignoreAllWhiteSpace);
+	}
+	public static void Equal(System.Span<char> expected, System.ReadOnlySpan<char> actual, bool ignoreCase = false, bool ignoreLineEndingDifferences = false, bool ignoreWhiteSpaceDifferences = false, bool ignoreAllWhiteSpace = false)
+	{
+		Equal(System.Span<char>.op_Implicit(expected), actual, ignoreCase, ignoreLineEndingDifferences, ignoreWhiteSpaceDifferences, ignoreAllWhiteSpace);
+	}
+	public static void Equal(System.ReadOnlySpan<char> expected, System.Span<char> actual, bool ignoreCase = false, bool ignoreLineEndingDifferences = false, bool ignoreWhiteSpaceDifferences = false, bool ignoreAllWhiteSpace = false)
+	{
+		Equal(expected, System.Span<char>.op_Implicit(actual), ignoreCase, ignoreLineEndingDifferences, ignoreWhiteSpaceDifferences, ignoreAllWhiteSpace);
+	}
+	public static void Equal(string? expected, string? actual, bool ignoreCase = false, bool ignoreLineEndingDifferences = false, bool ignoreWhiteSpaceDifferences = false, bool ignoreAllWhiteSpace = false)
+	{
+		if (expected != null || actual != null)
+		{
+			if (expected == null || actual == null)
+			{
+				throw EqualException.ForMismatchedStrings(expected, actual, -1, -1);
+			}
+			Equal(MemoryExtensions.AsSpan(expected), MemoryExtensions.AsSpan(actual), ignoreCase, ignoreLineEndingDifferences, ignoreWhiteSpaceDifferences, ignoreAllWhiteSpace);
+		}
+	}
+	public static void Matches([StringSyntax("Regex")] string expectedRegexPattern, string? actualString)
+	{
+		GuardArgumentNotNull("expectedRegexPattern", expectedRegexPattern);
+		if (actualString == null || !Regex.IsMatch(actualString, expectedRegexPattern))
+		{
+			throw MatchesException.ForMatchNotFound(expectedRegexPattern, actualString);
+		}
+	}
+	public static void Matches(Regex expectedRegex, string? actualString)
+	{
+		GuardArgumentNotNull<Regex>("expectedRegex", expectedRegex);
+		if (actualString == null || !expectedRegex.IsMatch(actualString))
+		{
+			throw MatchesException.ForMatchNotFound(((object)expectedRegex).ToString(), actualString);
+		}
+	}
+	public static void StartsWith(string? expectedStartString, string? actualString)
+	{
+		StartsWith(expectedStartString, actualString, (StringComparison)0);
+	}
+	public static void StartsWith(string? expectedStartString, string? actualString, StringComparison comparisonType)
+	{
+		if (expectedStartString == null || actualString == null || !actualString.StartsWith(expectedStartString, comparisonType))
+		{
+			throw StartsWithException.ForStringNotFound(expectedStartString, actualString);
+		}
+	}
+	public static void StartsWith(System.Memory<char> expectedStartString, System.Memory<char> actualString)
+	{
+		StartsWith(System.Memory<char>.op_Implicit(expectedStartString), System.Memory<char>.op_Implicit(actualString), (StringComparison)0);
+	}
+	public static void StartsWith(System.Memory<char> expectedStartString, ReadOnlyMemory<char> actualString)
+	{
+		StartsWith(System.Memory<char>.op_Implicit(expectedStartString), actualString, (StringComparison)0);
+	}
+	public static void StartsWith(ReadOnlyMemory<char> expectedStartString, System.Memory<char> actualString)
+	{
+		StartsWith(expectedStartString, System.Memory<char>.op_Implicit(actualString), (StringComparison)0);
+	}
+	public static void StartsWith(ReadOnlyMemory<char> expectedStartString, ReadOnlyMemory<char> actualString)
+	{
+		StartsWith(expectedStartString, actualString, (StringComparison)0);
+	}
+	public static void StartsWith(System.Memory<char> expectedStartString, System.Memory<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		StartsWith(System.Memory<char>.op_Implicit(expectedStartString), System.Memory<char>.op_Implicit(actualString), comparisonType);
+	}
+	public static void StartsWith(System.Memory<char> expectedStartString, ReadOnlyMemory<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		StartsWith(System.Memory<char>.op_Implicit(expectedStartString), actualString, comparisonType);
+	}
+	public static void StartsWith(ReadOnlyMemory<char> expectedStartString, System.Memory<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		StartsWith(expectedStartString, System.Memory<char>.op_Implicit(actualString), comparisonType);
+	}
+	public static void StartsWith(ReadOnlyMemory<char> expectedStartString, ReadOnlyMemory<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		GuardArgumentNotNull<ReadOnlyMemory<char>>("expectedStartString", expectedStartString);
+		StartsWith(expectedStartString.Span, actualString.Span, comparisonType);
+	}
+	public static void StartsWith(System.Span<char> expectedStartString, System.Span<char> actualString)
+	{
+		StartsWith(System.Span<char>.op_Implicit(expectedStartString), System.Span<char>.op_Implicit(actualString), (StringComparison)0);
+	}
+	public static void StartsWith(System.Span<char> expectedStartString, System.ReadOnlySpan<char> actualString)
+	{
+		StartsWith(System.Span<char>.op_Implicit(expectedStartString), actualString, (StringComparison)0);
+	}
+	public static void StartsWith(System.ReadOnlySpan<char> expectedStartString, System.Span<char> actualString)
+	{
+		StartsWith(expectedStartString, System.Span<char>.op_Implicit(actualString), (StringComparison)0);
+	}
+	public static void StartsWith(System.ReadOnlySpan<char> expectedStartString, System.ReadOnlySpan<char> actualString)
+	{
+		StartsWith(expectedStartString, actualString, (StringComparison)0);
+	}
+	public static void StartsWith(System.Span<char> expectedStartString, System.Span<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		StartsWith(System.Span<char>.op_Implicit(expectedStartString), System.Span<char>.op_Implicit(actualString), comparisonType);
+	}
+	public static void StartsWith(System.Span<char> expectedStartString, System.ReadOnlySpan<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		StartsWith(System.Span<char>.op_Implicit(expectedStartString), actualString, comparisonType);
+	}
+	public static void StartsWith(System.ReadOnlySpan<char> expectedStartString, System.Span<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		StartsWith(expectedStartString, System.Span<char>.op_Implicit(actualString), comparisonType);
+	}
+	public static void StartsWith(System.ReadOnlySpan<char> expectedStartString, System.ReadOnlySpan<char> actualString, StringComparison comparisonType = (StringComparison)0)
+	{
+		if (!MemoryExtensions.StartsWith(actualString, expectedStartString, comparisonType))
+		{
+			throw StartsWithException.ForStringNotFound(((object)expectedStartString/*cast due to .constrained prefix*/).ToString(), ((object)actualString/*cast due to .constrained prefix*/).ToString());
+		}
+	}
+	private unsafe static int SkipLineEnding(System.ReadOnlySpan<char> value, int index)
+	{
+		if (*(ushort*)value[index] == 13)
+		{
+			index++;
+		}
+		if (index < value.Length && *(ushort*)value[index] == 10)
+		{
+			index++;
+		}
+		return index;
+	}
+	private unsafe static int SkipWhitespace(System.ReadOnlySpan<char> value, int index)
+	{
+		while (index < value.Length)
+		{
+			if (charsWhitespace.Contains(*(char*)value[index]))
+			{
+				index++;
+				continue;
+			}
+			return index;
+		}
+		return index;
+	}
+	public static T IsAssignableFrom<T>(object? @object)
+	{
+		IsAssignableFrom(typeof(T), @object);
+		return (T)@object;
+	}
+	public static void IsAssignableFrom(System.Type expectedType, [NotNull] object? @object)
+	{
+		GuardArgumentNotNull("expectedType", expectedType);
+		if (@object == null || !IntrospectionExtensions.GetTypeInfo(expectedType).IsAssignableFrom(IntrospectionExtensions.GetTypeInfo(@object.GetType())))
+		{
+			throw IsAssignableFromException.ForIncompatibleType(expectedType, @object);
+		}
+	}
+	public static void IsNotAssignableFrom<T>(object? @object)
+	{
+		IsNotAssignableFrom(typeof(T), @object);
+	}
+	public static void IsNotAssignableFrom(System.Type expectedType, object? @object)
+	{
+		GuardArgumentNotNull("expectedType", expectedType);
+		if (@object != null && IntrospectionExtensions.GetTypeInfo(expectedType).IsAssignableFrom(IntrospectionExtensions.GetTypeInfo(@object.GetType())))
+		{
+			throw IsNotAssignableFromException.ForCompatibleType(expectedType, @object);
+		}
+	}
+	public static void IsNotType<T>(object? @object)
+	{
+		IsNotType(typeof(T), @object);
+	}
+	public static void IsNotType<T>(object? @object, bool exactMatch)
+	{
+		IsNotType(typeof(T), @object, exactMatch);
+	}
+	public static void IsNotType(System.Type expectedType, object? @object)
+	{
+		IsNotType(expectedType, @object, exactMatch: true);
+	}
+	public static void IsNotType(System.Type expectedType, object? @object, bool exactMatch)
+	{
+		GuardArgumentNotNull("expectedType", expectedType);
+		if (exactMatch)
+		{
+			if (@object != null && expectedType.Equals(@object.GetType()))
+			{
+				throw IsNotTypeException.ForExactType(expectedType);
+			}
+			return;
+		}
+		System.Type type = @object?.GetType();
+		if (type != (System.Type)null && IntrospectionExtensions.GetTypeInfo(expectedType).IsAssignableFrom(IntrospectionExtensions.GetTypeInfo(type)))
+		{
+			throw IsNotTypeException.ForCompatibleType(expectedType, type);
+		}
+	}
+	public static T IsType<T>([NotNull] object? @object)
+	{
+		IsType(typeof(T), @object, exactMatch: true);
+		return (T)@object;
+	}
+	public static T IsType<T>([NotNull] object? @object, bool exactMatch)
+	{
+		IsType(typeof(T), @object, exactMatch);
+		return (T)@object;
+	}
+	public static void IsType(System.Type expectedType, [NotNull] object? @object)
+	{
+		IsType(expectedType, @object, exactMatch: true);
+	}
+	public static void IsType(System.Type expectedType, [NotNull] object? @object, bool exactMatch)
+	{
+		GuardArgumentNotNull("expectedType", expectedType);
+		if (@object == null)
+		{
+			if (exactMatch)
+			{
+				throw IsTypeException.ForMismatchedType(ArgumentFormatter.Format(expectedType), null);
+			}
+			throw IsTypeException.ForIncompatibleType(ArgumentFormatter.Format(expectedType), null);
+		}
+		System.Type type = @object.GetType();
+		if (!(exactMatch ? (expectedType == type) : IntrospectionExtensions.GetTypeInfo(expectedType).IsAssignableFrom(IntrospectionExtensions.GetTypeInfo(type))))
+		{
+			string text = ArgumentFormatter.Format(expectedType);
+			string text2 = ArgumentFormatter.Format(type);
+			if (text == text2)
+			{
+				text += string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, " (from {0})", (object)((System.Type)(object)IntrospectionExtensions.GetTypeInfo(expectedType)).Assembly.GetName().FullName);
+				text2 += string.Format((IFormatProvider)(object)CultureInfo.CurrentCulture, " (from {0})", (object)((System.Type)(object)IntrospectionExtensions.GetTypeInfo(type)).Assembly.GetName().FullName);
+			}
+			if (exactMatch)
+			{
+				throw IsTypeException.ForMismatchedType(text, text2);
+			}
+			throw IsTypeException.ForIncompatibleType(text, text2);
+		}
+	}
+	static Assert()
+	{
+		HashSet<char> obj = new HashSet<char>();
+		obj.Add('\r');
+		obj.Add('\n');
+		charsLineEndings = obj;
+		HashSet<char> obj2 = new HashSet<char>();
+		obj2.Add('\t');
+		obj2.Add(' ');
+		obj2.Add('\u00a0');
+		obj2.Add('\u1680');
+		obj2.Add('\u180e');
+		obj2.Add('\u2000');
+		obj2.Add('\u2001');
+		obj2.Add('\u2002');
+		obj2.Add('\u2003');
+		obj2.Add('\u2004');
+		obj2.Add('\u2005');
+		obj2.Add('\u2006');
+		obj2.Add('\u2007');
+		obj2.Add('\u2008');
+		obj2.Add('\u2009');
+		obj2.Add('\u200a');
+		obj2.Add('\u200b');
+		obj2.Add('\u202f');
+		obj2.Add('\u205f');
+		obj2.Add('\u3000');
+		obj2.Add('\ufeff');
+		charsWhitespace = obj2;
+	}
+}
+```