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

package/out/atmpCache/deps/ToListCountAnalyzerTests_ToListinatorTests_test_AIUnitTestExample_code_d.deps

@@ -1,4037 +0,0 @@
-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;
-	}
-}
-```