diff --git a/Directory.Packages.props b/Directory.Packages.props
index 6a98636f..6b0b4140 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -9,6 +9,7 @@
 	<PackageVersion Include="coverlet.msbuild" Version="6.0.2" />
 	<PackageVersion Include="DocFx.App" Version="2.77.0" />
 	<PackageVersion Include="GitHubActionsTestLogger" Version="2.4.1" />
+	<PackageVersion Include="Microsoft.Bcl.HashCode" Version="1.1.1" />
 	<PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" />
 	<PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.10.0" />
 	<PackageVersion Include="Microsoft.CodeAnalysis.PublicApiAnalyzers" Version="3.3.4" />
@@ -17,6 +18,7 @@
 	<PackageVersion Include="MinVer" Version="5.0.0" />
 	<PackageVersion Include="Scriban" Version="5.10.0" />
 	<PackageVersion Include="System.Linq.Async" Version="6.0.1" />
+	<PackageVersion Include="System.Memory" Version="4.5.5" />
 	<PackageVersion Include="ThisAssembly.Resources" Version="1.4.3" />
 	<PackageVersion Include="xunit" Version="2.9.0" />
   </ItemGroup>
@@ -31,7 +33,6 @@
 
   <ItemGroup>
 	<GlobalPackageReference Include="Meziantou.Analyzer" Version="2.0.160" />
-	<GlobalPackageReference Include="Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers" Version="3.3.1" />
 	<GlobalPackageReference Include="PolySharp" Version="1.14.1" />
   </ItemGroup>
 </Project>
diff --git a/Source/SuperLinq.Async/ElementAt.cs b/Source/SuperLinq.Async/ElementAt.cs
index a55647c3..af4d5a5b 100644
--- a/Source/SuperLinq.Async/ElementAt.cs
+++ b/Source/SuperLinq.Async/ElementAt.cs
@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+#if !NO_INDEX
+
 namespace SuperLinq.Async;
 
 public static partial class AsyncSuperEnumerable
@@ -101,3 +103,5 @@ CancellationToken cancellationToken
 		return (false, default);
 	}
 }
+
+#endif
diff --git a/Source/SuperLinq.Async/FindIndex.cs b/Source/SuperLinq.Async/FindIndex.cs
index 8fc52fed..bb04ece2 100644
--- a/Source/SuperLinq.Async/FindIndex.cs
+++ b/Source/SuperLinq.Async/FindIndex.cs
@@ -1,3 +1,5 @@
+#if !NO_INDEX
+
 namespace SuperLinq.Async;
 
 public static partial class AsyncSuperEnumerable
@@ -202,3 +204,5 @@ CancellationToken cancellationToken
 		}
 	}
 }
+
+#endif
diff --git a/Source/SuperLinq.Async/FindLastIndex.cs b/Source/SuperLinq.Async/FindLastIndex.cs
index 83dad504..5051bc28 100644
--- a/Source/SuperLinq.Async/FindLastIndex.cs
+++ b/Source/SuperLinq.Async/FindLastIndex.cs
@@ -1,3 +1,5 @@
+#if !NO_INDEX
+
 namespace SuperLinq.Async;
 
 public static partial class AsyncSuperEnumerable
@@ -187,3 +189,5 @@ CancellationToken cancellationToken
 		}
 	}
 }
+
+#endif
diff --git a/Source/SuperLinq.Async/GetShortestPath.cs b/Source/SuperLinq.Async/GetShortestPath.cs
index c4aa54ca..74bfd75b 100644
--- a/Source/SuperLinq.Async/GetShortestPath.cs
+++ b/Source/SuperLinq.Async/GetShortestPath.cs
@@ -812,7 +812,7 @@ public partial class AsyncSuperEnumerable
 			var queue = new UpdatablePriorityQueue<TState, (TState? parent, TCost? cost)>(
 				16,
 				priorityComparer: Comparer<(TState? parent, TCost? cost)>.Create(
-					(x, y) => costComparer.Compare(x.cost, y.cost)),
+					(x, y) => costComparer.Compare(x.cost!, y.cost!)),
 				stateComparer);
 
 			var current = start;
@@ -1154,7 +1154,7 @@ public partial class AsyncSuperEnumerable
 				cancellationToken.ThrowIfCancellationRequested();
 
 				if (!totalCost.TryGetValue(current, out var oldCost)
-					|| costComparer.Compare(costs.traversed, oldCost) < 0)
+					|| costComparer.Compare(costs.traversed!, oldCost!) < 0)
 				{
 					totalCost[current] = costs.traversed;
 					if (await predicate(current).ConfigureAwait(false))
@@ -1503,7 +1503,7 @@ public partial class AsyncSuperEnumerable
 				cancellationToken.ThrowIfCancellationRequested();
 
 				if (!totalCost.TryGetValue(current, out var oldCost)
-					|| costComparer.Compare(from.traversed, oldCost.traversed) < 0)
+					|| costComparer.Compare(from.traversed!, oldCost.traversed!) < 0)
 				{
 					totalCost[current] = (from.parent, from.traversed);
 					if (await predicate(current).ConfigureAwait(false))
diff --git a/Source/SuperLinq.Async/IAsyncBuffer.cs b/Source/SuperLinq.Async/IAsyncBuffer.cs
index ba8684a7..a4099a54 100644
--- a/Source/SuperLinq.Async/IAsyncBuffer.cs
+++ b/Source/SuperLinq.Async/IAsyncBuffer.cs
@@ -1,4 +1,4 @@
-namespace SuperLinq.Async;
+namespace SuperLinq.Async;
 
 /// <summary>
 /// Represents a cached sequence that can be re-enumerated multiple times.
@@ -20,6 +20,7 @@ public interface IAsyncBuffer<out T> : IAsyncEnumerable<T>, IAsyncDisposable
 	/// </summary>
 	int Count { get; }
 
+#if NETCOREAPP
 	/// <summary>
 	///		Configures how awaits on the tasks returned from an async disposable are performed.
 	/// </summary>
@@ -31,4 +32,5 @@ public interface IAsyncBuffer<out T> : IAsyncEnumerable<T>, IAsyncDisposable
 	/// </returns>
 	public ConfiguredAsyncDisposable ConfigureAwait(bool continueOnCapturedContext) =>
 		((IAsyncDisposable)this).ConfigureAwait(continueOnCapturedContext);
+#endif
 }
diff --git a/Source/SuperLinq.Async/IndexOf.cs b/Source/SuperLinq.Async/IndexOf.cs
index 5cd5bcdf..c612a16e 100644
--- a/Source/SuperLinq.Async/IndexOf.cs
+++ b/Source/SuperLinq.Async/IndexOf.cs
@@ -1,3 +1,5 @@
+#if !NO_INDEX
+
 namespace SuperLinq.Async;
 
 public static partial class AsyncSuperEnumerable
@@ -126,3 +128,5 @@ public static ValueTask<int> IndexOf<TSource>(
 		return FindIndex(source, i => EqualityComparer<TSource>.Default.Equals(i, item), index, count, cancellationToken);
 	}
 }
+
+#endif
diff --git a/Source/SuperLinq.Async/Insert.cs b/Source/SuperLinq.Async/Insert.cs
index 3047a520..ce08113c 100644
--- a/Source/SuperLinq.Async/Insert.cs
+++ b/Source/SuperLinq.Async/Insert.cs
@@ -1,3 +1,5 @@
+#if !NO_INDEX
+
 namespace SuperLinq.Async;
 
 public static partial class AsyncSuperEnumerable
@@ -136,3 +138,5 @@ static async IAsyncEnumerable<T> Core(
 		}
 	}
 }
+
+#endif
diff --git a/Source/SuperLinq.Async/Join.MergeJoin.cs b/Source/SuperLinq.Async/Join.MergeJoin.cs
index d1b26a85..d499a91f 100644
--- a/Source/SuperLinq.Async/Join.MergeJoin.cs
+++ b/Source/SuperLinq.Async/Join.MergeJoin.cs
@@ -722,6 +722,10 @@ file sealed class ComparerEqualityComparer<TKey>(
 	IComparer<TKey> comparer
 ) : IEqualityComparer<TKey>
 {
-	public bool Equals([AllowNull] TKey x, [AllowNull] TKey y) => comparer.Compare(x, y) == 0;
+	public bool Equals([AllowNull] TKey x, [AllowNull] TKey y) => comparer.Compare(x!, y!) == 0;
+#if NETCOREAPP
 	public int GetHashCode([DisallowNull] TKey obj) => ThrowHelper.ThrowNotSupportedException<int>();
+#else
+	public int GetHashCode(TKey obj) => ThrowHelper.ThrowNotSupportedException<int>();
+#endif
 }
diff --git a/Source/SuperLinq.Async/LastIndexOf.cs b/Source/SuperLinq.Async/LastIndexOf.cs
index c314851f..e46ae2b5 100644
--- a/Source/SuperLinq.Async/LastIndexOf.cs
+++ b/Source/SuperLinq.Async/LastIndexOf.cs
@@ -1,3 +1,5 @@
+#if !NO_INDEX
+
 namespace SuperLinq.Async;
 
 public static partial class AsyncSuperEnumerable
@@ -135,3 +137,5 @@ public static ValueTask<int> LastIndexOf<TSource>(
 		);
 	}
 }
