using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.ExceptionServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.6.2", FrameworkDisplayName = ".NET Framework 4.6.2")]
[assembly: AssemblyMetadata("Serviceable", "True")]
[assembly: AssemblyMetadata("PreferInbox", "True")]
[assembly: AssemblyDefaultAlias("Microsoft.Bcl.AsyncInterfaces")]
[assembly: CLSCompliant(true)]
[assembly: AssemblyMetadata("IsTrimmable", "True")]
[assembly: AssemblyMetadata("IsAotCompatible", "True")]
[assembly: DefaultDllImportSearchPaths(DllImportSearchPath.System32 | DllImportSearchPath.AssemblyDirectory)]
[assembly: AssemblyCompany("Microsoft Corporation")]
[assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")]
[assembly: AssemblyDescription("Provides the IAsyncEnumerable<T> and IAsyncDisposable interfaces and helper types for .NET Standard 2.0. This package is not required starting with .NET Standard 2.1 and .NET Core 3.0.")]
[assembly: AssemblyFileVersion("10.0.1126.37416")]
[assembly: AssemblyInformationalVersion("10.0.11+e2f47b0110ed922f21a1522da67279133ce28f32")]
[assembly: AssemblyProduct("Microsoft® .NET")]
[assembly: AssemblyTitle("Microsoft.Bcl.AsyncInterfaces")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/dotnet")]
[assembly: AssemblyVersion("10.0.0.11")]
[module: RefSafetyRules(11)]
[module: NullablePublicOnly(false)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class NullablePublicOnlyAttribute : Attribute
	{
		public readonly bool IncludesInternals;

		public NullablePublicOnlyAttribute(bool P_0)
		{
			IncludesInternals = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class ExtensionMarkerAttribute : Attribute
	{
		public ExtensionMarkerAttribute(string name)
		{
		}
	}
}
namespace System
{
	public interface IAsyncDisposable
	{
		ValueTask DisposeAsync();
	}
	internal static class ExceptionPolyfills
	{
		[SpecialName]
		public sealed class <G>$E6188BA5B951F1F7AA9135E0EBB76F2B
		{
			[SpecialName]
			public static class <M>$96F0261AC622664B8B003966835C0332
			{
			}

			[ExtensionMarker("<M>$96F0261AC622664B8B003966835C0332")]
			public static void ThrowIfNull([NotNull] object argument, [CallerArgumentExpression("argument")] string paramName = null)
			{
				throw null;
			}
		}

		[SpecialName]
		public sealed class <G>$3F30F31B33543D5FB8E174FB4FD780B9
		{
			[SpecialName]
			public static class <M>$1F10CFA08738E6D8AF61CBECC6763DBC
			{
			}

			[ExtensionMarker("<M>$1F10CFA08738E6D8AF61CBECC6763DBC")]
			public static void ThrowIf([DoesNotReturnIf(true)] bool condition, object instance)
			{
				throw null;
			}

			[ExtensionMarker("<M>$1F10CFA08738E6D8AF61CBECC6763DBC")]
			public static void ThrowIf([DoesNotReturnIf(true)] bool condition, Type type)
			{
				throw null;
			}
		}

		public static void ThrowIfNull([NotNull] object argument, [CallerArgumentExpression("argument")] string paramName = null)
		{
			if (argument == null)
			{
				ThrowArgumentNullException(paramName);
			}
		}

		[DoesNotReturn]
		private static void ThrowArgumentNullException(string paramName)
		{
			throw new ArgumentNullException(paramName);
		}

		public static void ThrowIf([DoesNotReturnIf(true)] bool condition, object instance)
		{
			if (condition)
			{
				ThrowObjectDisposedException(instance);
			}
		}

		public static void ThrowIf([DoesNotReturnIf(true)] bool condition, Type type)
		{
			if (condition)
			{
				ThrowObjectDisposedException(type);
			}
		}

		[DoesNotReturn]
		private static void ThrowObjectDisposedException(object instance)
		{
			throw new ObjectDisposedException(instance?.GetType().FullName);
		}

		[DoesNotReturn]
		private static void ThrowObjectDisposedException(Type type)
		{
			throw new ObjectDisposedException(type?.FullName);
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	internal sealed class AllowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	internal sealed class DisallowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	internal sealed class MaybeNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	internal sealed class NotNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class MaybeNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public MaybeNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class NotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public NotNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
	internal sealed class NotNullIfNotNullAttribute : Attribute
	{
		public string ParameterName { get; }

		public NotNullIfNotNullAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	internal sealed class DoesNotReturnAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class DoesNotReturnIfAttribute : Attribute
	{
		public bool ParameterValue { get; }

		public DoesNotReturnIfAttribute(bool parameterValue)
		{
			ParameterValue = parameterValue;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
}
namespace System.Collections.Generic
{
	public interface IAsyncEnumerable<out T>
	{
		IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken));
	}
	public interface IAsyncEnumerator<out T> : IAsyncDisposable
	{
		T Current { get; }

		ValueTask<bool> MoveNextAsync();
	}
}
namespace System.Runtime.InteropServices
{
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	internal sealed class LibraryImportAttribute : Attribute
	{
		public string LibraryName { get; }

		public string EntryPoint { get; set; }

		public StringMarshalling StringMarshalling { get; set; }

		public Type StringMarshallingCustomType { get; set; }

		public bool SetLastError { get; set; }

		public LibraryImportAttribute(string libraryName)
		{
			LibraryName = libraryName;
		}
	}
	internal enum StringMarshalling
	{
		Custom,
		Utf8,
		Utf16
	}
}
namespace System.Runtime.CompilerServices
{
	[StructLayout(LayoutKind.Auto)]
	public struct AsyncIteratorMethodBuilder
	{
		private AsyncTaskMethodBuilder _methodBuilder;

		private object _id;

		internal object ObjectIdForDebugger => _id ?? Interlocked.CompareExchange(ref _id, new object(), null) ?? _id;

		public static AsyncIteratorMethodBuilder Create()
		{
			return new AsyncIteratorMethodBuilder
			{
				_methodBuilder = AsyncTaskMethodBuilder.Create()
			};
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void MoveNext<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
		{
			_methodBuilder.Start(ref stateMachine);
		}

		public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			_methodBuilder.AwaitOnCompleted(ref awaiter, ref stateMachine);
		}

		public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			_methodBuilder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);
		}

		public void Complete()
		{
			_methodBuilder.SetResult();
		}
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = false)]
	public sealed class AsyncIteratorStateMachineAttribute : StateMachineAttribute
	{
		public AsyncIteratorStateMachineAttribute(Type stateMachineType)
			: base(stateMachineType)
		{
		}
	}
	[StructLayout(LayoutKind.Auto)]
	public readonly struct ConfiguredAsyncDisposable
	{
		private readonly IAsyncDisposable _source;

		private readonly bool _continueOnCapturedContext;

		internal ConfiguredAsyncDisposable(IAsyncDisposable source, bool continueOnCapturedContext)
		{
			_source = source;
			_continueOnCapturedContext = continueOnCapturedContext;
		}

		public ConfiguredValueTaskAwaitable DisposeAsync()
		{
			return _source.DisposeAsync().ConfigureAwait(_continueOnCapturedContext);
		}
	}
	[StructLayout(LayoutKind.Auto)]
	public readonly struct ConfiguredCancelableAsyncEnumerable<T>
	{
		[StructLayout(LayoutKind.Auto)]
		public readonly struct Enumerator
		{
			private readonly IAsyncEnumerator<T> _enumerator;

			private readonly bool _continueOnCapturedContext;

			public T Current => _enumerator.Current;

			internal Enumerator(IAsyncEnumerator<T> enumerator, bool continueOnCapturedContext)
			{
				_enumerator = enumerator;
				_continueOnCapturedContext = continueOnCapturedContext;
			}

			public ConfiguredValueTaskAwaitable<bool> MoveNextAsync()
			{
				return _enumerator.MoveNextAsync().ConfigureAwait(_continueOnCapturedContext);
			}

			public ConfiguredValueTaskAwaitable DisposeAsync()
			{
				return _enumerator.DisposeAsync().ConfigureAwait(_continueOnCapturedContext);
			}
		}

		private readonly IAsyncEnumerable<T> _enumerable;

		private readonly CancellationToken _cancellationToken;

		private readonly bool _continueOnCapturedContext;

		internal ConfiguredCancelableAsyncEnumerable(IAsyncEnumerable<T> enumerable, bool continueOnCapturedContext, CancellationToken cancellationToken)
		{
			_enumerable = enumerable;
			_continueOnCapturedContext = continueOnCapturedContext;
			_cancellationToken = cancellationToken;
		}

		public ConfiguredCancelableAsyncEnumerable<T> ConfigureAwait(bool continueOnCapturedContext)
		{
			return new ConfiguredCancelableAsyncEnumerable<T>(_enumerable, continueOnCapturedContext, _cancellationToken);
		}

		public ConfiguredCancelableAsyncEnumerable<T> WithCancellation(CancellationToken cancellationToken)
		{
			return new ConfiguredCancelableAsyncEnumerable<T>(_enumerable, _continueOnCapturedContext, cancellationToken);
		}

		public Enumerator GetAsyncEnumerator()
		{
			return new Enumerator(_enumerable.GetAsyncEnumerator(_cancellationToken), _continueOnCapturedContext);
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	public sealed class EnumeratorCancellationAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	internal sealed class CallerArgumentExpressionAttribute : Attribute
	{
		public string ParameterName { get; }

		public CallerArgumentExpressionAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
}
namespace System.Threading.Tasks
{
	public static class TaskAsyncEnumerableExtensions
	{
		public static ConfiguredAsyncDisposable ConfigureAwait(this IAsyncDisposable source, bool continueOnCapturedContext)
		{
			return new ConfiguredAsyncDisposable(source, continueOnCapturedContext);
		}

		public static ConfiguredCancelableAsyncEnumerable<T> ConfigureAwait<T>(this IAsyncEnumerable<T> source, bool continueOnCapturedContext)
		{
			return new ConfiguredCancelableAsyncEnumerable<T>(source, continueOnCapturedContext, default(CancellationToken));
		}

		public static ConfiguredCancelableAsyncEnumerable<T> WithCancellation<T>(this IAsyncEnumerable<T> source, CancellationToken cancellationToken)
		{
			return new ConfiguredCancelableAsyncEnumerable<T>(source, continueOnCapturedContext: true, cancellationToken);
		}
	}
}
namespace System.Threading.Tasks.Sources
{
	[StructLayout(LayoutKind.Auto)]
	public struct ManualResetValueTaskSourceCore<TResult>
	{
		private Action<object> _continuation;

		private object _continuationState;

		private ExecutionContext _executionContext;

		private object _capturedContext;

		private bool _completed;

		private TResult _result;

		private ExceptionDispatchInfo _error;

		private short _version;

		public bool RunContinuationsAsynchronously { get; set; }

		public short Version => _version;

		public void Reset()
		{
			_version++;
			_completed = false;
			_result = default(TResult);
			_error = null;
			_executionContext = null;
			_capturedContext = null;
			_continuation = null;
			_continuationState = null;
		}

		public void SetResult(TResult result)
		{
			_result = result;
			SignalCompletion();
		}

		public void SetException(Exception error)
		{
			_error = ExceptionDispatchInfo.Capture(error);
			SignalCompletion();
		}

		public ValueTaskSourceStatus GetStatus(short token)
		{
			ValidateToken(token);
			if (_continuation != null && _completed)
			{
				if (_error != null)
				{
					if (!(_error.SourceException is OperationCanceledException))
					{
						return ValueTaskSourceStatus.Faulted;
					}
					return ValueTaskSourceStatus.Canceled;
				}
				return ValueTaskSourceStatus.Succeeded;
			}
			return ValueTaskSourceStatus.Pending;
		}

		public TResult GetResult(short token)
		{
			ValidateToken(token);
			if (!_completed)
			{
				throw new InvalidOperationException();
			}
			_error?.Throw();
			return _result;
		}

		public void OnCompleted(Action<object?> continuation, object? state, short token, ValueTaskSourceOnCompletedFlags flags)
		{
			ExceptionPolyfills.ThrowIfNull(continuation, "continuation");
			ValidateToken(token);
			if ((flags & ValueTaskSourceOnCompletedFlags.FlowExecutionContext) != ValueTaskSourceOnCompletedFlags.None)
			{
				_executionContext = ExecutionContext.Capture();
			}
			if ((flags & ValueTaskSourceOnCompletedFlags.UseSchedulingContext) != ValueTaskSourceOnCompletedFlags.None)
			{
				SynchronizationContext current = SynchronizationContext.Current;
				if (current != null && current.GetType() != typeof(SynchronizationContext))
				{
					_capturedContext = current;
				}
				else
				{
					TaskScheduler current2 = TaskScheduler.Current;
					if (current2 != TaskScheduler.Default)
					{
						_capturedContext = current2;
					}
				}
			}
			object obj = _continuation;
			if (obj == null)
			{
				_continuationState = state;
				obj = Interlocked.CompareExchange(ref _continuation, continuation, null);
			}
			if (obj == null)
			{
				return;
			}
			if (obj != System.Threading.Tasks.Sources.ManualResetValueTaskSourceCoreShared.s_sentinel)
			{
				throw new InvalidOperationException();
			}
			object capturedContext = _capturedContext;
			if (capturedContext != null)
			{
				if (!(capturedContext is SynchronizationContext synchronizationContext))
				{
					if (capturedContext is TaskScheduler scheduler)
					{
						Task.Factory.StartNew(continuation, state, CancellationToken.None, TaskCreationOptions.DenyChildAttach, scheduler);
					}
				}
				else
				{
					synchronizationContext.Post(delegate(object s)
					{
						Tuple<Action<object>, object> tuple = (Tuple<Action<object>, object>)s;
						tuple.Item1(tuple.Item2);
					}, Tuple.Create(continuation, state));
				}
			}
			else
			{
				Task.Factory.StartNew(continuation, state, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
			}
		}

		private void ValidateToken(short token)
		{
			if (token != _version)
			{
				throw new InvalidOperationException();
			}
		}

		private void SignalCompletion()
		{
			if (_completed)
			{
				throw new InvalidOperationException();
			}
			_completed = true;
			if (_continuation == null && Interlocked.CompareExchange(ref _continuation, System.Threading.Tasks.Sources.ManualResetValueTaskSourceCoreShared.s_sentinel, null) == null)
			{
				return;
			}
			if (_executionContext != null)
			{
				ExecutionContext.Run(_executionContext, delegate(object s)
				{
					((ManualResetValueTaskSourceCore<TResult>)s).InvokeContinuation();
				}, this);
			}
			else
			{
				InvokeContinuation();
			}
		}

		private void InvokeContinuation()
		{
			object capturedContext = _capturedContext;
			if (capturedContext != null)
			{
				if (!(capturedContext is SynchronizationContext synchronizationContext))
				{
					if (capturedContext is TaskScheduler scheduler)
					{
						Task.Factory.StartNew(_continuation, _continuationState, CancellationToken.None, TaskCreationOptions.DenyChildAttach, scheduler);
					}
				}
				else
				{
					synchronizationContext.Post(delegate(object s)
					{
						Tuple<Action<object>, object> tuple = (Tuple<Action<object>, object>)s;
						tuple.Item1(tuple.Item2);
					}, Tuple.Create(_continuation, _continuationState));
				}
			}
			else if (RunContinuationsAsynchronously)
			{
				Task.Factory.StartNew(_continuation, _continuationState, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
			}
			else
			{
				_continuation(_continuationState);
			}
		}
	}
	internal static class ManualResetValueTaskSourceCoreShared
	{
		internal static readonly Action<object> s_sentinel = CompletionSentinel;

		private static void CompletionSentinel(object _)
		{
			throw new InvalidOperationException();
		}
	}
}

using System;
using System.Buffers;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Threading.Tasks.Sources;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Linq;
using SoundCloudExplode.Bridge;
using SoundCloudExplode.Common;
using SoundCloudExplode.Exceptions;
using SoundCloudExplode.Playlists;
using SoundCloudExplode.Search;
using SoundCloudExplode.Tracks;
using SoundCloudExplode.Users;
using SoundCloudExplode.Utils;
using SoundCloudExplode.Utils.Extensions;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("Jerro")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyCopyright("Copyright (C) Jerry Berry")]
[assembly: AssemblyDescription("Library that provides an interface to query metadata of SoundCloud tracks and playlists, as well as to resolve and download audio.")]
[assembly: AssemblyFileVersion("0.0.0.0")]
[assembly: AssemblyInformationalVersion("0.0.0-dev+034b0495b31081f77ec3dfd71aaa3668ea48e5bf")]
[assembly: AssemblyProduct("SoundCloudExplode")]
[assembly: AssemblyTitle("SoundCloudExplode")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/modestimpala/SoundCloudExplode")]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsByRefLikeAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
[ExcludeFromCodeCoverage]
internal static class PolyfillExtensions
{
	public static async Task<Stream> GetStreamAsync(this HttpClient httpClient, string requestUri, CancellationToken cancellationToken = default(CancellationToken))
	{
		try
		{
			HttpResponseMessage response = await httpClient.GetAsync(requestUri, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			response.EnsureSuccessStatusCode();
			return await ReadAsStreamAsync(response.Content, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
		}
		catch (OperationCanceledException ex) when (ex.CancellationToken != cancellationToken && cancellationToken.IsCancellationRequested)
		{
			throw new OperationCanceledException(ex.Message, ex.InnerException, cancellationToken);
		}
	}

	public static async Task<Stream> GetStreamAsync(this HttpClient httpClient, Uri requestUri, CancellationToken cancellationToken = default(CancellationToken))
	{
		return await GetStreamAsync(httpClient, requestUri.ToString(), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
	}

	public static async Task<byte[]> GetByteArrayAsync(this HttpClient httpClient, string requestUri, CancellationToken cancellationToken = default(CancellationToken))
	{
		try
		{
			using HttpResponseMessage response = await httpClient.GetAsync(requestUri, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			response.EnsureSuccessStatusCode();
			return await ReadAsByteArrayAsync(response.Content, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
		}
		catch (OperationCanceledException ex) when (ex.CancellationToken != cancellationToken && cancellationToken.IsCancellationRequested)
		{
			throw new OperationCanceledException(ex.Message, ex.InnerException, cancellationToken);
		}
	}

	public static async Task<byte[]> GetByteArrayAsync(this HttpClient httpClient, Uri requestUri, CancellationToken cancellationToken = default(CancellationToken))
	{
		return await GetByteArrayAsync(httpClient, requestUri.ToString(), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
	}

	public static async Task<string> GetStringAsync(this HttpClient httpClient, string requestUri, CancellationToken cancellationToken = default(CancellationToken))
	{
		try
		{
			using HttpResponseMessage response = await httpClient.GetAsync(requestUri, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			response.EnsureSuccessStatusCode();
			return await ReadAsStringAsync(response.Content, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
		}
		catch (OperationCanceledException ex) when (ex.CancellationToken != cancellationToken && cancellationToken.IsCancellationRequested)
		{
			throw new OperationCanceledException(ex.Message, ex.InnerException, cancellationToken);
		}
	}

	public static async Task<string> GetStringAsync(this HttpClient httpClient, Uri requestUri, CancellationToken cancellationToken = default(CancellationToken))
	{
		return await GetStringAsync(httpClient, requestUri.ToString(), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
	}

	public static async Task<Stream> ReadAsStreamAsync(this HttpContent httpContent, CancellationToken cancellationToken = default(CancellationToken))
	{
		cancellationToken.ThrowIfCancellationRequested();
		return await httpContent.ReadAsStreamAsync().ConfigureAwait(continueOnCapturedContext: false);
	}

	public static async Task<byte[]> ReadAsByteArrayAsync(this HttpContent httpContent, CancellationToken cancellationToken = default(CancellationToken))
	{
		cancellationToken.ThrowIfCancellationRequested();
		return await httpContent.ReadAsByteArrayAsync().ConfigureAwait(continueOnCapturedContext: false);
	}

	public static async Task<string> ReadAsStringAsync(this HttpContent httpContent, CancellationToken cancellationToken = default(CancellationToken))
	{
		cancellationToken.ThrowIfCancellationRequested();
		return await httpContent.ReadAsStringAsync().ConfigureAwait(continueOnCapturedContext: false);
	}

	public static async Task WaitForExitAsync(this Process process, CancellationToken cancellationToken = default(CancellationToken))
	{
		TaskCompletionSource<object?> tcs = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
		try
		{
			process.EnableRaisingEvents = true;
		}
		catch when (process.HasExited)
		{
			return;
		}
		process.Exited += HandleExited;
		try
		{
			using (cancellationToken.Register(delegate
			{
				tcs.TrySetCanceled(cancellationToken);
			}))
			{
				await tcs.Task;
			}
		}
		finally
		{
			process.Exited -= HandleExited;
		}
		void HandleExited(object? sender, EventArgs args)
		{
			tcs.TrySetResult(null);
		}
	}

	public static bool IsAssignableTo(this Type type, Type? otherType)
	{
		return otherType?.IsAssignableFrom(type) ?? false;
	}

	public static string ReplaceLineEndings(this string str, string replacementText)
	{
		return Replace(Replace(Replace(str, "\r\n", "\n", StringComparison.Ordinal), "\r", "\n", StringComparison.Ordinal), "\n", replacementText, StringComparison.Ordinal);
	}

	public static string ReplaceLineEndings(this string str)
	{
		return ReplaceLineEndings(str, Environment.NewLine);
	}

	public static async Task WaitAsync(this Task task, TimeSpan timeout, CancellationToken cancellationToken)
	{
		Task cancellationTask = Task.Delay(timeout, cancellationToken);
		Task finishedTask = await Task.WhenAny(new Task[2] { task, cancellationTask }).ConfigureAwait(continueOnCapturedContext: false);
		await finishedTask.ConfigureAwait(continueOnCapturedContext: false);
		if (finishedTask == cancellationTask)
		{
			throw new TimeoutException("The operation has timed out.");
		}
	}

	public static async Task WaitAsync(this Task task, CancellationToken cancellationToken)
	{
		await WaitAsync(task, Timeout.InfiniteTimeSpan, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
	}

	public static async Task WaitAsync(this Task task, TimeSpan timeout)
	{
		await WaitAsync(task, timeout, CancellationToken.None).ConfigureAwait(continueOnCapturedContext: false);
	}

	public static async Task<T> WaitAsync<T>(this Task<T> task, TimeSpan timeout, CancellationToken cancellationToken)
	{
		Task cancellationTask = Task.Delay(timeout, cancellationToken);
		Task finishedTask = await Task.WhenAny(new Task[2] { task, cancellationTask }).ConfigureAwait(continueOnCapturedContext: false);
		await finishedTask.ConfigureAwait(continueOnCapturedContext: false);
		if (finishedTask == cancellationTask)
		{
			throw new TimeoutException("The operation has timed out.");
		}
		return task.Result;
	}

	public static async Task<T> WaitAsync<T>(this Task<T> task, CancellationToken cancellationToken)
	{
		return await WaitAsync(task, Timeout.InfiniteTimeSpan, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
	}

	public static async Task<T> WaitAsync<T>(this Task<T> task, TimeSpan timeout)
	{
		return await WaitAsync(task, timeout, CancellationToken.None).ConfigureAwait(continueOnCapturedContext: false);
	}

	public static int ReadAtLeast(this Stream stream, byte[] buffer, int minimumBytes, bool throwOnEndOfStream = true)
	{
		int i;
		int num;
		for (i = 0; i < buffer.Length; i += num)
		{
			num = stream.Read(buffer, i, Math.Min(minimumBytes, buffer.Length - i));
			if (num <= 0)
			{
				break;
			}
		}
		if (i < minimumBytes && throwOnEndOfStream)
		{
			throw new EndOfStreamException();
		}
		return i;
	}

	public static void ReadExactly(this Stream stream, byte[] buffer, int offset, int count)
	{
		int num;
		for (int i = 0; i < count; i += num)
		{
			num = stream.Read(buffer, offset + i, count - i);
			if (num <= 0)
			{
				throw new EndOfStreamException();
			}
		}
	}

	public static void ReadExactly(this Stream stream, byte[] buffer)
	{
		stream.ReadExactly(buffer, 0, buffer.Length);
	}

	public static async Task<int> ReadAtLeastAsync(this Stream stream, byte[] buffer, int minimumBytes, bool throwOnEndOfStream = true, CancellationToken cancellationToken = default(CancellationToken))
	{
		int totalBytesRead;
		int bytesRead;
		for (totalBytesRead = 0; totalBytesRead < buffer.Length; totalBytesRead += bytesRead)
		{
			bytesRead = await stream.ReadAsync(buffer, totalBytesRead, Math.Min(minimumBytes, buffer.Length - totalBytesRead), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			if (bytesRead <= 0)
			{
				break;
			}
		}
		if (totalBytesRead < minimumBytes && throwOnEndOfStream)
		{
			throw new EndOfStreamException();
		}
		return totalBytesRead;
	}

	public static async Task ReadExactlyAsync(this Stream stream, byte[] buffer, int offset, int count, CancellationToken cancellationToken = default(CancellationToken))
	{
		int bytesRead;
		for (int totalBytesRead = 0; totalBytesRead < count; totalBytesRead += bytesRead)
		{
			bytesRead = await stream.ReadAsync(buffer, offset + totalBytesRead, count - totalBytesRead, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			if (bytesRead <= 0)
			{
				throw new EndOfStreamException();
			}
		}
	}

	public static async Task ReadExactlyAsync(this Stream stream, byte[] buffer, CancellationToken cancellationToken = default(CancellationToken))
	{
		await stream.ReadExactlyAsync(buffer, 0, buffer.Length, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
	}

	public static int ReadAtLeast(this Stream stream, Span<byte> buffer, int minimumBytes, bool throwOnEndOfStream = true)
	{
		int i;
		int num;
		for (i = 0; i < buffer.Length; i += num)
		{
			num = Read(stream, buffer.Slice(i));
			if (num <= 0)
			{
				break;
			}
		}
		if (i < minimumBytes && throwOnEndOfStream)
		{
			throw new EndOfStreamException();
		}
		return i;
	}

	public static void ReadExactly(this Stream stream, Span<byte> buffer)
	{
		byte[] array = buffer.ToArray();
		stream.ReadExactly(array, 0, array.Length);
		array.CopyTo(buffer);
	}

	public static async Task<int> ReadAtLeastAsync(this Stream stream, Memory<byte> buffer, int minimumBytes, bool throwOnEndOfStream = true, CancellationToken cancellationToken = default(CancellationToken))
	{
		int totalBytesRead;
		int bytesRead;
		for (totalBytesRead = 0; totalBytesRead < buffer.Length; totalBytesRead += bytesRead)
		{
			bytesRead = await ReadAsync(stream, buffer.Slice(totalBytesRead), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			if (bytesRead <= 0)
			{
				break;
			}
		}
		if (totalBytesRead < minimumBytes && throwOnEndOfStream)
		{
			throw new EndOfStreamException();
		}
		return totalBytesRead;
	}

	public static async Task ReadExactlyAsync(this Stream stream, Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
	{
		byte[] bufferArray = buffer.ToArray();
		await stream.ReadExactlyAsync(bufferArray, 0, bufferArray.Length, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
		bufferArray.CopyTo(buffer);
	}

	public static Task CancelAsync(this CancellationTokenSource cts)
	{
		cts.Cancel();
		return Task.CompletedTask;
	}

	public static void Deconstruct(this DictionaryEntry entry, out object key, out object? value)
	{
		key = entry.Key;
		value = entry.Value;
	}

	public static void Deconstruct<TKey, TValue>(this KeyValuePair<TKey, TValue> pair, out TKey key, out TValue value)
	{
		key = pair.Key;
		value = pair.Value;
	}

	public static IEnumerable<Match> AsEnumerable(this MatchCollection matchCollection)
	{
		return matchCollection.Cast<Match>();
	}

	public static IEnumerator<Match> GetEnumerator(this MatchCollection matchCollection)
	{
		return matchCollection.AsEnumerable().GetEnumerator();
	}

	public static Match[] ToArray(this MatchCollection matchCollection)
	{
		return matchCollection.AsEnumerable().ToArray();
	}

	public static bool StartsWith(this string str, char c)
	{
		return str.Length > 0 && str[0] == c;
	}

	public static bool EndsWith(this string str, char c)
	{
		int result;
		if (str.Length > 0)
		{
			result = ((str[str.Length - 1] == c) ? 1 : 0);
		}
		else
		{
			result = 0;
		}
		return (byte)result != 0;
	}

	public static bool Contains(this string str, char c)
	{
		return str.IndexOf(c) >= 0;
	}

	public static string Replace(this string str, string oldValue, string? newValue, StringComparison comparison)
	{
		StringBuilder stringBuilder = new StringBuilder();
		int num = 0;
		int num2 = 0;
		while (true)
		{
			num = str.IndexOf(oldValue, num, comparison);
			if (num < 0)
			{
				break;
			}
			stringBuilder.Append(str, num2, num - num2);
			stringBuilder.Append(newValue);
			num += oldValue.Length;
			num2 = num;
		}
		stringBuilder.Append(str, num2, str.Length - num2);
		return stringBuilder.ToString();
	}

	public static string Replace(this string str, string oldValue, string? newValue, bool ignoreCase, CultureInfo? culture)
	{
		StringBuilder stringBuilder = new StringBuilder();
		int num = 0;
		int num2 = 0;
		while (true)
		{
			num = (culture ?? CultureInfo.CurrentCulture).CompareInfo.IndexOf(str, oldValue, num, ignoreCase ? CompareOptions.IgnoreCase : CompareOptions.None);
			if (num < 0)
			{
				break;
			}
			stringBuilder.Append(str, num2, num - num2);
			stringBuilder.Append(newValue);
			num += oldValue.Length;
			num2 = num;
		}
		stringBuilder.Append(str, num2, str.Length - num2);
		return stringBuilder.ToString();
	}

	public static string[] Split(this string str, char separator, int count, StringSplitOptions options = StringSplitOptions.None)
	{
		return str.Split(new char[1] { separator }, count, options);
	}

	public static string[] Split(this string str, char separator, StringSplitOptions options = StringSplitOptions.None)
	{
		return str.Split(new char[1] { separator }, options);
	}

	public static string[] Split(this string str, string? separator, int count, StringSplitOptions options = StringSplitOptions.None)
	{
		return str.Split(new string[1] { separator ?? "" }, count, options);
	}

	public static string[] Split(this string str, string? separator, StringSplitOptions options = StringSplitOptions.None)
	{
		return str.Split(new string[1] { separator ?? "" }, options);
	}

	public static void NextBytes(this Random random, Span<byte> buffer)
	{
		byte[] array = buffer.ToArray();
		random.NextBytes(array);
		array.CopyTo(buffer);
	}

	public static int Read(this Stream stream, byte[] buffer)
	{
		return stream.Read(buffer, 0, buffer.Length);
	}

	public static void Write(this Stream stream, byte[] buffer)
	{
		stream.Write(buffer, 0, buffer.Length);
	}

	public static async Task CopyToAsync(this Stream stream, Stream destination, CancellationToken cancellationToken = default(CancellationToken))
	{
		await stream.CopyToAsync(destination, 81920, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
	}

	public static async Task<int> ReadAsync(this Stream stream, byte[] buffer, CancellationToken cancellationToken = default(CancellationToken))
	{
		return await stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
	}

	public static async Task WriteAsync(this Stream stream, byte[] buffer, CancellationToken cancellationToken = default(CancellationToken))
	{
		await stream.WriteAsync(buffer, 0, buffer.Length, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
	}

	public static int Read(this Stream stream, Span<byte> buffer)
	{
		byte[] array = buffer.ToArray();
		int result = stream.Read(array, 0, array.Length);
		array.CopyTo(buffer);
		return result;
	}

	public static void Write(this Stream stream, ReadOnlySpan<byte> buffer)
	{
		byte[] array = buffer.ToArray();
		stream.Write(array, 0, array.Length);
	}

	public static async Task<int> ReadAsync(this Stream stream, Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
	{
		byte[] bufferArray = buffer.ToArray();
		int result = await stream.ReadAsync(bufferArray, 0, bufferArray.Length, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
		bufferArray.CopyTo(buffer);
		return result;
	}

	public static async Task WriteAsync(this Stream stream, ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
	{
		byte[] bufferArray = buffer.ToArray();
		await stream.WriteAsync(bufferArray, 0, bufferArray.Length, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
	}

	public static int Read(this StreamReader reader, char[] buffer)
	{
		return reader.Read(buffer, 0, buffer.Length);
	}

	public static async Task<int> ReadAsync(this StreamReader reader, char[] buffer, CancellationToken cancellationToken = default(CancellationToken))
	{
		cancellationToken.ThrowIfCancellationRequested();
		return await reader.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(continueOnCapturedContext: false);
	}

	public static int Read(this StreamReader reader, Span<char> buffer)
	{
		char[] array = buffer.ToArray();
		int result = reader.Read(array, 0, array.Length);
		array.CopyTo(buffer);
		return result;
	}

	public static async Task<int> ReadAsync(this StreamReader reader, Memory<char> buffer, CancellationToken cancellationToken = default(CancellationToken))
	{
		char[] bufferArray = buffer.ToArray();
		cancellationToken.ThrowIfCancellationRequested();
		int result = await reader.ReadAsync(bufferArray, 0, bufferArray.Length).ConfigureAwait(continueOnCapturedContext: false);
		bufferArray.CopyTo(buffer);
		return result;
	}

	public static void Write(this StreamWriter writer, ReadOnlySpan<char> buffer)
	{
		char[] array = buffer.ToArray();
		writer.Write(array, 0, array.Length);
	}

	public static async Task WriteAsync(this StreamWriter writer, Memory<char> buffer, CancellationToken cancellationToken = default(CancellationToken))
	{
		char[] bufferArray = buffer.ToArray();
		cancellationToken.ThrowIfCancellationRequested();
		await writer.WriteAsync(bufferArray, 0, bufferArray.Length).ConfigureAwait(continueOnCapturedContext: false);
	}

	public static bool Contains(this string str, char c, StringComparison comparison)
	{
		return Contains(str, c.ToString(), comparison);
	}

	public static bool Contains(this string str, string sub, StringComparison comparison)
	{
		return str.IndexOf(sub, comparison) >= 0;
	}
}
namespace SoundCloudExplode
{
	public static class Constants
	{
		public const string ClientId = "wDSKS1Bp8WmdlRPkZ7NQXGs67PMXl2Nd";

		public const string ResolveEndpoint = "https://api-v2.soundcloud.com/resolve";

		public const string TrackEndpoint = "https://api-v2.soundcloud.com/tracks";

		public const int DefaultOffset = 0;

		public const int DefaultLimit = 50;

		public const int MinLimit = 0;

		public const int MaxLimit = 200;
	}
	public interface ISoundCloudClient
	{
		bool IsInitialized { get; }

		ISearchClient Search { get; }

		ITrackClient Tracks { get; }

		IPlaylistClient Playlists { get; }

		IUserClient Users { get; }

		Task InitializeAsync(CancellationToken cancellationToken = default(CancellationToken));

		Task<string> GetClientIdAsync(CancellationToken cancellationToken = default(CancellationToken));

		Task<Kind> GetUrlKindAsync(string url, CancellationToken cancellationToken = default(CancellationToken));

		ValueTask DownloadAsync(Track track, string filePath, IProgress<double>? progress = null, Dictionary<string, string>? headers = null, CancellationToken cancellationToken = default(CancellationToken));
	}
	public class SoundCloudClient : ISoundCloudClient
	{
		private readonly HttpClient _http;

		private readonly SoundcloudEndpoint _endpoint;

		private readonly string BaseUrl = "https://soundcloud.com";

		public string ClientId { get; set; }

		public bool IsInitialized { get; private set; }

		public ISearchClient Search { get; }

		public ITrackClient Tracks { get; }

		public IPlaylistClient Playlists { get; }

		public IUserClient Users { get; }

		public SoundCloudClient(string clientId, HttpClient http, string? authorization = null)
		{
			ClientId = clientId;
			_http = http;
			if (!string.IsNullOrWhiteSpace(authorization))
			{
				http.DefaultRequestHeaders.Add("Authorization", authorization);
			}
			_endpoint = new SoundcloudEndpoint(http)
			{
				ClientId = clientId
			};
			Search = new SearchClient(http, _endpoint);
			Tracks = new TrackClient(http, _endpoint);
			Playlists = new PlaylistClient(http, _endpoint);
			Users = new UserClient(http, _endpoint);
		}

		public SoundCloudClient(string clientId, HttpClient http)
			: this(clientId, http, null)
		{
		}

		public SoundCloudClient()
			: this("wDSKS1Bp8WmdlRPkZ7NQXGs67PMXl2Nd", Http.Client)
		{
		}

		public SoundCloudClient(HttpClient http)
			: this("wDSKS1Bp8WmdlRPkZ7NQXGs67PMXl2Nd", http)
		{
		}

		public SoundCloudClient(string clientId, string authorization)
			: this(clientId, Http.Client, authorization)
		{
		}

		public SoundCloudClient(string clientId)
			: this(clientId, Http.Client)
		{
		}

		public async Task InitializeAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			ClientId = await GetClientIdAsync(cancellationToken);
			_endpoint.ClientId = ClientId;
			IsInitialized = true;
		}

		public async Task<string> GetClientIdAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			MatchCollection scripts = Regex.Matches(await _http.ExecuteGetAsync(BaseUrl, cancellationToken), "<script.*?src=\"(.*?)\"");
			string scriptUrl = scripts.Cast<Match>().LastOrDefault()?.Groups[1].Value;
			if (string.IsNullOrEmpty(scriptUrl))
			{
				return string.Empty;
			}
			return (await _http.ExecuteGetAsync(scriptUrl, cancellationToken)).Split(new string[1] { ",client_id" }, StringSplitOptions.None)[1].Split(new char[1] { '"' })[1];
		}

		public async Task<Kind> GetUrlKindAsync(string url, CancellationToken cancellationToken = default(CancellationToken))
		{
			string resolvedJson = await _endpoint.ResolveUrlAsync(url, cancellationToken);
			if (string.IsNullOrWhiteSpace(resolvedJson))
			{
				throw new SoundcloudExplodeException("Failed to resolve url.");
			}
			JObject jObject = JObject.Parse(resolvedJson);
			return JsonConvert.DeserializeObject<Kind>(((object)jObject["kind"]).ToString(), JsonSettings.Default);
		}

		public async ValueTask DownloadAsync(Track track, string filePath, IProgress<double>? progress = null, Dictionary<string, string>? headers = null, CancellationToken cancellationToken = default(CancellationToken))
		{
			string mp3TrackMediaUrl = await Tracks.GetDownloadUrlAsync(track, cancellationToken);
			if (mp3TrackMediaUrl == null)
			{
				return;
			}
			string dir = Path.GetDirectoryName(filePath);
			if (dir == null)
			{
				return;
			}
			if (!Directory.Exists(dir))
			{
				Directory.CreateDirectory(dir);
			}
			using FileStream destination = File.Create(filePath);
			HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, mp3TrackMediaUrl);
			if (headers != null)
			{
				foreach (var (key, value) in headers)
				{
					request.Headers.TryAddWithoutValidation(key, value);
				}
			}
			HttpResponseMessage response = await _http.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
			if (!response.IsSuccessStatusCode)
			{
				throw new HttpRequestException($"Response status code does not indicate success: {(int)response.StatusCode} ({response.StatusCode})." + Environment.NewLine + "Request:" + Environment.NewLine + request);
			}
			await StreamExtensions.CopyToAsync(totalLength: response.Content.Headers.ContentLength.GetValueOrDefault(), source: await PolyfillExtensions.ReadAsStreamAsync(response.Content, cancellationToken), destination: destination, progress: progress, bufferSize: 4096, cancellationToken: cancellationToken);
		}
	}
	internal static class JsonSettings
	{
		public static readonly JsonSerializerSettings Default = new JsonSerializerSettings
		{
			Converters = { (JsonConverter)new StringEnumConverter() },
			NullValueHandling = (NullValueHandling)1
		};
	}
}
namespace SoundCloudExplode.Utils
{
	internal static class Http
	{
		private static readonly Lazy<HttpClient> HttpClientLazy = new Lazy<HttpClient>(delegate
		{
			HttpClientHandler handler = new HttpClientHandler();
			return new HttpClient(handler, disposeHandler: true);
		});

		public static HttpClient Client => HttpClientLazy.Value;

		public static string ChromeUserAgent()
		{
			int num = Randomizer.Instance.Next(62, 70);
			int num2 = Randomizer.Instance.Next(2100, 3538);
			int num3 = Randomizer.Instance.Next(170);
			return "Mozilla/5.0 (" + RandomWindowsVersion() + ") AppleWebKit/537.36 (KHTML, like Gecko) " + $"Chrome/{num}.0.{num2}.{num3} Safari/537.36";
		}

		private static string RandomWindowsVersion()
		{
			string text = "Windows NT ";
			int num = Randomizer.Instance.Next(99) + 1;
			text = ((num >= 1 && num <= 45) ? (text + "10.0") : ((num > 45 && num <= 80) ? (text + "6.1") : ((num <= 80 || num > 95) ? (text + "6.2") : (text + "6.3"))));
			if (Randomizer.Instance.NextDouble() <= 0.65)
			{
				text += ((Randomizer.Instance.NextDouble() <= 0.5) ? "; WOW64" : "; Win64; x64");
			}
			return text;
		}
	}
	public static class Randomizer
	{
		[ThreadStatic]
		private static Random _rand;

		public static Random Instance => _rand ?? (_rand = Generate());

		private static Random Generate()
		{
			byte[] array = new byte[4];
			using RandomNumberGenerator randomNumberGenerator = RandomNumberGenerator.Create();
			randomNumberGenerator.GetBytes(array);
			return new Random(BitConverter.ToInt32(array, 0));
		}
	}
}
namespace SoundCloudExplode.Utils.Extensions
{
	internal static class AsyncCollectionExtensions
	{
		public static async IAsyncEnumerable<T> TakeAsync<T>(this IAsyncEnumerable<T> source, int count)
		{
			int currentCount = 0;
			await foreach (T i in source)
			{
				if (currentCount >= count)
				{
					break;
				}
				yield return i;
				currentCount++;
			}
		}

		public static async IAsyncEnumerable<T> SelectManyAsync<TSource, T>(this IAsyncEnumerable<TSource> source, Func<TSource, IEnumerable<T>> transform)
		{
			await foreach (TSource i in source)
			{
				foreach (T item in transform(i))
				{
					yield return item;
				}
			}
		}

		public static async IAsyncEnumerable<T> OfTypeAsync<T>(this IAsyncEnumerable<object> source)
		{
			T match = default(T);
			await foreach (object i in source)
			{
				int num;
				if (i is T)
				{
					match = (T)i;
					num = 1;
				}
				else
				{
					num = 0;
				}
				if (num != 0)
				{
					yield return match;
				}
				match = default(T);
			}
		}

		public static async ValueTask<List<T>> ToListAsync<T>(this IAsyncEnumerable<T> source)
		{
			List<T> list = new List<T>();
			await foreach (T i in source)
			{
				list.Add(i);
			}
			return list;
		}
	}
	public static class EnumerableExtensions
	{
		public static IEnumerable<IEnumerable<T>> ChunkBy<T>(this IEnumerable<T> source, int chunkSize)
		{
			return from x in source.Select((T x, int i) => new
				{
					Index = i,
					Value = x
				})
				group x by x.Index / chunkSize into x
				select from v in x
					select v.Value;
		}
	}
	internal static class GenericExtensions
	{
		public static TOut Pipe<TIn, TOut>(this TIn input, Func<TIn, TOut> transform)
		{
			return transform(input);
		}

		public static async Task<T> WithCancellation<T>(this Task<T> task, CancellationToken cancellationToken, Action action, bool useSynchronizationContext = true)
		{
			using (cancellationToken.Register(action, useSynchronizationContext))
			{
				try
				{
					return await task;
				}
				catch (Exception ex2)
				{
					Exception ex = ex2;
					if (cancellationToken.IsCancellationRequested)
					{
						throw new OperationCanceledException(ex.Message, ex, cancellationToken);
					}
					throw;
				}
			}
		}
	}
	internal static class HttpExtensions
	{
		public static async ValueTask<string> ExecuteGetAsync(this HttpClient http, string url, CancellationToken cancellationToken = default(CancellationToken))
		{
			using HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, url);
			return await http.ExecuteAsync(request, cancellationToken);
		}

		public static async ValueTask<string> ExecuteAsync(this HttpClient http, HttpRequestMessage request, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (!request.Headers.Contains("User-Agent"))
			{
				request.Headers.Add("User-Agent", Http.ChromeUserAgent());
			}
			using HttpResponseMessage response = await http.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
			if (response.StatusCode == HttpStatusCode.TooManyRequests)
			{
				throw new RequestLimitExceededException("Exceeded request rate limit. Please try again later. ");
			}
			if (!response.IsSuccessStatusCode)
			{
				throw new HttpRequestException($"Response status code does not indicate success: {(int)response.StatusCode} ({response.StatusCode})." + Environment.NewLine + "Request:" + Environment.NewLine + request);
			}
			return await PolyfillExtensions.ReadAsStringAsync(response.Content, cancellationToken);
		}
	}
	internal static class StreamExtensions
	{
		public static async ValueTask CopyToAsync(this Stream source, Stream destination, long totalLength, IProgress<double>? progress = null, int bufferSize = 4096, CancellationToken cancellationToken = default(CancellationToken))
		{
			using IMemoryOwner<byte> buffer = MemoryPool<byte>.Shared.Rent(bufferSize);
			long totalBytesRead = 0L;
			while (true)
			{
				int bytesRead = await PolyfillExtensions.ReadAsync(source, buffer.Memory, cancellationToken);
				if (bytesRead <= 0)
				{
					break;
				}
				await PolyfillExtensions.WriteAsync(destination, buffer.Memory.Slice(0, bytesRead), cancellationToken);
				totalBytesRead += bytesRead;
				progress?.Report(1.0 * (double)totalBytesRead / (double)totalLength);
			}
		}
	}
}
namespace SoundCloudExplode.Users
{
	public class Badges
	{
		[JsonProperty("pro_unlimited")]
		public bool ProUnlimited { get; set; }

		[JsonProperty("verified")]
		public bool Verified { get; set; }
	}
	public interface IUserClient
	{
		bool IsUrlValid(string url);

		bool IsLikesUrlValid(string url);

		ValueTask<User> GetAsync(string url, CancellationToken cancellationToken = default(CancellationToken));

		IAsyncEnumerable<Batch<Track>> GetTrackBatchesAsync(string url, UserTrackSortBy trackQuery, int offset = 0, int limit = 50, CancellationToken cancellationToken = default(CancellationToken));

		IAsyncEnumerable<Track> GetTracksAsync(string url, int offset = 0, int limit = 50, CancellationToken cancellationToken = default(CancellationToken));

		IAsyncEnumerable<Track> GetTracksAsync(string url, CancellationToken cancellationToken);

		IAsyncEnumerable<Track> GetPopularTracksAsync(string url, int offset = 0, int limit = 50, CancellationToken cancellationToken = default(CancellationToken));

		IAsyncEnumerable<Track> GetPopularTracksAsync(string url, CancellationToken cancellationToken);

		IAsyncEnumerable<Track> GetLikedTracksAsync(string url, int offset = 0, int limit = 50, CancellationToken cancellationToken = default(CancellationToken));

		IAsyncEnumerable<Track> GetLikedTracksAsync(string url, CancellationToken cancellationToken);

		IAsyncEnumerable<Batch<Playlist>> GetPlaylistBatchesAsync(string url, int offset = 0, int limit = 50, CancellationToken cancellationToken = default(CancellationToken));

		IAsyncEnumerable<Playlist> GetPlaylistsAsync(string url, int offset = 0, int limit = 50, CancellationToken cancellationToken = default(CancellationToken));

		IAsyncEnumerable<Playlist> GetPlaylistsAsync(string url, CancellationToken cancellationToken);

		IAsyncEnumerable<Batch<Playlist>> GetAlbumBatchesAsync(string url, int offset = 0, int limit = 50, CancellationToken cancellationToken = default(CancellationToken));

		IAsyncEnumerable<Playlist> GetAlbumsAsync(string url, int offset = 0, int limit = 50, CancellationToken cancellationToken = default(CancellationToken));

		IAsyncEnumerable<Playlist> GetAlbumsAsync(string url, CancellationToken cancellationToken);
	}
	public class PlaylistUser
	{
		[JsonProperty("avatar_url")]
		public Uri? AvatarUrl { get; set; }

		[JsonProperty("city")]
		public object? City { get; set; }

		[JsonProperty("comments_count")]
		public long CommentsCount { get; set; }

		[JsonProperty("country_code")]
		public string? CountryCode { get; set; }

		[JsonProperty("created_at")]
		public DateTimeOffset? CreatedAt { get; set; }

		[JsonProperty("creator_subscriptions")]
		public List<CreatorSubscription> CreatorSubscriptions { get; set; } = new List<CreatorSubscription>();


		[JsonProperty("creator_subscription")]
		public CreatorSubscription? CreatorSubscription { get; set; }

		[JsonProperty("description")]
		public object? Description { get; set; }

		[JsonProperty("followers_count")]
		public long? FollowersCount { get; set; }

		[JsonProperty("followings_count")]
		public long? FollowingsCount { get; set; }

		[JsonProperty("first_name")]
		public string? FirstName { get; set; }

		[JsonProperty("full_name")]
		public string? FullName { get; set; }

		[JsonProperty("groups_count")]
		public long? GroupsCount { get; set; }

		[JsonProperty("id")]
		public long? Id { get; set; }

		[JsonProperty("kind")]
		public string? Kind { get; set; }

		[JsonProperty("last_modified")]
		public DateTimeOffset? LastModified { get; set; }

		[JsonProperty("last_name")]
		public string? LastName { get; set; }

		[JsonProperty("likes_count")]
		public long? LikesCount { get; set; }

		[JsonProperty("playlist_likes_count")]
		public long? PlaylistLikesCount { get; set; }

		[JsonProperty("permalink")]
		public string? Permalink { get; set; }

		[JsonProperty("permalink_url")]
		public Uri? PermalinkUrl { get; set; }

		[JsonProperty("playlist_count")]
		public long? PlaylistCount { get; set; }

		[JsonProperty("reposts_count")]
		public object? RepostsCount { get; set; }

		[JsonProperty("track_count")]
		public long? TrackCount { get; set; }

		[JsonProperty("uri")]
		public Uri? Uri { get; set; }

		[JsonProperty("urn")]
		public string? Urn { get; set; }

		[JsonProperty("username")]
		public string? Username { get; set; }

		[JsonProperty("verified")]
		public bool Verified { get; set; }

		[JsonProperty("visuals")]
		public Visuals? Visuals { get; set; }

		[JsonProperty("badges")]
		public Badges? Badges { get; set; }
	}
	public class User : IBatchItem
	{
		[JsonProperty("avatar_url")]
		public Uri? AvatarUrl { get; set; }

		[JsonProperty("first_name")]
		public string? FirstName { get; set; }

		[JsonProperty("full_name")]
		public string? FullName { get; set; }

		[JsonProperty("id")]
		public long? Id { get; set; }

		[JsonProperty("kind")]
		public Kind Kind { get; set; }

		[JsonProperty("last_modified")]
		public DateTimeOffset? LastModified { get; set; }

		[JsonProperty("last_name")]
		public string? LastName { get; set; }

		[JsonProperty("permalink")]
		public string? Permalink { get; set; }

		[JsonProperty("permalink_url")]
		public string? PermalinkUrl { get; set; }

		[JsonProperty("uri")]
		public Uri? Uri { get; set; }

		[JsonProperty("urn")]
		public string? Urn { get; set; }

		[JsonProperty("username")]
		public string? Username { get; set; }

		[JsonProperty("verified")]
		public bool Verified { get; set; }

		[JsonProperty("city")]
		public string? City { get; set; }

		[JsonProperty("country_code")]
		public string? CountryCode { get; set; }

		[JsonProperty("badges")]
		public Badges? Badges { get; set; }

		[ExcludeFromCodeCoverage]
		public override string ToString()
		{
			return "User (" + ((!string.IsNullOrWhiteSpace(FullName)) ? FullName : Username) + ")";
		}
	}
	public class UserClient : IUserClient
	{
		[CompilerGenerated]
		private sealed class <GetAlbumBatchesAsync>d__17 : IAsyncEnumerable<Batch<Playlist>>, IAsyncEnumerator<Batch<Playlist>>, IAsyncDisposable, IValueTaskSource<bool>, IValueTaskSource, IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncIteratorMethodBuilder <>t__builder;

			public ManualResetValueTaskSourceCore<bool> <>v__promiseOfValueOrEnd;

			private Batch<Playlist> <>2__current;

			private bool <>w__disposeMode;

			private CancellationTokenSource <>x__combinedTokens;

			private int <>l__initialThreadId;

			private string url;

			public string <>3__url;

			private int offset;

			public int <>3__offset;

			private int limit;

			public int <>3__limit;

			private CancellationToken cancellationToken;

			public CancellationToken <>3__cancellationToken;

			public UserClient <>4__this;

			private User <user>5__1;

			private string <nextUrl>5__2;

			private User <>s__3;

			private string <response>5__4;

			private JObject <doc>5__5;

			private JToken <collection>5__6;

			private List<Playlist> <list>5__7;

			private string <>s__8;

			private ValueTaskAwaiter<User> <>u__1;

			private ValueTaskAwaiter<string> <>u__2;

			Batch<Playlist> IAsyncEnumerator<Batch<Playlist>>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetAlbumBatchesAsync>d__17(int <>1__state)
			{
				<>t__builder = AsyncIteratorMethodBuilder.Create();
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			private void MoveNext()
			{
				int num = <>1__state;
				try
				{
					ValueTaskAwaiter<User> awaiter2;
					ValueTaskAwaiter<string> awaiter;
					switch (num)
					{
					default:
						if (!<>w__disposeMode)
						{
							num = (<>1__state = -1);
							Limitor.Validate(limit);
							<>2__current = null;
							awaiter2 = <>4__this.GetAsync(url, cancellationToken).GetAwaiter();
							if (!awaiter2.IsCompleted)
							{
								num = (<>1__state = 0);
								<>u__1 = awaiter2;
								<GetAlbumBatchesAsync>d__17 stateMachine = this;
								<>t__builder.AwaitUnsafeOnCompleted(ref awaiter2, ref stateMachine);
								return;
							}
							goto IL_00ce;
						}
						goto end_IL_0007;
					case 0:
						awaiter2 = <>u__1;
						<>u__1 = default(ValueTaskAwaiter<User>);
						num = (<>1__state = -1);
						goto IL_00ce;
					case 1:
						awaiter = <>u__2;
						<>u__2 = default(ValueTaskAwaiter<string>);
						num = (<>1__state = -1);
						break;
					case -4:
						{
							num = (<>1__state = -1);
							if (!<>w__disposeMode)
							{
								<nextUrl>5__2 = ((object)<doc>5__5["next_href"])?.ToString();
								if (!string.IsNullOrEmpty(<nextUrl>5__2))
								{
									<nextUrl>5__2 = <nextUrl>5__2 + "&client_id=" + <>4__this.<endpoint>P.ClientId;
									<response>5__4 = null;
									<doc>5__5 = null;
									<collection>5__6 = null;
									<list>5__7 = null;
									goto IL_034d;
								}
							}
							goto end_IL_0007;
						}
						IL_00ce:
						<>s__3 = awaiter2.GetResult();
						<user>5__1 = <>s__3;
						<>s__3 = null;
						if (<user>5__1 != null)
						{
							<nextUrl>5__2 = null;
							goto IL_034d;
						}
						<>w__disposeMode = true;
						goto end_IL_0007;
						IL_034d:
						url = <nextUrl>5__2 ?? $"https://api-v2.soundcloud.com/users/{<user>5__1.Id}/albums?offset={offset}&limit={limit}&client_id={<>4__this.<endpoint>P.ClientId}";
						<>2__current = null;
						awaiter = <>4__this.<http>P.ExecuteGetAsync(url, cancellationToken).GetAwaiter();
						if (!awaiter.IsCompleted)
						{
							num = (<>1__state = 1);
							<>u__2 = awaiter;
							<GetAlbumBatchesAsync>d__17 stateMachine = this;
							<>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);
							return;
						}
						break;
					}
					<>s__8 = awaiter.GetResult();
					<response>5__4 = <>s__8;
					<>s__8 = null;
					<doc>5__5 = JObject.Parse(<response>5__4);
					<collection>5__6 = <doc>5__5["collection"];
					if (<collection>5__6 != null && ((IEnumerable<JToken>)<collection>5__6).Any())
					{
						<list>5__7 = JsonConvert.DeserializeObject<List<Playlist>>(((object)<collection>5__6).ToString(), JsonSettings.Default);
						if (<list>5__7 != null && <list>5__7.Count != 0)
						{
							<>2__current = Batch.Create(<list>5__7);
							num = (<>1__state = -4);
							goto IL_0459;
						}
					}
					end_IL_0007:;
				}
				catch (Exception exception)
				{
					<>1__state = -2;
					<user>5__1 = null;
					<nextUrl>5__2 = null;
					<>s__3 = null;
					<response>5__4 = null;
					<doc>5__5 = null;
					<collection>5__6 = null;
					<list>5__7 = null;
					<>s__8 = null;
					if (<>x__combinedTokens != null)
					{
						<>x__combinedTokens.Dispose();
						<>x__combinedTokens = null;
					}
					<>2__current = null;
					<>t__builder.Complete();
					<>v__promiseOfValueOrEnd.SetException(exception);
					return;
				}
				<>1__state = -2;
				<user>5__1 = null;
				<nextUrl>5__2 = null;
				<>s__3 = null;
				<response>5__4 = null;
				<doc>5__5 = null;
				<collection>5__6 = null;
				<list>5__7 = null;
				<>s__8 = null;
				if (<>x__combinedTokens != null)
				{
					<>x__combinedTokens.Dispose();
					<>x__combinedTokens = null;
				}
				<>2__current = null;
				<>t__builder.Complete();
				<>v__promiseOfValueOrEnd.SetResult(result: false);
				return;
				IL_0459:
				<>v__promiseOfValueOrEnd.SetResult(result: true);
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}

			[DebuggerHidden]
			IAsyncEnumerator<Batch<Playlist>> IAsyncEnumerable<Batch<Playlist>>.GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
			{
				<GetAlbumBatchesAsync>d__17 <GetAlbumBatchesAsync>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = -3;
					<>t__builder = AsyncIteratorMethodBuilder.Create();
					<>w__disposeMode = false;
					<GetAlbumBatchesAsync>d__ = this;
				}
				else
				{
					<GetAlbumBatchesAsync>d__ = new <GetAlbumBatchesAsync>d__17(-3)
					{
						<>4__this = <>4__this
					};
				}
				<GetAlbumBatchesAsync>d__.url = <>3__url;
				<GetAlbumBatchesAsync>d__.offset = <>3__offset;
				<GetAlbumBatchesAsync>d__.limit = <>3__limit;
				if (<>3__cancellationToken.Equals(default(CancellationToken)))
				{
					<GetAlbumBatchesAsync>d__.cancellationToken = cancellationToken;
				}
				else if (cancellationToken.Equals(<>3__cancellationToken) || cancellationToken.Equals(default(CancellationToken)))
				{
					<GetAlbumBatchesAsync>d__.cancellationToken = <>3__cancellationToken;
				}
				else
				{
					<>x__combinedTokens = CancellationTokenSource.CreateLinkedTokenSource(<>3__cancellationToken, cancellationToken);
					<GetAlbumBatchesAsync>d__.cancellationToken = <>x__combinedTokens.Token;
				}
				return <GetAlbumBatchesAsync>d__;
			}

			[DebuggerHidden]
			ValueTask<bool> IAsyncEnumerator<Batch<Playlist>>.MoveNextAsync()
			{
				if (<>1__state == -2)
				{
					return default(ValueTask<bool>);
				}
				<>v__promiseOfValueOrEnd.Reset();
				<GetAlbumBatchesAsync>d__17 stateMachine = this;
				<>t__builder.MoveNext(ref stateMachine);
				short version = <>v__promiseOfValueOrEnd.Version;
				if (<>v__promiseOfValueOrEnd.GetStatus(version) == ValueTaskSourceStatus.Succeeded)
				{
					return new ValueTask<bool>(<>v__promiseOfValueOrEnd.GetResult(version));
				}
				return new ValueTask<bool>(this, version);
			}

			[DebuggerHidden]
			bool IValueTaskSource<bool>.GetResult(short token)
			{
				return <>v__promiseOfValueOrEnd.GetResult(token);
			}

			[DebuggerHidden]
			ValueTaskSourceStatus IValueTaskSource<bool>.GetStatus(short token)
			{
				return <>v__promiseOfValueOrEnd.GetStatus(token);
			}

			[DebuggerHidden]
			void IValueTaskSource<bool>.OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags)
			{
				<>v__promiseOfValueOrEnd.OnCompleted(continuation, state, token, flags);
			}

			[DebuggerHidden]
			void IValueTaskSource.GetResult(short token)
			{
				<>v__promiseOfValueOrEnd.GetResult(token);
			}

			[DebuggerHidden]
			ValueTaskSourceStatus IValueTaskSource.GetStatus(short token)
			{
				return <>v__promiseOfValueOrEnd.GetStatus(token);
			}

			[DebuggerHidden]
			void IValueTaskSource.OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags)
			{
				<>v__promiseOfValueOrEnd.OnCompleted(continuation, state, token, flags);
			}

			[DebuggerHidden]
			ValueTask IAsyncDisposable.DisposeAsync()
			{
				if (<>1__state >= -1)
				{
					throw new NotSupportedException();
				}
				if (<>1__state == -2)
				{
					return default(ValueTask);
				}
				<>w__disposeMode = true;
				<>v__promiseOfValueOrEnd.Reset();
				<GetAlbumBatchesAsync>d__17 stateMachine = this;
				<>t__builder.MoveNext(ref stateMachine);
				return new ValueTask(this, <>v__promiseOfValueOrEnd.Version);
			}
		}

		[CompilerGenerated]
		private sealed class <GetPlaylistBatchesAsync>d__14 : IAsyncEnumerable<Batch<Playlist>>, IAsyncEnumerator<Batch<Playlist>>, IAsyncDisposable, IValueTaskSource<bool>, IValueTaskSource, IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncIteratorMethodBuilder <>t__builder;

			public ManualResetValueTaskSourceCore<bool> <>v__promiseOfValueOrEnd;

			private Batch<Playlist> <>2__current;

			private bool <>w__disposeMode;

			private CancellationTokenSource <>x__combinedTokens;

			private int <>l__initialThreadId;

			private string url;

			public string <>3__url;

			private int offset;

			public int <>3__offset;

			private int limit;

			public int <>3__limit;

			private CancellationToken cancellationToken;

			public CancellationToken <>3__cancellationToken;

			public UserClient <>4__this;

			private User <user>5__1;

			private string <nextUrl>5__2;

			private User <>s__3;

			private string <response>5__4;

			private JObject <doc>5__5;

			private JToken <collection>5__6;

			private List<Playlist> <list>5__7;

			private string <>s__8;

			private ValueTaskAwaiter<User> <>u__1;

			private ValueTaskAwaiter<string> <>u__2;

			Batch<Playlist> IAsyncEnumerator<Batch<Playlist>>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetPlaylistBatchesAsync>d__14(int <>1__state)
			{
				<>t__builder = AsyncIteratorMethodBuilder.Create();
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			private void MoveNext()
			{
				int num = <>1__state;
				try
				{
					ValueTaskAwaiter<User> awaiter2;
					ValueTaskAwaiter<string> awaiter;
					switch (num)
					{
					default:
						if (!<>w__disposeMode)
						{
							num = (<>1__state = -1);
							Limitor.Validate(limit);
							<>2__current = null;
							awaiter2 = <>4__this.GetAsync(url, cancellationToken).GetAwaiter();
							if (!awaiter2.IsCompleted)
							{
								num = (<>1__state = 0);
								<>u__1 = awaiter2;
								<GetPlaylistBatchesAsync>d__14 stateMachine = this;
								<>t__builder.AwaitUnsafeOnCompleted(ref awaiter2, ref stateMachine);
								return;
							}
							goto IL_00ce;
						}
						goto end_IL_0007;
					case 0:
						awaiter2 = <>u__1;
						<>u__1 = default(ValueTaskAwaiter<User>);
						num = (<>1__state = -1);
						goto IL_00ce;
					case 1:
						awaiter = <>u__2;
						<>u__2 = default(ValueTaskAwaiter<string>);
						num = (<>1__state = -1);
						break;
					case -4:
						{
							num = (<>1__state = -1);
							if (!<>w__disposeMode)
							{
								<nextUrl>5__2 = ((object)<doc>5__5["next_href"])?.ToString();
								if (!string.IsNullOrEmpty(<nextUrl>5__2))
								{
									<nextUrl>5__2 = <nextUrl>5__2 + "&client_id=" + <>4__this.<endpoint>P.ClientId;
									<response>5__4 = null;
									<doc>5__5 = null;
									<collection>5__6 = null;
									<list>5__7 = null;
									goto IL_034d;
								}
							}
							goto end_IL_0007;
						}
						IL_00ce:
						<>s__3 = awaiter2.GetResult();
						<user>5__1 = <>s__3;
						<>s__3 = null;
						if (<user>5__1 != null)
						{
							<nextUrl>5__2 = null;
							goto IL_034d;
						}
						<>w__disposeMode = true;
						goto end_IL_0007;
						IL_034d:
						url = <nextUrl>5__2 ?? $"https://api-v2.soundcloud.com/users/{<user>5__1.Id}/playlists?offset={offset}&limit={limit}&client_id={<>4__this.<endpoint>P.ClientId}";
						<>2__current = null;
						awaiter = <>4__this.<http>P.ExecuteGetAsync(url, cancellationToken).GetAwaiter();
						if (!awaiter.IsCompleted)
						{
							num = (<>1__state = 1);
							<>u__2 = awaiter;
							<GetPlaylistBatchesAsync>d__14 stateMachine = this;
							<>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);
							return;
						}
						break;
					}
					<>s__8 = awaiter.GetResult();
					<response>5__4 = <>s__8;
					<>s__8 = null;
					<doc>5__5 = JObject.Parse(<response>5__4);
					<collection>5__6 = <doc>5__5["collection"];
					if (<collection>5__6 != null && ((IEnumerable<JToken>)<collection>5__6).Any())
					{
						<list>5__7 = JsonConvert.DeserializeObject<List<Playlist>>(((object)<collection>5__6).ToString(), JsonSettings.Default);
						if (<list>5__7 != null && <list>5__7.Count != 0)
						{
							<>2__current = Batch.Create(<list>5__7);
							num = (<>1__state = -4);
							goto IL_0459;
						}
					}
					end_IL_0007:;
				}
				catch (Exception exception)
				{
					<>1__state = -2;
					<user>5__1 = null;
					<nextUrl>5__2 = null;
					<>s__3 = null;
					<response>5__4 = null;
					<doc>5__5 = null;
					<collection>5__6 = null;
					<list>5__7 = null;
					<>s__8 = null;
					if (<>x__combinedTokens != null)
					{
						<>x__combinedTokens.Dispose();
						<>x__combinedTokens = null;
					}
					<>2__current = null;
					<>t__builder.Complete();
					<>v__promiseOfValueOrEnd.SetException(exception);
					return;
				}
				<>1__state = -2;
				<user>5__1 = null;
				<nextUrl>5__2 = null;
				<>s__3 = null;
				<response>5__4 = null;
				<doc>5__5 = null;
				<collection>5__6 = null;
				<list>5__7 = null;
				<>s__8 = null;
				if (<>x__combinedTokens != null)
				{
					<>x__combinedTokens.Dispose();
					<>x__combinedTokens = null;
				}
				<>2__current = null;
				<>t__builder.Complete();
				<>v__promiseOfValueOrEnd.SetResult(result: false);
				return;
				IL_0459:
				<>v__promiseOfValueOrEnd.SetResult(result: true);
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}

			[DebuggerHidden]
			IAsyncEnumerator<Batch<Playlist>> IAsyncEnumerable<Batch<Playlist>>.GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
			{
				<GetPlaylistBatchesAsync>d__14 <GetPlaylistBatchesAsync>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = -3;
					<>t__builder = AsyncIteratorMethodBuilder.Create();
					<>w__disposeMode = false;
					<GetPlaylistBatchesAsync>d__ = this;
				}
				else
				{
					<GetPlaylistBatchesAsync>d__ = new <GetPlaylistBatchesAsync>d__14(-3)
					{
						<>4__this = <>4__this
					};
				}
				<GetPlaylistBatchesAsync>d__.url = <>3__url;
				<GetPlaylistBatchesAsync>d__.offset = <>3__offset;
				<GetPlaylistBatchesAsync>d__.limit = <>3__limit;
				if (<>3__cancellationToken.Equals(default(CancellationToken)))
				{
					<GetPlaylistBatchesAsync>d__.cancellationToken = cancellationToken;
				}
				else if (cancellationToken.Equals(<>3__cancellationToken) || cancellationToken.Equals(default(CancellationToken)))
				{
					<GetPlaylistBatchesAsync>d__.cancellationToken = <>3__cancellationToken;
				}
				else
				{
					<>x__combinedTokens = CancellationTokenSource.CreateLinkedTokenSource(<>3__cancellationToken, cancellationToken);
					<GetPlaylistBatchesAsync>d__.cancellationToken = <>x__combinedTokens.Token;
				}
				return <GetPlaylistBatchesAsync>d__;
			}

			[DebuggerHidden]
			ValueTask<bool> IAsyncEnumerator<Batch<Playlist>>.MoveNextAsync()
			{
				if (<>1__state == -2)
				{
					return default(ValueTask<bool>);
				}
				<>v__promiseOfValueOrEnd.Reset();
				<GetPlaylistBatchesAsync>d__14 stateMachine = this;
				<>t__builder.MoveNext(ref stateMachine);
				short version = <>v__promiseOfValueOrEnd.Version;
				if (<>v__promiseOfValueOrEnd.GetStatus(version) == ValueTaskSourceStatus.Succeeded)
				{
					return new ValueTask<bool>(<>v__promiseOfValueOrEnd.GetResult(version));
				}
				return new ValueTask<bool>(this, version);
			}

			[DebuggerHidden]
			bool IValueTaskSource<bool>.GetResult(short token)
			{
				return <>v__promiseOfValueOrEnd.GetResult(token);
			}

			[DebuggerHidden]
			ValueTaskSourceStatus IValueTaskSource<bool>.GetStatus(short token)
			{
				return <>v__promiseOfValueOrEnd.GetStatus(token);
			}

			[DebuggerHidden]
			void IValueTaskSource<bool>.OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags)
			{
				<>v__promiseOfValueOrEnd.OnCompleted(continuation, state, token, flags);
			}

			[DebuggerHidden]
			void IValueTaskSource.GetResult(short token)
			{
				<>v__promiseOfValueOrEnd.GetResult(token);
			}

			[DebuggerHidden]
			ValueTaskSourceStatus IValueTaskSource.GetStatus(short token)
			{
				return <>v__promiseOfValueOrEnd.GetStatus(token);
			}

			[DebuggerHidden]
			void IValueTaskSource.OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags)
			{
				<>v__promiseOfValueOrEnd.OnCompleted(continuation, state, token, flags);
			}

			[DebuggerHidden]
			ValueTask IAsyncDisposable.DisposeAsync()
			{
				if (<>1__state >= -1)
				{
					throw new NotSupportedException();
				}
				if (<>1__state == -2)
				{
					return default(ValueTask);
				}
				<>w__disposeMode = true;
				<>v__promiseOfValueOrEnd.Reset();
				<GetPlaylistBatchesAsync>d__14 stateMachine = this;
				<>t__builder.MoveNext(ref stateMachine);
				return new ValueTask(this, <>v__promiseOfValueOrEnd.Version);
			}
		}

		[CompilerGenerated]
		private sealed class <GetTrackBatchesAsync>d__7 : IAsyncEnumerable<Batch<Track>>, IAsyncEnumerator<Batch<Track>>, IAsyncDisposable, IValueTaskSource<bool>, IValueTaskSource, IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncIteratorMethodBuilder <>t__builder;

			public ManualResetValueTaskSourceCore<bool> <>v__promiseOfValueOrEnd;

			private Batch<Track> <>2__current;

			private bool <>w__disposeMode;

			private CancellationTokenSource <>x__combinedTokens;

			private int <>l__initialThreadId;

			private string url;

			public string <>3__url;

			private UserTrackSortBy trackQuery;

			public UserTrackSortBy <>3__trackQuery;

			private int offset;

			public int <>3__offset;

			private int limit;

			public int <>3__limit;

			private CancellationToken cancellationToken;

			public CancellationToken <>3__cancellationToken;

			public UserClient <>4__this;

			private User <user>5__1;

			private string <queryPart>5__2;

			private string <nextUrl>5__3;

			private User <>s__4;

			private string <response>5__5;

			private JObject <doc>5__6;

			private JToken <collection>5__7;

			private string <>s__8;

			private List<Track> <list>5__9;

			private List<Track> <list>5__10;

			private ValueTaskAwaiter<User> <>u__1;

			private ValueTaskAwaiter<string> <>u__2;

			Batch<Track> IAsyncEnumerator<Batch<Track>>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetTrackBatchesAsync>d__7(int <>1__state)
			{
				<>t__builder = AsyncIteratorMethodBuilder.Create();
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			private void MoveNext()
			{
				int num = <>1__state;
				try
				{
					ValueTaskAwaiter<User> awaiter2;
					ValueTaskAwaiter<string> awaiter;
					switch (num)
					{
					default:
						if (!<>w__disposeMode)
						{
							num = (<>1__state = -1);
							Limitor.Validate(limit);
							<>2__current = null;
							awaiter2 = <>4__this.GetAsync(url, cancellationToken).GetAwaiter();
							if (!awaiter2.IsCompleted)
							{
								num = (<>1__state = 0);
								<>u__1 = awaiter2;
								<GetTrackBatchesAsync>d__7 stateMachine = this;
								<>t__builder.AwaitUnsafeOnCompleted(ref awaiter2, ref stateMachine);
								return;
							}
							goto IL_00d7;
						}
						goto end_IL_0007;
					case 0:
						awaiter2 = <>u__1;
						<>u__1 = default(ValueTaskAwaiter<User>);
						num = (<>1__state = -1);
						goto IL_00d7;
					case 1:
						awaiter = <>u__2;
						<>u__2 = default(ValueTaskAwaiter<string>);
						num = (<>1__state = -1);
						break;
					case -4:
						num = (<>1__state = -1);
						if (!<>w__disposeMode)
						{
							<list>5__9 = null;
							goto IL_0401;
						}
						goto end_IL_0007;
					case -5:
						{
							num = (<>1__state = -1);
							if (!<>w__disposeMode)
							{
								<list>5__10 = null;
								goto IL_0401;
							}
							goto end_IL_0007;
						}
						IL_0472:
						url = <nextUrl>5__3 ?? $"https://api-v2.soundcloud.com/users/{<user>5__1.Id}/{<queryPart>5__2}?offset={offset}&limit={limit}&client_id={<>4__this.<endpoint>P.ClientId}";
						<>2__current = null;
						awaiter = <>4__this.<http>P.ExecuteGetAsync(url, cancellationToken).GetAwaiter();
						if (!awaiter.IsCompleted)
						{
							num = (<>1__state = 1);
							<>u__2 = awaiter;
							<GetTrackBatchesAsync>d__7 stateMachine = this;
							<>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);
							return;
						}
						break;
						IL_0401:
						<nextUrl>5__3 = ((object)<doc>5__6["next_href"])?.ToString();
						if (!string.IsNullOrEmpty(<nextUrl>5__3))
						{
							<nextUrl>5__3 = <nextUrl>5__3 + "&client_id=" + <>4__this.<endpoint>P.ClientId;
							<response>5__5 = null;
							<doc>5__6 = null;
							<collection>5__7 = null;
							goto IL_0472;
						}
						goto end_IL_0007;
						IL_00d7:
						<>s__4 = awaiter2.GetResult();
						<user>5__1 = <>s__4;
						<>s__4 = null;
						if (<user>5__1 != null)
						{
							if (1 == 0)
							{
							}
							string text = trackQuery switch
							{
								UserTrackSortBy.Popular => "toptracks", 
								UserTrackSortBy.Likes => "track_likes", 
								_ => "tracks", 
							};
							if (1 == 0)
							{
							}
							<queryPart>5__2 = text;
							<nextUrl>5__3 = null;
							goto IL_0472;
						}
						<>w__disposeMode = true;
						goto end_IL_0007;
					}
					<>s__8 = awaiter.GetResult();
					<response>5__5 = <>s__8;
					<>s__8 = null;
					<doc>5__6 = JObject.Parse(<response>5__5);
					<collection>5__7 = <doc>5__6["collection"];
					if (<collection>5__7 != null && ((IEnumerable<JToken>)<collection>5__7).Any())
					{
						if (trackQuery == UserTrackSortBy.Likes)
						{
							<list>5__9 = (from x in (IEnumerable<JToken>)<collection>5__7
								select JsonConvert.DeserializeObject<Track>(((object)x[(object)"track"]).ToString(), JsonSettings.Default) into track
								where track != null
								select (track)).ToList();
							<>2__current = Batch.Create(<list>5__9);
							num = (<>1__state = -4);
							goto IL_059a;
						}
						<list>5__10 = JsonConvert.DeserializeObject<List<Track>>(((object)<collection>5__7).ToString(), JsonSettings.Default);
						if (<list>5__10 != null && <list>5__10.Count != 0)
						{
							<>2__current = Batch.Create(<list>5__10);
							num = (<>1__state = -5);
							goto IL_059a;
						}
					}
					end_IL_0007:;
				}
				catch (Exception exception)
				{
					<>1__state = -2;
					<user>5__1 = null;
					<queryPart>5__2 = null;
					<nextUrl>5__3 = null;
					<>s__4 = null;
					<response>5__5 = null;
					<doc>5__6 = null;
					<collection>5__7 = null;
					<>s__8 = null;
					<list>5__9 = null;
					<list>5__10 = null;
					if (<>x__combinedTokens != null)
					{
						<>x__combinedTokens.Dispose();
						<>x__combinedTokens = null;
					}
					<>2__current = null;
					<>t__builder.Complete();
					<>v__promiseOfValueOrEnd.SetException(exception);
					return;
				}
				<>1__state = -2;
				<user>5__1 = null;
				<queryPart>5__2 = null;
				<nextUrl>5__3 = null;
				<>s__4 = null;
				<response>5__5 = null;
				<doc>5__6 = null;
				<collection>5__7 = null;
				<>s__8 = null;
				<list>5__9 = null;
				<list>5__10 = null;
				if (<>x__combinedTokens != null)
				{
					<>x__combinedTokens.Dispose();
					<>x__combinedTokens = null;
				}
				<>2__current = null;
				<>t__builder.Complete();
				<>v__promiseOfValueOrEnd.SetResult(result: false);
				return;
				IL_059a:
				<>v__promiseOfValueOrEnd.SetResult(result: true);
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}

			[DebuggerHidden]
			IAsyncEnumerator<Batch<Track>> IAsyncEnumerable<Batch<Track>>.GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
			{
				<GetTrackBatchesAsync>d__7 <GetTrackBatchesAsync>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = -3;
					<>t__builder = AsyncIteratorMethodBuilder.Create();
					<>w__disposeMode = false;
					<GetTrackBatchesAsync>d__ = this;
				}
				else
				{
					<GetTrackBatchesAsync>d__ = new <GetTrackBatchesAsync>d__7(-3)
					{
						<>4__this = <>4__this
					};
				}
				<GetTrackBatchesAsync>d__.url = <>3__url;
				<GetTrackBatchesAsync>d__.trackQuery = <>3__trackQuery;
				<GetTrackBatchesAsync>d__.offset = <>3__offset;
				<GetTrackBatchesAsync>d__.limit = <>3__limit;
				if (<>3__cancellationToken.Equals(default(CancellationToken)))
				{
					<GetTrackBatchesAsync>d__.cancellationToken = cancellationToken;
				}
				else if (cancellationToken.Equals(<>3__cancellationToken) || cancellationToken.Equals(default(CancellationToken)))
				{
					<GetTrackBatchesAsync>d__.cancellationToken = <>3__cancellationToken;
				}
				else
				{
					<>x__combinedTokens = CancellationTokenSource.CreateLinkedTokenSource(<>3__cancellationToken, cancellationToken);
					<GetTrackBatchesAsync>d__.cancellationToken = <>x__combinedTokens.Token;
				}
				return <GetTrackBatchesAsync>d__;
			}

			[DebuggerHidden]
			ValueTask<bool> IAsyncEnumerator<Batch<Track>>.MoveNextAsync()
			{
				if (<>1__state == -2)
				{
					return default(ValueTask<bool>);
				}
				<>v__promiseOfValueOrEnd.Reset();
				<GetTrackBatchesAsync>d__7 stateMachine = this;
				<>t__builder.MoveNext(ref stateMachine);
				short version = <>v__promiseOfValueOrEnd.Version;
				if (<>v__promiseOfValueOrEnd.GetStatus(version) == ValueTaskSourceStatus.Succeeded)
				{
					return new ValueTask<bool>(<>v__promiseOfValueOrEnd.GetResult(version));
				}
				return new ValueTask<bool>(this, version);
			}

			[DebuggerHidden]
			bool IValueTaskSource<bool>.GetResult(short token)
			{
				return <>v__promiseOfValueOrEnd.GetResult(token);
			}

			[DebuggerHidden]
			ValueTaskSourceStatus IValueTaskSource<bool>.GetStatus(short token)
			{
				return <>v__promiseOfValueOrEnd.GetStatus(token);
			}

			[DebuggerHidden]
			void IValueTaskSource<bool>.OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags)
			{
				<>v__promiseOfValueOrEnd.OnCompleted(continuation, state, token, flags);
			}

			[DebuggerHidden]
			void IValueTaskSource.GetResult(short token)
			{
				<>v__promiseOfValueOrEnd.GetResult(token);
			}

			[DebuggerHidden]
			ValueTaskSourceStatus IValueTaskSource.GetStatus(short token)
			{
				return <>v__promiseOfValueOrEnd.GetStatus(token);
			}

			[DebuggerHidden]
			void IValueTaskSource.OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags)
			{
				<>v__promiseOfValueOrEnd.OnCompleted(continuation, state, token, flags);
			}

			[DebuggerHidden]
			ValueTask IAsyncDisposable.DisposeAsync()
			{
				if (<>1__state >= -1)
				{
					throw new NotSupportedException();
				}
				if (<>1__state == -2)
				{
					return default(ValueTask);
				}
				<>w__disposeMode = true;
				<>v__promiseOfValueOrEnd.Reset();
				<GetTrackBatchesAsync>d__7 stateMachine = this;
				<>t__builder.MoveNext(ref stateMachine);
				return new ValueTask(this, <>v__promiseOfValueOrEnd.Version);
			}
		}

		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private HttpClient <http>P;

		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private SoundcloudEndpoint <endpoint>P;

		private readonly Regex LikesRegex;

		public UserClient(HttpClient http, SoundcloudEndpoint endpoint)
		{
			<http>P = http;
			<endpoint>P = endpoint;
			LikesRegex = new Regex("soundcloud\\..+?\\/(.*?)\\/likes");
			base..ctor();
		}

		public bool IsUrlValid(string url)
		{
			if (!Uri.IsWellFormedUriString(url, UriKind.Absolute))
			{
				return false;
			}
			url = url.ToLower();
			UriBuilder uriBuilder = new UriBuilder(url);
			return LikesRegex.IsMatch(url) || ((uriBuilder.Host == "soundcloud.com" || uriBuilder.Host == "m.soundcloud.com") && uriBuilder.Uri.Segments.Length == 2);
		}

		public bool IsLikesUrlValid(string url)
		{
			return Uri.IsWellFormedUriString(url, UriKind.Absolute) && LikesRegex.IsMatch(url);
		}

		public async ValueTask<User> GetAsync(string url, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (!IsUrlValid(url))
			{
				throw new SoundcloudExplodeException("Invalid user url");
			}
			return JsonConvert.DeserializeObject<User>(await <endpoint>P.ResolveUrlAsync(url, cancellationToken), JsonSettings.Default);
		}

		[AsyncIteratorStateMachine(typeof(<GetTrackBatchesAsync>d__7))]
		public IAsyncEnumerable<Batch<Track>> GetTrackBatchesAsync(string url, UserTrackSortBy trackQuery, int offset = 0, int limit = 50, [EnumeratorCancellation] CancellationToken cancellationToken = default(CancellationToken))
		{
			return new <GetTrackBatchesAsync>d__7(-2)
			{
				<>4__this = this,
				<>3__url = url,
				<>3__trackQuery = trackQuery,
				<>3__offset = offset,
				<>3__limit = limit,
				<>3__cancellationToken = cancellationToken
			};
		}

		public IAsyncEnumerable<Track> GetTracksAsync(string url, int offset = 0, int limit = 50, CancellationToken cancellationToken = default(CancellationToken))
		{
			return GetTrackBatchesAsync(url, UserTrackSortBy.Default, offset, limit, cancellationToken).FlattenAsync();
		}

		public IAsyncEnumerable<Track> GetTracksAsync(string url, CancellationToken cancellationToken)
		{
			return GetTrackBatchesAsync(url, UserTrackSortBy.Default, 0, 50, cancellationToken).FlattenAsync();
		}

		public IAsyncEnumerable<Track> GetPopularTracksAsync(string url, int offset = 0, int limit = 50, CancellationToken cancellationToken = default(CancellationToken))
		{
			return GetTrackBatchesAsync(url, UserTrackSortBy.Popular, offset, limit, cancellationToken).FlattenAsync();
		}

		public IAsyncEnumerable<Track> GetPopularTracksAsync(string url, CancellationToken cancellationToken)
		{
			return GetTrackBatchesAsync(url, UserTrackSortBy.Popular, 0, 50, cancellationToken).FlattenAsync();
		}

		public IAsyncEnumerable<Track> GetLikedTracksAsync(string url, int offset = 0, int limit = 50, CancellationToken cancellationToken = default(CancellationToken))
		{
			return GetTrackBatchesAsync(url, UserTrackSortBy.Likes, offset, limit, cancellationToken).FlattenAsync();
		}

		public IAsyncEnumerable<Track> GetLikedTracksAsync(string url, CancellationToken cancellationToken)
		{
			return GetTrackBatchesAsync(url, UserTrackSortBy.Likes, 0, 50, cancellationToken).FlattenAsync();
		}

		[AsyncIteratorStateMachine(typeof(<GetPlaylistBatchesAsync>d__14))]
		public IAsyncEnumerable<Batch<Playlist>> GetPlaylistBatchesAsync(string url, int offset = 0, int limit = 50, [EnumeratorCancellation] CancellationToken cancellationToken = default(CancellationToken))
		{
			return new <GetPlaylistBatchesAsync>d__14(-2)
			{
				<>4__this = this,
				<>3__url = url,
				<>3__offset = offset,
				<>3__limit = limit,
				<>3__cancellationToken = cancellationToken
			};
		}

		public IAsyncEnumerable<Playlist> GetPlaylistsAsync(string url, int offset = 0, int limit = 50, CancellationToken cancellationToken = default(CancellationToken))
		{
			return GetPlaylistBatchesAsync(url, offset, limit, cancellationToken).FlattenAsync();
		}

		public IAsyncEnumerable<Playlist> GetPlaylistsAsync(string url, CancellationToken cancellationToken)
		{
			return GetPlaylistBatchesAsync(url, 0, 50, cancellationToken).FlattenAsync();
		}

		[AsyncIteratorStateMachine(typeof(<GetAlbumBatchesAsync>d__17))]
		public IAsyncEnumerable<Batch<Playlist>> GetAlbumBatchesAsync(string url, int offset = 0, int limit = 50, [EnumeratorCancellation] CancellationToken cancellationToken = default(CancellationToken))
		{
			return new <GetAlbumBatchesAsync>d__17(-2)
			{
				<>4__this = this,
				<>3__url = url,
				<>3__offset = offset,
				<>3__limit = limit,
				<>3__cancellationToken = cancellationToken
			};
		}

		public IAsyncEnumerable<Playlist> GetAlbumsAsync(string url, int offset = 0, int limit = 50, CancellationToken cancellationToken = default(CancellationToken))
		{
			return GetAlbumBatchesAsync(url, offset, limit, cancellationToken).FlattenAsync();
		}

		public IAsyncEnumerable<Playlist> GetAlbumsAsync(string url, CancellationToken cancellationToken)
		{
			return GetAlbumBatchesAsync(url, 0, 50, cancellationToken).FlattenAsync();
		}
	}
	public enum UserTrackSortBy
	{
		Default,
		Popular,
		Likes
	}
}
namespace SoundCloudExplode.Tracks
{
	public class Format
	{
		[JsonProperty("protocol")]
		public string? Protocol { get; set; }

		[JsonProperty("mime_type")]
		public string? MimeType { get; set; }
	}
	public interface ITrackClient
	{
		Task<bool> IsUrlValidAsync(string url, CancellationToken cancellationToken = default(CancellationToken));

		ValueTask<Track?> GetAsync(string url, CancellationToken cancellationToken = default(CancellationToken));

		ValueTask<string?> GetUrlByIdAsync(long trackId, CancellationToken cancellationToken = default(CancellationToken));

		ValueTask<Track?> GetByIdAsync(long trackId, CancellationToken cancellationToken = default(CancellationToken));

		ValueTask<string?> GetDownloadUrlAsync(string url, CancellationToken cancellationToken = default(CancellationToken));

		ValueTask<string?> GetDownloadUrlAsync(Track track, CancellationToken cancellationToken = default(CancellationToken));
	}
	public class Media
	{
		[JsonProperty("transcodings")]
		public List<Transcoding> Transcodings { get; set; } = new List<Transcoding>();

	}
	public class PublisherMetadata
	{
		[JsonProperty("id")]
		public long? Id { get; set; }

		[JsonProperty("urn")]
		public string? Urn { get; set; }

		[JsonProperty("artist")]
		public string? Artist { get; set; }

		[JsonProperty("contains_music")]
		public bool ContainsMusic { get; set; }
	}
	public class Track : IBatchItem
	{
		[JsonProperty("artwork_url")]
		public Uri? ArtworkUrl { get; set; }

		[JsonProperty("caption")]
		public object? Caption { get; set; }

		[JsonProperty("commentable")]
		public bool Commentable { get; set; }

		[JsonProperty("comment_count")]
		public long? CommentCount { get; set; }

		[JsonProperty("created_at")]
		public DateTimeOffset CreatedAt { get; set; }

		[JsonProperty("description")]
		public string? Description { get; set; }

		[JsonProperty("downloadable")]
		public bool Downloadable { get; set; }

		[JsonProperty("download_count")]
		public long? DownloadCount { get; set; }

		[JsonProperty("duration")]
		public long? Duration { get; set; }

		[JsonProperty("full_duration")]
		public long? FullDuration { get; set; }

		[JsonProperty("embeddable_by")]
		public string? EmbeddableBy { get; set; }

		[JsonProperty("genre")]
		public string? Genre { get; set; }

		[JsonProperty("has_downloads_left")]
		public bool HasDownloadsLeft { get; set; }

		[JsonProperty("id")]
		public long Id { get; set; } = 0L;


		[JsonProperty("kind")]
		public Kind Kind { get; set; }

		[JsonProperty("label_name")]
		public string? LabelName { get; set; }

		[JsonProperty("last_modified")]
		public DateTimeOffset LastModified { get; set; }

		[JsonProperty("license")]
		public string? License { get; set; }

		[JsonProperty("likes_count")]
		public long? LikesCount { get; set; }

		[JsonProperty("permalink")]
		public string? Permalink { get; set; }

		[JsonProperty("permalink_url")]
		public Uri? PermalinkUrl { get; set; }

		[JsonProperty("playback_count")]
		public long? PlaybackCount { get; set; }

		[JsonProperty("public")]
		public bool Public { get; set; }

		[JsonProperty("publisher_metadata")]
		public PublisherMetadata? PublisherMetadata { get; set; }

		[JsonProperty("purchase_title")]
		public string? PurchaseTitle { get; set; }

		[JsonProperty("purchase_url")]
		public string? PurchaseUrl { get; set; }

		[JsonProperty("release_date")]
		public object? ReleaseDate { get; set; }

		[JsonProperty("reposts_count")]
		public long? RepostsCount { get; set; }

		[JsonProperty("secret_token")]
		public string? SecretToken { get; set; }

		[JsonProperty("sharing")]
		public string? Sharing { get; set; }

		[JsonProperty("state")]
		public string? State { get; set; }

		[JsonProperty("streamable")]
		public bool Streamable { get; set; }

		[JsonProperty("tag_list")]
		public string? TagList { get; set; }

		[JsonProperty("title")]
		public string? Title { get; set; }

		[JsonProperty("uri")]
		public Uri? Uri { get; set; }

		[JsonProperty("urn")]
		public string? Urn { get; set; }

		[JsonProperty("user_id")]
		public long? UserId { get; set; }

		[JsonProperty("visuals")]
		public object? Visuals { get; set; }

		[JsonProperty("waveform_url")]
		public string? WaveformUrl { get; set; }

		[JsonProperty("display_date")]
		public DateTimeOffset DisplayDate { get; set; }

		[JsonProperty("media")]
		public Media? Media { get; set; }

		[JsonProperty("monetization_model")]
		public string? MonetizationModel { get; set; }

		[JsonProperty("policy")]
		public string? Policy { get; set; }

		[JsonProperty("user")]
		public User? User { get; set; }

		public string? PlaylistName { get; set; }

		[ExcludeFromCodeCoverage]
		public override string ToString()
		{
			return "Track (" + Title + ")";
		}
	}
	public class TrackClient : ITrackClient
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private HttpClient <http>P;

		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private SoundcloudEndpoint <endpoint>P;

		private readonly Regex ShortUrlRegex;

		private readonly Regex SingleTrackRegex;

		private readonly Regex TracksRegex;

		public TrackClient(HttpClient http, SoundcloudEndpoint endpoint)
		{
			<http>P = http;
			<endpoint>P = endpoint;
			ShortUrlRegex = new Regex("on\\.soundcloud\\..+?\\/.+?");
			SingleTrackRegex = new Regex("soundcloud\\..+?\\/(.*?)\\/[a-zA-Z0-9~@#$^*()_+=[\\]{}|\\\\,.?: -]+");
			TracksRegex = new Regex("soundcloud\\..+?\\/(.*?)\\/track");
			base..ctor();
		}

		public async Task<bool> IsUrlValidAsync(string url, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (!Uri.IsWellFormedUriString(url, UriKind.Absolute))
			{
				return false;
			}
			url = url.ToLower();
			if (ShortUrlRegex.IsMatch(url))
			{
				using HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, url);
				using HttpResponseMessage response = await <http>P.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
				url = response.RequestMessage.RequestUri.ToString();
			}
			return TracksRegex.IsMatch(url) || SingleTrackRegex.IsMatch(url);
		}

		public async ValueTask<Track?> GetAsync(string url, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (!(await IsUrlValidAsync(url, cancellationToken)))
			{
				throw new SoundcloudExplodeException("Invalid track url");
			}
			return JsonConvert.DeserializeObject<Track>(await <endpoint>P.ResolveUrlAsync(url, cancellationToken), JsonSettings.Default);
		}

		public async ValueTask<string?> GetUrlByIdAsync(long trackId, CancellationToken cancellationToken = default(CancellationToken))
		{
			string trackInfoJson = await <http>P.ExecuteGetAsync(string.Format("{0}/{1}?client_id={2}", "https://api-v2.soundcloud.com/tracks", trackId, <endpoint>P.ClientId), cancellationToken);
			if (trackInfoJson == null)
			{
				return null;
			}
			Track track = JsonConvert.DeserializeObject<Track>(trackInfoJson, JsonSettings.Default);
			return (track == null || (object)track.PermalinkUrl == null) ? null : track.PermalinkUrl?.ToString();
		}

		public async ValueTask<Track?> GetByIdAsync(long trackId, CancellationToken cancellationToken = default(CancellationToken))
		{
			string trackUrl = await GetUrlByIdAsync(trackId, cancellationToken);
			return (trackUrl != null) ? (await GetAsync(trackUrl, cancellationToken)) : null;
		}

		private async ValueTask<string?> QueryTrackMp3Async(string trackM3u8, CancellationToken cancellationToken = default(CancellationToken))
		{
			string[] m3u8 = (await <http>P.ExecuteGetAsync(trackM3u8, cancellationToken)).Split(new char[1] { ',' });
			if (m3u8.Length == 0)
			{
				return null;
			}
			string link = "";
			string[] last_stream = m3u8.Last().Split(new char[1] { '/' });
			for (int i = 0; i < last_stream.Length; i++)
			{
				if (last_stream[i] == "media")
				{
					last_stream[i + 1] = "0";
					link = string.Join("/", last_stream).Split(new char[1] { '\n' })[1];
				}
			}
			return link;
		}

		public async ValueTask<string?> GetDownloadUrlAsync(string url, CancellationToken cancellationToken = default(CancellationToken))
		{
			Track track = await GetAsync(url, cancellationToken);
			if (track == null)
			{
				return null;
			}
			return await GetDownloadUrlAsync(track, cancellationToken);
		}

		public async ValueTask<string?> GetDownloadUrlAsync(Track track, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (track.Policy?.ToLower() == "block")
			{
				throw new TrackUnavailableException("This track is not available in your country");
			}
			if (track.Media == null || track.Media.Transcodings == null || track.Media.Transcodings.Count == 0)
			{
				throw new TrackUnavailableException("No transcodings found");
			}
			Transcoding transcoding = track.Media.Transcodings.FirstOrDefault(delegate(Transcoding x)
			{
				int result4;
				if (x.Quality == "hq")
				{
					Format? format4 = x.Format;
					if (format4 != null && (format4.MimeType?.Contains("audio/mp4")).GetValueOrDefault())
					{
						result4 = ((x.Format.Protocol == "progressive") ? 1 : 0);
						goto IL_0064;
					}
				}
				result4 = 0;
				goto IL_0064;
				IL_0064:
				return (byte)result4 != 0;
			}) ?? track.Media.Transcodings.FirstOrDefault(delegate(Transcoding x)
			{
				int result3;
				if (x.Quality == "hq")
				{
					Format? format3 = x.Format;
					if (format3 != null && (format3.MimeType?.Contains("audio/mp4")).GetValueOrDefault())
					{
						result3 = ((x.Format.Protocol == "hls") ? 1 : 0);
						goto IL_0064;
					}
				}
				result3 = 0;
				goto IL_0064;
				IL_0064:
				return (byte)result3 != 0;
			}) ?? track.Media.Transcodings.FirstOrDefault(delegate(Transcoding x)
			{
				int result2;
				if (x.Quality == "sq")
				{
					Format? format2 = x.Format;
					if (format2 != null && (format2.MimeType?.Contains("audio/mpeg")).GetValueOrDefault())
					{
						result2 = ((x.Format.Protocol == "progressive") ? 1 : 0);
						goto IL_0064;
					}
				}
				result2 = 0;
				goto IL_0064;
				IL_0064:
				return (byte)result2 != 0;
			}) ?? track.Media.Transcodings.FirstOrDefault(delegate(Transcoding x)
			{
				int result;
				if (x.Quality == "sq")
				{
					Format? format = x.Format;
					if (format != null && (format.MimeType?.Contains("ogg")).GetValueOrDefault())
					{
						result = ((x.Format.Protocol == "hls") ? 1 : 0);
						goto IL_0064;
					}
				}
				result = 0;
				goto IL_0064;
				IL_0064:
				return (byte)result != 0;
			});
			if (transcoding == null || (object)transcoding.Url == null)
			{
				return null;
			}
			JObject jObject = JObject.Parse(await HttpExtensions.ExecuteGetAsync(url: transcoding.Url.ToString() + "?client_id=" + <endpoint>P.ClientId, http: <http>P, cancellationToken: cancellationToken));
			string trackMediaUrl = ((object)jObject["url"])?.ToString();
			return (!(trackMediaUrl?.Contains(".m3u8") ?? false)) ? trackMediaUrl : (await QueryTrackMp3Async(trackMediaUrl, cancellationToken));
		}
	}
	public class Transcoding
	{
		[JsonProperty("url")]
		public Uri? Url { get; set; }

		[JsonProperty("preset")]
		public string? Preset { get; set; }

		[JsonProperty("duration")]
		public long? Duration { get; set; }

		[JsonProperty("snipped")]
		public bool Snipped { get; set; }

		[JsonProperty("format")]
		public Format? Format { get; set; }

		[JsonProperty("quality")]
		public string? Quality { get; set; }
	}
}
namespace SoundCloudExplode.Search
{
	public interface ISearchClient
	{
		bool IsUrlValid(string url);

		ValueTask<List<string>> GetSearchQueriesAsync(string query, int offset = 0, int limit = 50, CancellationToken cancellationToken = default(CancellationToken));

		IAsyncEnumerable<Batch<ISearchResult>> GetResultBatchesAsync(string searchQuery, SearchFilter searchFilter, int offset = 0, int limit = 50, CancellationToken cancellationToken = default(CancellationToken));

		IAsyncEnumerable<ISearchResult> GetResultsAsync(string searchQuery, int offset = 0, int limit = 50, CancellationToken cancellationToken = default(CancellationToken));

		IAsyncEnumerable<TrackSearchResult> GetTracksAsync(string searchQuery, int offset = 0, int limit = 50, CancellationToken cancellationToken = default(CancellationToken));

		IAsyncEnumerable<PlaylistSearchResult> GetPlaylistsAsync(string searchQuery, int offset = 0, int limit = 50, CancellationToken cancellationToken = default(CancellationToken));

		IAsyncEnumerable<PlaylistSearchResult> GetPlaylistsWithoutAlbumsAsync(string searchQuery, int offset = 0, int limit = 50, CancellationToken cancellationToken = default(CancellationToken));

		IAsyncEnumerable<PlaylistSearchResult> GetAlbumsAsync(string searchQuery, int offset = 0, int limit = 50, CancellationToken cancellationToken = default(CancellationToken));

		IAsyncEnumerable<UserSearchResult> GetUsersAsync(string searchQuery, int offset = 0, int limit = 50, CancellationToken cancellationToken = default(CancellationToken));
	}
	public interface ISearchResult : IBatchItem
	{
		string? Url { get; }

		string? Title { get; }
	}
	public class PlaylistSearchResult : Playlist, ISearchResult, IBatchItem
	{
		public string? Url => base.PermalinkUrl?.ToString();
	}
	public class SearchClient : ISearchClient
	{
		[CompilerGenerated]
		private sealed class <GetResultBatchesAsync>d__5 : IAsyncEnumerable<Batch<ISearchResult>>, IAsyncEnumerator<Batch<ISearchResult>>, IAsyncDisposable, IValueTaskSource<bool>, IValueTaskSource, IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncIteratorMethodBuilder <>t__builder;

			public ManualResetValueTaskSourceCore<bool> <>v__promiseOfValueOrEnd;

			private Batch<ISearchResult> <>2__current;

			private bool <>w__disposeMode;

			private CancellationTokenSource <>x__combinedTokens;

			private int <>l__initialThreadId;

			private string searchQuery;

			public string <>3__searchQuery;

			private SearchFilter searchFilter;

			public SearchFilter <>3__searchFilter;

			private int offset;

			public int <>3__offset;

			private int limit;

			public int <>3__limit;

			private CancellationToken cancellationToken;

			public CancellationToken <>3__cancellationToken;

			public SearchClient <>4__this;

			private HashSet<string> <encounteredUrls>5__1;

			private int <continuationOffset>5__2;

			private List<ISearchResult> <results>5__3;

			private string <searchFilterStr>5__4;

			private string <url>5__5;

			private string <response>5__6;

			private JObject <jObject>5__7;

			private JToken <collection>5__8;

			private string <>s__9;

			private IEnumerator<JToken> <>s__10;

			private JToken <item>5__11;

			private string <permalinkUrl>5__12;

			private Uri <permalinkUri>5__13;

			private UserSearchResult <user>5__14;

			private TrackSearchResult <track>5__15;

			private PlaylistSearchResult <playlist>5__16;

			private ValueTaskAwaiter<string> <>u__1;

			Batch<ISearchResult> IAsyncEnumerator<Batch<ISearchResult>>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetResultBatchesAsync>d__5(int <>1__state)
			{
				<>t__builder = AsyncIteratorMethodBuilder.Create();
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			private void MoveNext()
			{
				int num = <>1__state;
				try
				{
					ValueTaskAwaiter<string> awaiter;
					switch (num)
					{
					default:
						if (!<>w__disposeMode)
						{
							num = (<>1__state = -1);
							Limitor.Validate(limit);
							<encounteredUrls>5__1 = new HashSet<string>(StringComparer.Ordinal);
							<continuationOffset>5__2 = offset;
							<results>5__3 = new List<ISearchResult>();
							if (1 == 0)
							{
							}
							string text = searchFilter switch
							{
								SearchFilter.Track => "/tracks", 
								SearchFilter.Playlist => "/playlists", 
								SearchFilter.PlaylistWithoutAlbums => "/playlists_without_albums", 
								SearchFilter.Album => "/albums", 
								SearchFilter.User => "/users", 
								_ => "", 
							};
							if (1 == 0)
							{
							}
							<searchFilterStr>5__4 = text;
							goto IL_049f;
						}
						goto end_IL_0007;
					case 0:
						awaiter = <>u__1;
						<>u__1 = default(ValueTaskAwaiter<string>);
						num = (<>1__state = -1);
						break;
					case -4:
						{
							num = (<>1__state = -1);
							if (!<>w__disposeMode)
							{
								<continuationOffset>5__2 += <results>5__3.Count;
								<url>5__5 = null;
								<response>5__6 = null;
								<jObject>5__7 = null;
								<collection>5__8 = null;
								goto IL_049f;
							}
							goto end_IL_0007;
						}
						IL_049f:
						<results>5__3.Clear();
						<url>5__5 = $"https://api-v2.soundcloud.com/search{<searchFilterStr>5__4}?q={Uri.EscapeDataString(searchQuery)}&client_id={<>4__this.<endpoint>P.ClientId}&limit={limit}&offset={<continuationOffset>5__2}";
						<>2__current = null;
						awaiter = <>4__this.<http>P.ExecuteGetAsync(<url>5__5, cancellationToken).GetAwaiter();
						if (!awaiter.IsCompleted)
						{
							num = (<>1__state = 0);
							<>u__1 = awaiter;
							<GetResultBatchesAsync>d__5 stateMachine = this;
							<>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);
							return;
						}
						break;
					}
					<>s__9 = awaiter.GetResult();
					<response>5__6 = <>s__9;
					<>s__9 = null;
					<jObject>5__7 = JObject.Parse(<response>5__6);
					<collection>5__8 = <jObject>5__7["collection"];
					if (<collection>5__8 != null && ((IEnumerable<JToken>)<collection>5__8).Any())
					{
						<>s__10 = ((IEnumerable<JToken>)<collection>5__8).GetEnumerator();
						try
						{
							while (<>s__10.MoveNext())
							{
								<item>5__11 = <>s__10.Current;
								<permalinkUrl>5__12 = ((object)<item>5__11[(object)"permalink_url"])?.ToString();
								if (<permalinkUrl>5__12 == null || !Uri.IsWellFormedUriString(<permalinkUrl>5__12, UriKind.Absolute) || !<encounteredUrls>5__1.Add(<permalinkUrl>5__12))
								{
									continue;
								}
								<permalinkUri>5__13 = new Uri(<permalinkUrl>5__12);
								if (<permalinkUri>5__13.Segments.Length == 2)
								{
									<user>5__14 = JsonConvert.DeserializeObject<UserSearchResult>(((object)<item>5__11).ToString(), JsonSettings.Default);
									<results>5__3.Add(<user>5__14);
									continue;
								}
								if (<permalinkUri>5__13.Segments.Length == 3)
								{
									<track>5__15 = JsonConvert.DeserializeObject<TrackSearchResult>(((object)<item>5__11).ToString(), JsonSettings.Default);
									<results>5__3.Add(<track>5__15);
									continue;
								}
								if (<permalinkUri>5__13.Segments.Length == 4 && <permalinkUri>5__13.Segments[2] == "sets/")
								{
									<playlist>5__16 = JsonConvert.DeserializeObject<PlaylistSearchResult>(((object)<item>5__11).ToString(), JsonSettings.Default);
									<results>5__3.Add(<playlist>5__16);
									<playlist>5__16 = null;
								}
								<permalinkUrl>5__12 = null;
								<permalinkUri>5__13 = null;
								<item>5__11 = null;
							}
						}
						finally
						{
							if (num == -1 && <>s__10 != null)
							{
								<>s__10.Dispose();
							}
						}
						if (!<>w__disposeMode)
						{
							<>s__10 = null;
							if (<results>5__3.Count != 0)
							{
								<>2__current = Batch.Create(<results>5__3);
								num = (<>1__state = -4);
								goto IL_060d;
							}
						}
					}
					end_IL_0007:;
				}
				catch (Exception exception)
				{
					<>1__state = -2;
					<encounteredUrls>5__1 = null;
					<results>5__3 = null;
					<searchFilterStr>5__4 = null;
					<url>5__5 = null;
					<response>5__6 = null;
					<jObject>5__7 = null;
					<collection>5__8 = null;
					<>s__9 = null;
					<>s__10 = null;
					<item>5__11 = null;
					<permalinkUrl>5__12 = null;
					<permalinkUri>5__13 = null;
					<user>5__14 = null;
					<track>5__15 = null;
					<playlist>5__16 = null;
					if (<>x__combinedTokens != null)
					{
						<>x__combinedTokens.Dispose();
						<>x__combinedTokens = null;
					}
					<>2__current = null;
					<>t__builder.Complete();
					<>v__promiseOfValueOrEnd.SetException(exception);
					return;
				}
				<>1__state = -2;
				<encounteredUrls>5__1 = null;
				<results>5__3 = null;
				<searchFilterStr>5__4 = null;
				<url>5__5 = null;
				<response>5__6 = null;
				<jObject>5__7 = null;
				<collection>5__8 = null;
				<>s__9 = null;
				<>s__10 = null;
				<item>5__11 = null;
				<permalinkUrl>5__12 = null;
				<permalinkUri>5__13 = null;
				<user>5__14 = null;
				<track>5__15 = null;
				<playlist>5__16 = null;
				if (<>x__combinedTokens != null)
				{
					<>x__combinedTokens.Dispose();
					<>x__combinedTokens = null;
				}
				<>2__current = null;
				<>t__builder.Complete();
				<>v__promiseOfValueOrEnd.SetResult(result: false);
				return;
				IL_060d:
				<>v__promiseOfValueOrEnd.SetResult(result: true);
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}

			[DebuggerHidden]
			IAsyncEnumerator<Batch<ISearchResult>> IAsyncEnumerable<Batch<ISearchResult>>.GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
			{
				<GetResultBatchesAsync>d__5 <GetResultBatchesAsync>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = -3;
					<>t__builder = AsyncIteratorMethodBuilder.Create();
					<>w__disposeMode = false;
					<GetResultBatchesAsync>d__ = this;
				}
				else
				{
					<GetResultBatchesAsync>d__ = new <GetResultBatchesAsync>d__5(-3)
					{
						<>4__this = <>4__this
					};
				}
				<GetResultBatchesAsync>d__.searchQuery = <>3__searchQuery;
				<GetResultBatchesAsync>d__.searchFilter = <>3__searchFilter;
				<GetResultBatchesAsync>d__.offset = <>3__offset;
				<GetResultBatchesAsync>d__.limit = <>3__limit;
				if (<>3__cancellationToken.Equals(default(CancellationToken)))
				{
					<GetResultBatchesAsync>d__.cancellationToken = cancellationToken;
				}
				else if (cancellationToken.Equals(<>3__cancellationToken) || cancellationToken.Equals(default(CancellationToken)))
				{
					<GetResultBatchesAsync>d__.cancellationToken = <>3__cancellationToken;
				}
				else
				{
					<>x__combinedTokens = CancellationTokenSource.CreateLinkedTokenSource(<>3__cancellationToken, cancellationToken);
					<GetResultBatchesAsync>d__.cancellationToken = <>x__combinedTokens.Token;
				}
				return <GetResultBatchesAsync>d__;
			}

			[DebuggerHidden]
			ValueTask<bool> IAsyncEnumerator<Batch<ISearchResult>>.MoveNextAsync()
			{
				if (<>1__state == -2)
				{
					return default(ValueTask<bool>);
				}
				<>v__promiseOfValueOrEnd.Reset();
				<GetResultBatchesAsync>d__5 stateMachine = this;
				<>t__builder.MoveNext(ref stateMachine);
				short version = <>v__promiseOfValueOrEnd.Version;
				if (<>v__promiseOfValueOrEnd.GetStatus(version) == ValueTaskSourceStatus.Succeeded)
				{
					return new ValueTask<bool>(<>v__promiseOfValueOrEnd.GetResult(version));
				}
				return new ValueTask<bool>(this, version);
			}

			[DebuggerHidden]
			bool IValueTaskSource<bool>.GetResult(short token)
			{
				return <>v__promiseOfValueOrEnd.GetResult(token);
			}

			[DebuggerHidden]
			ValueTaskSourceStatus IValueTaskSource<bool>.GetStatus(short token)
			{
				return <>v__promiseOfValueOrEnd.GetStatus(token);
			}

			[DebuggerHidden]
			void IValueTaskSource<bool>.OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags)
			{
				<>v__promiseOfValueOrEnd.OnCompleted(continuation, state, token, flags);
			}

			[DebuggerHidden]
			void IValueTaskSource.GetResult(short token)
			{
				<>v__promiseOfValueOrEnd.GetResult(token);
			}

			[DebuggerHidden]
			ValueTaskSourceStatus IValueTaskSource.GetStatus(short token)
			{
				return <>v__promiseOfValueOrEnd.GetStatus(token);
			}

			[DebuggerHidden]
			void IValueTaskSource.OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags)
			{
				<>v__promiseOfValueOrEnd.OnCompleted(continuation, state, token, flags);
			}

			[DebuggerHidden]
			ValueTask IAsyncDisposable.DisposeAsync()
			{
				if (<>1__state >= -1)
				{
					throw new NotSupportedException();
				}
				if (<>1__state == -2)
				{
					return default(ValueTask);
				}
				<>w__disposeMode = true;
				<>v__promiseOfValueOrEnd.Reset();
				<GetResultBatchesAsync>d__5 stateMachine = this;
				<>t__builder.MoveNext(ref stateMachine);
				return new ValueTask(this, <>v__promiseOfValueOrEnd.Version);
			}
		}

		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private HttpClient <http>P;

		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private SoundcloudEndpoint <endpoint>P;

		public SearchClient(HttpClient http, SoundcloudEndpoint endpoint)
		{
			<http>P = http;
			<endpoint>P = endpoint;
			base..ctor();
		}

		public bool IsUrlValid(string url)
		{
			url = url.ToLower();
			return Uri.IsWellFormedUriString(url, UriKind.Absolute);
		}

		public async ValueTask<List<string>> GetSearchQueriesAsync(string query, int offset = 0, int limit = 50, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (string.IsNullOrWhiteSpace(query))
			{
				return new List<string>();
			}
			Limitor.Validate(limit);
			JObject jObject = JObject.Parse(await HttpExtensions.ExecuteGetAsync(url: $"https://api-v2.soundcloud.com/search/queries?q={Uri.EscapeDataString(query)}&client_id=Tl7CY6xVpYugZsGNqmzUhDCRX3urIPNv&limit={limit}&offset={offset}&linked_partitioning=1&app_version=1718276310&app_locale=en", http: <http>P, cancellationToken: cancellationToken));
			return ((IEnumerable<JToken>)jObject["collection"]).Select((JToken x) => ((object)x[(object)"output"]).ToString()).ToList();
		}

		[AsyncIteratorStateMachine(typeof(<GetResultBatchesAsync>d__5))]
		public IAsyncEnumerable<Batch<ISearchResult>> GetResultBatchesAsync(string searchQuery, SearchFilter searchFilter, int offset = 0, int limit = 50, [EnumeratorCancellation] CancellationToken cancellationToken = default(CancellationToken))
		{
			return new <GetResultBatchesAsync>d__5(-2)
			{
				<>4__this = this,
				<>3__searchQuery = searchQuery,
				<>3__searchFilter = searchFilter,
				<>3__offset = offset,
				<>3__limit = limit,
				<>3__cancellationToken = cancellationToken
			};
		}

		public IAsyncEnumerable<Batch<ISearchResult>> GetResultBatchesAsync(string searchQuery, int offset = 0, int limit = 50, CancellationToken cancellationToken = default(CancellationToken))
		{
			return GetResultBatchesAsync(searchQuery, SearchFilter.None, offset, limit, cancellationToken);
		}

		public IAsyncEnumerable<Batch<ISearchResult>> GetResultBatchesAsync(string searchQuery, CancellationToken cancellationToken)
		{
			return GetResultBatchesAsync(searchQuery, SearchFilter.None, 0, 50, cancellationToken);
		}

		public IAsyncEnumerable<ISearchResult> GetResultsAsync(string searchQuery, int offset = 0, int limit = 50, CancellationToken cancellationToken = default(CancellationToken))
		{
			return GetResultBatchesAsync(searchQuery, offset, limit, cancellationToken).FlattenAsync();
		}

		public IAsyncEnumerable<ISearc