+
+#endif
diff --git a/Source/SuperLinq.Async/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt b/Source/SuperLinq.Async/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt
new file mode 100644
index 00000000..7dc5c581
--- /dev/null
+++ b/Source/SuperLinq.Async/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt
@@ -0,0 +1 @@
+#nullable enable
diff --git a/Source/SuperLinq.Async/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt b/Source/SuperLinq.Async/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt
new file mode 100644
index 00000000..86cc8f2a
--- /dev/null
+++ b/Source/SuperLinq.Async/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt
@@ -0,0 +1,366 @@
+static SuperLinq.Async.AsyncSuperEnumerable.AggregateBy<TSource, TKey, TAccumulate>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, TAccumulate>! seedSelector, System.Func<TAccumulate, TSource, TAccumulate>! func, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.KeyValuePair<TKey, TAccumulate>>!
+static SuperLinq.Async.AsyncSuperEnumerable.AggregateBy<TSource, TKey, TAccumulate>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, TAccumulate seed, System.Func<TAccumulate, TSource, TAccumulate>! func, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.KeyValuePair<TKey, TAccumulate>>!
+static SuperLinq.Async.AsyncSuperEnumerable.AggregateRight<TSource, TAccumulate, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, TAccumulate seed, System.Func<TSource, TAccumulate, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TAccumulate>>! func, System.Func<TAccumulate, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>! resultSelector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<TResult>
+static SuperLinq.Async.AsyncSuperEnumerable.AggregateRight<TSource, TAccumulate, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, TAccumulate seed, System.Func<TSource, TAccumulate, System.Threading.Tasks.ValueTask<TAccumulate>>! func, System.Func<TAccumulate, System.Threading.Tasks.ValueTask<TResult>>! resultSelector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<TResult>
+static SuperLinq.Async.AsyncSuperEnumerable.AggregateRight<TSource, TAccumulate, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, TAccumulate seed, System.Func<TSource, TAccumulate, TAccumulate>! func, System.Func<TAccumulate, TResult>! resultSelector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<TResult>
+static SuperLinq.Async.AsyncSuperEnumerable.AggregateRight<TSource, TAccumulate>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, TAccumulate seed, System.Func<TSource, TAccumulate, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TAccumulate>>! func, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<TAccumulate>
+static SuperLinq.Async.AsyncSuperEnumerable.AggregateRight<TSource, TAccumulate>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, TAccumulate seed, System.Func<TSource, TAccumulate, System.Threading.Tasks.ValueTask<TAccumulate>>! func, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<TAccumulate>
+static SuperLinq.Async.AsyncSuperEnumerable.AggregateRight<TSource, TAccumulate>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, TAccumulate seed, System.Func<TSource, TAccumulate, TAccumulate>! func, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<TAccumulate>
+static SuperLinq.Async.AsyncSuperEnumerable.AggregateRight<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TSource>>! func, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<TSource>
+static SuperLinq.Async.AsyncSuperEnumerable.AggregateRight<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TSource, System.Threading.Tasks.ValueTask<TSource>>! func, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<TSource>
+static SuperLinq.Async.AsyncSuperEnumerable.AggregateRight<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TSource, TSource>! func, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<TSource>
+static SuperLinq.Async.AsyncSuperEnumerable.Amb<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, params System.Collections.Generic.IAsyncEnumerable<TSource>![]! otherSources) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Amb<TSource>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IAsyncEnumerable<TSource>!>! sources) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.AssertCount<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int count) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.AtLeast<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, int count, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<bool>
+static SuperLinq.Async.AsyncSuperEnumerable.AtMost<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, int count, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<bool>
+static SuperLinq.Async.AsyncSuperEnumerable.Batch<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int size) -> System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IList<TSource>!>!
+static SuperLinq.Async.AsyncSuperEnumerable.BindByIndex<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Collections.Generic.IAsyncEnumerable<int>! indices, System.Func<TSource, int, TResult>! resultSelector, System.Func<int, TResult>! missingSelector) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.BindByIndex<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Collections.Generic.IAsyncEnumerable<int>! indices) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Buffer<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int count, int skip) -> System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IList<TSource>!>!
+static SuperLinq.Async.AsyncSuperEnumerable.Buffer<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int count) -> System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IList<TSource>!>!
+static SuperLinq.Async.AsyncSuperEnumerable.Case<TValue, TResult>(System.Func<System.Threading.Tasks.ValueTask<TValue>>! selector, System.Collections.Generic.IDictionary<TValue, System.Collections.Generic.IAsyncEnumerable<TResult>!>! sources, System.Collections.Generic.IAsyncEnumerable<TResult>! defaultSource) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.Case<TValue, TResult>(System.Func<System.Threading.Tasks.ValueTask<TValue>>! selector, System.Collections.Generic.IDictionary<TValue, System.Collections.Generic.IAsyncEnumerable<TResult>!>! sources) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.Case<TValue, TResult>(System.Func<TValue>! selector, System.Collections.Generic.IDictionary<TValue, System.Collections.Generic.IAsyncEnumerable<TResult>!>! sources, System.Collections.Generic.IAsyncEnumerable<TResult>! defaultSource) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.Case<TValue, TResult>(System.Func<TValue>! selector, System.Collections.Generic.IDictionary<TValue, System.Collections.Generic.IAsyncEnumerable<TResult>!>! sources) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.Catch<TSource, TException>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TException!, System.Collections.Generic.IAsyncEnumerable<TSource>!>! handler) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Catch<TSource>(params System.Collections.Generic.IAsyncEnumerable<TSource>![]! sources) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Catch<TSource>(this System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IAsyncEnumerable<TSource>!>! sources) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Catch<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! first, System.Collections.Generic.IAsyncEnumerable<TSource>! second) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Catch<TSource>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IAsyncEnumerable<TSource>!>! sources) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Choose<T, TResult>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, (bool, TResult)>! chooser) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.Choose<T, TResult>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<(bool, TResult)>>! chooser) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.Choose<T, TResult>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, System.Threading.Tasks.ValueTask<(bool, TResult)>>! chooser) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.CollectionEqual<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! first, System.Collections.Generic.IAsyncEnumerable<TSource>! second, System.Collections.Generic.IEqualityComparer<TSource>? comparer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<bool>
+static SuperLinq.Async.AsyncSuperEnumerable.CollectionEqual<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! first, System.Collections.Generic.IAsyncEnumerable<TSource>! second, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<bool>
+static SuperLinq.Async.AsyncSuperEnumerable.CompareCount<TFirst, TSecond>(this System.Collections.Generic.IAsyncEnumerable<TFirst>! first, System.Collections.Generic.IAsyncEnumerable<TSecond>! second, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<int>
+static SuperLinq.Async.AsyncSuperEnumerable.ConcurrentMerge<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, params System.Collections.Generic.IAsyncEnumerable<TSource>![]! otherSources) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.ConcurrentMerge<TSource>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IAsyncEnumerable<TSource>!>! sources, int maxConcurrency) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.ConcurrentMerge<TSource>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IAsyncEnumerable<TSource>!>! sources) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Consume<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask
+static SuperLinq.Async.AsyncSuperEnumerable.CopyTo<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Collections.Generic.IList<TSource>! list, int index, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<int>
+static SuperLinq.Async.AsyncSuperEnumerable.CopyTo<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Collections.Generic.IList<TSource>! list, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<int>
+static SuperLinq.Async.AsyncSuperEnumerable.CountBetween<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, int min, int max, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<bool>
+static SuperLinq.Async.AsyncSuperEnumerable.CountBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.KeyValuePair<TKey, int>>!
+static SuperLinq.Async.AsyncSuperEnumerable.CountBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.KeyValuePair<TKey, int>>!
+static SuperLinq.Async.AsyncSuperEnumerable.CountDown<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int count, System.Func<TSource, int?, TResult>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.CountDown<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int count) -> System.Collections.Generic.IAsyncEnumerable<(TSource item, int? count)>!
+static SuperLinq.Async.AsyncSuperEnumerable.Defer<TResult>(System.Func<System.Collections.Generic.IAsyncEnumerable<TResult>!>! enumerableFactory) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.DensePartialSort<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, int count, SuperLinq.OrderByDirection direction) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.DensePartialSort<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, int count, System.Collections.Generic.IComparer<T>? comparer, SuperLinq.OrderByDirection direction) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.DensePartialSort<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, int count, System.Collections.Generic.IComparer<T>? comparer) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.DensePartialSort<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, int count) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.DensePartialSortBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector, SuperLinq.OrderByDirection direction) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.DensePartialSortBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer, SuperLinq.OrderByDirection direction) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.DensePartialSortBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.DensePartialSortBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.DenseRank<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, SuperLinq.OrderByDirection sortDirection) -> System.Collections.Generic.IAsyncEnumerable<(TSource item, int rank)>!
+static SuperLinq.Async.AsyncSuperEnumerable.DenseRank<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Collections.Generic.IComparer<TSource>! comparer, SuperLinq.OrderByDirection sortDirection) -> System.Collections.Generic.IAsyncEnumerable<(TSource item, int rank)>!
+static SuperLinq.Async.AsyncSuperEnumerable.DenseRank<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Collections.Generic.IComparer<TSource>! comparer) -> System.Collections.Generic.IAsyncEnumerable<(TSource item, int rank)>!
+static SuperLinq.Async.AsyncSuperEnumerable.DenseRank<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source) -> System.Collections.Generic.IAsyncEnumerable<(TSource item, int rank)>!
+static SuperLinq.Async.AsyncSuperEnumerable.DenseRankBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, SuperLinq.OrderByDirection sortDirection) -> System.Collections.Generic.IAsyncEnumerable<(TSource item, int rank)>!
+static SuperLinq.Async.AsyncSuperEnumerable.DenseRankBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>! comparer, SuperLinq.OrderByDirection sortDirection) -> System.Collections.Generic.IAsyncEnumerable<(TSource item, int rank)>!
+static SuperLinq.Async.AsyncSuperEnumerable.DenseRankBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>! comparer) -> System.Collections.Generic.IAsyncEnumerable<(TSource item, int rank)>!
+static SuperLinq.Async.AsyncSuperEnumerable.DenseRankBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IAsyncEnumerable<(TSource item, int rank)>!
+static SuperLinq.Async.AsyncSuperEnumerable.DistinctBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.DistinctBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.DistinctUntilChanged<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.DistinctUntilChanged<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>! keySelector) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.DistinctUntilChanged<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.DistinctUntilChanged<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.DistinctUntilChanged<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Collections.Generic.IEqualityComparer<TSource>? comparer) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.DistinctUntilChanged<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Action<TSource>! onNext, System.Action! onCompleted) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Action<TSource>! onNext, System.Action<System.Exception!>! onError, System.Action! onCompleted) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Action<TSource>! onNext, System.Action<System.Exception!>! onError) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Action<TSource>! onNext) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, System.Threading.Tasks.ValueTask>! onNext, System.Func<System.Exception!, System.Threading.Tasks.ValueTask>! onError, System.Func<System.Threading.Tasks.ValueTask>! onCompleted) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, System.Threading.Tasks.ValueTask>! onNext, System.Func<System.Exception!, System.Threading.Tasks.ValueTask>! onError) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, System.Threading.Tasks.ValueTask>! onNext, System.Func<System.Threading.Tasks.ValueTask>! onCompleted) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, System.Threading.Tasks.ValueTask>! onNext) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.DoWhile<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<bool>! condition) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.DoWhile<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<System.Threading.Tasks.ValueTask<bool>>! condition) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Duplicates<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Collections.Generic.IEqualityComparer<TSource>? comparer = null) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.EndsWith<T>(this System.Collections.Generic.IAsyncEnumerable<T>! first, System.Collections.Generic.IAsyncEnumerable<T>! second, System.Collections.Generic.IEqualityComparer<T>? comparer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<bool>
+static SuperLinq.Async.AsyncSuperEnumerable.EndsWith<T>(this System.Collections.Generic.IAsyncEnumerable<T>! first, System.Collections.Generic.IAsyncEnumerable<T>! second, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<bool>
+static SuperLinq.Async.AsyncSuperEnumerable.EndsWith<T>(this System.Collections.Generic.IAsyncEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Collections.Generic.IEqualityComparer<T>? comparer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<bool>
+static SuperLinq.Async.AsyncSuperEnumerable.EndsWith<T>(this System.Collections.Generic.IAsyncEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<bool>
+static SuperLinq.Async.AsyncSuperEnumerable.EquiZip<TFirst, TSecond, TResult>(this System.Collections.Generic.IAsyncEnumerable<TFirst>! first, System.Collections.Generic.IAsyncEnumerable<TSecond>! second, System.Func<TFirst, TSecond, TResult>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.EquiZip<TFirst, TSecond, TThird, TFourth, TResult>(this System.Collections.Generic.IAsyncEnumerable<TFirst>! first, System.Collections.Generic.IAsyncEnumerable<TSecond>! second, System.Collections.Generic.IAsyncEnumerable<TThird>! third, System.Collections.Generic.IAsyncEnumerable<TFourth>! fourth, System.Func<TFirst, TSecond, TThird, TFourth, TResult>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.EquiZip<TFirst, TSecond, TThird, TFourth>(this System.Collections.Generic.IAsyncEnumerable<TFirst>! first, System.Collections.Generic.IAsyncEnumerable<TSecond>! second, System.Collections.Generic.IAsyncEnumerable<TThird>! third, System.Collections.Generic.IAsyncEnumerable<TFourth>! fourth) -> System.Collections.Generic.IAsyncEnumerable<(TFirst, TSecond, TThird, TFourth)>!
+static SuperLinq.Async.AsyncSuperEnumerable.EquiZip<TFirst, TSecond, TThird, TResult>(this System.Collections.Generic.IAsyncEnumerable<TFirst>! first, System.Collections.Generic.IAsyncEnumerable<TSecond>! second, System.Collections.Generic.IAsyncEnumerable<TThird>! third, System.Func<TFirst, TSecond, TThird, TResult>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.EquiZip<TFirst, TSecond, TThird>(this System.Collections.Generic.IAsyncEnumerable<TFirst>! first, System.Collections.Generic.IAsyncEnumerable<TSecond>! second, System.Collections.Generic.IAsyncEnumerable<TThird>! third) -> System.Collections.Generic.IAsyncEnumerable<(TFirst, TSecond, TThird)>!
+static SuperLinq.Async.AsyncSuperEnumerable.EquiZip<TFirst, TSecond>(this System.Collections.Generic.IAsyncEnumerable<TFirst>! first, System.Collections.Generic.IAsyncEnumerable<TSecond>! second) -> System.Collections.Generic.IAsyncEnumerable<(TFirst, TSecond)>!
+static SuperLinq.Async.AsyncSuperEnumerable.Evaluate<T>(this System.Collections.Generic.IAsyncEnumerable<System.Func<System.Threading.Tasks.Task<T>!>!>! functions) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.Evaluate<T>(this System.Collections.Generic.IEnumerable<System.Func<System.Threading.Tasks.Task<T>!>!>! functions) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.Exactly<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, int count, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<bool>
+static SuperLinq.Async.AsyncSuperEnumerable.ExceptBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! first, System.Collections.Generic.IAsyncEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? keyComparer) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.ExceptBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! first, System.Collections.Generic.IAsyncEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.FallbackIfEmpty<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, params T[]! fallback) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.FallbackIfEmpty<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Collections.Generic.IAsyncEnumerable<T>! fallback) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.FallbackIfEmpty<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Collections.Generic.IEnumerable<T>! fallback) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.FillBackward<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, bool>! predicate, System.Func<T, T, System.Threading.Tasks.ValueTask<T>>! fillSelector) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.FillBackward<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, bool>! predicate, System.Func<T, T, T>! fillSelector) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.FillBackward<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, bool>! predicate) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.FillBackward<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, System.Threading.Tasks.ValueTask<bool>>! predicate, System.Func<T, T, System.Threading.Tasks.ValueTask<T>>! fillSelector) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.FillBackward<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, System.Threading.Tasks.ValueTask<bool>>! predicate, System.Func<T, T, T>! fillSelector) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.FillBackward<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, System.Threading.Tasks.ValueTask<bool>>! predicate) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.FillBackward<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.FillForward<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, bool>! predicate, System.Func<T, T, System.Threading.Tasks.ValueTask<T>>! fillSelector) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.FillForward<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, bool>! predicate, System.Func<T, T, T>! fillSelector) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.FillForward<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, bool>! predicate) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.FillForward<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, System.Threading.Tasks.ValueTask<bool>>! predicate, System.Func<T, T, System.Threading.Tasks.ValueTask<T>>! fillSelector) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.FillForward<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, System.Threading.Tasks.ValueTask<bool>>! predicate, System.Func<T, T, T>! fillSelector) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.FillForward<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, System.Threading.Tasks.ValueTask<bool>>! predicate) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.FillForward<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.Finally<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Action! finallyAction) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> System.Threading.Tasks.ValueTask<TResult>
+static SuperLinq.Async.AsyncSuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> System.Threading.Tasks.ValueTask<TResult>
+static SuperLinq.Async.AsyncSuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> System.Threading.Tasks.ValueTask<TResult>
+static SuperLinq.Async.AsyncSuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> System.Threading.Tasks.ValueTask<TResult>
+static SuperLinq.Async.AsyncSuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> System.Threading.Tasks.ValueTask<TResult>
+static SuperLinq.Async.AsyncSuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> System.Threading.Tasks.ValueTask<TResult>
+static SuperLinq.Async.AsyncSuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> System.Threading.Tasks.ValueTask<TResult>
+static SuperLinq.Async.AsyncSuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, TResult>! folder) -> System.Threading.Tasks.ValueTask<TResult>
+static SuperLinq.Async.AsyncSuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, TResult>! folder) -> System.Threading.Tasks.ValueTask<TResult>
+static SuperLinq.Async.AsyncSuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, TResult>! folder) -> System.Threading.Tasks.ValueTask<TResult>
+static SuperLinq.Async.AsyncSuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, T, T, T, T, T, TResult>! folder) -> System.Threading.Tasks.ValueTask<TResult>
+static SuperLinq.Async.AsyncSuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, T, T, T, T, TResult>! folder) -> System.Threading.Tasks.ValueTask<TResult>
+static SuperLinq.Async.AsyncSuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, T, T, T, TResult>! folder) -> System.Threading.Tasks.ValueTask<TResult>
+static SuperLinq.Async.AsyncSuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, T, T, TResult>! folder) -> System.Threading.Tasks.ValueTask<TResult>
+static SuperLinq.Async.AsyncSuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, T, TResult>! folder) -> System.Threading.Tasks.ValueTask<TResult>
+static SuperLinq.Async.AsyncSuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, TResult>! folder) -> System.Threading.Tasks.ValueTask<TResult>
+static SuperLinq.Async.AsyncSuperEnumerable.ForEach<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Action<TSource, int>! action, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask
+static SuperLinq.Async.AsyncSuperEnumerable.ForEach<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Action<TSource>! action, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask
+static SuperLinq.Async.AsyncSuperEnumerable.ForEach<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, int, System.Threading.Tasks.ValueTask>! action, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask
+static SuperLinq.Async.AsyncSuperEnumerable.ForEach<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, System.Threading.Tasks.ValueTask>! action, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask
+static SuperLinq.Async.AsyncSuperEnumerable.From<T>(params System.Func<System.Threading.Tasks.Task<T>!>![]! functions) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.From<T>(System.Func<System.Threading.Tasks.Task<T>!>! function) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.From<T>(System.Func<System.Threading.Tasks.Task<T>!>! function1, System.Func<System.Threading.Tasks.Task<T>!>! function2, System.Func<System.Threading.Tasks.Task<T>!>! function3) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.From<T>(System.Func<System.Threading.Tasks.Task<T>!>! function1, System.Func<System.Threading.Tasks.Task<T>!>! function2) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.FullOuterHashJoin<TLeft, TRight, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TLeft>! left, System.Collections.Generic.IAsyncEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Func<TLeft, TResult>! leftResultSelector, System.Func<TRight, TResult>! rightResultSelector, System.Func<TLeft, TRight, TResult>! bothResultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.FullOuterHashJoin<TLeft, TRight, TKey>(this System.Collections.Generic.IAsyncEnumerable<TLeft>! left, System.Collections.Generic.IAsyncEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IAsyncEnumerable<(TLeft? Left, TRight? Right)>!
+static SuperLinq.Async.AsyncSuperEnumerable.FullOuterMergeJoin<TLeft, TRight, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TLeft>! left, System.Collections.Generic.IAsyncEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Func<TLeft, TResult>! leftResultSelector, System.Func<TRight, TResult>! rightResultSelector, System.Func<TLeft, TRight, TResult>! bothResultSelector, System.Collections.Generic.IComparer<TKey>? comparer = null) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.FullOuterMergeJoin<TLeft, TRight, TKey>(this System.Collections.Generic.IAsyncEnumerable<TLeft>! left, System.Collections.Generic.IAsyncEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Collections.Generic.IComparer<TKey>? comparer = null) -> System.Collections.Generic.IAsyncEnumerable<(TLeft? Left, TRight? Right)>!
+static SuperLinq.Async.AsyncSuperEnumerable.Generate<TResult>(TResult initial, System.Func<TResult, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>! generator) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.Generate<TResult>(TResult initial, System.Func<TResult, System.Threading.Tasks.ValueTask<TResult>>! generator) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.GetShortestPath<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IAsyncEnumerable<(TState nextState, TCost cost, TCost bestGuess)>!>! getNeighbors, System.Func<TState, System.Threading.Tasks.ValueTask<bool>>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<System.Collections.Generic.IEnumerable<(TState nextState, TCost? cost)>!>
+static SuperLinq.Async.AsyncSuperEnumerable.GetShortestPath<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IAsyncEnumerable<(TState nextState, TCost cost, TCost bestGuess)>!>! getNeighbors, TState end, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<System.Collections.Generic.IEnumerable<(TState nextState, TCost? cost)>!>
+static SuperLinq.Async.AsyncSuperEnumerable.GetShortestPath<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IAsyncEnumerable<(TState nextState, TCost cost)>!>! getNeighbors, System.Func<TState, System.Threading.Tasks.ValueTask<bool>>! predicate, System.Collections.Generic.IEqualityComparer<TState>? stateComparer, System.Collections.Generic.IComparer<TCost>? costComparer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<System.Collections.Generic.IEnumerable<(TState state, TCost? cost)>!>
+static SuperLinq.Async.AsyncSuperEnumerable.GetShortestPath<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IAsyncEnumerable<(TState nextState, TCost cost)>!>! getNeighbors, System.Func<TState, System.Threading.Tasks.ValueTask<bool>>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<System.Collections.Generic.IEnumerable<(TState nextState, TCost? cost)>!>
+static SuperLinq.Async.AsyncSuperEnumerable.GetShortestPath<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IAsyncEnumerable<(TState nextState, TCost cost)>!>! getNeighbors, TState end, System.Collections.Generic.IEqualityComparer<TState>? stateComparer, System.Collections.Generic.IComparer<TCost>? costComparer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<System.Collections.Generic.IEnumerable<(TState state, TCost? cost)>!>
+static SuperLinq.Async.AsyncSuperEnumerable.GetShortestPath<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IAsyncEnumerable<(TState nextState, TCost cost)>!>! getNeighbors, TState end, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<System.Collections.Generic.IEnumerable<(TState nextState, TCost? cost)>!>
+static SuperLinq.Async.AsyncSuperEnumerable.GetShortestPath<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IAsyncEnumerable<(TState nextState, TCost traversed, TCost bestGuess)>!>! getNeighbors, System.Func<TState, System.Threading.Tasks.ValueTask<bool>>! predicate, System.Collections.Generic.IEqualityComparer<TState>? stateComparer, System.Collections.Generic.IComparer<TCost>? costComparer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<System.Collections.Generic.IEnumerable<(TState nextState, TCost? cost)>!>
+static SuperLinq.Async.AsyncSuperEnumerable.GetShortestPath<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IAsyncEnumerable<(TState nextState, TCost traversed, TCost bestGuess)>!>! getNeighbors, TState end, System.Collections.Generic.IEqualityComparer<TState>? stateComparer, System.Collections.Generic.IComparer<TCost>? costComparer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<System.Collections.Generic.IEnumerable<(TState nextState, TCost? cost)>!>
+static SuperLinq.Async.AsyncSuperEnumerable.GetShortestPathCost<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IAsyncEnumerable<(TState nextState, TCost cost, TCost bestGuess)>!>! getNeighbors, System.Func<TState, System.Threading.Tasks.ValueTask<bool>>! predicate, System.Collections.Generic.IEqualityComparer<TState>? stateComparer, System.Collections.Generic.IComparer<TCost>? costComparer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<TCost?>
+static SuperLinq.Async.AsyncSuperEnumerable.GetShortestPathCost<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IAsyncEnumerable<(TState nextState, TCost cost, TCost bestGuess)>!>! getNeighbors, System.Func<TState, System.Threading.Tasks.ValueTask<bool>>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<TCost?>
+static SuperLinq.Async.AsyncSuperEnumerable.GetShortestPathCost<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IAsyncEnumerable<(TState nextState, TCost cost, TCost bestGuess)>!>! getNeighbors, TState end, System.Collections.Generic.IEqualityComparer<TState>? stateComparer, System.Collections.Generic.IComparer<TCost>? costComparer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<TCost?>
+static SuperLinq.Async.AsyncSuperEnumerable.GetShortestPathCost<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IAsyncEnumerable<(TState nextState, TCost cost, TCost bestGuess)>!>! getNeighbors, TState end, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<TCost?>
+static SuperLinq.Async.AsyncSuperEnumerable.GetShortestPathCost<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IAsyncEnumerable<(TState nextState, TCost cost)>!>! getNeighbors, System.Func<TState, System.Threading.Tasks.ValueTask<bool>>! predicate, System.Collections.Generic.IEqualityComparer<TState>? stateComparer, System.Collections.Generic.IComparer<TCost>? costComparer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<TCost?>
+static SuperLinq.Async.AsyncSuperEnumerable.GetShortestPathCost<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IAsyncEnumerable<(TState nextState, TCost cost)>!>! getNeighbors, System.Func<TState, System.Threading.Tasks.ValueTask<bool>>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<TCost?>
+static SuperLinq.Async.AsyncSuperEnumerable.GetShortestPathCost<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IAsyncEnumerable<(TState nextState, TCost cost)>!>! getNeighbors, TState end, System.Collections.Generic.IEqualityComparer<TState>? stateComparer, System.Collections.Generic.IComparer<TCost>? costComparer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<TCost?>
+static SuperLinq.Async.AsyncSuperEnumerable.GetShortestPathCost<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IAsyncEnumerable<(TState nextState, TCost cost)>!>! getNeighbors, TState end, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<TCost?>
+static SuperLinq.Async.AsyncSuperEnumerable.GetShortestPaths<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IAsyncEnumerable<(TState nextState, TCost cost)>!>! getNeighbors, System.Collections.Generic.IEqualityComparer<TState>? stateComparer, System.Collections.Generic.IComparer<TCost>? costComparer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<System.Collections.Generic.IReadOnlyDictionary<TState, (TState? previousState, TCost? cost)>!>
+static SuperLinq.Async.AsyncSuperEnumerable.GetShortestPaths<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IAsyncEnumerable<(TState nextState, TCost cost)>!>! getNeighbors, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<System.Collections.Generic.IReadOnlyDictionary<TState, (TState? previousState, TCost? cost)>!>
+static SuperLinq.Async.AsyncSuperEnumerable.GroupAdjacent<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TElement>! elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IAsyncEnumerable<System.Linq.IGrouping<TKey, TElement>!>!
+static SuperLinq.Async.AsyncSuperEnumerable.GroupAdjacent<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TElement>! elementSelector) -> System.Collections.Generic.IAsyncEnumerable<System.Linq.IGrouping<TKey, TElement>!>!
+static SuperLinq.Async.AsyncSuperEnumerable.GroupAdjacent<TSource, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, System.Collections.Generic.IReadOnlyList<TSource>!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.GroupAdjacent<TSource, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, System.Collections.Generic.IReadOnlyList<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.GroupAdjacent<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IAsyncEnumerable<System.Linq.IGrouping<TKey, TSource>!>!
+static SuperLinq.Async.AsyncSuperEnumerable.GroupAdjacent<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IAsyncEnumerable<System.Linq.IGrouping<TKey, TSource>!>!
+static SuperLinq.Async.AsyncSuperEnumerable.HasDuplicates<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Collections.Generic.IEqualityComparer<T>? comparer) -> System.Threading.Tasks.ValueTask<bool>
+static SuperLinq.Async.AsyncSuperEnumerable.HasDuplicates<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source) -> System.Threading.Tasks.ValueTask<bool>
+static SuperLinq.Async.AsyncSuperEnumerable.HasDuplicates<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Threading.Tasks.ValueTask<bool>
+static SuperLinq.Async.AsyncSuperEnumerable.HasDuplicates<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Threading.Tasks.ValueTask<bool>
+static SuperLinq.Async.AsyncSuperEnumerable.Identity<T>(T x) -> T
+static SuperLinq.Async.AsyncSuperEnumerable.If<TResult>(System.Func<bool>! condition, System.Collections.Generic.IAsyncEnumerable<TResult>! thenSource, System.Collections.Generic.IAsyncEnumerable<TResult>! elseSource) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.If<TResult>(System.Func<bool>! condition, System.Collections.Generic.IAsyncEnumerable<TResult>! thenSource) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.If<TResult>(System.Func<System.Threading.Tasks.ValueTask<bool>>! condition, System.Collections.Generic.IAsyncEnumerable<TResult>! thenSource, System.Collections.Generic.IAsyncEnumerable<TResult>! elseSource) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.If<TResult>(System.Func<System.Threading.Tasks.ValueTask<bool>>! condition, System.Collections.Generic.IAsyncEnumerable<TResult>! thenSource) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.Index<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int startIndex) -> System.Collections.Generic.IAsyncEnumerable<(int index, TSource item)>!
+static SuperLinq.Async.AsyncSuperEnumerable.Index<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source) -> System.Collections.Generic.IAsyncEnumerable<(int index, TSource item)>!
+static SuperLinq.Async.AsyncSuperEnumerable.IndexBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IAsyncEnumerable<(int index, TSource item)>!
+static SuperLinq.Async.AsyncSuperEnumerable.IndexBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IAsyncEnumerable<(int index, TSource item)>!
+static SuperLinq.Async.AsyncSuperEnumerable.InnerHashJoin<TLeft, TRight, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TLeft>! left, System.Collections.Generic.IAsyncEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Func<TLeft, TRight, TResult>! bothResultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.InnerHashJoin<TLeft, TRight, TKey>(this System.Collections.Generic.IAsyncEnumerable<TLeft>! left, System.Collections.Generic.IAsyncEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IAsyncEnumerable<(TLeft Left, TRight Right)>!
+static SuperLinq.Async.AsyncSuperEnumerable.InnerLoopJoin<TLeft, TRight, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TLeft>! left, System.Collections.Generic.IAsyncEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Func<TLeft, TRight, TResult>! bothResultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.InnerLoopJoin<TLeft, TRight, TKey>(this System.Collections.Generic.IAsyncEnumerable<TLeft>! left, System.Collections.Generic.IAsyncEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IAsyncEnumerable<(TLeft Left, TRight Right)>!
+static SuperLinq.Async.AsyncSuperEnumerable.InnerMergeJoin<TLeft, TRight, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TLeft>! left, System.Collections.Generic.IAsyncEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Func<TLeft, TRight, TResult>! bothResultSelector, System.Collections.Generic.IComparer<TKey>? comparer = null) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.InnerMergeJoin<TLeft, TRight, TKey>(this System.Collections.Generic.IAsyncEnumerable<TLeft>! left, System.Collections.Generic.IAsyncEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Collections.Generic.IComparer<TKey>? comparer = null) -> System.Collections.Generic.IAsyncEnumerable<(TLeft Left, TRight Right)>!
+static SuperLinq.Async.AsyncSuperEnumerable.Interleave<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, params System.Collections.Generic.IAsyncEnumerable<T>![]! otherSources) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.Interleave<T>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IAsyncEnumerable<T>!>! sources) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.Lag<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int offset, System.Func<TSource, TSource?, TResult>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.Lag<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int offset, TSource defaultLagValue, System.Func<TSource, TSource, System.Threading.Tasks.ValueTask<TResult>>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.Lag<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int offset, TSource defaultLagValue, System.Func<TSource, TSource, TResult>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.Lag<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int offset) -> System.Collections.Generic.IAsyncEnumerable<(TSource current, TSource? lag)>!
+static SuperLinq.Async.AsyncSuperEnumerable.Lead<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int offset, System.Func<TSource, TSource?, TResult>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.Lead<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int offset, TSource defaultLeadValue, System.Func<TSource, TSource, System.Threading.Tasks.ValueTask<TResult>>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.Lead<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int offset, TSource defaultLeadValue, System.Func<TSource, TSource, TResult>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.Lead<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int offset) -> System.Collections.Generic.IAsyncEnumerable<(TSource current, TSource? lead)>!
+static SuperLinq.Async.AsyncSuperEnumerable.LeftOuterHashJoin<TLeft, TRight, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TLeft>! left, System.Collections.Generic.IAsyncEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Func<TLeft, TResult>! leftResultSelector, System.Func<TLeft, TRight, TResult>! bothResultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.LeftOuterHashJoin<TLeft, TRight, TKey>(this System.Collections.Generic.IAsyncEnumerable<TLeft>! left, System.Collections.Generic.IAsyncEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IAsyncEnumerable<(TLeft Left, TRight? Right)>!
+static SuperLinq.Async.AsyncSuperEnumerable.LeftOuterLoopJoin<TLeft, TRight, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TLeft>! left, System.Collections.Generic.IAsyncEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Func<TLeft, TResult>! leftResultSelector, System.Func<TLeft, TRight, TResult>! bothResultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.LeftOuterLoopJoin<TLeft, TRight, TKey>(this System.Collections.Generic.IAsyncEnumerable<TLeft>! left, System.Collections.Generic.IAsyncEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IAsyncEnumerable<(TLeft Left, TRight? Right)>!
+static SuperLinq.Async.AsyncSuperEnumerable.LeftOuterMergeJoin<TLeft, TRight, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TLeft>! left, System.Collections.Generic.IAsyncEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Func<TLeft, TResult>! leftResultSelector, System.Func<TLeft, TRight, TResult>! bothResultSelector, System.Collections.Generic.IComparer<TKey>? comparer = null) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.LeftOuterMergeJoin<TLeft, TRight, TKey>(this System.Collections.Generic.IAsyncEnumerable<TLeft>! left, System.Collections.Generic.IAsyncEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Collections.Generic.IComparer<TKey>? comparer = null) -> System.Collections.Generic.IAsyncEnumerable<(TLeft Left, TRight? Right)>!
+static SuperLinq.Async.AsyncSuperEnumerable.MaxByWithTies<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.MaxByWithTies<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.MaxItems<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Collections.Generic.IComparer<T>? comparer) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.MaxItems<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.MaxItemsBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.MaxItemsBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Memoize<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source) -> SuperLinq.Async.IAsyncBuffer<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.MinByWithTies<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.MinByWithTies<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.MinItems<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Collections.Generic.IComparer<T>? comparer) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.MinItems<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.MinItemsBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.MinItemsBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.OnErrorResumeNext<TSource>(params System.Collections.Generic.IAsyncEnumerable<TSource>![]! sources) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.OnErrorResumeNext<TSource>(this System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IAsyncEnumerable<TSource>!>! sources) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.OnErrorResumeNext<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! first, System.Collections.Generic.IAsyncEnumerable<TSource>! second) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.OnErrorResumeNext<TSource>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IAsyncEnumerable<TSource>!>! sources) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.OrderBy<T, TKey>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, TKey>! keySelector, SuperLinq.OrderByDirection direction) -> System.Linq.IOrderedAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.OrderBy<T, TKey>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>! comparer, SuperLinq.OrderByDirection direction) -> System.Linq.IOrderedAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.Pad<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int width, System.Func<int, TSource>! paddingSelector) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Pad<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int width, TSource padding) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Pad<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int width) -> System.Collections.Generic.IAsyncEnumerable<TSource?>!
+static SuperLinq.Async.AsyncSuperEnumerable.PadStart<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int width, System.Func<int, TSource>! paddingSelector) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.PadStart<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int width, TSource padding) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.PadStart<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int width) -> System.Collections.Generic.IAsyncEnumerable<TSource?>!
+static SuperLinq.Async.AsyncSuperEnumerable.PartialSort<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, int count, SuperLinq.OrderByDirection direction) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.PartialSort<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, int count, System.Collections.Generic.IComparer<T>? comparer, SuperLinq.OrderByDirection direction) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.PartialSort<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, int count, System.Collections.Generic.IComparer<T>? comparer) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.PartialSort<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, int count) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.PartialSortBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector, SuperLinq.OrderByDirection direction) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.PartialSortBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer, SuperLinq.OrderByDirection direction) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.PartialSortBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.PartialSortBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Partition<T, TResult>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, bool>! predicate, System.Func<System.Collections.Generic.IEnumerable<T>!, System.Collections.Generic.IEnumerable<T>!, TResult>! resultSelector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<TResult>
+static SuperLinq.Async.AsyncSuperEnumerable.Partition<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, bool>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<(System.Collections.Generic.IEnumerable<T>! True, System.Collections.Generic.IEnumerable<T>! False)>
+static SuperLinq.Async.AsyncSuperEnumerable.PreScan<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TSource, TSource>! transformation, TSource identity) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Publish<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source) -> SuperLinq.Async.IAsyncBuffer<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Random() -> System.Collections.Generic.IAsyncEnumerable<int>!
+static SuperLinq.Async.AsyncSuperEnumerable.Random(int maxValue) -> System.Collections.Generic.IAsyncEnumerable<int>!
+static SuperLinq.Async.AsyncSuperEnumerable.Random(int minValue, int maxValue) -> System.Collections.Generic.IAsyncEnumerable<int>!
+static SuperLinq.Async.AsyncSuperEnumerable.Random(System.Random! rand, int maxValue) -> System.Collections.Generic.IAsyncEnumerable<int>!
+static SuperLinq.Async.AsyncSuperEnumerable.Random(System.Random! rand, int minValue, int maxValue) -> System.Collections.Generic.IAsyncEnumerable<int>!
+static SuperLinq.Async.AsyncSuperEnumerable.Random(System.Random! rand) -> System.Collections.Generic.IAsyncEnumerable<int>!
+static SuperLinq.Async.AsyncSuperEnumerable.RandomDouble() -> System.Collections.Generic.IAsyncEnumerable<double>!
+static SuperLinq.Async.AsyncSuperEnumerable.RandomDouble(System.Random! rand) -> System.Collections.Generic.IAsyncEnumerable<double>!
+static SuperLinq.Async.AsyncSuperEnumerable.Range(int start, int count, int step) -> System.Collections.Generic.IAsyncEnumerable<int>!
+static SuperLinq.Async.AsyncSuperEnumerable.Rank<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, SuperLinq.OrderByDirection sortDirection) -> System.Collections.Generic.IAsyncEnumerable<(TSource item, int rank)>!
+static SuperLinq.Async.AsyncSuperEnumerable.Rank<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Collections.Generic.IComparer<TSource>! comparer, SuperLinq.OrderByDirection sortDirection) -> System.Collections.Generic.IAsyncEnumerable<(TSource item, int rank)>!
+static SuperLinq.Async.AsyncSuperEnumerable.Rank<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Collections.Generic.IComparer<TSource>! comparer) -> System.Collections.Generic.IAsyncEnumerable<(TSource item, int rank)>!
+static SuperLinq.Async.AsyncSuperEnumerable.Rank<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source) -> System.Collections.Generic.IAsyncEnumerable<(TSource item, int rank)>!
+static SuperLinq.Async.AsyncSuperEnumerable.RankBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, SuperLinq.OrderByDirection sortDirection) -> System.Collections.Generic.IAsyncEnumerable<(TSource item, int rank)>!
+static SuperLinq.Async.AsyncSuperEnumerable.RankBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>! comparer, SuperLinq.OrderByDirection sortDirection) -> System.Collections.Generic.IAsyncEnumerable<(TSource item, int rank)>!
+static SuperLinq.Async.AsyncSuperEnumerable.RankBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>! comparer) -> System.Collections.Generic.IAsyncEnumerable<(TSource item, int rank)>!
+static SuperLinq.Async.AsyncSuperEnumerable.RankBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IAsyncEnumerable<(TSource item, int rank)>!
+static SuperLinq.Async.AsyncSuperEnumerable.Repeat<TResult>(TResult value) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.Repeat<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int count) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Repeat<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Retry<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int count) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Retry<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Return<T>(T item) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.RightOuterHashJoin<TLeft, TRight, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TLeft>! left, System.Collections.Generic.IAsyncEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Func<TRight, TResult>! rightResultSelector, System.Func<TLeft, TRight, TResult>! bothResultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.RightOuterHashJoin<TLeft, TRight, TKey>(this System.Collections.Generic.IAsyncEnumerable<TLeft>! left, System.Collections.Generic.IAsyncEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IAsyncEnumerable<(TLeft? Left, TRight Right)>!
+static SuperLinq.Async.AsyncSuperEnumerable.RightOuterMergeJoin<TLeft, TRight, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TLeft>! left, System.Collections.Generic.IAsyncEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Func<TRight, TResult>! rightResultSelector, System.Func<TLeft, TRight, TResult>! bothResultSelector, System.Collections.Generic.IComparer<TKey>? comparer = null) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.RightOuterMergeJoin<TLeft, TRight, TKey>(this System.Collections.Generic.IAsyncEnumerable<TLeft>! left, System.Collections.Generic.IAsyncEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Collections.Generic.IComparer<TKey>? comparer = null) -> System.Collections.Generic.IAsyncEnumerable<(TLeft? Left, TRight Right)>!
+static SuperLinq.Async.AsyncSuperEnumerable.RunLengthEncode<T>(this System.Collections.Generic.IAsyncEnumerable<T>! sequence, System.Collections.Generic.IEqualityComparer<T>? comparer) -> System.Collections.Generic.IAsyncEnumerable<(T value, int count)>!
+static SuperLinq.Async.AsyncSuperEnumerable.RunLengthEncode<T>(this System.Collections.Generic.IAsyncEnumerable<T>! sequence) -> System.Collections.Generic.IAsyncEnumerable<(T value, int count)>!
+static SuperLinq.Async.AsyncSuperEnumerable.Scan<TSource, TState>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, TState seed, System.Func<TState, TSource, TState>! transformation) -> System.Collections.Generic.IAsyncEnumerable<TState>!
+static SuperLinq.Async.AsyncSuperEnumerable.Scan<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TSource, TSource>! transformation) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.ScanBy<TSource, TKey, TState>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>! keySelector, System.Func<TKey, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TState>>! seedSelector, System.Func<TState, TKey, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TState>>! accumulator, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IAsyncEnumerable<(TKey key, TState state)>!
+static SuperLinq.Async.AsyncSuperEnumerable.ScanBy<TSource, TKey, TState>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>! keySelector, System.Func<TKey, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TState>>! seedSelector, System.Func<TState, TKey, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TState>>! accumulator) -> System.Collections.Generic.IAsyncEnumerable<(TKey key, TState state)>!
+static SuperLinq.Async.AsyncSuperEnumerable.ScanBy<TSource, TKey, TState>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>! keySelector, System.Func<TKey, System.Threading.Tasks.ValueTask<TState>>! seedSelector, System.Func<TState, TKey, TSource, System.Threading.Tasks.ValueTask<TState>>! accumulator, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IAsyncEnumerable<(TKey key, TState state)>!
+static SuperLinq.Async.AsyncSuperEnumerable.ScanBy<TSource, TKey, TState>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>! keySelector, System.Func<TKey, System.Threading.Tasks.ValueTask<TState>>! seedSelector, System.Func<TState, TKey, TSource, System.Threading.Tasks.ValueTask<TState>>! accumulator) -> System.Collections.Generic.IAsyncEnumerable<(TKey key, TState state)>!
+static SuperLinq.Async.AsyncSuperEnumerable.ScanBy<TSource, TKey, TState>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, TState>! seedSelector, System.Func<TState, TKey, TSource, TState>! accumulator, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IAsyncEnumerable<(TKey key, TState state)>!
+static SuperLinq.Async.AsyncSuperEnumerable.ScanBy<TSource, TKey, TState>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, TState>! seedSelector, System.Func<TState, TKey, TSource, TState>! accumulator) -> System.Collections.Generic.IAsyncEnumerable<(TKey key, TState state)>!
+static SuperLinq.Async.AsyncSuperEnumerable.ScanRight<TSource, TAccumulate>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, TAccumulate seed, System.Func<TSource, TAccumulate, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TAccumulate>>! func) -> System.Collections.Generic.IAsyncEnumerable<TAccumulate>!
+static SuperLinq.Async.AsyncSuperEnumerable.ScanRight<TSource, TAccumulate>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, TAccumulate seed, System.Func<TSource, TAccumulate, System.Threading.Tasks.ValueTask<TAccumulate>>! func) -> System.Collections.Generic.IAsyncEnumerable<TAccumulate>!
+static SuperLinq.Async.AsyncSuperEnumerable.ScanRight<TSource, TAccumulate>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, TAccumulate seed, System.Func<TSource, TAccumulate, TAccumulate>! func) -> System.Collections.Generic.IAsyncEnumerable<TAccumulate>!
+static SuperLinq.Async.AsyncSuperEnumerable.ScanRight<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TSource>>! func) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.ScanRight<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TSource, System.Threading.Tasks.ValueTask<TSource>>! func) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.ScanRight<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TSource, TSource>! func) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Segment<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, bool>! newSegmentPredicate) -> System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IReadOnlyList<T>!>!
+static SuperLinq.Async.AsyncSuperEnumerable.Segment<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, int, bool>! newSegmentPredicate) -> System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IReadOnlyList<T>!>!
+static SuperLinq.Async.AsyncSuperEnumerable.Segment<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, int, System.Threading.Tasks.ValueTask<bool>>! newSegmentPredicate) -> System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IReadOnlyList<T>!>!
+static SuperLinq.Async.AsyncSuperEnumerable.Segment<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, System.Threading.Tasks.ValueTask<bool>>! newSegmentPredicate) -> System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IReadOnlyList<T>!>!
+static SuperLinq.Async.AsyncSuperEnumerable.Segment<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, T, int, bool>! newSegmentPredicate) -> System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IReadOnlyList<T>!>!
+static SuperLinq.Async.AsyncSuperEnumerable.Segment<T>(this System.Collections.Generic.IAsyncEnumerable<T>! source, System.Func<T, T, int, System.Threading.Tasks.ValueTask<bool>>! newSegmentPredicate) -> System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IReadOnlyList<T>!>!
+static SuperLinq.Async.AsyncSuperEnumerable.Sequence(int start, int stop, int step) -> System.Collections.Generic.IAsyncEnumerable<int>!
+static SuperLinq.Async.AsyncSuperEnumerable.Sequence(int start, int stop) -> System.Collections.Generic.IAsyncEnumerable<int>!
+static SuperLinq.Async.AsyncSuperEnumerable.Share<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source) -> SuperLinq.Async.IAsyncBuffer<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.SkipUntil<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, bool>! predicate) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.SortedMerge<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, params System.Collections.Generic.IAsyncEnumerable<TSource>![]! otherSequences) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.SortedMerge<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, SuperLinq.OrderByDirection direction, params System.Collections.Generic.IAsyncEnumerable<TSource>![]! otherSequences) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.SortedMerge<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, SuperLinq.OrderByDirection direction, System.Collections.Generic.IComparer<TSource>? comparer, params System.Collections.Generic.IAsyncEnumerable<TSource>![]! otherSequences) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.SortedMerge<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Collections.Generic.IComparer<TSource>? comparer, params System.Collections.Generic.IAsyncEnumerable<TSource>![]! otherSequences) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.SortedMergeBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, params System.Collections.Generic.IAsyncEnumerable<TSource>![]! otherSequences) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.SortedMergeBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, SuperLinq.OrderByDirection direction, params System.Collections.Generic.IAsyncEnumerable<TSource>![]! otherSequences) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.SortedMergeBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, SuperLinq.OrderByDirection direction, System.Collections.Generic.IComparer<TKey>? comparer, params System.Collections.Generic.IAsyncEnumerable<TSource>![]! otherSequences) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.SortedMergeBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer, params System.Collections.Generic.IAsyncEnumerable<TSource>![]! otherSequences) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Split<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, bool>! separatorFunc, int count, System.Func<System.Collections.Generic.IReadOnlyList<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.Split<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, bool>! separatorFunc, System.Func<System.Collections.Generic.IReadOnlyList<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.Split<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, TSource separator, int count, System.Func<System.Collections.Generic.IReadOnlyList<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.Split<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, TSource separator, System.Collections.Generic.IEqualityComparer<TSource>! comparer, System.Func<System.Collections.Generic.IReadOnlyList<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.Split<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, TSource separator, System.Collections.Generic.IEqualityComparer<TSource>? comparer, int count, System.Func<System.Collections.Generic.IReadOnlyList<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.Split<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, TSource separator, System.Func<System.Collections.Generic.IReadOnlyList<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.Split<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, bool>! separatorFunc, int count) -> System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IReadOnlyList<TSource>!>!
+static SuperLinq.Async.AsyncSuperEnumerable.Split<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, bool>! separatorFunc) -> System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IReadOnlyList<TSource>!>!
+static SuperLinq.Async.AsyncSuperEnumerable.Split<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, TSource separator, int count) -> System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IReadOnlyList<TSource>!>!
+static SuperLinq.Async.AsyncSuperEnumerable.Split<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, TSource separator, System.Collections.Generic.IEqualityComparer<TSource>? comparer, int count) -> System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IReadOnlyList<TSource>!>!
+static SuperLinq.Async.AsyncSuperEnumerable.Split<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, TSource separator, System.Collections.Generic.IEqualityComparer<TSource>? comparer) -> System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IReadOnlyList<TSource>!>!
+static SuperLinq.Async.AsyncSuperEnumerable.Split<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, TSource separator) -> System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IReadOnlyList<TSource>!>!
+static SuperLinq.Async.AsyncSuperEnumerable.StartsWith<T>(this System.Collections.Generic.IAsyncEnumerable<T>! first, System.Collections.Generic.IAsyncEnumerable<T>! second, System.Collections.Generic.IEqualityComparer<T>? comparer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<bool>
+static SuperLinq.Async.AsyncSuperEnumerable.StartsWith<T>(this System.Collections.Generic.IAsyncEnumerable<T>! first, System.Collections.Generic.IAsyncEnumerable<T>! second, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<bool>
+static SuperLinq.Async.AsyncSuperEnumerable.StartsWith<T>(this System.Collections.Generic.IAsyncEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Collections.Generic.IEqualityComparer<T>? comparer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<bool>
+static SuperLinq.Async.AsyncSuperEnumerable.StartsWith<T>(this System.Collections.Generic.IAsyncEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<bool>
+static SuperLinq.Async.AsyncSuperEnumerable.TagFirstLast<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, bool, bool, TResult>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.TagFirstLast<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source) -> System.Collections.Generic.IAsyncEnumerable<(TSource item, bool isFirst, bool isLast)>!
+static SuperLinq.Async.AsyncSuperEnumerable.TakeEvery<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int step) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.TakeUntil<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, bool>! predicate) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.ThenBy<T, TKey>(this System.Linq.IOrderedAsyncEnumerable<T>! source, System.Func<T, TKey>! keySelector, SuperLinq.OrderByDirection direction) -> System.Linq.IOrderedAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.ThenBy<T, TKey>(this System.Linq.IOrderedAsyncEnumerable<T>! source, System.Func<T, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>! comparer, SuperLinq.OrderByDirection direction) -> System.Linq.IOrderedAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.Throw<TSource>(System.Exception! exception) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Timeout<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.TimeSpan timeout) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.TraverseBreadthFirst<T>(T root, System.Func<T, System.Collections.Generic.IAsyncEnumerable<T>!>! childrenSelector) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.TraverseDepthFirst<T>(T root, System.Func<T, System.Collections.Generic.IAsyncEnumerable<T>!>! childrenSelector) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static SuperLinq.Async.AsyncSuperEnumerable.TrySingle<T, TCardinality, TResult>(this System.Collections.Generic.IAsyncEnumerable<T>! source, TCardinality zero, TCardinality one, TCardinality many, System.Func<TCardinality, T?, TResult>! resultSelector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<TResult>
+static SuperLinq.Async.AsyncSuperEnumerable.TrySingle<T, TCardinality>(this System.Collections.Generic.IAsyncEnumerable<T>! source, TCardinality zero, TCardinality one, TCardinality many, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<(TCardinality Cardinality, T? Value)>
+static SuperLinq.Async.AsyncSuperEnumerable.TrySingle<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<TSource?>
+static SuperLinq.Async.AsyncSuperEnumerable.Using<TSource, TResource>(System.Func<TResource>! resourceFactory, System.Func<TResource, System.Collections.Generic.IAsyncEnumerable<TSource>!>! enumerableFactory) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Where<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Collections.Generic.IAsyncEnumerable<bool>! filter) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.WhereLag<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int offset, System.Func<TSource, TSource?, bool>! predicate) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.WhereLag<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int offset, System.Func<TSource, TSource?, System.Threading.Tasks.ValueTask<bool>>! predicate) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.WhereLag<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int offset, TSource defaultLagValue, System.Func<TSource, TSource, bool>! predicate) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.WhereLag<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int offset, TSource defaultLagValue, System.Func<TSource, TSource, System.Threading.Tasks.ValueTask<bool>>! predicate) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.WhereLead<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int offset, System.Func<TSource, TSource?, bool>! predicate) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.WhereLead<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int offset, System.Func<TSource, TSource?, System.Threading.Tasks.ValueTask<bool>>! predicate) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.WhereLead<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int offset, TSource defaultLeadValue, System.Func<TSource, TSource, bool>! predicate) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.WhereLead<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int offset, TSource defaultLeadValue, System.Func<TSource, TSource, System.Threading.Tasks.ValueTask<bool>>! predicate) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.While<TSource>(System.Func<bool>! condition, System.Collections.Generic.IAsyncEnumerable<TSource>! source) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.While<TSource>(System.Func<System.Threading.Tasks.ValueTask<bool>>! condition, System.Collections.Generic.IAsyncEnumerable<TSource>! source) -> System.Collections.Generic.IAsyncEnumerable<TSource>!
+static SuperLinq.Async.AsyncSuperEnumerable.Window<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int size) -> System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IList<TSource>!>!
+static SuperLinq.Async.AsyncSuperEnumerable.WindowLeft<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int size) -> System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IList<TSource>!>!
+static SuperLinq.Async.AsyncSuperEnumerable.WindowRight<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, int size) -> System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IList<TSource>!>!
+static SuperLinq.Async.AsyncSuperEnumerable.ZipLongest<T1, T2, T3, T4, TResult>(this System.Collections.Generic.IAsyncEnumerable<T1>! first, System.Collections.Generic.IAsyncEnumerable<T2>! second, System.Collections.Generic.IAsyncEnumerable<T3>! third, System.Collections.Generic.IAsyncEnumerable<T4>! fourth, System.Func<T1?, T2?, T3?, T4?, TResult>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.ZipLongest<T1, T2, T3, T4>(this System.Collections.Generic.IAsyncEnumerable<T1>! first, System.Collections.Generic.IAsyncEnumerable<T2>! second, System.Collections.Generic.IAsyncEnumerable<T3>! third, System.Collections.Generic.IAsyncEnumerable<T4>! fourth) -> System.Collections.Generic.IAsyncEnumerable<(T1?, T2?, T3?, T4?)>!
+static SuperLinq.Async.AsyncSuperEnumerable.ZipLongest<T1, T2, T3, TResult>(this System.Collections.Generic.IAsyncEnumerable<T1>! first, System.Collections.Generic.IAsyncEnumerable<T2>! second, System.Collections.Generic.IAsyncEnumerable<T3>! third, System.Func<T1?, T2?, T3?, TResult>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.ZipLongest<T1, T2, T3>(this System.Collections.Generic.IAsyncEnumerable<T1>! first, System.Collections.Generic.IAsyncEnumerable<T2>! second, System.Collections.Generic.IAsyncEnumerable<T3>! third) -> System.Collections.Generic.IAsyncEnumerable<(T1?, T2?, T3?)>!
+static SuperLinq.Async.AsyncSuperEnumerable.ZipLongest<T1, T2, TResult>(this System.Collections.Generic.IAsyncEnumerable<T1>! first, System.Collections.Generic.IAsyncEnumerable<T2>! second, System.Func<T1?, T2?, TResult>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.ZipLongest<T1, T2>(this System.Collections.Generic.IAsyncEnumerable<T1>! first, System.Collections.Generic.IAsyncEnumerable<T2>! second) -> System.Collections.Generic.IAsyncEnumerable<(T1?, T2?)>!
+static SuperLinq.Async.AsyncSuperEnumerable.ZipMap<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>! selector) -> System.Collections.Generic.IAsyncEnumerable<(TSource item, TResult result)>!
+static SuperLinq.Async.AsyncSuperEnumerable.ZipMap<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, System.Threading.Tasks.ValueTask<TResult>>! selector) -> System.Collections.Generic.IAsyncEnumerable<(TSource item, TResult result)>!
+static SuperLinq.Async.AsyncSuperEnumerable.ZipMap<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource>! source, System.Func<TSource, TResult>! selector) -> System.Collections.Generic.IAsyncEnumerable<(TSource item, TResult result)>!
+static SuperLinq.Async.AsyncSuperEnumerable.ZipShortest<TFirst, TSecond, TResult>(this System.Collections.Generic.IAsyncEnumerable<TFirst>! first, System.Collections.Generic.IAsyncEnumerable<TSecond>! second, System.Func<TFirst, TSecond, TResult>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.ZipShortest<TFirst, TSecond, TThird, TFourth, TResult>(this System.Collections.Generic.IAsyncEnumerable<TFirst>! first, System.Collections.Generic.IAsyncEnumerable<TSecond>! second, System.Collections.Generic.IAsyncEnumerable<TThird>! third, System.Collections.Generic.IAsyncEnumerable<TFourth>! fourth, System.Func<TFirst, TSecond, TThird, TFourth, TResult>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.ZipShortest<TFirst, TSecond, TThird, TFourth>(this System.Collections.Generic.IAsyncEnumerable<TFirst>! first, System.Collections.Generic.IAsyncEnumerable<TSecond>! second, System.Collections.Generic.IAsyncEnumerable<TThird>! third, System.Collections.Generic.IAsyncEnumerable<TFourth>! fourth) -> System.Collections.Generic.IAsyncEnumerable<(TFirst, TSecond, TThird, TFourth)>!
+static SuperLinq.Async.AsyncSuperEnumerable.ZipShortest<TFirst, TSecond, TThird, TResult>(this System.Collections.Generic.IAsyncEnumerable<TFirst>! first, System.Collections.Generic.IAsyncEnumerable<TSecond>! second, System.Collections.Generic.IAsyncEnumerable<TThird>! third, System.Func<TFirst, TSecond, TThird, TResult>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable<TResult>!
+static SuperLinq.Async.AsyncSuperEnumerable.ZipShortest<TFirst, TSecond, TThird>(this System.Collections.Generic.IAsyncEnumerable<TFirst>! first, System.Collections.Generic.IAsyncEnumerable<TSecond>! second, System.Collections.Generic.IAsyncEnumerable<TThird>! third) -> System.Collections.Generic.IAsyncEnumerable<(TFirst, TSecond, TThird)>!
+static SuperLinq.Async.AsyncSuperEnumerable.ZipShortest<TFirst, TSecond>(this System.Collections.Generic.IAsyncEnumerable<TFirst>! first, System.Collections.Generic.IAsyncEnumerable<TSecond>! second) -> System.Collections.Generic.IAsyncEnumerable<(TFirst, TSecond)>!
+SuperLinq.Async.AsyncSuperEnumerable
+SuperLinq.Async.IAsyncBuffer<T>
+SuperLinq.Async.IAsyncBuffer<T>.Count.get -> int
+SuperLinq.Async.IAsyncBuffer<T>.Reset(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask
diff --git a/Source/SuperLinq.Async/Replace.cs b/Source/SuperLinq.Async/Replace.cs
index c9ad0c66..b8d2b063 100644
--- a/Source/SuperLinq.Async/Replace.cs
+++ b/Source/SuperLinq.Async/Replace.cs
@@ -1,4 +1,6 @@
-namespace SuperLinq.Async;
+#if !NO_INDEX
+
+namespace SuperLinq.Async;
 
 public static partial class AsyncSuperEnumerable
 {
@@ -98,3 +100,5 @@ static async IAsyncEnumerable<TSource> Core(
 		}
 	}
 }
+
+#endif
diff --git a/Source/SuperLinq.Async/SuperLinq.Async.csproj b/Source/SuperLinq.Async/SuperLinq.Async.csproj
index d3f29efb..fb1970fa 100644
--- a/Source/SuperLinq.Async/SuperLinq.Async.csproj
+++ b/Source/SuperLinq.Async/SuperLinq.Async.csproj
@@ -3,142 +3,149 @@
   <Import Project="../../TargetFrameworks.props" />
 
   <PropertyGroup>
-    <AssemblyName>SuperLinq.Async</AssemblyName>
-    <RootNamespace>SuperLinq.Async</RootNamespace>
+	<AssemblyName>SuperLinq.Async</AssemblyName>
+	<RootNamespace>SuperLinq.Async</RootNamespace>
+	<TargetFrameworks>netstandard2.0;$(TargetFrameworks)</TargetFrameworks>
 
-    <IsAotCompatible Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net7.0'))">true</IsAotCompatible>
+	<IsAotCompatible Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net7.0'))">true</IsAotCompatible>
   </PropertyGroup>
 
   <PropertyGroup Label="Nuget">
-    <Title>SuperLinq.Async</Title>
+	<Title>SuperLinq.Async</Title>
 
-    <Authors>SuperLinq Developers</Authors>
-    <PackageTags>linq;extensions;async</PackageTags>
+	<Authors>SuperLinq Developers</Authors>
+	<PackageTags>linq;extensions;async</PackageTags>
 
-    <PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>
-    <PackageReadmeFile>readme.md</PackageReadmeFile>
+	<PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>
+	<PackageReadmeFile>readme.md</PackageReadmeFile>
 
-    <PublishRepositoryUrl>true</PublishRepositoryUrl>
-    <RepositoryUrl>https://github.com/viceroypenguin/SuperLinq</RepositoryUrl>
+	<PublishRepositoryUrl>true</PublishRepositoryUrl>
+	<RepositoryUrl>https://github.com/viceroypenguin/SuperLinq</RepositoryUrl>
 
-    <IncludeSymbols>true</IncludeSymbols>
-    <SymbolPackageFormat>snupkg</SymbolPackageFormat>
+	<IncludeSymbols>true</IncludeSymbols>
+	<SymbolPackageFormat>snupkg</SymbolPackageFormat>
   </PropertyGroup>
 
   <PropertyGroup>
-    <Description>
-      This project enhances Async LINQ to Objects with the following methods:
-
-      - AggregateRight
-      - AssertCount
-      - AtLeast
-      - AtMost
-      - Choose
-      - CollectionEqual
-      - CompareCount
-      - ConcurrentMerge
-      - Consume
-      - CountBetween
-      - CountBy
-      - CountDown
-      - DenseRank
-      - DenseRankBy
-      - DistinctBy
-      - ElementAt
-      - EndsWith
-      - Exactly
-      - ExceptBy
-      - FallbackIfEmpty
-      - FillBackward
-      - FillForward
-      - Fold
-      - From
-      - Generate
-      - GroupAdjacent
-      - Index
-      - IndexBy
-      - Insert
-      - Interleave
-      - OrderBy
-      - Pad
-      - PadStart
-      - PartialSort
-      - PartialSortBy
-      - Random
-      - Rank
-      - RankBy
-      - RunLengthEncode
-      - ScanBy
-      - ScanRight
-      - Segment
-      - Sequence
-      - SkipUntil
-      - SortedMerge
-      - Split
-      - StartsWith
-      - TagFirstLast
-      - Take
-      - TakeEvery
-      - TakeUntil
-      - ThenBy
-      - Where
-      - Window
-      - WindowLeft
-      - WindowRight
-      - ZipLongest
-      - ZipMap
-      - ZipShortest
-    </Description>
-    <Description>$([System.Text.RegularExpressions.Regex]::Replace($(Description), `\s+`, ` `).Trim().Replace(` - `, `, `).Replace(`:,`, `:`))</Description>
-
-    <Copyright>
-      Portions © 2008 Jonathan Skeet.
-      Portions © 2009 Atif Aziz, Chris Ammerman, Konrad Rudolph.
-      Portions © 2010 Johannes Rudolph, Leopold Bushkin.
-      Portions © 2015 Felipe Sateler, “sholland”.
-      Portions © 2016 Andreas Gullberg Larsen, Leandro F. Vieira (leandromoh).
-      Portions © 2017 Jonas Nyrup (jnyrup).
-      Portions © 2022 Turning Code, LLC
-      Portions © 2022 Amichai Mantinband
-      Portions © Microsoft. All rights reserved.
-    </Copyright>
-    <Copyright>$([System.Text.RegularExpressions.Regex]::Replace($(Copyright), `\s+`, ` `).Trim())</Copyright>
+	<Description>
+	  This project enhances Async LINQ to Objects with the following methods:
+
+	  - AggregateRight
+	  - AssertCount
+	  - AtLeast
+	  - AtMost
+	  - Choose
+	  - CollectionEqual
+	  - CompareCount
+	  - ConcurrentMerge
+	  - Consume
+	  - CountBetween
+	  - CountBy
+	  - CountDown
+	  - DenseRank
+	  - DenseRankBy
+	  - DistinctBy
+	  - ElementAt
+	  - EndsWith
+	  - Exactly
+	  - ExceptBy
+	  - FallbackIfEmpty
+	  - FillBackward
+	  - FillForward
+	  - Fold
+	  - From
+	  - Generate
+	  - GroupAdjacent
+	  - Index
+	  - IndexBy
+	  - Insert
+	  - Interleave
+	  - OrderBy
+	  - Pad
+	  - PadStart
+	  - PartialSort
+	  - PartialSortBy
+	  - Random
+	  - Rank
+	  - RankBy
+	  - RunLengthEncode
+	  - ScanBy
+	  - ScanRight
+	  - Segment
+	  - Sequence
+	  - SkipUntil
+	  - SortedMerge
+	  - Split
+	  - StartsWith
+	  - TagFirstLast
+	  - Take
+	  - TakeEvery
+	  - TakeUntil
+	  - ThenBy
+	  - Where
+	  - Window
+	  - WindowLeft
+	  - WindowRight
+	  - ZipLongest
+	  - ZipMap
+	  - ZipShortest
+	</Description>
+	<Description>$([System.Text.RegularExpressions.Regex]::Replace($(Description), `\s+`, ` `).Trim().Replace(` - `, `, `).Replace(`:,`, `:`))</Description>
+
+	<Copyright>
+	  Portions © 2008 Jonathan Skeet.
+	  Portions © 2009 Atif Aziz, Chris Ammerman, Konrad Rudolph.
+	  Portions © 2010 Johannes Rudolph, Leopold Bushkin.
+	  Portions © 2015 Felipe Sateler, “sholland”.
+	  Portions © 2016 Andreas Gullberg Larsen, Leandro F. Vieira (leandromoh).
+	  Portions © 2017 Jonas Nyrup (jnyrup).
+	  Portions © 2022 Turning Code, LLC
+	  Portions © 2022 Amichai Mantinband
+	  Portions © Microsoft. All rights reserved.
+	</Copyright>
+	<Copyright>$([System.Text.RegularExpressions.Regex]::Replace($(Copyright), `\s+`, ` `).Trim())</Copyright>
   </PropertyGroup>
 
   <ItemGroup>
-    <None Include="readme.md" Pack="true" PackagePath="\" />
-    <AdditionalFiles Include="PublicAPI/$(TargetFramework)/PublicAPI.Shipped.txt" />
-    <AdditionalFiles Include="PublicAPI/$(TargetFramework)/PublicAPI.Unshipped.txt" />
+	<None Include="readme.md" Pack="true" PackagePath="\" />
+	<AdditionalFiles Include="PublicAPI/$(TargetFramework)/PublicAPI.Shipped.txt" />
+	<AdditionalFiles Include="PublicAPI/$(TargetFramework)/PublicAPI.Unshipped.txt" />
   </ItemGroup>
 
   <ItemGroup>
-    <Using Include="SuperLinq.Exceptions" />
-    <Using Include="System.Runtime.CompilerServices" />
+	<Using Include="SuperLinq.Exceptions" />
+	<Using Include="System.Runtime.CompilerServices" />
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.PublicApiAnalyzers" PrivateAssets="All" />
-    <PackageReference Include="Microsoft.SourceLink.GitHub" PrivateAssets="All" />
-    <PackageReference Include="MinVer" PrivateAssets="All" />
-    <PackageReference Include="System.Linq.Async" />
-    <ProjectReference Include="..\SuperLinq\SuperLinq.csproj" />
+	<PackageReference Include="Microsoft.Bcl.HashCode" />
+	<PackageReference Include="Microsoft.CodeAnalysis.PublicApiAnalyzers" PrivateAssets="All" />
+	<PackageReference Include="Microsoft.SourceLink.GitHub" PrivateAssets="All" />
+	<PackageReference Include="MinVer" PrivateAssets="All" />
+	<PackageReference Include="System.Linq.Async" />
+	<PackageReference Include="System.Memory" />
+	<ProjectReference Include="..\SuperLinq\SuperLinq.csproj" />
   </ItemGroup>
 
+  <PropertyGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+	<DefineConstants>$(DefineConstants);NO_INDEX</DefineConstants>
+  </PropertyGroup>
+
   <PropertyGroup Label="SourceGenerator">
-    <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
-    <CompilerGeneratedFilesOutputPath>Generated</CompilerGeneratedFilesOutputPath>
+	<EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
+	<CompilerGeneratedFilesOutputPath>Generated</CompilerGeneratedFilesOutputPath>
   </PropertyGroup>
 
   <ItemGroup Label="SourceGenerator">
-    <ProjectReference Include="..\..\Generators\SuperLinq.Async.Generator\SuperLinq.Async.Generator.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
-    <Compile Remove="$(CompilerGeneratedFilesOutputPath)/**/*.cs" />
-    <None Include="$(CompilerGeneratedFilesOutputPath)/SuperLinq.Async.Generator/**/*.cs" />
+	<ProjectReference Include="..\..\Generators\SuperLinq.Async.Generator\SuperLinq.Async.Generator.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
+	<Compile Remove="$(CompilerGeneratedFilesOutputPath)/**/*.cs" />
+	<None Include="$(CompilerGeneratedFilesOutputPath)/SuperLinq.Async.Generator/**/*.cs" />
   </ItemGroup>
 
   <PropertyGroup Label="MinVer">
-    <MinVerAutoIncrement>minor</MinVerAutoIncrement>
-    <MinVerDefaultPreReleaseIdentifiers>preview.0</MinVerDefaultPreReleaseIdentifiers>
-    <MinVerTagPrefix>v</MinVerTagPrefix>
+	<MinVerAutoIncrement>minor</MinVerAutoIncrement>
+	<MinVerDefaultPreReleaseIdentifiers>preview.0</MinVerDefaultPreReleaseIdentifiers>
+	<MinVerTagPrefix>v</MinVerTagPrefix>
   </PropertyGroup>
 
 </Project>
diff --git a/Source/SuperLinq.Async/Take.cs b/Source/SuperLinq.Async/Take.cs
index be0e9aa1..ee6c0445 100644
--- a/Source/SuperLinq.Async/Take.cs
+++ b/Source/SuperLinq.Async/Take.cs
@@ -1,3 +1,5 @@
+#if !NO_INDEX
+
 namespace SuperLinq.Async;
 
 public static partial class AsyncSuperEnumerable
@@ -124,3 +126,5 @@ private static async IAsyncEnumerable<TSource> TakeRangeFromEndIterator<TSource>
 		}
 	}
 }
+
+#endif
diff --git a/Source/SuperLinq/Backsert.cs b/Source/SuperLinq/Backsert.cs
index d98969ac..a2e4b5ee 100644
--- a/Source/SuperLinq/Backsert.cs
+++ b/Source/SuperLinq/Backsert.cs
@@ -1,4 +1,6 @@
-namespace SuperLinq;
+#if !NO_INDEX
+
+namespace SuperLinq;
 
 public static partial class SuperEnumerable
 {
@@ -44,3 +46,5 @@ public static IEnumerable<T> Backsert<T>(this IEnumerable<T> first, IEnumerable<
 		return first.Insert(second, ^index);
 	}
 }
+
+#endif
diff --git a/Source/SuperLinq/Collections/UpdatablePriorityQueue.cs b/Source/SuperLinq/Collections/UpdatablePriorityQueue.cs
index 7c78e3db..6a40f9cb 100644
--- a/Source/SuperLinq/Collections/UpdatablePriorityQueue.cs
+++ b/Source/SuperLinq/Collections/UpdatablePriorityQueue.cs
@@ -6,7 +6,10 @@
 using System.Collections;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+
+#if NETCOREAPP
 using System.Runtime.CompilerServices;
+#endif
 
 namespace SuperLinq.Collections;
 
@@ -650,7 +653,9 @@ public void EnqueueRangeMinimum(IEnumerable<TElement> elements, TPriority priori
 	/// </summary>
 	public void Clear()
 	{
+#if NETCOREAPP
 		if (RuntimeHelpers.IsReferenceOrContainsReferences<(TElement, TPriority)>())
+#endif
 		{
 			// Clear the elements so that the gc can reclaim the references
 			Array.Clear(_nodes, 0, Count);
@@ -748,8 +753,12 @@ private void RemoveRootNode()
 				MoveDownCustomComparer(lastNode, 0);
 		}
 
+#if NETCOREAPP
 		if (RuntimeHelpers.IsReferenceOrContainsReferences<(TElement, TPriority)>())
+#endif
+		{
 			_nodes[lastNodeIndex] = default;
+		}
 	}
 
 	/// <summary>
diff --git a/Source/SuperLinq/ElementAt.cs b/Source/SuperLinq/ElementAt.cs
index df2c9120..88b8381c 100644
--- a/Source/SuperLinq/ElementAt.cs
+++ b/Source/SuperLinq/ElementAt.cs
@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+#if !NO_INDEX
+
 using System.Diagnostics.CodeAnalysis;
 
 namespace SuperLinq;
@@ -144,3 +146,5 @@ private static bool TryGetElementFromEnd<TSource>(
 		return false;
 	}
 }
+
+#endif
diff --git a/Source/SuperLinq/EndsWith.cs b/Source/SuperLinq/EndsWith.cs
index 05564cb1..cdfe9957 100644
--- a/Source/SuperLinq/EndsWith.cs
+++ b/Source/SuperLinq/EndsWith.cs
@@ -1,3 +1,5 @@
+#if !NO_INDEX
+
 namespace SuperLinq;
 
 public static partial class SuperEnumerable
@@ -75,7 +77,9 @@ public static bool EndsWith<T>(this IEnumerable<T> first, IEnumerable<T> second,
 		comparer ??= EqualityComparer<T>.Default;
 
 		var snd = second.ToList();
-		return first.TakeLast(snd.Count)
+		return first.Take(^snd.Count..)
 			.SequenceEqual(snd, comparer);
 	}
 }
+
+#endif
diff --git a/Source/SuperLinq/Exclude.cs b/Source/SuperLinq/Exclude.cs
index abb2fa48..87334b26 100644
--- a/Source/SuperLinq/Exclude.cs
+++ b/Source/SuperLinq/Exclude.cs
@@ -1,3 +1,5 @@
+#if !NO_INDEX
+
 namespace SuperLinq;
 
 public static partial class SuperEnumerable
@@ -237,3 +239,5 @@ private static IEnumerable<T> ExcludeEndFromEnd<T>(IEnumerable<T> sequence, Rang
 			yield return element;
 	}
 }
+
+#endif
diff --git a/Source/SuperLinq/FindIndex.cs b/Source/SuperLinq/FindIndex.cs
index 2ec725da..1274d0c9 100644
--- a/Source/SuperLinq/FindIndex.cs
+++ b/Source/SuperLinq/FindIndex.cs
@@ -1,3 +1,5 @@
+#if !NO_INDEX
+
 namespace SuperLinq;
 
 public static partial class SuperEnumerable
@@ -198,3 +200,5 @@ public static int FindIndex<TSource>(this IEnumerable<TSource> source, Func<TSou
 		}
 	}
 }
+
+#endif
diff --git a/Source/SuperLinq/FindLastIndex.cs b/Source/SuperLinq/FindLastIndex.cs
index 023daf8b..fced708a 100644
--- a/Source/SuperLinq/FindLastIndex.cs
+++ b/Source/SuperLinq/FindLastIndex.cs
@@ -1,3 +1,5 @@
+#if !NO_INDEX
+
 namespace SuperLinq;
 
 public static partial class SuperEnumerable
@@ -184,3 +186,5 @@ public static int FindLastIndex<TSource>(this IEnumerable<TSource> source, Func<
 		}
 	}
 }
+
+#endif
diff --git a/Source/SuperLinq/Future.cs b/Source/SuperLinq/Future.cs
new file mode 100644
index 00000000..f05a848c
--- /dev/null
+++ b/Source/SuperLinq/Future.cs
@@ -0,0 +1,37 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#if !NETCOREAPP
+
+using System.Diagnostics.CodeAnalysis;
+
+namespace SuperLinq;
+
+[ExcludeFromCodeCoverage]
+internal static class Future
+{
+	public static bool TryGetValue<T>(this SortedSet<T> set, T equalValue, [MaybeNullWhen(false)] out T actualValue)
+	{
+		foreach (var x in set)
+		{
+			if (set.Comparer.Compare(x, equalValue) == 0)
+			{
+				actualValue = x;
+				return true;
+			}
+		}
+
+		actualValue = default;
+		return false;
+	}
+
+	public static HashSet<TSource> ToHashSet<TSource>(
+		this IEnumerable<TSource> source,
+		IEqualityComparer<TSource>? comparer)
+	{
+		ArgumentNullException.ThrowIfNull(source);
+		return new HashSet<TSource>(source, comparer);
+	}
+}
+
+#endif
diff --git a/Source/SuperLinq/GetShortestPath.A-Star.cs b/Source/SuperLinq/GetShortestPath.A-Star.cs
index 6f0362fd..363139d1 100644
--- a/Source/SuperLinq/GetShortestPath.A-Star.cs
+++ b/Source/SuperLinq/GetShortestPath.A-Star.cs
@@ -333,7 +333,7 @@ public partial class SuperEnumerable
 		do
 		{
 			if (!totalCost.TryGetValue(current, out var oldCost)
-				|| costComparer.Compare(from.traversed, oldCost.traversed) < 0)
+				|| costComparer.Compare(from.traversed!, oldCost.traversed!) < 0)
 			{
 				totalCost[current] = (from.parent, from.traversed);
 				if (predicate(current))
diff --git a/Source/SuperLinq/GetShortestPathCost.A-Star.cs b/Source/SuperLinq/GetShortestPathCost.A-Star.cs
index a98cdce5..34e34c28 100644
--- a/Source/SuperLinq/GetShortestPathCost.A-Star.cs
+++ b/Source/SuperLinq/GetShortestPathCost.A-Star.cs
@@ -328,7 +328,7 @@ public partial class SuperEnumerable
 		do
 		{
 			if (!totalCost.TryGetValue(current, out var oldCost)
-				|| costComparer.Compare(costs.traversed, oldCost) < 0)
+				|| costComparer.Compare(costs.traversed!, oldCost!) < 0)
 			{
 				totalCost[current] = costs.traversed;
 				if (predicate(current))
diff --git a/Source/SuperLinq/GetShortestPaths.cs b/Source/SuperLinq/GetShortestPaths.cs
index 9e080fb2..1e480385 100644
--- a/Source/SuperLinq/GetShortestPaths.cs
+++ b/Source/SuperLinq/GetShortestPaths.cs
@@ -152,7 +152,7 @@ public partial class SuperEnumerable
 		var queue = new UpdatablePriorityQueue<TState, (TState? parent, TCost? cost)>(
 			16,
 			priorityComparer: Comparer<(TState? parent, TCost? cost)>.Create(
-				(x, y) => costComparer.Compare(x.cost, y.cost)),
+				(x, y) => costComparer.Compare(x.cost!, y.cost!)),
 			stateComparer);
 
 		var current = start;
diff --git a/Source/SuperLinq/IndexOf.cs b/Source/SuperLinq/IndexOf.cs
index 2ffca79c..f71c2c7f 100644
--- a/Source/SuperLinq/IndexOf.cs
+++ b/Source/SuperLinq/IndexOf.cs
@@ -1,4 +1,6 @@
-namespace SuperLinq;
+#if !NO_INDEX
+
+namespace SuperLinq;
 
 public static partial class SuperEnumerable
 {
@@ -134,3 +136,5 @@ public static int IndexOf<TSource>(this IEnumerable<TSource> source, TSource ite
 		return FindIndex(source, i => EqualityComparer<TSource>.Default.Equals(i, item), index, count);
 	}
 }
+
+#endif
diff --git a/Source/SuperLinq/Insert.cs b/Source/SuperLinq/Insert.cs
index 3a70eb7c..f78c4759 100644
--- a/Source/SuperLinq/Insert.cs
+++ b/Source/SuperLinq/Insert.cs
@@ -1,3 +1,5 @@
+#if !NO_INDEX
+
 namespace SuperLinq;
 
 public static partial class SuperEnumerable
@@ -271,3 +273,5 @@ protected override T ElementAt(int index)
 		}
 	}
 }
+
+#endif
diff --git a/Source/SuperLinq/Join.MergeJoin.cs b/Source/SuperLinq/Join.MergeJoin.cs
index 1b0a128c..857b8291 100644
--- a/Source/SuperLinq/Join.MergeJoin.cs
+++ b/Source/SuperLinq/Join.MergeJoin.cs
@@ -725,6 +725,10 @@ file sealed class ComparerEqualityComparer<TKey>(
 	IComparer<TKey> comparer
 ) : IEqualityComparer<TKey>
 {
-	public bool Equals([AllowNull] TKey x, [AllowNull] TKey y) => comparer.Compare(x, y) == 0;
+	public bool Equals([AllowNull] TKey x, [AllowNull] TKey y) => comparer.Compare(x!, y!) == 0;
+#if NETCOREAPP
 	public int GetHashCode([DisallowNull] TKey obj) => ThrowHelper.ThrowNotSupportedException<int>();
+#else
+	public int GetHashCode(TKey obj) => ThrowHelper.ThrowNotSupportedException<int>();
+#endif
 }
diff --git a/Source/SuperLinq/LastIndexOf.cs b/Source/SuperLinq/LastIndexOf.cs
index 9441a00a..32510d4b 100644
--- a/Source/SuperLinq/LastIndexOf.cs
+++ b/Source/SuperLinq/LastIndexOf.cs
@@ -1,4 +1,6 @@
-namespace SuperLinq;
+#if !NO_INDEX
+
+namespace SuperLinq;
 
 public static partial class SuperEnumerable
 {
@@ -136,3 +138,5 @@ public static int LastIndexOf<TSource>(this IEnumerable<TSource> source, TSource
 		return FindLastIndex(source, i => EqualityComparer<TSource>.Default.Equals(i, item), index, count);
 	}
 }
+
+#endif
diff --git a/Source/SuperLinq/ListIterator.cs b/Source/SuperLinq/ListIterator.cs
index 774f8c08..5a653d73 100644
--- a/Source/SuperLinq/ListIterator.cs
+++ b/Source/SuperLinq/ListIterator.cs
@@ -21,7 +21,22 @@ public T this[int index]
 
 		protected abstract T ElementAt(int index);
 
+#if !NO_INDEX
 		public virtual int IndexOf(T item) =>
 			GetEnumerable().IndexOf(item);
+#else
+		public virtual int IndexOf(T item)
+		{
+			var index = 0;
+			foreach (var i in this)
+			{
+				if (EqualityComparer<T>.Default.Equals(item, i))
+					return index;
+				index++;
+			}
+
+			return -1;
+		}
+#endif
 	}
 }
diff --git a/Source/SuperLinq/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt b/Source/SuperLinq/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt
new file mode 100644
index 00000000..7dc5c581
--- /dev/null
+++ b/Source/SuperLinq/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt
@@ -0,0 +1 @@
+#nullable enable
diff --git a/Source/SuperLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt b/Source/SuperLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt
new file mode 100644
index 00000000..dc4a206b
--- /dev/null
+++ b/Source/SuperLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt
@@ -0,0 +1,431 @@
+static SuperLinq.SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, TAccumulate5 seed5, System.Func<TAccumulate5, T, TAccumulate5>! accumulator5, TAccumulate6 seed6, System.Func<TAccumulate6, T, TAccumulate6>! accumulator6, TAccumulate7 seed7, System.Func<TAccumulate7, T, TAccumulate7>! accumulator7, TAccumulate8 seed8, System.Func<TAccumulate8, T, TAccumulate8>! accumulator8, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult>! resultSelector) -> TResult
+static SuperLinq.SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, TAccumulate5 seed5, System.Func<TAccumulate5, T, TAccumulate5>! accumulator5, TAccumulate6 seed6, System.Func<TAccumulate6, T, TAccumulate6>! accumulator6, TAccumulate7 seed7, System.Func<TAccumulate7, T, TAccumulate7>! accumulator7, TAccumulate8 seed8, System.Func<TAccumulate8, T, TAccumulate8>! accumulator8) -> (TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8)
+static SuperLinq.SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, TAccumulate5 seed5, System.Func<TAccumulate5, T, TAccumulate5>! accumulator5, TAccumulate6 seed6, System.Func<TAccumulate6, T, TAccumulate6>! accumulator6, TAccumulate7 seed7, System.Func<TAccumulate7, T, TAccumulate7>! accumulator7, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult>! resultSelector) -> TResult
+static SuperLinq.SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, TAccumulate5 seed5, System.Func<TAccumulate5, T, TAccumulate5>! accumulator5, TAccumulate6 seed6, System.Func<TAccumulate6, T, TAccumulate6>! accumulator6, TAccumulate7 seed7, System.Func<TAccumulate7, T, TAccumulate7>! accumulator7) -> (TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7)
+static SuperLinq.SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, TAccumulate5 seed5, System.Func<TAccumulate5, T, TAccumulate5>! accumulator5, TAccumulate6 seed6, System.Func<TAccumulate6, T, TAccumulate6>! accumulator6, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult>! resultSelector) -> TResult
+static SuperLinq.SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, TAccumulate5 seed5, System.Func<TAccumulate5, T, TAccumulate5>! accumulator5, TAccumulate6 seed6, System.Func<TAccumulate6, T, TAccumulate6>! accumulator6) -> (TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6)
+static SuperLinq.SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, TAccumulate5 seed5, System.Func<TAccumulate5, T, TAccumulate5>! accumulator5, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult>! resultSelector) -> TResult
+static SuperLinq.SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, TAccumulate5 seed5, System.Func<TAccumulate5, T, TAccumulate5>! accumulator5) -> (TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5)
+static SuperLinq.SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult>! resultSelector) -> TResult
+static SuperLinq.SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4) -> (TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4)
+static SuperLinq.SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TResult>! resultSelector) -> TResult
+static SuperLinq.SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3) -> (TAccumulate1, TAccumulate2, TAccumulate3)
+static SuperLinq.SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, System.Func<TAccumulate1, TAccumulate2, TResult>! resultSelector) -> TResult
+static SuperLinq.SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2) -> (TAccumulate1, TAccumulate2)
+static SuperLinq.SuperEnumerable.AggregateBy<TSource, TKey, TAccumulate>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, TAccumulate>! seedSelector, System.Func<TAccumulate, TSource, TAccumulate>! func, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TAccumulate>>!
+static SuperLinq.SuperEnumerable.AggregateBy<TSource, TKey, TAccumulate>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, TAccumulate seed, System.Func<TAccumulate, TSource, TAccumulate>! func, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TAccumulate>>!
+static SuperLinq.SuperEnumerable.AggregateRight<TSource, TAccumulate, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TAccumulate seed, System.Func<TSource, TAccumulate, TAccumulate>! func, System.Func<TAccumulate, TResult>! resultSelector) -> TResult
+static SuperLinq.SuperEnumerable.AggregateRight<TSource, TAccumulate>(this System.Collections.Generic.IEnumerable<TSource>! source, TAccumulate seed, System.Func<TSource, TAccumulate, TAccumulate>! func) -> TAccumulate
+static SuperLinq.SuperEnumerable.AggregateRight<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TSource, TSource>! func) -> TSource
+static SuperLinq.SuperEnumerable.AssertCount<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int count) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.AtLeast<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> bool
+static SuperLinq.SuperEnumerable.AtMost<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> bool
+static SuperLinq.SuperEnumerable.Batch<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int size, SuperLinq.SuperEnumerable.ReadOnlySpanFunc<TSource, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Batch<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource[]! array, int size, SuperLinq.SuperEnumerable.ReadOnlySpanFunc<TSource, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Batch<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource[]! array, SuperLinq.SuperEnumerable.ReadOnlySpanFunc<TSource, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Batch<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<TSource>!>!
+static SuperLinq.SuperEnumerable.BindByIndex<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IEnumerable<int>! indices, System.Func<TSource, int, TResult>! resultSelector, System.Func<int, TResult>! missingSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.BindByIndex<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IEnumerable<int>! indices) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Buffer<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, int skip) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<TSource>!>!
+static SuperLinq.SuperEnumerable.Buffer<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int count) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<TSource>!>!
+static SuperLinq.SuperEnumerable.Cartesian<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Collections.Generic.IEnumerable<T7>! seventh, System.Collections.Generic.IEnumerable<T8>! eighth, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Cartesian<T1, T2, T3, T4, T5, T6, T7, T8>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Collections.Generic.IEnumerable<T7>! seventh, System.Collections.Generic.IEnumerable<T8>! eighth) -> System.Collections.Generic.IEnumerable<(T1, T2, T3, T4, T5, T6, T7, T8)>!
+static SuperLinq.SuperEnumerable.Cartesian<T1, T2, T3, T4, T5, T6, T7, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Collections.Generic.IEnumerable<T7>! seventh, System.Func<T1, T2, T3, T4, T5, T6, T7, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Cartesian<T1, T2, T3, T4, T5, T6, T7>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Collections.Generic.IEnumerable<T7>! seventh) -> System.Collections.Generic.IEnumerable<(T1, T2, T3, T4, T5, T6, T7)>!
+static SuperLinq.SuperEnumerable.Cartesian<T1, T2, T3, T4, T5, T6, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Func<T1, T2, T3, T4, T5, T6, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Cartesian<T1, T2, T3, T4, T5, T6>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth) -> System.Collections.Generic.IEnumerable<(T1, T2, T3, T4, T5, T6)>!
+static SuperLinq.SuperEnumerable.Cartesian<T1, T2, T3, T4, T5, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Func<T1, T2, T3, T4, T5, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Cartesian<T1, T2, T3, T4, T5>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth) -> System.Collections.Generic.IEnumerable<(T1, T2, T3, T4, T5)>!
+static SuperLinq.SuperEnumerable.Cartesian<T1, T2, T3, T4, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Func<T1, T2, T3, T4, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Cartesian<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1, T2, T3, T4)>!
+static SuperLinq.SuperEnumerable.Cartesian<T1, T2, T3, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Func<T1, T2, T3, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Cartesian<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1, T2, T3)>!
+static SuperLinq.SuperEnumerable.Cartesian<T1, T2, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Func<T1, T2, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Cartesian<T1, T2>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second) -> System.Collections.Generic.IEnumerable<(T1, T2)>!
+static SuperLinq.SuperEnumerable.Case<TValue, TResult>(System.Func<TValue>! selector, System.Collections.Generic.IDictionary<TValue, System.Collections.Generic.IEnumerable<TResult>!>! sources, System.Collections.Generic.IEnumerable<TResult>! defaultSource) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Case<TValue, TResult>(System.Func<TValue>! selector, System.Collections.Generic.IDictionary<TValue, System.Collections.Generic.IEnumerable<TResult>!>! sources) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Catch<TSource, TException>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TException!, System.Collections.Generic.IEnumerable<TSource>!>! handler) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Catch<TSource>(params System.Collections.Generic.IEnumerable<TSource>![]! sources) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Catch<TSource>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>! sources) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Catch<TSource>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Choose<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, (bool, TResult)>! chooser) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.CollectionEqual<TSource>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Collections.Generic.IEqualityComparer<TSource>? comparer) -> bool
+static SuperLinq.SuperEnumerable.CollectionEqual<TSource>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second) -> bool
+static SuperLinq.SuperEnumerable.CompareCount<TFirst, TSecond>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second) -> int
+static SuperLinq.SuperEnumerable.Consume<T>(this System.Collections.Generic.IEnumerable<T>! source) -> void
+static SuperLinq.SuperEnumerable.CopyTo<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IList<TSource>! list, int index) -> int
+static SuperLinq.SuperEnumerable.CopyTo<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IList<TSource>! list) -> int
+static SuperLinq.SuperEnumerable.CopyTo<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Span<TSource> span) -> int
+static SuperLinq.SuperEnumerable.CopyTo<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource[]! array) -> int
+static SuperLinq.SuperEnumerable.CountBetween<T>(this System.Collections.Generic.IEnumerable<T>! source, int min, int max) -> bool
+static SuperLinq.SuperEnumerable.CountBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, int>>!
+static SuperLinq.SuperEnumerable.CountBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, int>>!
+static SuperLinq.SuperEnumerable.CountDown<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<TSource, int?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.CountDown<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int count) -> System.Collections.Generic.IEnumerable<(TSource item, int? count)>!
+static SuperLinq.SuperEnumerable.Defer<TResult>(System.Func<System.Collections.Generic.IEnumerable<TResult>!>! enumerableFactory) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.DensePartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count, SuperLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.DensePartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count, System.Collections.Generic.IComparer<T>? comparer, SuperLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.DensePartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count, System.Collections.Generic.IComparer<T>? comparer) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.DensePartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.DensePartialSortBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector, SuperLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.DensePartialSortBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer, SuperLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.DensePartialSortBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.DensePartialSortBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.DenseRank<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, SuperLinq.OrderByDirection sortDirection) -> System.Collections.Generic.IEnumerable<(TSource item, int rank)>!
+static SuperLinq.SuperEnumerable.DenseRank<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IComparer<TSource>! comparer, SuperLinq.OrderByDirection sortDirection) -> System.Collections.Generic.IEnumerable<(TSource item, int rank)>!
+static SuperLinq.SuperEnumerable.DenseRank<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IComparer<TSource>! comparer) -> System.Collections.Generic.IEnumerable<(TSource item, int rank)>!
+static SuperLinq.SuperEnumerable.DenseRank<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<(TSource item, int rank)>!
+static SuperLinq.SuperEnumerable.DenseRankBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, SuperLinq.OrderByDirection sortDirection) -> System.Collections.Generic.IEnumerable<(TSource item, int rank)>!
+static SuperLinq.SuperEnumerable.DenseRankBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>! comparer, SuperLinq.OrderByDirection sortDirection) -> System.Collections.Generic.IEnumerable<(TSource item, int rank)>!
+static SuperLinq.SuperEnumerable.DenseRankBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>! comparer) -> System.Collections.Generic.IEnumerable<(TSource item, int rank)>!
+static SuperLinq.SuperEnumerable.DenseRankBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<(TSource item, int rank)>!
+static SuperLinq.SuperEnumerable.DistinctBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.DistinctBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.DistinctUntilChanged<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.DistinctUntilChanged<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.DistinctUntilChanged<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IEqualityComparer<TSource>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.DistinctUntilChanged<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Do<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Action<TSource>! onNext, System.Action! onCompleted) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Do<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Action<TSource>! onNext, System.Action<System.Exception!>! onError, System.Action! onCompleted) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Do<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Action<TSource>! onNext, System.Action<System.Exception!>! onError) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Do<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Action<TSource>! onNext) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.DoWhile<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<bool>! condition) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Duplicates<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IEqualityComparer<TSource>? comparer = null) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.EquiZip<TFirst, TSecond, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TSecond, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.EquiZip<TFirst, TSecond, TThird, TFourth, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Collections.Generic.IEnumerable<TThird>! third, System.Collections.Generic.IEnumerable<TFourth>! fourth, System.Func<TFirst, TSecond, TThird, TFourth, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.EquiZip<TFirst, TSecond, TThird, TFourth>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Collections.Generic.IEnumerable<TThird>! third, System.Collections.Generic.IEnumerable<TFourth>! fourth) -> System.Collections.Generic.IEnumerable<(TFirst, TSecond, TThird, TFourth)>!
+static SuperLinq.SuperEnumerable.EquiZip<TFirst, TSecond, TThird, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Collections.Generic.IEnumerable<TThird>! third, System.Func<TFirst, TSecond, TThird, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.EquiZip<TFirst, TSecond, TThird>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Collections.Generic.IEnumerable<TThird>! third) -> System.Collections.Generic.IEnumerable<(TFirst, TSecond, TThird)>!
+static SuperLinq.SuperEnumerable.EquiZip<TFirst, TSecond>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second) -> System.Collections.Generic.IEnumerable<(TFirst, TSecond)>!
+static SuperLinq.SuperEnumerable.Evaluate<T>(this System.Collections.Generic.IEnumerable<System.Func<T>!>! functions) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.Exactly<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> bool
+static SuperLinq.SuperEnumerable.ExceptBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? keyComparer) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.ExceptBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Collections.Generic.IEnumerable<T>! fallback) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.FillBackward<T>(this System.Collections.Generic.IEnumerable<T?>! source) -> System.Collections.Generic.IEnumerable<T?>!
+static SuperLinq.SuperEnumerable.FillBackward<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate, System.Func<T, T, T>! fillSelector) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.FillBackward<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.FillForward<T>(this System.Collections.Generic.IEnumerable<T?>! source) -> System.Collections.Generic.IEnumerable<T?>!
+static SuperLinq.SuperEnumerable.FillForward<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate, System.Func<T, T, T>! fillSelector) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.FillForward<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.Finally<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Action! finallyAction) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func<object?, System.Collections.IEnumerable?>! selector) -> System.Collections.Generic.IEnumerable<object?>!
+static SuperLinq.SuperEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func<System.Collections.IEnumerable!, bool>! predicate) -> System.Collections.Generic.IEnumerable<object?>!
+static SuperLinq.SuperEnumerable.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable<object?>!
+static SuperLinq.SuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static SuperLinq.SuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static SuperLinq.SuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static SuperLinq.SuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static SuperLinq.SuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static SuperLinq.SuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static SuperLinq.SuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static SuperLinq.SuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static SuperLinq.SuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static SuperLinq.SuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static SuperLinq.SuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, TResult>! folder) -> TResult
+static SuperLinq.SuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, TResult>! folder) -> TResult
+static SuperLinq.SuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, TResult>! folder) -> TResult
+static SuperLinq.SuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, TResult>! folder) -> TResult
+static SuperLinq.SuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, TResult>! folder) -> TResult
+static SuperLinq.SuperEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, TResult>! folder) -> TResult
+static SuperLinq.SuperEnumerable.ForEach<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Action<TSource, int>! action) -> void
+static SuperLinq.SuperEnumerable.ForEach<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Action<TSource>! action) -> void
+static SuperLinq.SuperEnumerable.From<T>(params System.Func<T>![]! functions) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.From<T>(System.Func<T>! function) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.From<T>(System.Func<T>! function1, System.Func<T>! function2, System.Func<T>! function3) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.From<T>(System.Func<T>! function1, System.Func<T>! function2) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.FullGroupJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TFirst>!, System.Collections.Generic.IEnumerable<TSecond>!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.FullGroupJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TFirst>!, System.Collections.Generic.IEnumerable<TSecond>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.FullGroupJoin<TFirst, TSecond, TKey>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable<TFirst>! First, System.Collections.Generic.IEnumerable<TSecond>! Second)>!
+static SuperLinq.SuperEnumerable.FullGroupJoin<TFirst, TSecond, TKey>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable<TFirst>! First, System.Collections.Generic.IEnumerable<TSecond>! Second)>!
+static SuperLinq.SuperEnumerable.FullOuterHashJoin<TLeft, TRight, TKey, TResult>(this System.Collections.Generic.IEnumerable<TLeft>! left, System.Collections.Generic.IEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Func<TLeft, TResult>! leftResultSelector, System.Func<TRight, TResult>! rightResultSelector, System.Func<TLeft, TRight, TResult>! bothResultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.FullOuterHashJoin<TLeft, TRight, TKey>(this System.Collections.Generic.IEnumerable<TLeft>! left, System.Collections.Generic.IEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IEnumerable<(TLeft? Left, TRight? Right)>!
+static SuperLinq.SuperEnumerable.FullOuterMergeJoin<TLeft, TRight, TKey, TResult>(this System.Collections.Generic.IEnumerable<TLeft>! left, System.Collections.Generic.IEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Func<TLeft, TResult>! leftResultSelector, System.Func<TRight, TResult>! rightResultSelector, System.Func<TLeft, TRight, TResult>! bothResultSelector, System.Collections.Generic.IComparer<TKey>? comparer = null) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.FullOuterMergeJoin<TLeft, TRight, TKey>(this System.Collections.Generic.IEnumerable<TLeft>! left, System.Collections.Generic.IEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Collections.Generic.IComparer<TKey>? comparer = null) -> System.Collections.Generic.IEnumerable<(TLeft? Left, TRight? Right)>!
+static SuperLinq.SuperEnumerable.Generate<TResult>(TResult initial, System.Func<TResult, TResult>! generator) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.GetShortestPath<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IEnumerable<(TState nextState, TCost cost, TCost bestGuess)>!>! getNeighbors, System.Func<TState, bool>! predicate) -> System.Collections.Generic.IEnumerable<(TState nextState, TCost? cost)>!
+static SuperLinq.SuperEnumerable.GetShortestPath<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IEnumerable<(TState nextState, TCost cost, TCost bestGuess)>!>! getNeighbors, TState end) -> System.Collections.Generic.IEnumerable<(TState nextState, TCost? cost)>!
+static SuperLinq.SuperEnumerable.GetShortestPath<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IEnumerable<(TState nextState, TCost cost)>!>! getNeighbors, System.Func<TState, bool>! predicate, System.Collections.Generic.IEqualityComparer<TState>? stateComparer, System.Collections.Generic.IComparer<TCost>? costComparer) -> System.Collections.Generic.IEnumerable<(TState state, TCost? cost)>!
+static SuperLinq.SuperEnumerable.GetShortestPath<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IEnumerable<(TState nextState, TCost cost)>!>! getNeighbors, System.Func<TState, bool>! predicate) -> System.Collections.Generic.IEnumerable<(TState nextState, TCost? cost)>!
+static SuperLinq.SuperEnumerable.GetShortestPath<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IEnumerable<(TState nextState, TCost cost)>!>! getNeighbors, TState end, System.Collections.Generic.IEqualityComparer<TState>? stateComparer, System.Collections.Generic.IComparer<TCost>? costComparer) -> System.Collections.Generic.IEnumerable<(TState state, TCost? cost)>!
+static SuperLinq.SuperEnumerable.GetShortestPath<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IEnumerable<(TState nextState, TCost cost)>!>! getNeighbors, TState end) -> System.Collections.Generic.IEnumerable<(TState nextState, TCost? cost)>!
+static SuperLinq.SuperEnumerable.GetShortestPath<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IEnumerable<(TState nextState, TCost traversed, TCost bestGuess)>!>! getNeighbors, System.Func<TState, bool>! predicate, System.Collections.Generic.IEqualityComparer<TState>? stateComparer, System.Collections.Generic.IComparer<TCost>? costComparer) -> System.Collections.Generic.IEnumerable<(TState nextState, TCost? cost)>!
+static SuperLinq.SuperEnumerable.GetShortestPath<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IEnumerable<(TState nextState, TCost traversed, TCost bestGuess)>!>! getNeighbors, TState end, System.Collections.Generic.IEqualityComparer<TState>? stateComparer, System.Collections.Generic.IComparer<TCost>? costComparer) -> System.Collections.Generic.IEnumerable<(TState nextState, TCost? cost)>!
+static SuperLinq.SuperEnumerable.GetShortestPathCost<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IEnumerable<(TState nextState, TCost cost, TCost bestGuess)>!>! getNeighbors, System.Func<TState, bool>! predicate, System.Collections.Generic.IEqualityComparer<TState>? stateComparer, System.Collections.Generic.IComparer<TCost>? costComparer) -> TCost?
+static SuperLinq.SuperEnumerable.GetShortestPathCost<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IEnumerable<(TState nextState, TCost cost, TCost bestGuess)>!>! getNeighbors, System.Func<TState, bool>! predicate) -> TCost?
+static SuperLinq.SuperEnumerable.GetShortestPathCost<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IEnumerable<(TState nextState, TCost cost, TCost bestGuess)>!>! getNeighbors, TState end, System.Collections.Generic.IEqualityComparer<TState>? stateComparer, System.Collections.Generic.IComparer<TCost>? costComparer) -> TCost?
+static SuperLinq.SuperEnumerable.GetShortestPathCost<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IEnumerable<(TState nextState, TCost cost, TCost bestGuess)>!>! getNeighbors, TState end) -> TCost?
+static SuperLinq.SuperEnumerable.GetShortestPathCost<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IEnumerable<(TState nextState, TCost cost)>!>! getNeighbors, System.Func<TState, bool>! predicate, System.Collections.Generic.IEqualityComparer<TState>? stateComparer, System.Collections.Generic.IComparer<TCost>? costComparer) -> TCost?
+static SuperLinq.SuperEnumerable.GetShortestPathCost<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IEnumerable<(TState nextState, TCost cost)>!>! getNeighbors, System.Func<TState, bool>! predicate) -> TCost?
+static SuperLinq.SuperEnumerable.GetShortestPathCost<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IEnumerable<(TState nextState, TCost cost)>!>! getNeighbors, TState end, System.Collections.Generic.IEqualityComparer<TState>? stateComparer, System.Collections.Generic.IComparer<TCost>? costComparer) -> TCost?
+static SuperLinq.SuperEnumerable.GetShortestPathCost<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IEnumerable<(TState nextState, TCost cost)>!>! getNeighbors, TState end) -> TCost?
+static SuperLinq.SuperEnumerable.GetShortestPaths<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IEnumerable<(TState nextState, TCost cost)>!>! getNeighbors, System.Collections.Generic.IEqualityComparer<TState>? stateComparer, System.Collections.Generic.IComparer<TCost>? costComparer) -> System.Collections.Generic.IReadOnlyDictionary<TState, (TState? previousState, TCost? cost)>!
+static SuperLinq.SuperEnumerable.GetShortestPaths<TState, TCost>(TState start, System.Func<TState, TCost?, System.Collections.Generic.IEnumerable<(TState nextState, TCost cost)>!>! getNeighbors) -> System.Collections.Generic.IReadOnlyDictionary<TState, (TState? previousState, TCost? cost)>!
+static SuperLinq.SuperEnumerable.GroupAdjacent<TSource, TKey, TElement>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TElement>! elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!
+static SuperLinq.SuperEnumerable.GroupAdjacent<TSource, TKey, TElement>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TElement>! elementSelector) -> System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!
+static SuperLinq.SuperEnumerable.GroupAdjacent<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, System.Collections.Generic.IReadOnlyList<TSource>!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.GroupAdjacent<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, System.Collections.Generic.IReadOnlyList<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.GroupAdjacent<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TSource>!>!
+static SuperLinq.SuperEnumerable.GroupAdjacent<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TSource>!>!
+static SuperLinq.SuperEnumerable.HasDuplicates<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Collections.Generic.IEqualityComparer<T>? comparer) -> bool
+static SuperLinq.SuperEnumerable.HasDuplicates<T>(this System.Collections.Generic.IEnumerable<T>! source) -> bool
+static SuperLinq.SuperEnumerable.HasDuplicates<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> bool
+static SuperLinq.SuperEnumerable.HasDuplicates<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> bool
+static SuperLinq.SuperEnumerable.Identity<T>(T x) -> T
+static SuperLinq.SuperEnumerable.If<TResult>(System.Func<bool>! condition, System.Collections.Generic.IEnumerable<TResult>! thenSource, System.Collections.Generic.IEnumerable<TResult>! elseSource) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.If<TResult>(System.Func<bool>! condition, System.Collections.Generic.IEnumerable<TResult>! thenSource) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Index<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int startIndex) -> System.Collections.Generic.IEnumerable<(int Index, TSource Item)>!
+static SuperLinq.SuperEnumerable.Index<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<(int Index, TSource Item)>!
+static SuperLinq.SuperEnumerable.IndexBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<(int index, TSource item)>!
+static SuperLinq.SuperEnumerable.IndexBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<(int index, TSource item)>!
+static SuperLinq.SuperEnumerable.InnerHashJoin<TLeft, TRight, TKey, TResult>(this System.Collections.Generic.IEnumerable<TLeft>! left, System.Collections.Generic.IEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Func<TLeft, TRight, TResult>! bothResultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.InnerHashJoin<TLeft, TRight, TKey>(this System.Collections.Generic.IEnumerable<TLeft>! left, System.Collections.Generic.IEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IEnumerable<(TLeft Left, TRight Right)>!
+static SuperLinq.SuperEnumerable.InnerLoopJoin<TLeft, TRight, TKey, TResult>(this System.Collections.Generic.IEnumerable<TLeft>! left, System.Collections.Generic.IEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Func<TLeft, TRight, TResult>! bothResultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.InnerLoopJoin<TLeft, TRight, TKey>(this System.Collections.Generic.IEnumerable<TLeft>! left, System.Collections.Generic.IEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IEnumerable<(TLeft Left, TRight Right)>!
+static SuperLinq.SuperEnumerable.InnerMergeJoin<TLeft, TRight, TKey, TResult>(this System.Collections.Generic.IEnumerable<TLeft>! left, System.Collections.Generic.IEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Func<TLeft, TRight, TResult>! bothResultSelector, System.Collections.Generic.IComparer<TKey>? comparer = null) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.InnerMergeJoin<TLeft, TRight, TKey>(this System.Collections.Generic.IEnumerable<TLeft>! left, System.Collections.Generic.IEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Collections.Generic.IComparer<TKey>? comparer = null) -> System.Collections.Generic.IEnumerable<(TLeft Left, TRight Right)>!
+static SuperLinq.SuperEnumerable.Interleave<T>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>! sources) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.Interleave<T>(this System.Collections.Generic.IEnumerable<T>! source, params System.Collections.Generic.IEnumerable<T>![]! otherSources) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.Lag<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, System.Func<TSource, TSource?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Lag<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, TSource defaultLagValue, System.Func<TSource, TSource, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Lag<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset) -> System.Collections.Generic.IEnumerable<(TSource current, TSource? lag)>!
+static SuperLinq.SuperEnumerable.Lead<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, System.Func<TSource, TSource?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Lead<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, TSource defaultLeadValue, System.Func<TSource, TSource, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Lead<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset) -> System.Collections.Generic.IEnumerable<(TSource current, TSource? lead)>!
+static SuperLinq.SuperEnumerable.LeftOuterHashJoin<TLeft, TRight, TKey, TResult>(this System.Collections.Generic.IEnumerable<TLeft>! left, System.Collections.Generic.IEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Func<TLeft, TResult>! leftResultSelector, System.Func<TLeft, TRight, TResult>! bothResultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.LeftOuterHashJoin<TLeft, TRight, TKey>(this System.Collections.Generic.IEnumerable<TLeft>! left, System.Collections.Generic.IEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IEnumerable<(TLeft Left, TRight? Right)>!
+static SuperLinq.SuperEnumerable.LeftOuterLoopJoin<TLeft, TRight, TKey, TResult>(this System.Collections.Generic.IEnumerable<TLeft>! left, System.Collections.Generic.IEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Func<TLeft, TResult>! leftResultSelector, System.Func<TLeft, TRight, TResult>! bothResultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.LeftOuterLoopJoin<TLeft, TRight, TKey>(this System.Collections.Generic.IEnumerable<TLeft>! left, System.Collections.Generic.IEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IEnumerable<(TLeft Left, TRight? Right)>!
+static SuperLinq.SuperEnumerable.LeftOuterMergeJoin<TLeft, TRight, TKey, TResult>(this System.Collections.Generic.IEnumerable<TLeft>! left, System.Collections.Generic.IEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Func<TLeft, TResult>! leftResultSelector, System.Func<TLeft, TRight, TResult>! bothResultSelector, System.Collections.Generic.IComparer<TKey>? comparer = null) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.LeftOuterMergeJoin<TLeft, TRight, TKey>(this System.Collections.Generic.IEnumerable<TLeft>! left, System.Collections.Generic.IEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Collections.Generic.IComparer<TKey>? comparer = null) -> System.Collections.Generic.IEnumerable<(TLeft Left, TRight? Right)>!
+static SuperLinq.SuperEnumerable.MaxByWithTies<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.MaxByWithTies<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.MaxItems<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Collections.Generic.IComparer<T>? comparer) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.MaxItems<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.MaxItemsBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.MaxItemsBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Memoize<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, bool forceCache = true) -> SuperLinq.IBuffer<TSource>!
+static SuperLinq.SuperEnumerable.MinByWithTies<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.MinByWithTies<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.MinItems<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Collections.Generic.IComparer<T>? comparer) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.MinItems<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.MinItemsBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.MinItemsBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Move<T>(this System.Collections.Generic.IEnumerable<T>! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.OnErrorResumeNext<TSource>(params System.Collections.Generic.IEnumerable<TSource>![]! sources) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.OnErrorResumeNext<TSource>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>! sources) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.OnErrorResumeNext<TSource>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.OrderBy<T, TKey>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, TKey>! keySelector, SuperLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable<T>!
+static SuperLinq.SuperEnumerable.OrderBy<T, TKey>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer, SuperLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable<T>!
+static SuperLinq.SuperEnumerable.Pad<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width, System.Func<int, TSource>! paddingSelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Pad<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Pad<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width) -> System.Collections.Generic.IEnumerable<TSource?>!
+static SuperLinq.SuperEnumerable.PadStart<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width, System.Func<int, TSource>! paddingSelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.PadStart<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.PadStart<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width) -> System.Collections.Generic.IEnumerable<TSource?>!
+static SuperLinq.SuperEnumerable.PartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count, SuperLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.PartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count, System.Collections.Generic.IComparer<T>? comparer, SuperLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.PartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count, System.Collections.Generic.IComparer<T>? comparer) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.PartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.PartialSortBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector, SuperLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.PartialSortBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer, SuperLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.PartialSortBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.PartialSortBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Partition<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate, System.Func<System.Collections.Generic.IEnumerable<T>!, System.Collections.Generic.IEnumerable<T>!, TResult>! resultSelector) -> TResult
+static SuperLinq.SuperEnumerable.Partition<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate) -> (System.Collections.Generic.IEnumerable<T>! True, System.Collections.Generic.IEnumerable<T>! False)
+static SuperLinq.SuperEnumerable.Permutations<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<T>!>!
+static SuperLinq.SuperEnumerable.Pipe<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Action<TSource>! action) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.PreScan<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TSource, TSource>! transformation, TSource identity) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Publish<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> SuperLinq.IBuffer<TSource>!
+static SuperLinq.SuperEnumerable.Random() -> System.Collections.Generic.IEnumerable<int>!
+static SuperLinq.SuperEnumerable.Random(int maxValue) -> System.Collections.Generic.IEnumerable<int>!
+static SuperLinq.SuperEnumerable.Random(int minValue, int maxValue) -> System.Collections.Generic.IEnumerable<int>!
+static SuperLinq.SuperEnumerable.Random(System.Random! rand, int maxValue) -> System.Collections.Generic.IEnumerable<int>!
+static SuperLinq.SuperEnumerable.Random(System.Random! rand, int minValue, int maxValue) -> System.Collections.Generic.IEnumerable<int>!
+static SuperLinq.SuperEnumerable.Random(System.Random! rand) -> System.Collections.Generic.IEnumerable<int>!
+static SuperLinq.SuperEnumerable.RandomDouble() -> System.Collections.Generic.IEnumerable<double>!
+static SuperLinq.SuperEnumerable.RandomDouble(System.Random! rand) -> System.Collections.Generic.IEnumerable<double>!
+static SuperLinq.SuperEnumerable.RandomSubset<T>(this System.Collections.Generic.IEnumerable<T>! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.RandomSubset<T>(this System.Collections.Generic.IEnumerable<T>! source, int subsetSize) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.Range(int start, int count, int step) -> System.Collections.Generic.IEnumerable<int>!
+static SuperLinq.SuperEnumerable.Rank<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, SuperLinq.OrderByDirection sortDirection) -> System.Collections.Generic.IEnumerable<(TSource item, int rank)>!
+static SuperLinq.SuperEnumerable.Rank<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IComparer<TSource>! comparer, SuperLinq.OrderByDirection sortDirection) -> System.Collections.Generic.IEnumerable<(TSource item, int rank)>!
+static SuperLinq.SuperEnumerable.Rank<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IComparer<TSource>! comparer) -> System.Collections.Generic.IEnumerable<(TSource item, int rank)>!
+static SuperLinq.SuperEnumerable.Rank<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<(TSource item, int rank)>!
+static SuperLinq.SuperEnumerable.RankBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, SuperLinq.OrderByDirection sortDirection) -> System.Collections.Generic.IEnumerable<(TSource item, int rank)>!
+static SuperLinq.SuperEnumerable.RankBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>! comparer, SuperLinq.OrderByDirection sortDirection) -> System.Collections.Generic.IEnumerable<(TSource item, int rank)>!
+static SuperLinq.SuperEnumerable.RankBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>! comparer) -> System.Collections.Generic.IEnumerable<(TSource item, int rank)>!
+static SuperLinq.SuperEnumerable.RankBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<(TSource item, int rank)>!
+static SuperLinq.SuperEnumerable.Repeat<TResult>(TResult value) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Repeat<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int count) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Repeat<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Retry<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int count) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Retry<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Return<T>(T item) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.RightOuterHashJoin<TLeft, TRight, TKey, TResult>(this System.Collections.Generic.IEnumerable<TLeft>! left, System.Collections.Generic.IEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Func<TRight, TResult>! rightResultSelector, System.Func<TLeft, TRight, TResult>! bothResultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.RightOuterHashJoin<TLeft, TRight, TKey>(this System.Collections.Generic.IEnumerable<TLeft>! left, System.Collections.Generic.IEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer = null) -> System.Collections.Generic.IEnumerable<(TLeft? Left, TRight Right)>!
+static SuperLinq.SuperEnumerable.RightOuterMergeJoin<TLeft, TRight, TKey, TResult>(this System.Collections.Generic.IEnumerable<TLeft>! left, System.Collections.Generic.IEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Func<TRight, TResult>! rightResultSelector, System.Func<TLeft, TRight, TResult>! bothResultSelector, System.Collections.Generic.IComparer<TKey>? comparer = null) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.RightOuterMergeJoin<TLeft, TRight, TKey>(this System.Collections.Generic.IEnumerable<TLeft>! left, System.Collections.Generic.IEnumerable<TRight>! right, System.Func<TLeft, TKey>! leftKeySelector, System.Func<TRight, TKey>! rightKeySelector, System.Collections.Generic.IComparer<TKey>? comparer = null) -> System.Collections.Generic.IEnumerable<(TLeft? Left, TRight Right)>!
+static SuperLinq.SuperEnumerable.RunLengthEncode<T>(this System.Collections.Generic.IEnumerable<T>! sequence, System.Collections.Generic.IEqualityComparer<T>? comparer) -> System.Collections.Generic.IEnumerable<(T value, int count)>!
+static SuperLinq.SuperEnumerable.RunLengthEncode<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<(T value, int count)>!
+static SuperLinq.SuperEnumerable.Scan<TSource, TState>(this System.Collections.Generic.IEnumerable<TSource>! source, TState seed, System.Func<TState, TSource, TState>! transformation) -> System.Collections.Generic.IEnumerable<TState>!
+static SuperLinq.SuperEnumerable.Scan<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TSource, TSource>! transformation) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.ScanBy<TSource, TKey, TState>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, TState>! seedSelector, System.Func<TState, TKey, TSource, TState>! accumulator, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<(TKey key, TState state)>!
+static SuperLinq.SuperEnumerable.ScanBy<TSource, TKey, TState>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, TState>! seedSelector, System.Func<TState, TKey, TSource, TState>! accumulator) -> System.Collections.Generic.IEnumerable<(TKey key, TState state)>!
+static SuperLinq.SuperEnumerable.ScanRight<TSource, TAccumulate>(this System.Collections.Generic.IEnumerable<TSource>! source, TAccumulate seed, System.Func<TSource, TAccumulate, TAccumulate>! func) -> System.Collections.Generic.IEnumerable<TAccumulate>!
+static SuperLinq.SuperEnumerable.ScanRight<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TSource, TSource>! func) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Segment<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! newSegmentPredicate) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IReadOnlyList<T>!>!
+static SuperLinq.SuperEnumerable.Segment<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, int, bool>! newSegmentPredicate) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IReadOnlyList<T>!>!
+static SuperLinq.SuperEnumerable.Segment<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, int, bool>! newSegmentPredicate) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IReadOnlyList<T>!>!
+static SuperLinq.SuperEnumerable.Sequence(int start, int stop, int step) -> System.Collections.Generic.IEnumerable<int>!
+static SuperLinq.SuperEnumerable.Sequence(int start, int stop) -> System.Collections.Generic.IEnumerable<int>!
+static SuperLinq.SuperEnumerable.Share<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> SuperLinq.IBuffer<TSource>!
+static SuperLinq.SuperEnumerable.Shuffle<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Random! rand) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.Shuffle<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.SkipUntil<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! predicate) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Slice<T>(this System.Collections.Generic.IEnumerable<T>! source, int startIndex, int count) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.SortedMerge<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, params System.Collections.Generic.IEnumerable<TSource>![]! otherSequences) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.SortedMerge<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, SuperLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable<TSource>![]! otherSequences) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.SortedMerge<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, SuperLinq.OrderByDirection direction, System.Collections.Generic.IComparer<TSource>? comparer, params System.Collections.Generic.IEnumerable<TSource>![]! otherSequences) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.SortedMerge<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IComparer<TSource>? comparer, params System.Collections.Generic.IEnumerable<TSource>![]! otherSequences) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.SortedMergeBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, params System.Collections.Generic.IEnumerable<TSource>![]! otherSequences) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.SortedMergeBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, SuperLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable<TSource>![]! otherSequences) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.SortedMergeBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, SuperLinq.OrderByDirection direction, System.Collections.Generic.IComparer<TKey>? comparer, params System.Collections.Generic.IEnumerable<TSource>![]! otherSequences) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.SortedMergeBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer, params System.Collections.Generic.IEnumerable<TSource>![]! otherSequences) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! separatorFunc, int count, System.Func<System.Collections.Generic.IReadOnlyList<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! separatorFunc, System.Func<System.Collections.Generic.IReadOnlyList<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, int count, System.Func<System.Collections.Generic.IReadOnlyList<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, System.Collections.Generic.IEqualityComparer<TSource>! comparer, System.Func<System.Collections.Generic.IReadOnlyList<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, System.Collections.Generic.IEqualityComparer<TSource>? comparer, int count, System.Func<System.Collections.Generic.IReadOnlyList<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, System.Func<System.Collections.Generic.IReadOnlyList<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! separatorFunc, int count) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IReadOnlyList<TSource>!>!
+static SuperLinq.SuperEnumerable.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! separatorFunc) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IReadOnlyList<TSource>!>!
+static SuperLinq.SuperEnumerable.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IReadOnlyList<TSource>!>!
+static SuperLinq.SuperEnumerable.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, System.Collections.Generic.IEqualityComparer<TSource>? comparer, int count) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IReadOnlyList<TSource>!>!
+static SuperLinq.SuperEnumerable.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, System.Collections.Generic.IEqualityComparer<TSource>? comparer) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IReadOnlyList<TSource>!>!
+static SuperLinq.SuperEnumerable.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IReadOnlyList<TSource>!>!
+static SuperLinq.SuperEnumerable.StartsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Collections.Generic.IEqualityComparer<T>? comparer) -> bool
+static SuperLinq.SuperEnumerable.StartsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> bool
+static SuperLinq.SuperEnumerable.Subsets<T>(this System.Collections.Generic.IEnumerable<T>! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<T>!>!
+static SuperLinq.SuperEnumerable.Subsets<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<T>!>!
+static SuperLinq.SuperEnumerable.TagFirstLast<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool, bool, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.TagFirstLast<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<(TSource item, bool isFirst, bool isLast)>!
+static SuperLinq.SuperEnumerable.TakeEvery<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int step) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.TakeUntil<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! predicate) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.ThenBy<T, TKey>(this System.Linq.IOrderedEnumerable<T>! source, System.Func<T, TKey>! keySelector, SuperLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable<T>!
+static SuperLinq.SuperEnumerable.ThenBy<T, TKey>(this System.Linq.IOrderedEnumerable<T>! source, System.Func<T, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer, SuperLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable<T>!
+static SuperLinq.SuperEnumerable.Throw<TSource>(System.Exception! exception) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.ToArrayByIndex<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, int length, System.Func<T, int>! indexSelector, System.Func<T, int, TResult>! resultSelector) -> TResult?[]!
+static SuperLinq.SuperEnumerable.ToArrayByIndex<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, int length, System.Func<T, int>! indexSelector, System.Func<T, TResult>! resultSelector) -> TResult?[]!
+static SuperLinq.SuperEnumerable.ToArrayByIndex<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, int>! indexSelector, System.Func<T, int, TResult>! resultSelector) -> TResult?[]!
+static SuperLinq.SuperEnumerable.ToArrayByIndex<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, int>! indexSelector, System.Func<T, TResult>! resultSelector) -> TResult?[]!
+static SuperLinq.SuperEnumerable.ToArrayByIndex<T>(this System.Collections.Generic.IEnumerable<T>! source, int length, System.Func<T, int>! indexSelector) -> T?[]!
+static SuperLinq.SuperEnumerable.ToArrayByIndex<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, int>! indexSelector) -> T?[]!
+static SuperLinq.SuperEnumerable.ToDataTable<T, TTable>(this System.Collections.Generic.IEnumerable<T>! source, TTable! table, params System.Linq.Expressions.Expression<System.Func<T, object!>!>![]! expressions) -> TTable!
+static SuperLinq.SuperEnumerable.ToDataTable<T, TTable>(this System.Collections.Generic.IEnumerable<T>! source, TTable! table) -> TTable!
+static SuperLinq.SuperEnumerable.ToDataTable<T>(this System.Collections.Generic.IEnumerable<T>! source, params System.Linq.Expressions.Expression<System.Func<T, object!>!>![]! expressions) -> System.Data.DataTable!
+static SuperLinq.SuperEnumerable.ToDataTable<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Data.DataTable!
+static SuperLinq.SuperEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<bool>! source, string! delimiter) -> string!
+static SuperLinq.SuperEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<byte>! source, string! delimiter) -> string!
+static SuperLinq.SuperEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<char>! source, string! delimiter) -> string!
+static SuperLinq.SuperEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<decimal>! source, string! delimiter) -> string!
+static SuperLinq.SuperEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<double>! source, string! delimiter) -> string!
+static SuperLinq.SuperEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<float>! source, string! delimiter) -> string!
+static SuperLinq.SuperEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<int>! source, string! delimiter) -> string!
+static SuperLinq.SuperEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<long>! source, string! delimiter) -> string!
+static SuperLinq.SuperEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<sbyte>! source, string! delimiter) -> string!
+static SuperLinq.SuperEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<short>! source, string! delimiter) -> string!
+static SuperLinq.SuperEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<string!>! source, string! delimiter) -> string!
+static SuperLinq.SuperEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<uint>! source, string! delimiter) -> string!
+static SuperLinq.SuperEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<ulong>! source, string! delimiter) -> string!
+static SuperLinq.SuperEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<ushort>! source, string! delimiter) -> string!
+static SuperLinq.SuperEnumerable.ToDelimitedString<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, string! delimiter) -> string!
+static SuperLinq.SuperEnumerable.ToDictionary<TKey, TValue>(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.Dictionary<TKey, TValue>!
+static SuperLinq.SuperEnumerable.ToDictionary<TKey, TValue>(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary<TKey, TValue>!
+static SuperLinq.SuperEnumerable.ToDictionary<TKey, TValue>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! source, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.Dictionary<TKey, TValue>!
+static SuperLinq.SuperEnumerable.ToDictionary<TKey, TValue>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! source) -> System.Collections.Generic.Dictionary<TKey, TValue>!
+static SuperLinq.SuperEnumerable.ToLookup<TKey, TValue>(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Linq.ILookup<TKey, TValue>!
+static SuperLinq.SuperEnumerable.ToLookup<TKey, TValue>(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup<TKey, TValue>!
+static SuperLinq.SuperEnumerable.ToLookup<TKey, TValue>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! source, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Linq.ILookup<TKey, TValue>!
+static SuperLinq.SuperEnumerable.ToLookup<TKey, TValue>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! source) -> System.Linq.ILookup<TKey, TValue>!
+static SuperLinq.SuperEnumerable.Transpose<T>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>! source) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>!
+static SuperLinq.SuperEnumerable.TraverseBreadthFirst<T>(T root, System.Func<T, System.Collections.Generic.IEnumerable<T>!>! childrenSelector) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.TraverseDepthFirst<T>(T root, System.Func<T, System.Collections.Generic.IEnumerable<T>!>! childrenSelector) -> System.Collections.Generic.IEnumerable<T>!
+static SuperLinq.SuperEnumerable.TrySingle<T, TCardinality, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TCardinality zero, TCardinality one, TCardinality many, System.Func<TCardinality, T?, TResult>! resultSelector) -> TResult
+static SuperLinq.SuperEnumerable.TrySingle<T, TCardinality>(this System.Collections.Generic.IEnumerable<T>! source, TCardinality zero, TCardinality one, TCardinality many) -> (TCardinality Cardinality, T? Value)
+static SuperLinq.SuperEnumerable.TrySingle<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> TSource?
+static SuperLinq.SuperEnumerable.Using<TSource, TResource>(System.Func<TResource>! resourceFactory, System.Func<TResource, System.Collections.Generic.IEnumerable<TSource>!>! enumerableFactory) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Where<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IEnumerable<bool>! filter) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.WhereLag<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, System.Func<TSource, TSource?, bool>! predicate) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.WhereLag<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, TSource defaultLagValue, System.Func<TSource, TSource, bool>! predicate) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.WhereLead<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, System.Func<TSource, TSource?, bool>! predicate) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.WhereLead<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, TSource defaultLeadValue, System.Func<TSource, TSource, bool>! predicate) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.While<TSource>(System.Func<bool>! condition, System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<TSource>!
+static SuperLinq.SuperEnumerable.Window<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int size, SuperLinq.SuperEnumerable.ReadOnlySpanFunc<TSource, TResult>! selector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Window<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource[]! array, int size, SuperLinq.SuperEnumerable.ReadOnlySpanFunc<TSource, TResult>! selector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Window<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource[]! array, SuperLinq.SuperEnumerable.ReadOnlySpanFunc<TSource, TResult>! selector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.Window<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<TSource>!>!
+static SuperLinq.SuperEnumerable.WindowLeft<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int size, SuperLinq.SuperEnumerable.ReadOnlySpanFunc<TSource, TResult>! selector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.WindowLeft<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource[]! array, int size, SuperLinq.SuperEnumerable.ReadOnlySpanFunc<TSource, TResult>! selector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.WindowLeft<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource[]! array, SuperLinq.SuperEnumerable.ReadOnlySpanFunc<TSource, TResult>! selector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.WindowLeft<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<TSource>!>!
+static SuperLinq.SuperEnumerable.WindowRight<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int size, SuperLinq.SuperEnumerable.ReadOnlySpanFunc<TSource, TResult>! selector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.WindowRight<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource[]! array, int size, SuperLinq.SuperEnumerable.ReadOnlySpanFunc<TSource, TResult>! selector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.WindowRight<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource[]! array, SuperLinq.SuperEnumerable.ReadOnlySpanFunc<TSource, TResult>! selector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.WindowRight<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<TSource>!>!
+static SuperLinq.SuperEnumerable.ZipLongest<T1, T2, T3, T4, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Func<T1?, T2?, T3?, T4?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.ZipLongest<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1?, T2?, T3?, T4?)>!
+static SuperLinq.SuperEnumerable.ZipLongest<T1, T2, T3, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Func<T1?, T2?, T3?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.ZipLongest<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1?, T2?, T3?)>!
+static SuperLinq.SuperEnumerable.ZipLongest<T1, T2, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Func<T1?, T2?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.ZipLongest<T1, T2>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second) -> System.Collections.Generic.IEnumerable<(T1?, T2?)>!
+static SuperLinq.SuperEnumerable.ZipMap<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TResult>! selector) -> System.Collections.Generic.IEnumerable<(TSource item, TResult result)>!
+static SuperLinq.SuperEnumerable.ZipShortest<TFirst, TSecond, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TSecond, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.ZipShortest<TFirst, TSecond, TThird, TFourth, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Collections.Generic.IEnumerable<TThird>! third, System.Collections.Generic.IEnumerable<TFourth>! fourth, System.Func<TFirst, TSecond, TThird, TFourth, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.ZipShortest<TFirst, TSecond, TThird, TFourth>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Collections.Generic.IEnumerable<TThird>! third, System.Collections.Generic.IEnumerable<TFourth>! fourth) -> System.Collections.Generic.IEnumerable<(TFirst, TSecond, TThird, TFourth)>!
+static SuperLinq.SuperEnumerable.ZipShortest<TFirst, TSecond, TThird, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Collections.Generic.IEnumerable<TThird>! third, System.Func<TFirst, TSecond, TThird, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static SuperLinq.SuperEnumerable.ZipShortest<TFirst, TSecond, TThird>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Collections.Generic.IEnumerable<TThird>! third) -> System.Collections.Generic.IEnumerable<(TFirst, TSecond, TThird)>!
+static SuperLinq.SuperEnumerable.ZipShortest<TFirst, TSecond>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second) -> System.Collections.Generic.IEnumerable<(TFirst, TSecond)>!
+static SuperLinq.ValueTupleComparer.Create<T1, T2>(System.Collections.Generic.IComparer<T1>? comparer1, System.Collections.Generic.IComparer<T2>? comparer2) -> System.Collections.Generic.IComparer<(T1, T2)>!
+static SuperLinq.ValueTupleEqualityComparer.Create<T1, T2>(System.Collections.Generic.IEqualityComparer<T1>? comparer1, System.Collections.Generic.IEqualityComparer<T2>? comparer2) -> System.Collections.Generic.IEqualityComparer<(T1, T2)>!
+static SuperLinq.ValueTupleEqualityComparer.Create<T1>(System.Collections.Generic.IEqualityComparer<T1>? comparer1) -> System.Collections.Generic.IEqualityComparer<System.ValueTuple<T1>>!
+SuperLinq.Collections.UpdatablePriorityQueue<TElement, TPriority>
+SuperLinq.Collections.UpdatablePriorityQueue<TElement, TPriority>.Clear() -> void
+SuperLinq.Collections.UpdatablePriorityQueue<TElement, TPriority>.Comparer.get -> System.Collections.Generic.IComparer<TPriority>!
+SuperLinq.Collections.UpdatablePriorityQueue<TElement, TPriority>.Count.get -> int
+SuperLinq.Collections.UpdatablePriorityQueue<TElement, TPriority>.Dequeue() -> TElement
+SuperLinq.Collections.UpdatablePriorityQueue<TElement, TPriority>.Enqueue(TElement element, TPriority priority) -> void
+SuperLinq.Collections.UpdatablePriorityQueue<TElement, TPriority>.EnqueueDequeue(TElement element, TPriority priority) -> TElement
+SuperLinq.Collections.UpdatablePriorityQueue<TElement, TPriority>.EnqueueMinimum(TElement element, TPriority priority) -> void
+SuperLinq.Collections.UpdatablePriorityQueue<TElement, TPriority>.EnqueueRange(System.Collections.Generic.IEnumerable<(TElement Element, TPriority Priority)>! items) -> void
+SuperLinq.Collections.UpdatablePriorityQueue<TElement, TPriority>.EnqueueRange(System.Collections.Generic.IEnumerable<TElement>! elements, TPriority priority) -> void
+SuperLinq.Collections.UpdatablePriorityQueue<TElement, TPriority>.EnqueueRangeMinimum(System.Collections.Generic.IEnumerable<(TElement Element, TPriority Priority)>! items) -> void
+SuperLinq.Collections.UpdatablePriorityQueue<TElement, TPriority>.EnqueueRangeMinimum(System.Collections.Generic.IEnumerable<TElement>! elements, TPriority priority) -> void
+SuperLinq.Collections.UpdatablePriorityQueue<TElement, TPriority>.EnsureCapacity(int capacity) -> int
+SuperLinq.Collections.UpdatablePriorityQueue<TElement, TPriority>.Peek() -> TElement
+SuperLinq.Collections.UpdatablePriorityQueue<TElement, TPriority>.TrimExcess() -> void
+SuperLinq.Collections.UpdatablePriorityQueue<TElement, TPriority>.TryDequeue(out TElement element, out TPriority priority) -> bool
+SuperLinq.Collections.UpdatablePriorityQueue<TElement, TPriority>.TryPeek(out TElement element, out TPriority priority) -> bool
+SuperLinq.Collections.UpdatablePriorityQueue<TElement, TPriority>.UnorderedItems.get -> System.Collections.Generic.IReadOnlyCollection<(TElement Element, TPriority Priority)>!
+SuperLinq.Collections.UpdatablePriorityQueue<TElement, TPriority>.UpdatablePriorityQueue() -> void
+SuperLinq.Collections.UpdatablePriorityQueue<TElement, TPriority>.UpdatablePriorityQueue(int initialCapacity, System.Collections.Generic.IComparer<TPriority>? priorityComparer, System.Collections.Generic.IEqualityComparer<TElement>? elementComparer) -> void
+SuperLinq.Collections.UpdatablePriorityQueue<TElement, TPriority>.UpdatablePriorityQueue(int initialCapacity) -> void
+SuperLinq.Collections.UpdatablePriorityQueue<TElement, TPriority>.UpdatablePriorityQueue(System.Collections.Generic.IComparer<TPriority>? priorityComparer) -> void
+SuperLinq.Collections.UpdatablePriorityQueue<TElement, TPriority>.UpdatablePriorityQueue(System.Collections.Generic.IEnumerable<(TElement Element, TPriority Priority)>! items, System.Collections.Generic.IComparer<TPriority>? priorityComparer, System.Collections.Generic.IEqualityComparer<TElement>? elementComparer) -> void
+SuperLinq.Collections.UpdatablePriorityQueue<TElement, TPriority>.UpdatablePriorityQueue(System.Collections.Generic.IEnumerable<(TElement Element, TPriority Priority)>! items) -> void
+SuperLinq.Collections.UpdatablePriorityQueue<TElement, TPriority>.UpdatablePriorityQueue(System.Collections.Generic.IEqualityComparer<TElement>? elementComparer) -> void
+SuperLinq.IBuffer<T>
+SuperLinq.IBuffer<T>.Count.get -> int
+SuperLinq.IBuffer<T>.Reset() -> void
+SuperLinq.OrderByDirection
+SuperLinq.OrderByDirection.Ascending = 0 -> SuperLinq.OrderByDirection
+SuperLinq.OrderByDirection.Descending = 1 -> SuperLinq.OrderByDirection
+SuperLinq.SuperEnumerable
+SuperLinq.SuperEnumerable.ReadOnlySpanFunc<TSource, TResult>
+SuperLinq.ValueTupleComparer
+SuperLinq.ValueTupleEqualityComparer
+System.Diagnostics.UnreachableException
+System.Diagnostics.UnreachableException.UnreachableException() -> void
+System.Diagnostics.UnreachableException.UnreachableException(string? message, System.Exception? innerException) -> void
+System.Diagnostics.UnreachableException.UnreachableException(string? message) -> void
diff --git a/Source/SuperLinq/Replace.cs b/Source/SuperLinq/Replace.cs
index f7da40bd..0f78f197 100644
--- a/Source/SuperLinq/Replace.cs
+++ b/Source/SuperLinq/Replace.cs
@@ -1,4 +1,6 @@
-namespace SuperLinq;
+#if !NO_INDEX
+
+namespace SuperLinq;
 
 public static partial class SuperEnumerable
 {
@@ -174,3 +176,5 @@ protected override TSource ElementAt(int index)
 		}
 	}
 }
+
+#endif
diff --git a/Source/SuperLinq/ReverseComparer.cs b/Source/SuperLinq/ReverseComparer.cs
index 2c6c7bb9..23f31976 100644
--- a/Source/SuperLinq/ReverseComparer.cs
+++ b/Source/SuperLinq/ReverseComparer.cs
@@ -5,5 +5,5 @@ IComparer<T> underlying
 ) : IComparer<T>
 {
 	public int Compare(T? x, T? y) =>
-		-underlying.Compare(x, y);
+		-underlying.Compare(x!, y!);
 }
diff --git a/Source/SuperLinq/Slice.cs b/Source/SuperLinq/Slice.cs
index 7128e71c..b3832521 100644
--- a/Source/SuperLinq/Slice.cs
+++ b/Source/SuperLinq/Slice.cs
@@ -1,4 +1,4 @@
-namespace SuperLinq;
+namespace SuperLinq;
 
 public static partial class SuperEnumerable
 {
@@ -30,6 +30,10 @@ public static partial class SuperEnumerable
 	/// </remarks>
 	public static IEnumerable<T> Slice<T>(this IEnumerable<T> source, int startIndex, int count)
 	{
+#if !NO_INDEX
 		return source.Take(startIndex..(startIndex + count));
+#else
+		return source.Skip(startIndex).Take(count);
+#endif
 	}
 }
diff --git a/Source/SuperLinq/SuperLinq.csproj b/Source/SuperLinq/SuperLinq.csproj
index 067b9287..b1a3b083 100644
--- a/Source/SuperLinq/SuperLinq.csproj
+++ b/Source/SuperLinq/SuperLinq.csproj
@@ -5,8 +5,10 @@
   <PropertyGroup>
     <AssemblyName>SuperLinq</AssemblyName>
     <RootNamespace>SuperLinq</RootNamespace>
+    <TargetFrameworks>netstandard2.0;$(TargetFrameworks)</TargetFrameworks>
 
     <PolySharpIncludeRuntimeSupportedAttributes>true</PolySharpIncludeRuntimeSupportedAttributes>
+
     <IsAotCompatible Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net7.0'))">true</IsAotCompatible>
   </PropertyGroup>
 
@@ -158,11 +160,17 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.Bcl.HashCode" />
     <PackageReference Include="Microsoft.CodeAnalysis.PublicApiAnalyzers" PrivateAssets="All" />
     <PackageReference Include="Microsoft.SourceLink.GitHub" PrivateAssets="All" />
     <PackageReference Include="MinVer" PrivateAssets="All" />
+    <PackageReference Include="System.Memory" />
   </ItemGroup>
 
+  <PropertyGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+	<DefineConstants>$(DefineConstants);NO_INDEX</DefineConstants>
+  </PropertyGroup>
+
   <PropertyGroup Label="SourceGenerator">
     <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
     <CompilerGeneratedFilesOutputPath>Generated</CompilerGeneratedFilesOutputPath>
diff --git a/Source/SuperLinq/Take.cs b/Source/SuperLinq/Take.cs
index 378f896d..7c2783b0 100644
--- a/Source/SuperLinq/Take.cs
+++ b/Source/SuperLinq/Take.cs
@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+#if !NO_INDEX
+
 namespace SuperLinq;
 
 public static partial class SuperEnumerable
@@ -33,10 +35,10 @@ public static partial class SuperEnumerable
 	///	    This method is implemented by using deferred execution.
 	/// </para>
 	/// </remarks>
-#if !NET6_0_OR_GREATER
-	public static IEnumerable<TSource> Take<TSource>(this IEnumerable<TSource> source, Range range)
-#else
+#if NET6_0_OR_GREATER
 	public static IEnumerable<TSource> Take<TSource>(IEnumerable<TSource> source, Range range)
+#else
+	public static IEnumerable<TSource> Take<TSource>(this IEnumerable<TSource> source, Range range)
 #endif
 	{
 		ArgumentNullException.ThrowIfNull(source);
@@ -158,3 +160,5 @@ private static IEnumerable<TSource> TakeRangeFromEndIterator<TSource>(IEnumerabl
 		}
 	}
 }
+
+#endif
diff --git a/TargetFrameworks.props b/TargetFrameworks.props
index b9fdeb1b..635585bd 100644
--- a/TargetFrameworks.props
+++ b/TargetFrameworks.props
@@ -1,7 +1,7 @@
 <Project>
 
 	<PropertyGroup>
-		<TargetFrameworks>netcoreapp3.1;net6.0;</TargetFrameworks>
+		<TargetFrameworks>netcoreapp3.1;net6.0</TargetFrameworks>
 		<TargetFrameworks Condition="$([MSBuild]::VersionGreaterThanOrEquals('$(NETCoreSdkVersion)', '8.0'))">$(TargetFrameworks);net8.0</TargetFrameworks>
 		<TargetFrameworks Condition="$([MSBuild]::VersionGreaterThanOrEquals('$(NETCoreSdkVersion)', '9.0'))">$(TargetFrameworks);net9.0</TargetFrameworks>
 	</PropertyGroup>
diff --git a/Tests/SuperLinq.Async.Test/CountByTest.cs b/Tests/SuperLinq.Async.Test/CountByTest.cs
index bedcbec9..d3d078d4 100644
--- a/Tests/SuperLinq.Async.Test/CountByTest.cs
+++ b/Tests/SuperLinq.Async.Test/CountByTest.cs
@@ -9,12 +9,12 @@ public async Task CountBySimpleTest()
 
 		await xs.CountBy(SuperEnumerable.Identity)
 			.AssertSequenceEqual(
-				KeyValuePair.Create(1, 4),
-				KeyValuePair.Create(2, 3),
-				KeyValuePair.Create(3, 2),
-				KeyValuePair.Create(4, 1),
-				KeyValuePair.Create(5, 1),
-				KeyValuePair.Create(6, 1));
+				CreatePair(1, 4),
+				CreatePair(2, 3),
+				CreatePair(3, 2),
+				CreatePair(4, 1),
+				CreatePair(5, 1),
+				CreatePair(6, 1));
 	}
 
 	[Fact]
@@ -24,11 +24,11 @@ public async Task CountByWithSecondOccurenceImmediatelyAfterFirst()
 
 		await xs.CountBy(SuperEnumerable.Identity)
 			.AssertSequenceEqual(
-				KeyValuePair.Create('j', 1),
-				KeyValuePair.Create('a', 1),
-				KeyValuePair.Create('f', 2),
-				KeyValuePair.Create('e', 1),
-				KeyValuePair.Create('r', 1));
+				CreatePair('j', 1),
+				CreatePair('a', 1),
+				CreatePair('f', 2),
+				CreatePair('e', 1),
+				CreatePair('r', 1));
 	}
 
 	[Fact]
@@ -40,8 +40,8 @@ public async Task CountByEvenOddTest()
 		await xs
 			.CountBy(c => c % 2)
 			.AssertSequenceEqual(
-				KeyValuePair.Create(1, 50),
-				KeyValuePair.Create(0, 50));
+				CreatePair(1, 50),
+				CreatePair(0, 50));
 	}
 
 	[Fact]
@@ -52,9 +52,9 @@ public async Task CountByWithEqualityComparer()
 		await xs
 			.CountBy(SuperEnumerable.Identity, StringComparer.OrdinalIgnoreCase)
 			.AssertSequenceEqual(
-				KeyValuePair.Create("a", 3),
-				KeyValuePair.Create("B", 2),
-				KeyValuePair.Create("c", 1));
+				CreatePair("a", 3),
+				CreatePair("B", 2),
+				CreatePair("c", 1));
 	}
 
 	[Fact]
@@ -83,9 +83,11 @@ public async Task CountByWithSomeNullKeys()
 
 		await ss.CountBy(SuperEnumerable.Identity)
 			.AssertSequenceEqual(
-				KeyValuePair.Create((string?)"foo", 2),
-				KeyValuePair.Create((string?)null, 4),
-				KeyValuePair.Create((string?)"bar", 2),
-				KeyValuePair.Create((string?)"baz", 2));
+				CreatePair((string?)"foo", 2),
+				CreatePair((string?)null, 4),
+				CreatePair((string?)"bar", 2),
+				CreatePair((string?)"baz", 2));
 	}
+
+	private static KeyValuePair<TKey, TValue> CreatePair<TKey, TValue>(TKey key, TValue value) => new(key, value);
 }
diff --git a/Tests/SuperLinq.Async.Test/DensePartialSortByTest.cs b/Tests/SuperLinq.Async.Test/DensePartialSortByTest.cs
index 308d55a4..eb7476bd 100644
--- a/Tests/SuperLinq.Async.Test/DensePartialSortByTest.cs
+++ b/Tests/SuperLinq.Async.Test/DensePartialSortByTest.cs
@@ -13,7 +13,7 @@ public async Task DensePartialSortBy()
 	{
 		var ns = SuperEnumerable.RandomDouble().Take(10).ToArray();
 
-		await using var xs = ns.Select((n, i) => KeyValuePair.Create(i, n))
+		await using var xs = ns.Select((n, i) => CreatePair(i, n))
 			.Repeat(2)
 			.Reverse()
 			.AsTestingSequence();
@@ -34,7 +34,7 @@ public async Task DensePartialSortWithOrder(OrderByDirection direction)
 			.ToArray()
 			.AsEnumerable();
 
-		await using var xs = ns.Select((n, i) => KeyValuePair.Create(i, n))
+		await using var xs = ns.Select((n, i) => CreatePair(i, n))
 			.Repeat(2)
 			.Reverse()
 			.AsTestingSequence();
@@ -56,7 +56,7 @@ public async Task DensePartialSortWithComparer()
 			.Select((n, i) => ((char)((i % 2 == 0 ? 'A' : 'a') + n)).ToString())
 			.ToArray();
 
-		var ns = alphabet.Zip(SuperEnumerable.RandomDouble(), KeyValuePair.Create).ToArray();
+		var ns = alphabet.Zip(SuperEnumerable.RandomDouble(), CreatePair).ToArray();
 		await using var xs = ns.AsTestingSequence();
 
 		var sorted = xs.DensePartialSortBy(3, e => e.Key, StringComparer.Ordinal);
@@ -103,4 +103,6 @@ await sorted.AssertSequenceEqual(
 				stableSort.Take(i * 2));
 		}
 	}
+
+	private static KeyValuePair<TKey, TValue> CreatePair<TKey, TValue>(TKey key, TValue value) => new(key, value);
 }
diff --git a/Tests/SuperLinq.Async.Test/ElementAtTest.cs b/Tests/SuperLinq.Async.Test/ElementAtTest.cs
index 972487cd..d05d362f 100644
--- a/Tests/SuperLinq.Async.Test/ElementAtTest.cs
+++ b/Tests/SuperLinq.Async.Test/ElementAtTest.cs
@@ -1,6 +1,8 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+#if !NO_INDEX
+
 namespace Test.Async;
 
 public sealed class ElementAtTest
@@ -81,3 +83,5 @@ public async Task FromEndIndexOutOfRangeString()
 		Assert.Equal(default, await q.ElementAtOrDefaultAsync(^10));
 	}
 }
+
+#endif
diff --git a/Tests/SuperLinq.Async.Test/FillForwardTest.cs b/Tests/SuperLinq.Async.Test/FillForwardTest.cs
index 1446a1a4..072a1cf4 100644
--- a/Tests/SuperLinq.Async.Test/FillForwardTest.cs
+++ b/Tests/SuperLinq.Async.Test/FillForwardTest.cs
@@ -39,7 +39,7 @@ Africa Egypt       Cairo       789
 			from line in Table.Split('\n')
 			select line.Trim() into line
 			where !string.IsNullOrEmpty(line)
-			let x = line.Split(' ', StringSplitOptions.RemoveEmptyEntries)
+			let x = line.Split([' '], StringSplitOptions.RemoveEmptyEntries)
 			select new
 			{
 				Continent = x[0],
diff --git a/Tests/SuperLinq.Async.Test/FindIndexTest.cs b/Tests/SuperLinq.Async.Test/FindIndexTest.cs
index 26ad9c7f..2b80c477 100644
--- a/Tests/SuperLinq.Async.Test/FindIndexTest.cs
+++ b/Tests/SuperLinq.Async.Test/FindIndexTest.cs
@@ -1,4 +1,6 @@
-namespace Test.Async;
+#if !NO_INDEX
+
+namespace Test.Async;
 
 public sealed class FindIndexTest
 {
@@ -128,3 +130,5 @@ public async Task FindIndexDoesNotIterateUnnecessaryElementsCount()
 		Assert.Equal(-1, await source.FindIndex(i => i == "carlos", 0, 5));
 	}
 }
+
+#endif
diff --git a/Tests/SuperLinq.Async.Test/FindLastIndexTest.cs b/Tests/SuperLinq.Async.Test/FindLastIndexTest.cs
index 48a44165..ff7f3783 100644
--- a/Tests/SuperLinq.Async.Test/FindLastIndexTest.cs
+++ b/Tests/SuperLinq.Async.Test/FindLastIndexTest.cs
@@ -1,4 +1,6 @@
-namespace Test.Async;
+#if !NO_INDEX
+
+namespace Test.Async;
 
 public sealed class FindLastIndexTest
 {
@@ -96,3 +98,5 @@ public async Task FindLastIndexMissingValueFromEndCount()
 			await sequence.FindLastIndex(i => i == 100, ^1, 3));
 	}
 }
+
+#endif
diff --git a/Tests/SuperLinq.Async.Test/Future.cs b/Tests/SuperLinq.Async.Test/Future.cs
new file mode 100644
index 00000000..92c3ba8d
--- /dev/null
+++ b/Tests/SuperLinq.Async.Test/Future.cs
@@ -0,0 +1,12 @@
+#if !NETCOREAPP
+
+namespace Test.Async;
+
+public static class Future
+{
+	public static IEnumerable<(TFirst First, TSecond Scond)> Zip<TFirst, TSecond>(this IEnumerable<TFirst> first,
+		IEnumerable<TSecond> second)
+		=> first.Zip(second, (first, second) => (first, second));
+}
+
+#endif
diff --git a/Tests/SuperLinq.Async.Test/GroupAdjacentTest.cs b/Tests/SuperLinq.Async.Test/GroupAdjacentTest.cs
index 2b3d6609..71fa0074 100644
--- a/Tests/SuperLinq.Async.Test/GroupAdjacentTest.cs
+++ b/Tests/SuperLinq.Async.Test/GroupAdjacentTest.cs
@@ -1,4 +1,4 @@
-namespace Test.Async;
+namespace Test.Async;
 
 public sealed class GroupAdjacentTest
 {
@@ -172,7 +172,10 @@ public async Task GroupAdjacentSourceSequenceResultSelectorComparer()
 	public async Task GroupAdjacentSourceSequenceWithSomeNullKeys()
 	{
 		using var source = AsyncEnumerable.Range(1, 5)
-			.SelectMany(x => Enumerable.Repeat((int?)x, x).Append(null).ToAsyncEnumerable())
+			.SelectMany(x => Enumerable.Repeat((int?)x, x)
+				.Concat([null])
+				.ToAsyncEnumerable()
+			)
 			.AsTestingSequence();
 
 		var groupings = source.GroupAdjacent(SuperEnumerable.Identity);
diff --git a/Tests/SuperLinq.Async.Test/IndexOfTest.cs b/Tests/SuperLinq.Async.Test/IndexOfTest.cs
index f54eed7e..ad55ad63 100644
--- a/Tests/SuperLinq.Async.Test/IndexOfTest.cs
+++ b/Tests/SuperLinq.Async.Test/IndexOfTest.cs
@@ -1,4 +1,6 @@
-namespace Test.Async;
+#if !NO_INDEX
+
+namespace Test.Async;
 
 public sealed class IndexOfTest
 {
@@ -125,3 +127,5 @@ public async Task IndexOfDoesNotIterateUnnecessaryElementsCount()
 		Assert.Equal(-1, await source.IndexOf("carlos", 0, 5));
 	}
 }
+
+#endif
diff --git a/Tests/SuperLinq.Async.Test/InsertTest.cs b/Tests/SuperLinq.Async.Test/InsertTest.cs
index f339aa9f..12ef2372 100644
--- a/Tests/SuperLinq.Async.Test/InsertTest.cs
+++ b/Tests/SuperLinq.Async.Test/InsertTest.cs
@@ -1,4 +1,6 @@
-namespace Test.Async;
+#if !NO_INDEX
+
+namespace Test.Async;
 
 public sealed class InsertTest
 {
@@ -104,3 +106,5 @@ public async Task Backsert(int[] seq1, int index, int[] seq2, int[] expected)
 		await test1.Insert(test2, ^index).AssertSequenceEqual(expected);
 	}
 }
+
+#endif
diff --git a/Tests/SuperLinq.Async.Test/LastIndexOfTest.cs b/Tests/SuperLinq.Async.Test/LastIndexOfTest.cs
index 114f0f4f..e17e603c 100644
--- a/Tests/SuperLinq.Async.Test/LastIndexOfTest.cs
+++ b/Tests/SuperLinq.Async.Test/LastIndexOfTest.cs
@@ -1,4 +1,6 @@
-namespace Test.Async;
+#if !NO_INDEX
+
+namespace Test.Async;
 
 public sealed class LastIndexOfTest
 {
@@ -97,3 +99,5 @@ public async Task LastIndexOfMissingValueFromEndCount()
 			await sequence.LastIndexOf(100, ^1, 3));
 	}
 }
+
+#endif
diff --git a/Tests/SuperLinq.Async.Test/NullArgumentTest.cs b/Tests/SuperLinq.Async.Test/NullArgumentTest.cs
index b842f1de..4cf8322d 100644
--- a/Tests/SuperLinq.Async.Test/NullArgumentTest.cs
+++ b/Tests/SuperLinq.Async.Test/NullArgumentTest.cs
@@ -1,9 +1,12 @@
 using System.Collections;
 using System.Diagnostics;
+#if NETCOREAPP
 using System.Diagnostics.CodeAnalysis;
+#endif
 using System.Linq.Expressions;
 using System.Reflection;
 using CommunityToolkit.Diagnostics;
+using Debug = System.Diagnostics.Debug;
 
 namespace Test.Async;
 
@@ -280,7 +283,11 @@ public sealed class Dictionary<TKey, TValue> : IDictionary<TKey, TValue>
 			where TKey : notnull
 		{
 			public TValue this[TKey key] { get => throw new NotSupportedException(); set => throw new NotSupportedException(); }
+#if NETCOREAPP
 			public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value) => throw new NotSupportedException();
+#else
+			public bool TryGetValue(TKey key, out TValue value) => throw new NotSupportedException();
+#endif
 			public ICollection<TKey> Keys => throw new NotSupportedException();
 			public ICollection<TValue> Values => throw new NotSupportedException();
 			public int Count => throw new NotSupportedException();
diff --git a/Tests/SuperLinq.Async.Test/PartialSortTest.cs b/Tests/SuperLinq.Async.Test/PartialSortTest.cs
index 4b9866d8..be0cbbf7 100644
--- a/Tests/SuperLinq.Async.Test/PartialSortTest.cs
+++ b/Tests/SuperLinq.Async.Test/PartialSortTest.cs
@@ -1,4 +1,4 @@
-namespace Test.Async;
+namespace Test.Async;
 
 public sealed class PartialSortTests
 {
@@ -7,7 +7,7 @@ public async Task PartialSort()
 	{
 		await using var sequence = Enumerable.Range(1, 10)
 			.Reverse()
-			.Append(0)
+			.Concat([0])
 			.AsTestingSequence();
 
 		await sequence
@@ -20,7 +20,7 @@ public async Task PartialSortWithOrder()
 	{
 		await using var sequence = Enumerable.Range(1, 10)
 			.Reverse()
-			.Append(0)
+			.Concat([0])
 			.AsTestingSequence(maxEnumerations: 2);
 
 		await sequence
diff --git a/Tests/SuperLinq.Async.Test/ReplaceTest.cs b/Tests/SuperLinq.Async.Test/ReplaceTest.cs
index 0fce4a53..46b343b6 100644
--- a/Tests/SuperLinq.Async.Test/ReplaceTest.cs
+++ b/Tests/SuperLinq.Async.Test/ReplaceTest.cs
@@ -1,4 +1,6 @@
-namespace Test.Async;
+#if !NO_INDEX
+
+namespace Test.Async;
 
 public sealed class ReplaceTest
 {
@@ -33,7 +35,7 @@ public async Task ReplaceIntIndex(int index)
 		var result = seq.Replace(index, 30);
 		await result.AssertSequenceEqual(
 			Enumerable.Range(1, index)
-				.Append(30)
+				.Concat([30])
 				.Concat(Enumerable.Range(index + 2, 9 - index)));
 	}
 
@@ -45,7 +47,7 @@ public async Task ReplaceStartIndex(int index)
 		var result = seq.Replace(new Index(index), 30);
 		await result.AssertSequenceEqual(
 			Enumerable.Range(1, index)
-				.Append(30)
+				.Concat([30])
 				.Concat(Enumerable.Range(index + 2, 9 - index)));
 	}
 
@@ -57,7 +59,7 @@ public async Task ReplaceEndIndex(int index)
 		var result = seq.Replace(^index, 30);
 		await result.AssertSequenceEqual(
 			Enumerable.Range(1, 9 - index)
-				.Append(30)
+				.Concat([30])
 				.Concat(Enumerable.Range(11 - index, index)));
 	}
 
@@ -88,3 +90,5 @@ public async Task ReplaceEndIndexPastSequenceLength()
 		await result.AssertSequenceEqual(Enumerable.Range(1, 10));
 	}
 }
+
+#endif
diff --git a/Tests/SuperLinq.Async.Test/SplitTest.cs b/Tests/SuperLinq.Async.Test/SplitTest.cs
index abacf8fd..a2ecaee3 100644
--- a/Tests/SuperLinq.Async.Test/SplitTest.cs
+++ b/Tests/SuperLinq.Async.Test/SplitTest.cs
@@ -1,4 +1,6 @@
-namespace Test.Async;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Test.Async;
 
 public sealed class SplitTest
 {
@@ -26,6 +28,7 @@ public async Task SplitWithComparerUptoMaxCount()
 	}
 
 	[Fact]
+	[SuppressMessage("Style", "IDE0305:Simplify collection initialization")]
 	public async Task SplitWithSeparatorAndResultTransformation()
 	{
 		await using var sequence = "the quick brown fox".AsTestingSequence();
@@ -34,6 +37,7 @@ public async Task SplitWithSeparatorAndResultTransformation()
 	}
 
 	[Fact]
+	[SuppressMessage("Style", "IDE0305:Simplify collection initialization")]
 	public async Task SplitUptoMaxCount()
 	{
 		await using var sequence = "the quick brown fox".AsTestingSequence();
diff --git a/Tests/SuperLinq.Async.Test/SuperLinq.Async.Test.csproj b/Tests/SuperLinq.Async.Test/SuperLinq.Async.Test.csproj
index 02338b19..a99fce0e 100644
--- a/Tests/SuperLinq.Async.Test/SuperLinq.Async.Test.csproj
+++ b/Tests/SuperLinq.Async.Test/SuperLinq.Async.Test.csproj
@@ -3,43 +3,49 @@
   <Import Project="../../TargetFrameworks.props" />
 
   <PropertyGroup>
-    <AssemblyTitle>SuperLinq.Async.Test</AssemblyTitle>
-    <AssemblyName>SuperLinq.Async.Test</AssemblyName>
-    <RootNamespace>Test.Async</RootNamespace>
+	<AssemblyTitle>SuperLinq.Async.Test</AssemblyTitle>
+	<AssemblyName>SuperLinq.Async.Test</AssemblyName>
+	<RootNamespace>Test.Async</RootNamespace>
+	<TargetFrameworks>net47;$(TargetFrameworks)</TargetFrameworks>
 
-    <IsPackable>false</IsPackable>
-    <AnalysisLevel>latest-recommended</AnalysisLevel>
+	<IsPackable>false</IsPackable>
+	<AnalysisLevel>latest-recommended</AnalysisLevel>
   </PropertyGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\..\Source\SuperLinq\SuperLinq.csproj" />
-    <ProjectReference Include="..\..\Source\SuperLinq.Async\SuperLinq.Async.csproj" />
+	<ProjectReference Include="..\..\Source\SuperLinq\SuperLinq.csproj" />
+	<ProjectReference Include="..\..\Source\SuperLinq.Async\SuperLinq.Async.csproj" />
   </ItemGroup>
 
   <ItemGroup>
-    <Compile Include="..\SuperLinq.Test\BreakingAction.cs" Link="BreakingAction.cs" />
-    <Compile Include="..\SuperLinq.Test\BreakingFunc.cs" Link="BreakingFunc.cs" />
-    <Compile Include="..\SuperLinq.Test\EqualityComparer.cs" Link="EqualityComparer.cs" />
-    <Compile Include="..\SuperLinq.Test\FuncModule.cs" Link="FuncModule.cs" />
-    <Compile Include="..\SuperLinq.Test\TestException.cs" Link="TestException.cs" />
+	<Compile Include="..\SuperLinq.Test\BreakingAction.cs" Link="BreakingAction.cs" />
+	<Compile Include="..\SuperLinq.Test\BreakingFunc.cs" Link="BreakingFunc.cs" />
+	<Compile Include="..\SuperLinq.Test\EqualityComparer.cs" Link="EqualityComparer.cs" />
+	<Compile Include="..\SuperLinq.Test\FuncModule.cs" Link="FuncModule.cs" />
+	<Compile Include="..\SuperLinq.Test\TestException.cs" Link="TestException.cs" />
   </ItemGroup>
 
   <ItemGroup>
-    <Using Include="SuperLinq" />
-    <Using Include="SuperLinq.Async" />
-    <Using Include="Xunit" />
-    <Using Include="Test.FuncModule" Static="true" />
-    <Using Include="Test.Async.TestExtensions" Static="true" />
+	<Using Include="SuperLinq" />
+	<Using Include="SuperLinq.Async" />
+	<Using Include="Xunit" />
+	<Using Include="Xunit.Assert" Alias="Assert" />
+	<Using Include="Test.FuncModule" Static="true" />
+	<Using Include="Test.Async.TestExtensions" Static="true" />
   </ItemGroup>
 
+  <PropertyGroup Condition="'$(TargetFramework)' == 'net47'">
+	<DefineConstants>$(DefineConstants);NO_INDEX</DefineConstants>
+  </PropertyGroup>
+
   <ItemGroup>
-    <PackageReference Include="CommunityToolkit.Diagnostics" />
-    <PackageReference Include="coverlet.collector" PrivateAssets="All" />
-    <PackageReference Include="coverlet.msbuild" PrivateAssets="All" />
-    <PackageReference Include="GitHubActionsTestLogger" PrivateAssets="All" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" />
-    <PackageReference Include="xunit" />
-    <PackageReference Include="xunit.runner.visualstudio" PrivateAssets="All" />
+	<PackageReference Include="CommunityToolkit.Diagnostics" />
+	<PackageReference Include="coverlet.collector" PrivateAssets="All" />
+	<PackageReference Include="coverlet.msbuild" PrivateAssets="All" />
+	<PackageReference Include="GitHubActionsTestLogger" PrivateAssets="All" />
+	<PackageReference Include="Microsoft.NET.Test.Sdk" />
+	<PackageReference Include="xunit" />
+	<PackageReference Include="xunit.runner.visualstudio" PrivateAssets="All" />
   </ItemGroup>
 
 </Project>
diff --git a/Tests/SuperLinq.Async.Test/TakeTest.cs b/Tests/SuperLinq.Async.Test/TakeTest.cs
index 53b10dcd..f42e7f5b 100644
--- a/Tests/SuperLinq.Async.Test/TakeTest.cs
+++ b/Tests/SuperLinq.Async.Test/TakeTest.cs
@@ -1,6 +1,8 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+#if !NO_INDEX
+
 namespace Test.Async;
 
 public sealed class TakeTest
@@ -290,3 +292,5 @@ public async Task EmptySourceDoNotThrowException()
 		Assert.Empty(await Source().Take(^6..^7).ToListAsync());
 	}
 }
+
+#endif
diff --git a/Tests/SuperLinq.Async.Test/TestExtensions.cs b/Tests/SuperLinq.Async.Test/TestExtensions.cs
index dcdf5595..a21ffb8e 100644
--- a/Tests/SuperLinq.Async.Test/TestExtensions.cs
+++ b/Tests/SuperLinq.Async.Test/TestExtensions.cs
@@ -1,4 +1,4 @@
-namespace Test.Async;
+namespace Test.Async;
 
 internal static partial class TestExtensions
 {
@@ -11,7 +11,7 @@ public static IAsyncEnumerable<int> AsyncSeqExceptionAt(int index) =>
 		AsyncSuperEnumerable.From(
 			Enumerable.Range(1, index - 1)
 				.Select(i => Func(() => Task.FromResult(i)))
-				.Append(AsyncBreakingFunc.Of<int>())
+				.Concat([AsyncBreakingFunc.Of<int>()])
 				.ToArray());
 
 	internal static async Task AssertEmpty<T>(this IAsyncEnumerable<T> actual) =>
diff --git a/Tests/SuperLinq.Test/AggregateTest.cs b/Tests/SuperLinq.Test/AggregateTest.cs
index 7450a0e3..50d62717 100644
--- a/Tests/SuperLinq.Test/AggregateTest.cs
+++ b/Tests/SuperLinq.Test/AggregateTest.cs
@@ -1,4 +1,4 @@
-using System.Globalization;
+using System.Globalization;
 using System.Linq.Expressions;
 using System.Reflection;
 
@@ -22,14 +22,18 @@ public static IEnumerable<object[]> AccumulatorsTestSource() =>
 		from m in typeof(SuperEnumerable).GetMethods(BindingFlags.Public | BindingFlags.Static)
 		where m.Name == nameof(SuperEnumerable.Aggregate)
 		   && m.IsGenericMethodDefinition
+#if NETCOREAPP
 		where !m.ReturnType.Name.Contains(nameof(ValueTuple), StringComparison.Ordinal)
+#else
+		where !m.ReturnType.Name.Contains(nameof(ValueTuple))
+#endif
 		select new
 		{
 			Source = source,
 			Expectation = sum,
 			Instantiation = m.MakeGenericMethod(
 				Enumerable.Repeat(typeof(int), m.GetGenericArguments().Length - 1)
-					.Append(typeof(int[])) // TResult
+					.Concat([typeof(int[])]) // TResult
 					.ToArray()),
 		}
 		into m
@@ -62,7 +66,7 @@ into m
 						  .Concat(from pairs in Enumerable.Repeat(new object[] { /* seed */ 0, accumulator }, m.AccumulatorCount)
 								  from pair in pairs
 								  select pair)
-						  .Append(resultSelector)
+						  .Concat([resultSelector])
 						  .ToArray(),
 			Expectation =
 				Enumerable.Repeat(m.Expectation, m.AccumulatorCount)
diff --git a/Tests/SuperLinq.Test/AssertCountTest.cs b/Tests/SuperLinq.Test/AssertCountTest.cs
index 2534a9eb..f6d3a69d 100644
--- a/Tests/SuperLinq.Test/AssertCountTest.cs
+++ b/Tests/SuperLinq.Test/AssertCountTest.cs
@@ -1,4 +1,4 @@
-namespace Test;
+namespace Test;
 
 public sealed class AssertCountTest
 {
@@ -78,7 +78,9 @@ public void AssertCountListBehavior()
 
 		Assert.Equal(200, result.ElementAt(200));
 		Assert.Equal(1_200, result.ElementAt(1_200));
+#if !NO_INDEX
 		Assert.Equal(8_800, result.ElementAt(^1_200));
+#endif
 	}
 
 	[Fact]
diff --git a/Tests/SuperLinq.Test/BacksertTest.cs b/Tests/SuperLinq.Test/BacksertTest.cs
index 152de6c9..60d3674f 100644
--- a/Tests/SuperLinq.Test/BacksertTest.cs
+++ b/Tests/SuperLinq.Test/BacksertTest.cs
@@ -1,4 +1,6 @@
-namespace Test;
+#if !NO_INDEX
+
+namespace Test;
 
 [Obsolete("References `Backsert` which is obsolete in favor of `Insert`")]
 public sealed class BacksertTest
@@ -41,3 +43,5 @@ public void Backsert(int[] seq1, int index, int[] seq2, int[] expected)
 		Assert.Equal(expected, test1.Backsert(test2, index).ToArray());
 	}
 }
+
+#endif
diff --git a/Tests/SuperLinq.Test/BatchTest.cs b/Tests/SuperLinq.Test/BatchTest.cs
index f3cc88a2..be6e56fc 100644
--- a/Tests/SuperLinq.Test/BatchTest.cs
+++ b/Tests/SuperLinq.Test/BatchTest.cs
@@ -279,7 +279,9 @@ public void BatchListEvenlyDivisibleBehavior()
 		result.AssertListElementChecking(length);
 
 		Assert.Equal(Enumerable.Range(1_000, 20), result.ElementAt(50));
+#if !NO_INDEX
 		Assert.Equal(Enumerable.Range(9_980, 20), result.ElementAt(^1));
+#endif
 	}
 
 	[Fact]
@@ -293,7 +295,9 @@ public void BatchListUnevenlyDivisibleBehavior()
 		result.AssertListElementChecking(length);
 
 		Assert.Equal(Enumerable.Range(1_000, 20), result.ElementAt(50));
+#if !NO_INDEX
 		Assert.Equal(Enumerable.Range(9_980, 20), result.ElementAt(^2));
 		Assert.Equal(Enumerable.Range(10_000, 2), result.ElementAt(^1));
+#endif
 	}
 }
diff --git a/Tests/SuperLinq.Test/CountByTest.cs b/Tests/SuperLinq.Test/CountByTest.cs
index 39004dbe..4c67cfc7 100644
--- a/Tests/SuperLinq.Test/CountByTest.cs
+++ b/Tests/SuperLinq.Test/CountByTest.cs
@@ -11,12 +11,12 @@ public void CountBySimpleTest()
 		SuperEnumerable
 			.CountBy(xs, SuperEnumerable.Identity)
 			.AssertSequenceEqual(
-				KeyValuePair.Create(1, 4),
-				KeyValuePair.Create(2, 3),
-				KeyValuePair.Create(3, 2),
-				KeyValuePair.Create(4, 1),
-				KeyValuePair.Create(5, 1),
-				KeyValuePair.Create(6, 1));
+				CreatePair(1, 4),
+				CreatePair(2, 3),
+				CreatePair(3, 2),
+				CreatePair(4, 1),
+				CreatePair(5, 1),
+				CreatePair(6, 1));
 	}
 
 	[Fact]
@@ -27,11 +27,11 @@ public void CountByWithSecondOccurenceImmediatelyAfterFirst()
 		SuperEnumerable
 			.CountBy(xs, SuperEnumerable.Identity)
 			.AssertSequenceEqual(
-				KeyValuePair.Create('j', 1),
-				KeyValuePair.Create('a', 1),
-				KeyValuePair.Create('f', 2),
-				KeyValuePair.Create('e', 1),
-				KeyValuePair.Create('r', 1));
+				CreatePair('j', 1),
+				CreatePair('a', 1),
+				CreatePair('f', 2),
+				CreatePair('e', 1),
+				CreatePair('r', 1));
 	}
 
 	[Fact]
@@ -42,8 +42,8 @@ public void CountByEvenOddTest()
 		SuperEnumerable
 			.CountBy(xs, c => c % 2)
 			.AssertSequenceEqual(
-				KeyValuePair.Create(1, 50),
-				KeyValuePair.Create(0, 50));
+				CreatePair(1, 50),
+				CreatePair(0, 50));
 	}
 
 	[Fact]
@@ -54,9 +54,9 @@ public void CountByWithEqualityComparer()
 		SuperEnumerable
 			.CountBy(xs, SuperEnumerable.Identity, StringComparer.OrdinalIgnoreCase)
 			.AssertSequenceEqual(
-				KeyValuePair.Create("a", 3),
-				KeyValuePair.Create("B", 2),
-				KeyValuePair.Create("c", 1));
+				CreatePair("a", 3),
+				CreatePair("B", 2),
+				CreatePair("c", 1));
 	}
 
 	[Fact]
@@ -84,9 +84,11 @@ public void CountByWithSomeNullKeys()
 		SuperEnumerable
 			.CountBy(xs, SuperEnumerable.Identity)
 			.AssertSequenceEqual(
-				KeyValuePair.Create((string?)"foo", 2),
-				KeyValuePair.Create((string?)null, 4),
-				KeyValuePair.Create((string?)"bar", 2),
-				KeyValuePair.Create((string?)"baz", 2));
+				CreatePair((string?)"foo", 2),
+				CreatePair((string?)null, 4),
+				CreatePair((string?)"bar", 2),
+				CreatePair((string?)"baz", 2));
 	}
+
+	private static KeyValuePair<TKey, TValue> CreatePair<TKey, TValue>(TKey key, TValue value) => new(key, value);
 }
diff --git a/Tests/SuperLinq.Test/CountDownTest.cs b/Tests/SuperLinq.Test/CountDownTest.cs
index 3a929666..8690aec6 100644
--- a/Tests/SuperLinq.Test/CountDownTest.cs
+++ b/Tests/SuperLinq.Test/CountDownTest.cs
@@ -1,4 +1,4 @@
-namespace Test;
+namespace Test;
 
 public sealed class CountDownTest
 {
@@ -72,6 +72,8 @@ public void CountDownListBehavior()
 
 		Assert.Equal((10, default(int?)), result.ElementAt(10));
 		Assert.Equal((50, default(int?)), result.ElementAt(50));
+#if !NO_INDEX
 		Assert.Equal((9_995, 4), result.ElementAt(^5));
+#endif
 	}
 }
diff --git a/Tests/SuperLinq.Test/DensePartialSortByTest.cs b/Tests/SuperLinq.Test/DensePartialSortByTest.cs
index 1d1d2728..d55512f8 100644
--- a/Tests/SuperLinq.Test/DensePartialSortByTest.cs
+++ b/Tests/SuperLinq.Test/DensePartialSortByTest.cs
@@ -13,7 +13,7 @@ public void DensePartialSortBy()
 	{
 		var ns = SuperEnumerable.RandomDouble().Take(10).ToArray();
 
-		using var xs = ns.Select((n, i) => KeyValuePair.Create(i, n))
+		using var xs = ns.Select((n, i) => CreatePair(i, n))
 			.Repeat(2)
 			.Reverse()
 			.AsTestingSequence();
@@ -33,7 +33,7 @@ public void DensePartialSortWithOrder(OrderByDirection direction)
 			.Take(10)
 			.ToArray().AsEnumerable();
 
-		using var xs = ns.Select((n, i) => KeyValuePair.Create(i, n))
+		using var xs = ns.Select((n, i) => CreatePair(i, n))
 			.Repeat(2)
 			.Reverse()
 			.AsTestingSequence();
@@ -56,7 +56,7 @@ public void DensePartialSortWithComparer()
 			.ToArray();
 
 		using var ns = alphabet
-			.Zip(SuperEnumerable.RandomDouble(), KeyValuePair.Create)
+			.Zip(SuperEnumerable.RandomDouble(), CreatePair)
 			.AsTestingSequence();
 
 		ns
@@ -103,4 +103,6 @@ public void DensePartialSortByIsStable()
 				stableSort.Take(i * 2));
 		}
 	}
+
+	private static KeyValuePair<TKey, TValue> CreatePair<TKey, TValue>(TKey key, TValue value) => new(key, value);
 }
diff --git a/Tests/SuperLinq.Test/DensePartialSortTest.cs b/Tests/SuperLinq.Test/DensePartialSortTest.cs
index bd38c6a8..1713695a 100644
--- a/Tests/SuperLinq.Test/DensePartialSortTest.cs
+++ b/Tests/SuperLinq.Test/DensePartialSortTest.cs
@@ -1,4 +1,4 @@
-namespace Test;
+namespace Test;
 
 public sealed class DensePartialSortTests
 {
@@ -14,7 +14,7 @@ public void DensePartialSort()
 		using var xs = Enumerable.Range(1, 10)
 			.Repeat(2)
 			.Reverse()
-			.Append(0)
+			.Concat([0])
 			.AsTestingSequence();
 
 		xs
@@ -30,7 +30,7 @@ public void DensePartialSortWithOrder(OrderByDirection direction)
 		using var xs = Enumerable.Range(1, 10)
 			.Repeat(2)
 			.Reverse()
-			.Append(0)
+			.Concat([0])
 			.AsTestingSequence();
 
 		var sorted = xs.DensePartialSort(3, direction);
diff --git a/Tests/SuperLinq.Test/ElementAtTest.cs b/Tests/SuperLinq.Test/ElementAtTest.cs
index c52d5db7..b4e67d77 100644
--- a/Tests/SuperLinq.Test/ElementAtTest.cs
+++ b/Tests/SuperLinq.Test/ElementAtTest.cs
@@ -1,6 +1,8 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+#if !NO_INDEX
+
 namespace Test;
 
 public sealed class ElementAtTest
@@ -28,4 +30,6 @@ public void SameResultsRepeatCallsStringQuery()
 		Assert.Equal(q[1].ElementAt(new Index(4)), q[1].ElementAtOrDefault(new Index(4)));
 		Assert.Equal(q[2].ElementAt(^2), q[2].ElementAtOrDefault(^2));
 	}
-}
\ No newline at end of file
+}
+
+#endif
diff --git a/Tests/SuperLinq.Test/EndsWithTest.cs b/Tests/SuperLinq.Test/EndsWithTest.cs
index 8727b345..da9fd423 100644
--- a/Tests/SuperLinq.Test/EndsWithTest.cs
+++ b/Tests/SuperLinq.Test/EndsWithTest.cs
@@ -1,4 +1,6 @@
-namespace Test;
+#if !NO_INDEX
+
+namespace Test;
 
 public sealed class EndsWithTest
 {
@@ -82,3 +84,5 @@ public void EndsWithUsesCollectionsCountToAvoidUnnecessaryIteration()
 		Assert.False(first.EndsWith(second));
 	}
 }
+
+#endif
diff --git a/Tests/SuperLinq.Test/EquiZipTest.cs b/Tests/SuperLinq.Test/EquiZipTest.cs
index f2bbe40b..6ebc182a 100644
--- a/Tests/SuperLinq.Test/EquiZipTest.cs
+++ b/Tests/SuperLinq.Test/EquiZipTest.cs
@@ -1,4 +1,4 @@
-using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Test;
 
@@ -135,7 +135,9 @@ public void TwoParamsEqualListBehavior()
 		Assert.Equal(10_000, result.Count());
 		Assert.Equal((10, 10), result.ElementAt(10));
 		Assert.Equal((50, 50), result.ElementAt(50));
+#if !NO_INDEX
 		Assert.Equal((9_950, 9_950), result.ElementAt(^50));
+#endif
 	}
 
 	[Fact]
@@ -261,7 +263,9 @@ public void ThreeParamsListBehavior()
 		Assert.Equal(10_000, result.Count());
 		Assert.Equal((10, 10, 10), result.ElementAt(10));
 		Assert.Equal((50, 50, 50), result.ElementAt(50));
+#if !NO_INDEX
 		Assert.Equal((9_950, 9_950, 9_950), result.ElementAt(^50));
+#endif
 	}
 
 	[Fact]
@@ -405,7 +409,9 @@ public void FourParamsListBehavior()
 		Assert.Equal(10_000, result.Count());
 		Assert.Equal((10, 10, 10, 10), result.ElementAt(10));
 		Assert.Equal((50, 50, 50, 50), result.ElementAt(50));
+#if !NO_INDEX
 		Assert.Equal((9_950, 9_950, 9_950, 9_950), result.ElementAt(^50));
+#endif
 	}
 
 	[Fact]
diff --git a/Tests/SuperLinq.Test/ExcludeTest.cs b/Tests/SuperLinq.Test/ExcludeTest.cs
index 9321f256..1340e55e 100644
--- a/Tests/SuperLinq.Test/ExcludeTest.cs
+++ b/Tests/SuperLinq.Test/ExcludeTest.cs
@@ -1,3 +1,5 @@
+#if !NO_INDEX
+
 namespace Test;
 
 /// <summary>
@@ -239,3 +241,5 @@ public void ExcludeRangeCollectionBehavior(Range range, bool __, bool shouldThro
 		result.AssertSequenceEqual(expected);
 	}
 }
+
+#endif
diff --git a/Tests/SuperLinq.Test/FillForwardTest.cs b/Tests/SuperLinq.Test/FillForwardTest.cs
index 0e22cb5d..a5b1d4cf 100644
--- a/Tests/SuperLinq.Test/FillForwardTest.cs
+++ b/Tests/SuperLinq.Test/FillForwardTest.cs
@@ -77,7 +77,7 @@ Africa Egypt       Cairo       789
 			from line in Table.Split('\n')
 			select line.Trim() into line
 			where !string.IsNullOrEmpty(line)
-			let x = line.Split(' ', StringSplitOptions.RemoveEmptyEntries)
+			let x = line.Split([' '], StringSplitOptions.RemoveEmptyEntries)
 			select new
 			{
 				Continent = x[0],
diff --git a/Tests/SuperLinq.Test/FindIndexTest.cs b/Tests/SuperLinq.Test/FindIndexTest.cs
index cbe2c527..355bbd7d 100644
--- a/Tests/SuperLinq.Test/FindIndexTest.cs
+++ b/Tests/SuperLinq.Test/FindIndexTest.cs
@@ -1,4 +1,6 @@
-namespace Test;
+#if !NO_INDEX
+
+namespace Test;
 
 public sealed class FindIndexTest
 {
@@ -144,3 +146,5 @@ public void FindIndexDoesNotIterateUnnecessaryElementsCount()
 		Assert.Equal(-1, source.FindIndex(i => i == "carlos", 0, 5));
 	}
 }
+
+#endif
diff --git a/Tests/SuperLinq.Test/FindLastIndexTest.cs b/Tests/SuperLinq.Test/FindLastIndexTest.cs
index a0528049..9666e2f7 100644
--- a/Tests/SuperLinq.Test/FindLastIndexTest.cs
+++ b/Tests/SuperLinq.Test/FindLastIndexTest.cs
@@ -1,4 +1,6 @@
-namespace Test;
+#if !NO_INDEX
+
+namespace Test;
 
 public sealed class FindLastIndexTest
 {
@@ -111,3 +113,5 @@ public void FindLastIndexMissingValueFromEndCount()
 			sequence.FindLastIndex(i => i == 100, ^1, 3));
 	}
 }
+
+#endif
diff --git a/Tests/SuperLinq.Test/Future.cs b/Tests/SuperLinq.Test/Future.cs
new file mode 100644
index 00000000..e8a154f3
--- /dev/null
+++ b/Tests/SuperLinq.Test/Future.cs
@@ -0,0 +1,12 @@
+#if !NETCOREAPP
+
+namespace Test;
+
+internal static class Future
+{
+	public static IEnumerable<(TFirst First, TSecond Scond)> Zip<TFirst, TSecond>(this IEnumerable<TFirst> first,
+		IEnumerable<TSecond> second)
+		=> first.Zip(second, (first, second) => (first, second));
+}
+
+#endif
diff --git a/Tests/SuperLinq.Test/GroupAdjacentTest.cs b/Tests/SuperLinq.Test/GroupAdjacentTest.cs
index 441524cc..3b23641c 100644
--- a/Tests/SuperLinq.Test/GroupAdjacentTest.cs
+++ b/Tests/SuperLinq.Test/GroupAdjacentTest.cs
@@ -1,4 +1,4 @@
-namespace Test;
+namespace Test;
 
 public sealed class GroupAdjacentTest
 {
@@ -172,7 +172,7 @@ public void GroupAdjacentSourceSequenceResultSelectorComparer()
 	public void GroupAdjacentSourceSequenceWithSomeNullKeys()
 	{
 		using var source = Enumerable.Range(1, 5)
-			.SelectMany(x => Enumerable.Repeat((int?)x, x).Append(null))
+			.SelectMany(x => Enumerable.Repeat((int?)x, x).Concat([null]))
 			.AsTestingSequence();
 
 		var groupings = source.GroupAdjacent(SuperEnumerable.Identity);
diff --git a/Tests/SuperLinq.Test/IndexOfTest.cs b/Tests/SuperLinq.Test/IndexOfTest.cs
index e65b1d4d..e1b77189 100644
--- a/Tests/SuperLinq.Test/IndexOfTest.cs
+++ b/Tests/SuperLinq.Test/IndexOfTest.cs
@@ -1,4 +1,6 @@
-namespace Test;
+#if !NO_INDEX
+
+namespace Test;
 
 public sealed class IndexOfTest
 {
@@ -135,3 +137,5 @@ public void IndexOfDoesNotIterateUnnecessaryElementsCount()
 		Assert.Equal(-1, source.IndexOf("carlos", 0, 5));
 	}
 }
+
+#endif
diff --git a/Tests/SuperLinq.Test/IndexTest.cs b/Tests/SuperLinq.Test/IndexTest.cs
index ae26c3b6..8b65377d 100644
--- a/Tests/SuperLinq.Test/IndexTest.cs
+++ b/Tests/SuperLinq.Test/IndexTest.cs
@@ -1,4 +1,4 @@
-namespace Test;
+namespace Test;
 
 [Obsolete("References `Index` which is obsolete in net9+")]
 public sealed class IndexTest
@@ -67,6 +67,8 @@ public void IndexListBehavior()
 
 		Assert.Equal((10_200, 200), result.ElementAt(200));
 		Assert.Equal((11_200, 1_200), result.ElementAt(1_200));
+#if !NO_INDEX
 		Assert.Equal((18_800, 8_800), result.ElementAt(^1_200));
+#endif
 	}
 }
diff --git a/Tests/SuperLinq.Test/InsertTest.cs b/Tests/SuperLinq.Test/InsertTest.cs
index 3eea0f3b..15e8df64 100644
--- a/Tests/SuperLinq.Test/InsertTest.cs
+++ b/Tests/SuperLinq.Test/InsertTest.cs
@@ -1,4 +1,6 @@
-using System.Diagnostics.CodeAnalysis;
+#if !NO_INDEX
+
+using System.Diagnostics.CodeAnalysis;
 
 namespace Test;
 
@@ -153,3 +155,5 @@ public void InsertListAtEndBehavior()
 		Assert.Equal(8_800, result.ElementAt(^1_200));
 	}
 }
+
+#endif
diff --git a/Tests/SuperLinq.Test/LagTest.cs b/Tests/SuperLinq.Test/LagTest.cs
index d594041b..594c1bc7 100644
--- a/Tests/SuperLinq.Test/LagTest.cs
+++ b/Tests/SuperLinq.Test/LagTest.cs
@@ -1,4 +1,4 @@
-namespace Test;
+namespace Test;
 
 /// <summary>
 /// Verify the behavior of the Lag operator
@@ -161,6 +161,8 @@ public void LagListBehavior()
 
 		Assert.Equal((10, 0), result.ElementAt(10));
 		Assert.Equal((50, 30), result.ElementAt(50));
+#if !NO_INDEX
 		Assert.Equal((9_950, 9_930), result.ElementAt(^50));
+#endif
 	}
 }
diff --git a/Tests/SuperLinq.Test/LastIndexOfTest.cs b/Tests/SuperLinq.Test/LastIndexOfTest.cs
index 5263d03a..db92bc03 100644
--- a/Tests/SuperLinq.Test/LastIndexOfTest.cs
+++ b/Tests/SuperLinq.Test/LastIndexOfTest.cs
@@ -1,4 +1,6 @@
-namespace Test;
+#if !NO_INDEX
+
+namespace Test;
 
 public sealed class LastIndexOfTest
 {
@@ -108,3 +110,5 @@ public void LastIndexOfMissingValueFromEndCount()
 			sequence.LastIndexOf(100, ^1, 3));
 	}
 }
+
+#endif
diff --git a/Tests/SuperLinq.Test/LeadTest.cs b/Tests/SuperLinq.Test/LeadTest.cs
index d050ca9a..6fb5e53e 100644
--- a/Tests/SuperLinq.Test/LeadTest.cs
+++ b/Tests/SuperLinq.Test/LeadTest.cs
@@ -1,4 +1,4 @@
-namespace Test;
+namespace Test;
 
 /// <summary>
 /// Verify the behavior of the Lead operator.
@@ -163,7 +163,9 @@ public void LeadListBehavior()
 		result.AssertListElementChecking(10_000);
 
 		Assert.Equal((50, 70), result.ElementAt(50));
+#if !NO_INDEX
 		Assert.Equal((9_950, 9_970), result.ElementAt(^50));
 		Assert.Equal((9_990, 0), result.ElementAt(^10));
+#endif
 	}
 }
diff --git a/Tests/SuperLinq.Test/MoveTest.cs b/Tests/SuperLinq.Test/MoveTest.cs
index 6dca66df..d4b63484 100644
--- a/Tests/SuperLinq.Test/MoveTest.cs
+++ b/Tests/SuperLinq.Test/MoveTest.cs
@@ -1,4 +1,4 @@
-namespace Test;
+namespace Test;
 
 public sealed class MoveTest
 {
@@ -38,8 +38,8 @@ public void Move(int length, int fromIndex, int count, int toIndex)
 
 		var result = test.Move(fromIndex, count, toIndex);
 
-		var slice = source.Take(fromIndex..(fromIndex + count));
-		var exclude = source.Exclude(fromIndex, count);
+		var slice = source.Skip(fromIndex).Take(count);
+		var exclude = source.Take(fromIndex).Concat(source.Skip(fromIndex + count));
 		var expectations = exclude.Take(toIndex).Concat(slice).Concat(exclude.Skip(toIndex));
 		result.AssertSequenceEqual(expectations);
 	}
@@ -67,7 +67,9 @@ public void MoveWithSequenceShorterThanToIndex(int length, int fromIndex, int co
 
 		var result = test.Move(fromIndex, count, toIndex);
 
-		var expectations = source.Exclude(fromIndex, count).Concat(source.Take(fromIndex..(fromIndex + count)));
+		var expectations = source.Take(fromIndex)
+			.Concat(source.Skip(fromIndex + count))
+			.Concat(source.Skip(fromIndex).Take(count));
 		Assert.Equal(expectations, result);
 	}
 
diff --git a/Tests/SuperLinq.Test/NullArgumentTest.cs b/Tests/SuperLinq.Test/NullArgumentTest.cs
index 9e773a36..fba08991 100644
--- a/Tests/SuperLinq.Test/NullArgumentTest.cs
+++ b/Tests/SuperLinq.Test/NullArgumentTest.cs
@@ -1,9 +1,12 @@
 using System.Collections;
 using System.Diagnostics;
+#if NETCOREAPP
 using System.Diagnostics.CodeAnalysis;
+#endif
 using System.Linq.Expressions;
 using System.Reflection;
 using CommunityToolkit.Diagnostics;
+using Debug = System.Diagnostics.Debug;
 
 namespace Test;
 
@@ -231,7 +234,11 @@ public sealed class Dictionary<TKey, TValue> : IDictionary<TKey, TValue>
 			where TKey : notnull
 		{
 			public TValue this[TKey key] { get => throw new NotSupportedException(); set => throw new NotSupportedException(); }
+#if NETCOREAPP
 			public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value) => throw new NotSupportedException();
+#else
+			public bool TryGetValue(TKey key, out TValue value) => throw new NotSupportedException();
+#endif
 			public ICollection<TKey> Keys => throw new NotSupportedException();
 			public ICollection<TValue> Values => throw new NotSupportedException();
 			public int Count => throw new NotSupportedException();
diff --git a/Tests/SuperLinq.Test/PadStartTest.cs b/Tests/SuperLinq.Test/PadStartTest.cs
index 5f36a40e..a3f5925b 100644
--- a/Tests/SuperLinq.Test/PadStartTest.cs
+++ b/Tests/SuperLinq.Test/PadStartTest.cs
@@ -1,4 +1,4 @@
-namespace Test;
+namespace Test;
 
 public sealed class PadStartTest
 {
@@ -54,7 +54,9 @@ public void PadStartWideListBehavior()
 		result.AssertListElementChecking(10_000);
 
 		Assert.Equal(1_200, result.ElementAt(1_200));
+#if !NO_INDEX
 		Assert.Equal(8_800, result.ElementAt(^1_200));
+#endif
 	}
 
 	[Theory]
@@ -116,7 +118,9 @@ public void PadStartNarrowListBehavior()
 
 		Assert.Equal(200, result.ElementAt(1_200));
 		Assert.Equal(1_200, result.ElementAt(31_200));
+#if !NO_INDEX
 		Assert.Equal(8_800, result.ElementAt(^1_200));
+#endif
 	}
 
 	public static IEnumerable<object[]> GetCharSequences() =>
diff --git a/Tests/SuperLinq.Test/PadTest.cs b/Tests/SuperLinq.Test/PadTest.cs
index 4bd4f696..44ab4085 100644
--- a/Tests/SuperLinq.Test/PadTest.cs
+++ b/Tests/SuperLinq.Test/PadTest.cs
@@ -54,7 +54,9 @@ public void PadWideListBehavior()
 		result.AssertListElementChecking(10_000);
 
 		Assert.Equal(1_200, result.ElementAt(1_200));
+#if !NO_INDEX
 		Assert.Equal(8_800, result.ElementAt(^1_200));
+#endif
 	}
 
 	[Theory]
@@ -116,7 +118,9 @@ public void PadNarrowListBehavior()
 
 		Assert.Equal(1_200, result.ElementAt(1_200));
 		Assert.Equal(200, result.ElementAt(11_200));
+#if !NO_INDEX
 		Assert.Equal(800, result.ElementAt(^1_200));
+#endif
 	}
 
 	public static IEnumerable<object[]> GetCharSequences() =>
diff --git a/Tests/SuperLinq.Test/PartialSortTest.cs b/Tests/SuperLinq.Test/PartialSortTest.cs
index ebb03245..6de80f59 100644
--- a/Tests/SuperLinq.Test/PartialSortTest.cs
+++ b/Tests/SuperLinq.Test/PartialSortTest.cs
@@ -1,4 +1,4 @@
-namespace Test;
+namespace Test;
 
 public sealed class PartialSortTests
 {
@@ -7,7 +7,7 @@ public void PartialSort()
 	{
 		using var sequence = Enumerable.Range(1, 10)
 			.Reverse()
-			.Append(0)
+			.Concat([0])
 			.AsTestingSequence();
 
 		sequence
@@ -20,7 +20,7 @@ public void PartialSortWithOrder()
 	{
 		using var sequence = Enumerable.Range(1, 10)
 			.Reverse()
-			.Append(0)
+			.Concat([0])
 			.AsTestingSequence(maxEnumerations: 2);
 
 		sequence
diff --git a/Tests/SuperLinq.Test/PermutationsTest.cs b/Tests/SuperLinq.Test/PermutationsTest.cs
index ce896f4f..946a73c4 100644
--- a/Tests/SuperLinq.Test/PermutationsTest.cs
+++ b/Tests/SuperLinq.Test/PermutationsTest.cs
@@ -1,4 +1,4 @@
-using System.Collections;
+using System.Collections;
 using CommunityToolkit.Diagnostics;
 
 namespace Test;
@@ -37,7 +37,17 @@ public void TestExceptionWhenTooLong(IDisposableEnumerable<int> seq)
 				"sequence",
 				() => seq.Permutations().Consume());
 
+#if NETCOREAPP
 			Assert.Equal("Input set is too large to permute properly. (Parameter 'sequence')", ex.Message);
+#else
+			Assert.Equal(
+				"""
+				Input set is too large to permute properly.
+				Parameter name: sequence
+				""",
+				ex.Message
+			);
+#endif
 		}
 	}
 
diff --git a/Tests/SuperLinq.Test/ReplaceTest.cs b/Tests/SuperLinq.Test/ReplaceTest.cs
index 399ac9a4..567c805b 100644
--- a/Tests/SuperLinq.Test/ReplaceTest.cs
+++ b/Tests/SuperLinq.Test/ReplaceTest.cs
@@ -1,4 +1,6 @@
-namespace Test;
+#if !NO_INDEX
+
+namespace Test;
 
 public sealed class ReplaceTest
 {
@@ -36,7 +38,7 @@ public void ReplaceIntIndex(int index, IDisposableEnumerable<int> seq)
 			var result = seq.Replace(index, 30);
 			result.AssertSequenceEqual(
 				Enumerable.Range(1, index)
-					.Append(30)
+					.Concat([30])
 					.Concat(Enumerable.Range(index + 2, 9 - index)),
 				testCollectionEnumerable: true);
 		}
@@ -50,7 +52,7 @@ public void ReplaceStartIndex(int index, IDisposableEnumerable<int> seq)
 			var result = seq.Replace(new Index(index), 30);
 			result.AssertSequenceEqual(
 				Enumerable.Range(1, index)
-					.Append(30)
+					.Concat([30])
 					.Concat(Enumerable.Range(index + 2, 9 - index)),
 				testCollectionEnumerable: true);
 		}
@@ -65,7 +67,7 @@ public void ReplaceEndIndex(int index, IDisposableEnumerable<int> seq)
 			var result = seq.Replace(^(index + 1), 30);
 			result.AssertSequenceEqual(
 				Enumerable.Range(1, 9 - index)
-					.Append(30)
+					.Concat([30])
 					.Concat(Enumerable.Range(11 - index, index)),
 				testCollectionEnumerable: true);
 		}
@@ -131,7 +133,9 @@ public void ReplaceListBehavior()
 		result.ToList()
 			.AssertSequenceEqual(
 				Enumerable.Range(0, 20)
-					.Append(-1)
+					.Concat([-1])
 					.Concat(Enumerable.Range(21, 9_979)));
 	}
 }
+
+#endif
diff --git a/Tests/SuperLinq.Test/SequenceTest.cs b/Tests/SuperLinq.Test/SequenceTest.cs
index 0869b957..063a3f2f 100644
--- a/Tests/SuperLinq.Test/SequenceTest.cs
+++ b/Tests/SuperLinq.Test/SequenceTest.cs
@@ -1,4 +1,4 @@
-namespace Test;
+namespace Test;
 
 public sealed class SequenceTest
 {
@@ -45,8 +45,8 @@ public void SequenceWithAscendingRange(int start, int stop)
 	{
 		var result = SuperEnumerable.Sequence(start, stop);
 
-		Assert.Equal(start, result.ElementAt(0));
-		Assert.Equal(stop, result.ElementAt(^1));
+		Assert.Equal(start, result.First());
+		Assert.Equal(stop, result.Last());
 		Assert.Equal(stop - start + 1, result.Count());
 
 		result.AssertSequenceEqual(Enumerable.Range(start, stop - start + 1));
@@ -62,8 +62,8 @@ public void SequenceWithDescendingRange(int start, int stop)
 	{
 		var result = SuperEnumerable.Sequence(start, stop);
 
-		Assert.Equal(start, result.ElementAt(0));
-		Assert.Equal(stop, result.ElementAt(^1));
+		Assert.Equal(start, result.First());
+		Assert.Equal(stop, result.Last());
 		Assert.Equal(start - stop + 1, result.Count());
 
 		result.AssertSequenceEqual(Enumerable.Range(stop, start - stop + 1).Reverse());
@@ -174,6 +174,8 @@ public void SequenceListBehavior()
 
 		Assert.Equal(10, result.ElementAt(10));
 		Assert.Equal(20, result.ElementAt(20));
+#if !NO_INDEX
 		Assert.Equal(9_950, result.ElementAt(^50));
+#endif
 	}
 }
diff --git a/Tests/SuperLinq.Test/SplitTest.cs b/Tests/SuperLinq.Test/SplitTest.cs
index de2671e3..46d12363 100644
--- a/Tests/SuperLinq.Test/SplitTest.cs
+++ b/Tests/SuperLinq.Test/SplitTest.cs
@@ -1,4 +1,6 @@
-namespace Test;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Test;
 
 public sealed class SplitTest
 {
@@ -26,6 +28,7 @@ public void SplitWithComparerUptoMaxCount()
 	}
 
 	[Fact]
+	[SuppressMessage("Style", "IDE0305:Simplify collection initialization")]
 	public void SplitWithSeparatorAndResultTransformation()
 	{
 		using var sequence = "the quick brown fox".AsTestingSequence();
@@ -34,6 +37,7 @@ public void SplitWithSeparatorAndResultTransformation()
 	}
 
 	[Fact]
+	[SuppressMessage("Style", "IDE0305:Simplify collection initialization")]
 	public void SplitUptoMaxCount()
 	{
 		using var sequence = "the quick brown fox".AsTestingSequence();
diff --git a/Tests/SuperLinq.Test/SuperLinq.Test.csproj b/Tests/SuperLinq.Test/SuperLinq.Test.csproj
index 1f65093f..7cb8f7c7 100644
--- a/Tests/SuperLinq.Test/SuperLinq.Test.csproj
+++ b/Tests/SuperLinq.Test/SuperLinq.Test.csproj
@@ -3,33 +3,39 @@
   <Import Project="../../TargetFrameworks.props" />
 
   <PropertyGroup>
-    <AssemblyTitle>SuperLinq.Test</AssemblyTitle>
-    <AssemblyName>SuperLinq.Test</AssemblyName>
-    <RootNamespace>Test</RootNamespace>
+	<AssemblyTitle>SuperLinq.Test</AssemblyTitle>
+	<AssemblyName>SuperLinq.Test</AssemblyName>
+	<RootNamespace>Test</RootNamespace>
+	<TargetFrameworks>net47;$(TargetFrameworks)</TargetFrameworks>
 
-    <IsPackable>false</IsPackable>
-    <AnalysisLevel>latest-recommended</AnalysisLevel>
+	<IsPackable>false</IsPackable>
+	<AnalysisLevel>latest-recommended</AnalysisLevel>
   </PropertyGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\..\Source\SuperLinq\SuperLinq.csproj" />
+	<ProjectReference Include="..\..\Source\SuperLinq\SuperLinq.csproj" />
   </ItemGroup>
 
   <ItemGroup>
-    <Using Include="SuperLinq" />
-    <Using Include="Test.FuncModule" Static="true" />
-    <Using Include="Test.TestExtensions" Static="true" />
-    <Using Include="Xunit" />
+	<Using Include="SuperLinq" />
+	<Using Include="Test.FuncModule" Static="true" />
+	<Using Include="Test.TestExtensions" Static="true" />
+	<Using Include="Xunit" />
+	<Using Include="Xunit.Assert" Alias="Assert" />
   </ItemGroup>
 
+  <PropertyGroup Condition="'$(TargetFramework)' == 'net47'">
+	<DefineConstants>$(DefineConstants);NO_INDEX</DefineConstants>
+  </PropertyGroup>
+
   <ItemGroup>
-    <PackageReference Include="CommunityToolkit.Diagnostics" />
-    <PackageReference Include="coverlet.collector" PrivateAssets="All" />
-    <PackageReference Include="coverlet.msbuild" PrivateAssets="All" />
-    <PackageReference Include="GitHubActionsTestLogger" PrivateAssets="All" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" />
-    <PackageReference Include="xunit" />
-    <PackageReference Include="xunit.runner.visualstudio" PrivateAssets="All" />
+	<PackageReference Include="CommunityToolkit.Diagnostics" />
+	<PackageReference Include="coverlet.collector" PrivateAssets="All" />
+	<PackageReference Include="coverlet.msbuild" PrivateAssets="All" />
+	<PackageReference Include="GitHubActionsTestLogger" PrivateAssets="All" />
+	<PackageReference Include="Microsoft.NET.Test.Sdk" />
+	<PackageReference Include="xunit" />
+	<PackageReference Include="xunit.runner.visualstudio" PrivateAssets="All" />
   </ItemGroup>
 
 </Project>
diff --git a/Tests/SuperLinq.Test/TagFirstLastTest.cs b/Tests/SuperLinq.Test/TagFirstLastTest.cs
index edbec2de..ccde80ac 100644
--- a/Tests/SuperLinq.Test/TagFirstLastTest.cs
+++ b/Tests/SuperLinq.Test/TagFirstLastTest.cs
@@ -1,4 +1,4 @@
-namespace Test;
+namespace Test;
 
 public sealed class TagFirstLastTest
 {
@@ -40,6 +40,8 @@ public void TagFirstLastListBehavior()
 
 		Assert.Equal((0, true, false), result.ElementAt(0));
 		Assert.Equal((30, false, false), result.ElementAt(30));
+#if !NO_INDEX
 		Assert.Equal((9_999, false, true), result.ElementAt(^1));
+#endif
 	}
 }
diff --git a/Tests/SuperLinq.Test/TakeTest.cs b/Tests/SuperLinq.Test/TakeTest.cs
index 75f80be0..e2df85d0 100644
--- a/Tests/SuperLinq.Test/TakeTest.cs
+++ b/Tests/SuperLinq.Test/TakeTest.cs
@@ -1,11 +1,12 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+#if !NO_INDEX
+
 namespace Test;
 
 public sealed class TakeTest
 {
-#if !NET60_OR_GREATER
 	[Fact]
 	public void SameResultsRepeatCallsIntQuery()
 	{
@@ -1439,11 +1440,11 @@ public void EmptySourceDoNotThrowExceptionNotList()
 		Assert.Empty(ForceNotCollection(source).Take(3..^8));
 		Assert.Empty(ForceNotCollection(source).Take(^6..^7));
 	}
-
 	private static IEnumerable<T> ForceNotCollection<T>(IEnumerable<T> source)
 	{
 		foreach (var i in source)
 			yield return i;
 	}
-#endif
 }
+
+#endif
diff --git a/Tests/SuperLinq.Test/TestExtensions.cs b/Tests/SuperLinq.Test/TestExtensions.cs
index 9af108d2..ea92c1d2 100644
--- a/Tests/SuperLinq.Test/TestExtensions.cs
+++ b/Tests/SuperLinq.Test/TestExtensions.cs
@@ -1,4 +1,4 @@
-using CommunityToolkit.Diagnostics;
+using CommunityToolkit.Diagnostics;
 
 namespace Test;
 
@@ -17,7 +17,7 @@ public static IEnumerable<int> SeqExceptionAt(int index) =>
 		SuperEnumerable.From(
 			Enumerable.Range(1, index - 1)
 				.Select(i => Func(() => i))
-				.Append(BreakingFunc.Of<int>())
+				.Concat([BreakingFunc.Of<int>()])
 				.ToArray());
 	#endregion
 
@@ -80,7 +80,7 @@ internal static void AssertCollectionErrorChecking<T>(this IEnumerable<T> result
 			"arrayIndex",
 			() => coll.CopyTo(array, length + 1));
 
-		Assert.True(array.All(x => EqualityComparer<T>.Default.Equals(x, default)));
+		Assert.True(array.All(x => EqualityComparer<T>.Default.Equals(x, default!)));
 	}
 
 	internal static void AssertListElementChecking<T>(this IEnumerable<T> result, int length)
diff --git a/Tests/SuperLinq.Test/ToArrayByIndexTest.cs b/Tests/SuperLinq.Test/ToArrayByIndexTest.cs
index 09fc8d07..90483f0c 100644
--- a/Tests/SuperLinq.Test/ToArrayByIndexTest.cs
+++ b/Tests/SuperLinq.Test/ToArrayByIndexTest.cs
@@ -31,9 +31,9 @@ public void ToArrayByIndex(bool withLength, int[] indices)
 			: input.ToArrayByIndex(e => e.Index).ToList();
 
 		var maxLength = withLength ? 10 : indices.DefaultIfEmpty(-1).Max() + 1;
-		var expected = Enumerable.Repeat(default(int?), maxLength);
+		var expected = new int?[maxLength];
 		foreach (var i in indices)
-			expected = expected.Replace(i, i);
+			expected[i] = i;
 
 		result.AssertSequenceEqual(
 			expected.Select(x => x is null ? null : new { Index = x.Value }));
diff --git a/Tests/SuperLinq.Test/ToDictionaryTest.cs b/Tests/SuperLinq.Test/ToDictionaryTest.cs
index 76322485..202a1340 100644
--- a/Tests/SuperLinq.Test/ToDictionaryTest.cs
+++ b/Tests/SuperLinq.Test/ToDictionaryTest.cs
@@ -7,9 +7,9 @@ public sealed class ToDictionaryTest
 	public void ToDictionaryWithKeyValuePairs()
 	{
 		using var pairs = TestingSequence.Of(
-			KeyValuePair.Create("foo", 123),
-			KeyValuePair.Create("bar", 456),
-			KeyValuePair.Create("baz", 789));
+			CreatePair("foo", 123),
+			CreatePair("bar", 456),
+			CreatePair("baz", 789));
 
 		var dict = SuperEnumerable.ToDictionary(pairs);
 
@@ -37,9 +37,9 @@ public void ToDictionaryWithCouples()
 	public void ToDictionaryWithKeyValuePairsWithComparer()
 	{
 		using var pairs = TestingSequence.Of(
-			KeyValuePair.Create("foo", 123),
-			KeyValuePair.Create("bar", 456),
-			KeyValuePair.Create("baz", 789));
+			CreatePair("foo", 123),
+			CreatePair("bar", 456),
+			CreatePair("baz", 789));
 
 		var dict = SuperEnumerable.ToDictionary(pairs, StringComparer.OrdinalIgnoreCase);
 
@@ -62,4 +62,6 @@ public void ToDictionaryWithCouplesWithComparer()
 		Assert.Equal(456, dict["BAR"]);
 		Assert.Equal(789, dict["BAZ"]);
 	}
+
+	private static KeyValuePair<TKey, TValue> CreatePair<TKey, TValue>(TKey key, TValue value) => new(key, value);
 }
diff --git a/Tests/SuperLinq.Test/ToLookupTest.cs b/Tests/SuperLinq.Test/ToLookupTest.cs
index ecfaa66d..91c6bc1a 100644
--- a/Tests/SuperLinq.Test/ToLookupTest.cs
+++ b/Tests/SuperLinq.Test/ToLookupTest.cs
@@ -7,12 +7,12 @@ public void ToLookupWithKeyValuePairs()
 	{
 		var pairs = new[]
 		{
-				KeyValuePair.Create("foo", 1),
-				KeyValuePair.Create("bar", 3),
-				KeyValuePair.Create("baz", 4),
-				KeyValuePair.Create("foo", 2),
-				KeyValuePair.Create("baz", 5),
-				KeyValuePair.Create("baz", 6),
+				CreatePair("foo", 1),
+				CreatePair("bar", 3),
+				CreatePair("baz", 4),
+				CreatePair("foo", 2),
+				CreatePair("baz", 5),
+				CreatePair("baz", 6),
 			};
 
 		var dict = pairs.ToLookup();
@@ -49,12 +49,12 @@ public void ToLookupWithKeyValuePairsWithComparer()
 	{
 		var pairs = new[]
 		{
-				KeyValuePair.Create("foo", 1),
-				KeyValuePair.Create("bar", 3),
-				KeyValuePair.Create("baz", 4),
-				KeyValuePair.Create("foo", 2),
-				KeyValuePair.Create("baz", 5),
-				KeyValuePair.Create("baz", 6),
+				CreatePair("foo", 1),
+				CreatePair("bar", 3),
+				CreatePair("baz", 4),
+				CreatePair("foo", 2),
+				CreatePair("baz", 5),
+				CreatePair("baz", 6),
 			};
 
 		var dict = pairs.ToLookup(StringComparer.OrdinalIgnoreCase);
@@ -85,4 +85,6 @@ public void ToLookupWithCouplesWithComparer()
 		Assert.Equal([3], dict["BAR"]);
 		Assert.Equal([4, 5, 6], dict["BAZ"]);
 	}
+
+	private static KeyValuePair<TKey, TValue> CreatePair<TKey, TValue>(TKey key, TValue value) => new(key, value);
 }
diff --git a/Tests/SuperLinq.Test/ValueTupleEqualityComparerTest.cs b/Tests/SuperLinq.Test/ValueTupleEqualityComparerTest.cs
index dfe53ba6..23c6e862 100644
--- a/Tests/SuperLinq.Test/ValueTupleEqualityComparerTest.cs
+++ b/Tests/SuperLinq.Test/ValueTupleEqualityComparerTest.cs
@@ -1,4 +1,6 @@
+#if NETCOREAPP
 using System.Diagnostics.CodeAnalysis;
+#endif
 
 namespace Test;
 
@@ -8,7 +10,11 @@ private sealed record TestObject(string Value);
 	private sealed class TestComparer<T>(Func<T?, T?, bool> comparer) : IEqualityComparer<T>
 	{
 		public bool Equals(T? x, T? y) => comparer(x, y);
+#if NETCOREAPP
 		public int GetHashCode([DisallowNull] T obj) => obj.GetHashCode();
+#else
+		public int GetHashCode(T obj) => obj!.GetHashCode();
+#endif
 	}
 
 	[Fact]
diff --git a/Tests/SuperLinq.Test/WindowLeftTest.cs b/Tests/SuperLinq.Test/WindowLeftTest.cs
index 7cb1f78e..518542bf 100644
--- a/Tests/SuperLinq.Test/WindowLeftTest.cs
+++ b/Tests/SuperLinq.Test/WindowLeftTest.cs
@@ -185,6 +185,8 @@ public void WindowLeftListBehavior()
 		result.AssertListElementChecking(10_000);
 
 		Assert.Equal(Enumerable.Range(50, 20), result.ElementAt(50));
+#if !NO_INDEX
 		Assert.Equal(Enumerable.Range(9_999, 1), result.ElementAt(^1));
+#endif
 	}
 }
diff --git a/Tests/SuperLinq.Test/WindowRightTest.cs b/Tests/SuperLinq.Test/WindowRightTest.cs
index 2d0a0ecc..746f26b3 100644
--- a/Tests/SuperLinq.Test/WindowRightTest.cs
+++ b/Tests/SuperLinq.Test/WindowRightTest.cs
@@ -189,6 +189,8 @@ public void WindowRightListBehavior()
 		result.AssertListElementChecking(10_000);
 
 		Assert.Equal(Enumerable.Range(0, 10), result.ElementAt(10));
+#if !NO_INDEX
 		Assert.Equal(Enumerable.Range(9_980, 20), result.ElementAt(^1));
+#endif
 	}
 }
diff --git a/Tests/SuperLinq.Test/WindowTest.cs b/Tests/SuperLinq.Test/WindowTest.cs
index f2469900..d2a253f4 100644
--- a/Tests/SuperLinq.Test/WindowTest.cs
+++ b/Tests/SuperLinq.Test/WindowTest.cs
@@ -186,6 +186,8 @@ public void WindowListBehavior()
 		result.AssertListElementChecking(length);
 
 		Assert.Equal(Enumerable.Range(50, 20), result.ElementAt(50));
+#if !NO_INDEX
 		Assert.Equal(Enumerable.Range(9_980, 20), result.ElementAt(^1));
+#endif
 	}
 }
diff --git a/Tests/SuperLinq.Test/ZipLongestTest.cs b/Tests/SuperLinq.Test/ZipLongestTest.cs
index 47e6d23e..ac7b9a2c 100644
--- a/Tests/SuperLinq.Test/ZipLongestTest.cs
+++ b/Tests/SuperLinq.Test/ZipLongestTest.cs
@@ -1,4 +1,4 @@
-namespace Test;
+namespace Test;
 public sealed class ZipLongestTest
 {
 	[Fact]
@@ -54,9 +54,12 @@ public void TwoParamsWorksProperly(IEnumerable<int> seq1, IEnumerable<int> seq2,
 			result.AssertSequenceEqual(
 				Enumerable.Range(1, 2)
 					.Select(x => (x, x))
-					.Append((
-						shortSeq == 0 ? 0 : 3,
-						shortSeq == 1 ? 0 : 3)));
+					.Concat([
+						(
+							shortSeq == 0 ? 0 : 3,
+							shortSeq == 1 ? 0 : 3
+						),
+					]));
 		}
 	}
 
@@ -72,13 +75,17 @@ public void TwoParamsListBehavior()
 
 		Assert.Equal((10, 10), result.ElementAt(10));
 		Assert.Equal((50, 50), result.ElementAt(50));
+#if !NO_INDEX
 		Assert.Equal((9_950, 0), result.ElementAt(^50));
+#endif
 
 		result = seq2.ZipLongest(seq1);
 		result.AssertCollectionErrorChecking(10_000);
 		result.AssertListElementChecking(10_000);
 
+#if !NO_INDEX
 		Assert.Equal((0, 9_950), result.ElementAt(^50));
+#endif
 	}
 
 	[Fact]
@@ -163,10 +170,13 @@ public void ThreeParamsWorksProperly(IEnumerable<int> seq1, IEnumerable<int> seq
 			result.AssertSequenceEqual(
 				Enumerable.Range(1, 2)
 					.Select(x => (x, x, x))
-					.Append((
-						shortSeq == 0 ? 0 : 3,
-						shortSeq == 1 ? 0 : 3,
-						shortSeq == 2 ? 0 : 3)));
+					.Concat([
+						(
+							shortSeq == 0 ? 0 : 3,
+							shortSeq == 1 ? 0 : 3,
+							shortSeq == 2 ? 0 : 3
+						),
+					]));
 		}
 	}
 
@@ -183,13 +193,16 @@ public void ThreeParamsListBehavior()
 
 		Assert.Equal((10, 10, 10), result.ElementAt(10));
 		Assert.Equal((50, 50, 50), result.ElementAt(50));
+#if !NO_INDEX
 		Assert.Equal((9_950, 0, 0), result.ElementAt(^50));
-
+#endif
 		result = seq2.ZipLongest(seq1, seq3);
 		result.AssertCollectionErrorChecking(10_000);
 		result.AssertListElementChecking(10_000);
 
+#if !NO_INDEX
 		Assert.Equal((0, 9_950, 0), result.ElementAt(^50));
+#endif
 	}
 
 	[Fact]
@@ -291,11 +304,14 @@ public void FourParamsWorksProperly(IEnumerable<int> seq1, IEnumerable<int> seq2
 			result.AssertSequenceEqual(
 				Enumerable.Range(1, 2)
 					.Select(x => (x, x, x, x))
-					.Append((
-						shortSeq == 0 ? 0 : 3,
-						shortSeq == 1 ? 0 : 3,
-						shortSeq == 2 ? 0 : 3,
-						shortSeq == 3 ? 0 : 3)));
+					.Concat([
+						(
+							shortSeq == 0 ? 0 : 3,
+							shortSeq == 1 ? 0 : 3,
+							shortSeq == 2 ? 0 : 3,
+							shortSeq == 3 ? 0 : 3
+						),
+					]));
 		}
 	}
 
@@ -313,12 +329,16 @@ public void FourParamsListBehavior()
 
 		Assert.Equal((10, 10, 10, 10), result.ElementAt(10));
 		Assert.Equal((50, 50, 50, 50), result.ElementAt(50));
+#if !NO_INDEX
 		Assert.Equal((9_950, 0, 0, 0), result.ElementAt(^50));
+#endif
 
 		result = seq2.ZipLongest(seq1, seq3, seq4);
 		result.AssertCollectionErrorChecking(10_000);
 		result.AssertListElementChecking(10_000);
 
+#if !NO_INDEX
 		Assert.Equal((0, 9_950, 0, 0), result.ElementAt(^50));
+#endif
 	}
 }
diff --git a/Tests/SuperLinq.Test/ZipMapTest.cs b/Tests/SuperLinq.Test/ZipMapTest.cs
index 52e49482..8e2ceb0a 100644
--- a/Tests/SuperLinq.Test/ZipMapTest.cs
+++ b/Tests/SuperLinq.Test/ZipMapTest.cs
@@ -71,7 +71,9 @@ public void ZipMapListBehavior()
 		result.AssertListElementChecking(10_000);
 
 		Assert.Equal((20, 30), result.ElementAt(20));
+#if !NO_INDEX
 		Assert.Equal((9_980, 9_990), result.ElementAt(^20));
+#endif
 	}
 
 	[Fact]
diff --git a/Tests/SuperLinq.Test/ZipShortestTest.cs b/Tests/SuperLinq.Test/ZipShortestTest.cs
index f5397881..822f4e93 100644
--- a/Tests/SuperLinq.Test/ZipShortestTest.cs
+++ b/Tests/SuperLinq.Test/ZipShortestTest.cs
@@ -1,4 +1,4 @@
-namespace Test;
+namespace Test;
 public sealed class ZipShortestTest
 {
 	[Fact]
@@ -97,13 +97,17 @@ public void TwoParamsListBehavior()
 
 		Assert.Equal((10, 10), result.ElementAt(10));
 		Assert.Equal((50, 50), result.ElementAt(50));
+#if !NO_INDEX
 		Assert.Equal((4_950, 4_950), result.ElementAt(^50));
+#endif
 
 		result = seq2.ZipShortest(seq1);
 		result.AssertCollectionErrorChecking(5_000);
 		result.AssertListElementChecking(5_000);
 
+#if !NO_INDEX
 		Assert.Equal((4_950, 4_950), result.ElementAt(^50));
+#endif
 	}
 
 	[Fact]
@@ -204,13 +208,17 @@ public void ThreeParamsListBehavior()
 
 		Assert.Equal((10, 10, 10), result.ElementAt(10));
 		Assert.Equal((50, 50, 50), result.ElementAt(50));
+#if !NO_INDEX
 		Assert.Equal((4_950, 4_950, 4_950), result.ElementAt(^50));
+#endif
 
 		result = seq2.ZipShortest(seq1, seq3);
 		result.AssertCollectionErrorChecking(5_000);
 		result.AssertListElementChecking(5_000);
 
+#if !NO_INDEX
 		Assert.Equal((4_950, 4_950, 4_950), result.ElementAt(^50));
+#endif
 	}
 
 	[Fact]
@@ -329,12 +337,16 @@ public void FourParamsListBehavior()
 
 		Assert.Equal((10, 10, 10, 10), result.ElementAt(10));
 		Assert.Equal((50, 50, 50, 50), result.ElementAt(50));
+#if !NO_INDEX
 		Assert.Equal((4_950, 4_950, 4_950, 4_950), result.ElementAt(^50));
+#endif
 
 		result = seq2.ZipShortest(seq1, seq3, seq4);
 		result.AssertCollectionErrorChecking(5_000);
 		result.AssertListElementChecking(5_000);
 
+#if !NO_INDEX
 		Assert.Equal((4_950, 4_950, 4_950, 4_950), result.ElementAt(^50));
+#endif
 	}
 }