using System;
using System.Buffers;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using FxResources.Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Internal;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(/*Could not decode attribute arguments.*/)]
[assembly: InternalsVisibleTo("Microsoft.Extensions.Logging.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]
[assembly: TargetFramework(".NETCoreApp,Version=v8.0", FrameworkDisplayName = ".NET 8.0")]
[assembly: AssemblyMetadata("Serviceable", "True")]
[assembly: AssemblyMetadata("PreferInbox", "True")]
[assembly: AssemblyDefaultAlias("Microsoft.Extensions.Logging.Abstractions")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: CLSCompliant(true)]
[assembly: AssemblyMetadata("IsTrimmable", "True")]
[assembly: DefaultDllImportSearchPaths(/*Could not decode attribute arguments.*/)]
[assembly: AssemblyCompany("Microsoft Corporation")]
[assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")]
[assembly: AssemblyDescription("Logging abstractions for Microsoft.Extensions.Logging.\r\n\r\nCommonly Used Types:\r\nMicrosoft.Extensions.Logging.ILogger\r\nMicrosoft.Extensions.Logging.ILoggerFactory\r\nMicrosoft.Extensions.Logging.ILogger<TCategoryName>\r\nMicrosoft.Extensions.Logging.LogLevel\r\nMicrosoft.Extensions.Logging.Logger<T>\r\nMicrosoft.Extensions.Logging.LoggerMessage\r\nMicrosoft.Extensions.Logging.Abstractions.NullLogger")]
[assembly: AssemblyFileVersion("8.0.23.53103")]
[assembly: AssemblyInformationalVersion("8.0.0+5535e31a712343a63f5d7d796cd874e563e5ac14")]
[assembly: AssemblyProduct("Microsoft® .NET")]
[assembly: AssemblyTitle("Microsoft.Extensions.Logging.Abstractions")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/runtime")]
[assembly: SecurityPermission(8, SkipVerification = true)]
[assembly: AssemblyVersion("8.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NullablePublicOnly(true)]
namespace FxResources.Microsoft.Extensions.Logging.Abstractions
{
	internal static class SR
	{
	}
}
namespace System
{
	internal static class ThrowHelper
	{
		internal static void ThrowIfNull([NotNull] object? argument, [CallerArgumentExpression("argument")] string? paramName = null)
		{
			if (argument == null)
			{
				Throw(paramName);
			}
		}

		[DoesNotReturn]
		private static void Throw(string paramName)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			throw new ArgumentNullException(paramName);
		}

		[MethodImpl(256)]
		[return: NotNull]
		public static string IfNullOrWhitespace([NotNull] string? argument, [CallerArgumentExpression("argument")] string paramName = "")
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(argument))
			{
				if (argument == null)
				{
					throw new ArgumentNullException(paramName);
				}
				throw new ArgumentException(paramName, "Argument is whitespace");
			}
			return argument;
		}
	}
	internal static class SR
	{
		private static readonly bool s_usingResourceKeys;

		private static ResourceManager s_resourceManager;

		internal static ResourceManager ResourceManager
		{
			get
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Expected O, but got Unknown
				object obj = s_resourceManager;
				if (obj == null)
				{
					ResourceManager val = new ResourceManager(typeof(FxResources.Microsoft.Extensions.Logging.Abstractions.SR));
					s_resourceManager = val;
					obj = (object)val;
				}
				return (ResourceManager)obj;
			}
		}

		internal static string UnexpectedNumberOfNamedParameters => GetResourceString("UnexpectedNumberOfNamedParameters");

		internal static bool UsingResourceKeys()
		{
			return s_usingResourceKeys;
		}

		private static string GetResourceString(string resourceKey)
		{
			if (UsingResourceKeys())
			{
				return resourceKey;
			}
			string result = null;
			try
			{
				result = ResourceManager.GetString(resourceKey);
			}
			catch (MissingManifestResourceException)
			{
			}
			return result;
		}

		private static string GetResourceString(string resourceKey, string defaultString)
		{
			string resourceString = GetResourceString(resourceKey);
			if (!(resourceKey == resourceString) && resourceString != null)
			{
				return resourceString;
			}
			return defaultString;
		}

		internal static string Format(string resourceFormat, object? p1)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", new object[2] { resourceFormat, p1 });
			}
			return string.Format(resourceFormat, p1);
		}

		internal static string Format(string resourceFormat, object? p1, object? p2)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", new object[3] { resourceFormat, p1, p2 });
			}
			return string.Format(resourceFormat, p1, p2);
		}

		internal static string Format(string resourceFormat, object? p1, object? p2, object? p3)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", new object[4] { resourceFormat, p1, p2, p3 });
			}
			return string.Format(resourceFormat, p1, p2, p3);
		}

		internal static string Format(string resourceFormat, params object?[]? args)
		{
			if (args != null)
			{
				if (UsingResourceKeys())
				{
					return resourceFormat + ", " + string.Join(", ", args);
				}
				return string.Format(resourceFormat, args);
			}
			return resourceFormat;
		}

		internal static string Format(IFormatProvider? provider, string resourceFormat, object? p1)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", new object[2] { resourceFormat, p1 });
			}
			return string.Format(provider, resourceFormat, p1);
		}

		internal static string Format(IFormatProvider? provider, string resourceFormat, object? p1, object? p2)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", new object[3] { resourceFormat, p1, p2 });
			}
			return string.Format(provider, resourceFormat, p1, p2);
		}

		internal static string Format(IFormatProvider? provider, string resourceFormat, object? p1, object? p2, object? p3)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", new object[4] { resourceFormat, p1, p2, p3 });
			}
			return string.Format(provider, resourceFormat, p1, p2, p3);
		}

		internal static string Format(IFormatProvider? provider, string resourceFormat, params object?[]? args)
		{
			if (args != null)
			{
				if (UsingResourceKeys())
				{
					return resourceFormat + ", " + string.Join(", ", args);
				}
				return string.Format(provider, resourceFormat, args);
			}
			return resourceFormat;
		}

		static SR()
		{
			bool flag = default(bool);
			s_usingResourceKeys = AppContext.TryGetSwitch("System.Resources.UseSystemResourceKeys", ref flag) && flag;
		}
	}
}
namespace System.Text
{
	[Obsolete("Types with embedded references are not supported in this version of your compiler.", true)]
	[CompilerFeatureRequired("RefStructs")]
	[DefaultMember("Item")]
	internal ref struct ValueStringBuilder
	{
		private char[] _arrayToReturnToPool;

		private System.Span<char> _chars;

		private int _pos;

		public int Length
		{
			get
			{
				return _pos;
			}
			set
			{
				_pos = value;
			}
		}

		public int Capacity => _chars.Length;

		public ref char this[int index] => ref _chars[index];

		public System.Span<char> RawChars => _chars;

		public ValueStringBuilder(System.Span<char> initialBuffer)
		{
			_arrayToReturnToPool = null;
			_chars = initialBuffer;
			_pos = 0;
		}

		public ValueStringBuilder(int initialCapacity)
		{
			_arrayToReturnToPool = ArrayPool<char>.Shared.Rent(initialCapacity);
			_chars = System.Span<char>.op_Implicit(_arrayToReturnToPool);
			_pos = 0;
		}

		public void EnsureCapacity(int capacity)
		{
			if ((uint)capacity > (uint)_chars.Length)
			{
				Grow(capacity - _pos);
			}
		}

		public ref char GetPinnableReference()
		{
			return ref MemoryMarshal.GetReference<char>(_chars);
		}

		public ref char GetPinnableReference(bool terminate)
		{
			if (terminate)
			{
				EnsureCapacity(Length + 1);
				_chars[Length] = '\0';
			}
			return ref MemoryMarshal.GetReference<char>(_chars);
		}

		public string ToString()
		{
			string result = ((object)_chars.Slice(0, _pos)).ToString();
			Dispose();
			return result;
		}

		public System.ReadOnlySpan<char> AsSpan(bool terminate)
		{
			if (terminate)
			{
				EnsureCapacity(Length + 1);
				_chars[Length] = '\0';
			}
			return System.Span<char>.op_Implicit(_chars.Slice(0, _pos));
		}

		public System.ReadOnlySpan<char> AsSpan()
		{
			return System.Span<char>.op_Implicit(_chars.Slice(0, _pos));
		}

		public System.ReadOnlySpan<char> AsSpan(int start)
		{
			return System.Span<char>.op_Implicit(_chars.Slice(start, _pos - start));
		}

		public System.ReadOnlySpan<char> AsSpan(int start, int length)
		{
			return System.Span<char>.op_Implicit(_chars.Slice(start, length));
		}

		public bool TryCopyTo(System.Span<char> destination, out int charsWritten)
		{
			if (_chars.Slice(0, _pos).TryCopyTo(destination))
			{
				charsWritten = _pos;
				Dispose();
				return true;
			}
			charsWritten = 0;
			Dispose();
			return false;
		}

		public void Insert(int index, char value, int count)
		{
			if (_pos > _chars.Length - count)
			{
				Grow(count);
			}
			int num = _pos - index;
			_chars.Slice(index, num).CopyTo(_chars.Slice(index + count));
			_chars.Slice(index, count).Fill(value);
			_pos += count;
		}

		public void Insert(int index, string? s)
		{
			if (s != null)
			{
				int length = s.Length;
				if (_pos > _chars.Length - length)
				{
					Grow(length);
				}
				int num = _pos - index;
				_chars.Slice(index, num).CopyTo(_chars.Slice(index + length));
				s.CopyTo(_chars.Slice(index));
				_pos += length;
			}
		}

		[MethodImpl(256)]
		public void Append(char c)
		{
			int pos = _pos;
			System.Span<char> chars = _chars;
			if ((uint)pos < (uint)chars.Length)
			{
				chars[pos] = c;
				_pos = pos + 1;
			}
			else
			{
				GrowAndAppend(c);
			}
		}

		[MethodImpl(256)]
		public void Append(string? s)
		{
			if (s != null)
			{
				int pos = _pos;
				if (s.Length == 1 && (uint)pos < (uint)_chars.Length)
				{
					_chars[pos] = s[0];
					_pos = pos + 1;
				}
				else
				{
					AppendSlow(s);
				}
			}
		}

		private void AppendSlow(string s)
		{
			int pos = _pos;
			if (pos > _chars.Length - s.Length)
			{
				Grow(s.Length);
			}
			s.CopyTo(_chars.Slice(pos));
			_pos += s.Length;
		}

		public void Append(char c, int count)
		{
			if (_pos > _chars.Length - count)
			{
				Grow(count);
			}
			System.Span<char> span = _chars.Slice(_pos, count);
			for (int i = 0; i < span.Length; i++)
			{
				span[i] = c;
			}
			_pos += count;
		}

		public unsafe void Append(char* value, int length)
		{
			int pos = _pos;
			if (pos > _chars.Length - length)
			{
				Grow(length);
			}
			System.Span<char> span = _chars.Slice(_pos, length);
			for (int i = 0; i < span.Length; i++)
			{
				span[i] = *(value++);
			}
			_pos += length;
		}

		public void Append(System.ReadOnlySpan<char> value)
		{
			int pos = _pos;
			if (pos > _chars.Length - value.Length)
			{
				Grow(value.Length);
			}
			value.CopyTo(_chars.Slice(_pos));
			_pos += value.Length;
		}

		[MethodImpl(256)]
		public System.Span<char> AppendSpan(int length)
		{
			int pos = _pos;
			if (pos > _chars.Length - length)
			{
				Grow(length);
			}
			_pos = pos + length;
			return _chars.Slice(pos, length);
		}

		[MethodImpl(8)]
		private void GrowAndAppend(char c)
		{
			Grow(1);
			Append(c);
		}

		[MethodImpl(8)]
		private void Grow(int additionalCapacityBeyondPos)
		{
			int num = (int)Math.Max((uint)(_pos + additionalCapacityBeyondPos), Math.Min((uint)(_chars.Length * 2), 2147483591u));
			char[] array = ArrayPool<char>.Shared.Rent(num);
			_chars.Slice(0, _pos).CopyTo(System.Span<char>.op_Implicit(array));
			char[] arrayToReturnToPool = _arrayToReturnToPool;
			_chars = System.Span<char>.op_Implicit(_arrayToReturnToPool = array);
			if (arrayToReturnToPool != null)
			{
				ArrayPool<char>.Shared.Return(arrayToReturnToPool, false);
			}
		}

		[MethodImpl(256)]
		public void Dispose()
		{
			char[] arrayToReturnToPool = _arrayToReturnToPool;
			this = default(ValueStringBuilder);
			if (arrayToReturnToPool != null)
			{
				ArrayPool<char>.Shared.Return(arrayToReturnToPool, false);
			}
		}
	}
}
namespace Microsoft.Extensions.Internal
{
	internal static class TypeNameHelper
	{
		private readonly struct DisplayNameOptions
		{
			[field: CompilerGenerated]
			public bool FullName
			{
				[CompilerGenerated]
				get;
			}

			[field: CompilerGenerated]
			public bool IncludeGenericParameters
			{
				[CompilerGenerated]
				get;
			}

			[field: CompilerGenerated]
			public bool IncludeGenericParameterNames
			{
				[CompilerGenerated]
				get;
			}

			[field: CompilerGenerated]
			public char NestedTypeDelimiter
			{
				[CompilerGenerated]
				get;
			}

			public DisplayNameOptions(bool fullName, bool includeGenericParameterNames, bool includeGenericParameters, char nestedTypeDelimiter)
			{
				FullName = fullName;
				IncludeGenericParameters = includeGenericParameters;
				IncludeGenericParameterNames = includeGenericParameterNames;
				NestedTypeDelimiter = nestedTypeDelimiter;
			}
		}

		private const char DefaultNestedTypeDelimiter = '+';

		private static readonly Dictionary<System.Type, string> _builtInTypeNames;

		[return: NotNullIfNotNull("item")]
		public static string? GetTypeDisplayName(object? item, bool fullName = true)
		{
			if (item != null)
			{
				return GetTypeDisplayName(item.GetType(), fullName);
			}
			return null;
		}

		public static string GetTypeDisplayName(System.Type type, bool fullName = true, bool includeGenericParameterNames = false, bool includeGenericParameters = true, char nestedTypeDelimiter = '+')
		{
			StringBuilder builder = null;
			DisplayNameOptions options = new DisplayNameOptions(fullName, includeGenericParameterNames, includeGenericParameters, nestedTypeDelimiter);
			string text = ProcessType(ref builder, type, in options);
			return text ?? ((object)builder)?.ToString() ?? string.Empty;
		}

		private static string ProcessType(ref StringBuilder builder, System.Type type, in DisplayNameOptions options)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			string text = default(string);
			if (type.IsGenericType)
			{
				System.Type[] genericArguments = type.GetGenericArguments();
				if (builder == null)
				{
					builder = new StringBuilder();
				}
				ProcessGenericType(builder, type, genericArguments, genericArguments.Length, in options);
			}
			else if (type.IsArray)
			{
				if (builder == null)
				{
					builder = new StringBuilder();
				}
				ProcessArrayType(builder, type, in options);
			}
			else if (_builtInTypeNames.TryGetValue(type, ref text))
			{
				if (builder == null)
				{
					return text;
				}
				builder.Append(text);
			}
			else if (type.IsGenericParameter)
			{
				if (options.IncludeGenericParameterNames)
				{
					if (builder == null)
					{
						return ((MemberInfo)type).Name;
					}
					builder.Append(((MemberInfo)type).Name);
				}
			}
			else
			{
				string text2 = (options.FullName ? type.FullName : ((MemberInfo)type).Name);
				if (builder == null)
				{
					if (options.NestedTypeDelimiter != '+')
					{
						return text2.Replace('+', options.NestedTypeDelimiter);
					}
					return text2;
				}
				builder.Append(text2);
				if (options.NestedTypeDelimiter != '+')
				{
					builder.Replace('+', options.NestedTypeDelimiter, builder.Length - text2.Length, text2.Length);
				}
			}
			return null;
		}

		private static void ProcessArrayType(StringBuilder builder, System.Type type, in DisplayNameOptions options)
		{
			System.Type type2 = type;
			while (type2.IsArray)
			{
				type2 = type2.GetElementType();
			}
			ProcessType(ref builder, type2, in options);
			while (type.IsArray)
			{
				builder.Append('[');
				builder.Append(',', type.GetArrayRank() - 1);
				builder.Append(']');
				type = type.GetElementType();
			}
		}

		private static void ProcessGenericType(StringBuilder builder, System.Type type, System.Type[] genericArguments, int length, in DisplayNameOptions options)
		{
			int num = 0;
			if (type.IsNested)
			{
				num = ((MemberInfo)type).DeclaringType.GetGenericArguments().Length;
			}
			if (options.FullName)
			{
				if (type.IsNested)
				{
					ProcessGenericType(builder, ((MemberInfo)type).DeclaringType, genericArguments, num, in options);
					builder.Append(options.NestedTypeDelimiter);
				}
				else if (!string.IsNullOrEmpty(type.Namespace))
				{
					builder.Append(type.Namespace);
					builder.Append('.');
				}
			}
			int num2 = ((MemberInfo)type).Name.IndexOf('`');
			if (num2 <= 0)
			{
				builder.Append(((MemberInfo)type).Name);
				return;
			}
			builder.Append(((MemberInfo)type).Name, 0, num2);
			if (!options.IncludeGenericParameters)
			{
				return;
			}
			builder.Append('<');
			for (int i = num; i < length; i++)
			{
				ProcessType(ref builder, genericArguments[i], in options);
				if (i + 1 != length)
				{
					builder.Append(',');
					if (options.IncludeGenericParameterNames || !genericArguments[i + 1].IsGenericParameter)
					{
						builder.Append(' ');
					}
				}
			}
			builder.Append('>');
		}

		static TypeNameHelper()
		{
			Dictionary<System.Type, string> val = new Dictionary<System.Type, string>();
			val.Add(typeof(void), "void");
			val.Add(typeof(bool), "bool");
			val.Add(typeof(byte), "byte");
			val.Add(typeof(char), "char");
			val.Add(typeof(decimal), "decimal");
			val.Add(typeof(double), "double");
			val.Add(typeof(float), "float");
			val.Add(typeof(int), "int");
			val.Add(typeof(long), "long");
			val.Add(typeof(object), "object");
			val.Add(typeof(sbyte), "sbyte");
			val.Add(typeof(short), "short");
			val.Add(typeof(string), "string");
			val.Add(typeof(uint), "uint");
			val.Add(typeof(ulong), "ulong");
			val.Add(typeof(ushort), "ushort");
			_builtInTypeNames = val;
		}
	}
}
namespace Microsoft.Extensions.Logging
{
	public readonly struct EventId : IEquatable<EventId>
	{
		[field: CompilerGenerated]
		public int Id
		{
			[CompilerGenerated]
			get;
		}

		[field: CompilerGenerated]
		public string? Name
		{
			[CompilerGenerated]
			get;
		}

		public static implicit operator EventId(int i)
		{
			return new EventId(i);
		}

		public static bool operator ==(EventId left, EventId right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(EventId left, EventId right)
		{
			return !left.Equals(right);
		}

		public EventId(int id, string? name = null)
		{
			Id = id;
			Name = name;
		}

		public override string ToString()
		{
			return Name ?? Id.ToString();
		}

		public bool Equals(EventId other)
		{
			return Id == other.Id;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj == null)
			{
				return false;
			}
			if (obj is EventId other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Id;
		}
	}
	[DefaultMember("Item")]
	internal readonly struct FormattedLogValues : System.Collections.Generic.IReadOnlyList<KeyValuePair<string, object?>>, System.Collections.Generic.IEnumerable<KeyValuePair<string, object?>>, System.Collections.IEnumerable, System.Collections.Generic.IReadOnlyCollection<KeyValuePair<string, object?>>
	{
		[CompilerGenerated]
		private sealed class <GetEnumerator>d__14 : System.Collections.Generic.IEnumerator<KeyValuePair<string, object>>, System.Collections.IEnumerator, System.IDisposable
		{
			private int <>1__state;

			private KeyValuePair<string, object> <>2__current;

			public FormattedLogValues <>4__this;

			private int <i>5__2;

			KeyValuePair<string, object> System.Collections.Generic.IEnumerator<KeyValuePair<string, object>>.Current
			{
				[DebuggerHidden]
				get
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					return <>2__current;
				}
			}

			object System.Collections.IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetEnumerator>d__14(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void System.IDisposable.Dispose()
			{
			}

			private bool MoveNext()
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<i>5__2 = 0;
					break;
				case 1:
				{
					<>1__state = -1;
					int num = <i>5__2 + 1;
					<i>5__2 = num;
					break;
				}
				}
				if (<i>5__2 < <>4__this.Count)
				{
					<>2__current = <>4__this[<i>5__2];
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool System.Collections.IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void System.Collections.IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}
		}

		internal const int MaxCachedFormatters = 1024;

		private const string NullFormat = "[null]";

		private static int s_count;

		private static readonly ConcurrentDictionary<string, LogValuesFormatter> s_formatters = new ConcurrentDictionary<string, LogValuesFormatter>();

		private readonly LogValuesFormatter _formatter;

		private readonly object[] _values;

		private readonly string _originalMessage;

		internal LogValuesFormatter? Formatter => _formatter;

		public KeyValuePair<string, object?> this[int index]
		{
			get
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				if (index < 0 || index >= Count)
				{
					throw new IndexOutOfRangeException("index");
				}
				if (index == Count - 1)
				{
					return new KeyValuePair<string, object>("{OriginalFormat}", (object)_originalMessage);
				}
				return _formatter.GetValue(_values, index);
			}
		}

		public int Count
		{
			get
			{
				if (_formatter == null)
				{
					return 1;
				}
				return _formatter.ValueNames.Count + 1;
			}
		}

		public FormattedLogValues(string? format, params object?[]? values)
		{
			if (values != null && values.Length != 0 && format != null)
			{
				if (s_count >= 1024)
				{
					if (!s_formatters.TryGetValue(format, ref _formatter))
					{
						_formatter = new LogValuesFormatter(format);
					}
				}
				else
				{
					_formatter = s_formatters.GetOrAdd(format, (Func<string, LogValuesFormatter>)delegate(string f)
					{
						Interlocked.Increment(ref s_count);
						return new LogValuesFormatter(f);
					});
				}
			}
			else
			{
				_formatter = null;
			}
			_originalMessage = format ?? "[null]";
			_values = values;
		}

		[IteratorStateMachine(typeof(<GetEnumerator>d__14))]
		public System.Collections.Generic.IEnumerator<KeyValuePair<string, object?>> GetEnumerator()
		{
			int i = 0;
			while (i < Count)
			{
				yield return this[i];
				int num = i + 1;
				i = num;
			}
		}

		public string ToString()
		{
			if (_formatter == null)
			{
				return _originalMessage;
			}
			return _formatter.Format(_values);
		}

		System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
		{
			return (System.Collections.IEnumerator)GetEnumerator();
		}
	}
	public interface IExternalScopeProvider
	{
		void ForEachScope<TState>(Action<object?, TState> callback, TState state);

		System.IDisposable Push(object? state);
	}
	public interface ILogger
	{
		void Log<TState>(LogLevel logLevel, EventId eventId, TState state, System.Exception? exception, Func<TState, System.Exception?, string> formatter);

		bool IsEnabled(LogLevel logLevel);

		System.IDisposable? BeginScope<TState>(TState state) where TState : notnull;
	}
	public interface ILoggerFactory : System.IDisposable
	{
		ILogger CreateLogger(string categoryName);

		void AddProvider(ILoggerProvider provider);
	}
	public interface ILoggerProvider : System.IDisposable
	{
		ILogger CreateLogger(string categoryName);
	}
	public interface ILogger<out TCategoryName> : ILogger
	{
	}
	public interface ILoggingBuilder
	{
		IServiceCollection Services { get; }
	}
	public interface ISupportExternalScope
	{
		void SetScopeProvider(IExternalScopeProvider scopeProvider);
	}
	public class LogDefineOptions
	{
		[field: CompilerGenerated]
		public bool SkipEnabledCheck
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			set;
		}
	}
	public static class LoggerExtensions
	{
		private static readonly Func<FormattedLogValues, System.Exception, string> _messageFormatter = MessageFormatter;

		public static void LogDebug(this ILogger logger, EventId eventId, System.Exception? exception, string? message, params object?[] args)
		{
			logger.Log(LogLevel.Debug, eventId, exception, message, args);
		}

		public static void LogDebug(this ILogger logger, EventId eventId, string? message, params object?[] args)
		{
			logger.Log(LogLevel.Debug, eventId, message, args);
		}

		public static void LogDebug(this ILogger logger, System.Exception? exception, string? message, params object?[] args)
		{
			logger.Log(LogLevel.Debug, exception, message, args);
		}

		public static void LogDebug(this ILogger logger, string? message, params object?[] args)
		{
			logger.Log(LogLevel.Debug, message, args);
		}

		public static void LogTrace(this ILogger logger, EventId eventId, System.Exception? exception, string? message, params object?[] args)
		{
			logger.Log(LogLevel.Trace, eventId, exception, message, args);
		}

		public static void LogTrace(this ILogger logger, EventId eventId, string? message, params object?[] args)
		{
			logger.Log(LogLevel.Trace, eventId, message, args);
		}

		public static void LogTrace(this ILogger logger, System.Exception? exception, string? message, params object?[] args)
		{
			logger.Log(LogLevel.Trace, exception, message, args);
		}

		public static void LogTrace(this ILogger logger, string? message, params object?[] args)
		{
			logger.Log(LogLevel.Trace, message, args);
		}

		public static void LogInformation(this ILogger logger, EventId eventId, System.Exception? exception, string? message, params object?[] args)
		{
			logger.Log(LogLevel.Information, eventId, exception, message, args);
		}

		public static void LogInformation(this ILogger logger, EventId eventId, string? message, params object?[] args)
		{
			logger.Log(LogLevel.Information, eventId, message, args);
		}

		public static void LogInformation(this ILogger logger, System.Exception? exception, string? message, params object?[] args)
		{
			logger.Log(LogLevel.Information, exception, message, args);
		}

		public static void LogInformation(this ILogger logger, string? message, params object?[] args)
		{
			logger.Log(LogLevel.Information, message, args);
		}

		public static void LogWarning(this ILogger logger, EventId eventId, System.Exception? exception, string? message, params object?[] args)
		{
			logger.Log(LogLevel.Warning, eventId, exception, message, args);
		}

		public static void LogWarning(this ILogger logger, EventId eventId, string? message, params object?[] args)
		{
			logger.Log(LogLevel.Warning, eventId, message, args);
		}

		public static void LogWarning(this ILogger logger, System.Exception? exception, string? message, params object?[] args)
		{
			logger.Log(LogLevel.Warning, exception, message, args);
		}

		public static void LogWarning(this ILogger logger, string? message, params object?[] args)
		{
			logger.Log(LogLevel.Warning, message, args);
		}

		public static void LogError(this ILogger logger, EventId eventId, System.Exception? exception, string? message, params object?[] args)
		{
			logger.Log(LogLevel.Error, eventId, exception, message, args);
		}

		public static void LogError(this ILogger logger, EventId eventId, string? message, params object?[] args)
		{
			logger.Log(LogLevel.Error, eventId, message, args);
		}

		public static void LogError(this ILogger logger, System.Exception? exception, string? message, params object?[] args)
		{
			logger.Log(LogLevel.Error, exception, message, args);
		}

		public static void LogError(this ILogger logger, string? message, params object?[] args)
		{
			logger.Log(LogLevel.Error, message, args);
		}

		public static void LogCritical(this ILogger logger, EventId eventId, System.Exception? exception, string? message, params object?[] args)
		{
			logger.Log(LogLevel.Critical, eventId, exception, message, args);
		}

		public static void LogCritical(this ILogger logger, EventId eventId, string? message, params object?[] args)
		{
			logger.Log(LogLevel.Critical, eventId, message, args);
		}

		public static void LogCritical(this ILogger logger, System.Exception? exception, string? message, params object?[] args)
		{
			logger.Log(LogLevel.Critical, exception, message, args);
		}

		public static void LogCritical(this ILogger logger, string? message, params object?[] args)
		{
			logger.Log(LogLevel.Critical, message, args);
		}

		public static void Log(this ILogger logger, LogLevel logLevel, string? message, params object?[] args)
		{
			logger.Log(logLevel, 0, null, message, args);
		}

		public static void Log(this ILogger logger, LogLevel logLevel, EventId eventId, string? message, params object?[] args)
		{
			logger.Log(logLevel, eventId, null, message, args);
		}

		public static void Log(this ILogger logger, LogLevel logLevel, System.Exception? exception, string? message, params object?[] args)
		{
			logger.Log(logLevel, 0, exception, message, args);
		}

		public static void Log(this ILogger logger, LogLevel logLevel, EventId eventId, System.Exception? exception, string? message, params object?[] args)
		{
			ThrowHelper.ThrowIfNull(logger, "logger");
			logger.Log(logLevel, eventId, new FormattedLogValues(message, args), exception, _messageFormatter);
		}

		public static System.IDisposable? BeginScope(this ILogger logger, string messageFormat, params object?[] args)
		{
			ThrowHelper.ThrowIfNull(logger, "logger");
			return logger.BeginScope(new FormattedLogValues(messageFormat, args));
		}

		private static string MessageFormatter(FormattedLogValues state, System.Exception error)
		{
			return ((object)state).ToString();
		}
	}
	public class LoggerExternalScopeProvider : IExternalScopeProvider
	{
		private sealed class Scope : System.IDisposable
		{
			private readonly LoggerExternalScopeProvider _provider;

			private bool _isDisposed;

			[field: CompilerGenerated]
			public Scope Parent
			{
				[CompilerGenerated]
				get;
			}

			[field: CompilerGenerated]
			public object State
			{
				[CompilerGenerated]
				get;
			}

			internal Scope(LoggerExternalScopeProvider provider, object state, Scope parent)
			{
				_provider = provider;
				State = state;
				Parent = parent;
			}

			public string ToString()
			{
				return State?.ToString();
			}

			public void Dispose()
			{
				if (!_isDisposed)
				{
					_provider._currentScope.Value = Parent;
					_isDisposed = true;
				}
			}
		}

		private readonly AsyncLocal<Scope> _currentScope = new AsyncLocal<Scope>();

		public void ForEachScope<TState>(Action<object?, TState> callback, TState state)
		{
			Action<object, TState> callback2 = callback;
			TState state2 = state;
			Report(_currentScope.Value);
			[CompilerGenerated]
			void Report(Scope? current)
			{
				if (current != null)
				{
					Report(current.Parent);
					callback2.Invoke(current.State, state2);
				}
			}
		}

		public System.IDisposable Push(object? state)
		{
			Scope value = _currentScope.Value;
			Scope scope = new Scope(this, state, value);
			_currentScope.Value = scope;
			return scope;
		}
	}
	public static class LoggerFactoryExtensions
	{
		public static ILogger<T> CreateLogger<T>(this ILoggerFactory factory)
		{
			ThrowHelper.ThrowIfNull(factory, "factory");
			return new Logger<T>(factory);
		}

		public static ILogger CreateLogger(this ILoggerFactory factory, System.Type type)
		{
			ThrowHelper.ThrowIfNull(factory, "factory");
			ThrowHelper.ThrowIfNull(type, "type");
			return factory.CreateLogger(TypeNameHelper.GetTypeDisplayName(type, fullName: true, includeGenericParameterNames: false, includeGenericParameters: false, '.'));
		}
	}
	public static class LoggerMessage
	{
		[DefaultMember("Item")]
		private readonly struct LogValues : System.Collections.Generic.IReadOnlyList<KeyValuePair<string, object>>, System.Collections.Generic.IEnumerable<KeyValuePair<string, object>>, System.Collections.IEnumerable, System.Collections.Generic.IReadOnlyCollection<KeyValuePair<string, object>>
		{
			[CompilerGenerated]
			private sealed class <GetEnumerator>d__7 : System.Collections.Generic.IEnumerator<KeyValuePair<string, object>>, System.Collections.IEnumerator, System.IDisposable
			{
				private int <>1__state;

				private KeyValuePair<string, object> <>2__current;

				public LogValues <>4__this;

				KeyValuePair<string, object> System.Collections.Generic.IEnumerator<KeyValuePair<string, object>>.Current
				{
					[DebuggerHidden]
					get
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						return <>2__current;
					}
				}

				object System.Collections.IEnumerator.Current
				{
					[DebuggerHidden]
					get
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						return <>2__current;
					}
				}

				[DebuggerHidden]
				public <GetEnumerator>d__7(int <>1__state)
				{
					this.<>1__state = <>1__state;
				}

				[DebuggerHidden]
				void System.IDisposable.Dispose()
				{
				}

				private bool MoveNext()
				{
					//IL_001f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0024: Unknown result type (might be due to invalid IL or missing references)
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = <>4__this[0];
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						return false;
					}
				}

				bool System.Collections.IEnumerator.MoveNext()
				{
					//ILSpy generated this explicit interface implementation from .override directive in MoveNext
					return this.MoveNext();
				}

				[DebuggerHidden]
				void System.Collections.IEnumerator.Reset()
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					throw new NotSupportedException();
				}
			}

			public static readonly Func<LogValues, System.Exception, string> Callback = (LogValues state, System.Exception exception) => ((object)state).ToString();

			private readonly LogValuesFormatter _formatter;

			public KeyValuePair<string, object> this[int index]
			{
				get
				{
					//IL_001e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0013: Unknown result type (might be due to invalid IL or missing references)
					if (index == 0)
					{
						return new KeyValuePair<string, object>("{OriginalFormat}", (object)_formatter.OriginalFormat);
					}
					throw new IndexOutOfRangeException("index");
				}
			}

			public int Count => 1;

			public LogValues(LogValuesFormatter formatter)
			{
				_formatter = formatter;
			}

			[IteratorStateMachine(typeof(<GetEnumerator>d__7))]
			public System.Collections.Generic.IEnumerator<KeyValuePair<string, object>> GetEnumerator()
			{
				yield return this[0];
			}

			public string ToString()
			{
				return _formatter.Format();
			}

			System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
			{
				return (System.Collections.IEnumerator)GetEnumerator();
			}
		}

		[DefaultMember("Item")]
		private readonly struct LogValues<T0> : System.Collections.Generic.IReadOnlyList<KeyValuePair<string, object>>, System.Collections.Generic.IEnumerable<KeyValuePair<string, object>>, System.Collections.IEnumerable, System.Collections.Generic.IReadOnlyCollection<KeyValuePair<string, object>>
		{
			[CompilerGenerated]
			private sealed class <GetEnumerator>d__8 : System.Collections.Generic.IEnumerator<KeyValuePair<string, object>>, System.Collections.IEnumerator, System.IDisposable
			{
				private int <>1__state;

				private KeyValuePair<string, object> <>2__current;

				public LogValues<T0> <>4__this;

				private int <i>5__2;

				KeyValuePair<string, object> System.Collections.Generic.IEnumerator<KeyValuePair<string, object>>.Current
				{
					[DebuggerHidden]
					get
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						return <>2__current;
					}
				}

				object System.Collections.IEnumerator.Current
				{
					[DebuggerHidden]
					get
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						return <>2__current;
					}
				}

				[DebuggerHidden]
				public <GetEnumerator>d__8(int <>1__state)
				{
					this.<>1__state = <>1__state;
				}

				[DebuggerHidden]
				void System.IDisposable.Dispose()
				{
				}

				private bool MoveNext()
				{
					//IL_002d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0032: Unknown result type (might be due to invalid IL or missing references)
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<i>5__2 = 0;
						break;
					case 1:
					{
						<>1__state = -1;
						int num = <i>5__2 + 1;
						<i>5__2 = num;
						break;
					}
					}
					if (<i>5__2 < <>4__this.Count)
					{
						<>2__current = <>4__this[<i>5__2];
						<>1__state = 1;
						return true;
					}
					return false;
				}

				bool System.Collections.IEnumerator.MoveNext()
				{
					//ILSpy generated this explicit interface implementation from .override directive in MoveNext
					return this.MoveNext();
				}

				[DebuggerHidden]
				void System.Collections.IEnumerator.Reset()
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					throw new NotSupportedException();
				}
			}

			public static readonly Func<LogValues<T0>, System.Exception, string> Callback = (Func<LogValues<T0>, System.Exception, string>)(object)(Func<LogValues<LogValues<T0>>, System.Exception, string>)((LogValues<T0> state, System.Exception exception) => ((object)state).ToString());

			private readonly LogValuesFormatter _formatter;

			private readonly T0 _value0;

			public KeyValuePair<string, object> this[int index] => (KeyValuePair<string, object>)(index switch
			{
				0 => new KeyValuePair<string, object>(_formatter.ValueNames[0], (object)_value0), 
				1 => new KeyValuePair<string, object>("{OriginalFormat}", (object)_formatter.OriginalFormat), 
				_ => throw new IndexOutOfRangeException("index"), 
			});

			public int Count => 2;

			public LogValues(LogValuesFormatter formatter, T0 value0)
			{
				_formatter = formatter;
				_value0 = value0;
			}

			[IteratorStateMachine(typeof(LogValues<>.<GetEnumerator>d__8))]
			public System.Collections.Generic.IEnumerator<KeyValuePair<string, object>> GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return this[i];
					int num = i + 1;
					i = num;
				}
			}

			public string ToString()
			{
				return _formatter.Format(_value0);
			}

			System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
			{
				return (System.Collections.IEnumerator)GetEnumerator();
			}
		}

		[DefaultMember("Item")]
		private readonly struct LogValues<T0, T1> : System.Collections.Generic.IReadOnlyList<KeyValuePair<string, object>>, System.Collections.Generic.IEnumerable<KeyValuePair<string, object>>, System.Collections.IEnumerable, System.Collections.Generic.IReadOnlyCollection<KeyValuePair<string, object>>
		{
			[CompilerGenerated]
			private sealed class <GetEnumerator>d__9 : System.Collections.Generic.IEnumerator<KeyValuePair<string, object>>, System.Collections.IEnumerator, System.IDisposable
			{
				private int <>1__state;

				private KeyValuePair<string, object> <>2__current;

				public LogValues<T0, T1> <>4__this;

				private int <i>5__2;

				KeyValuePair<string, object> System.Collections.Generic.IEnumerator<KeyValuePair<string, object>>.Current
				{
					[DebuggerHidden]
					get
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						return <>2__current;
					}
				}

				object System.Collections.IEnumerator.Current
				{
					[DebuggerHidden]
					get
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						return <>2__current;
					}
				}

				[DebuggerHidden]
				public <GetEnumerator>d__9(int <>1__state)
				{
					this.<>1__state = <>1__state;
				}

				[DebuggerHidden]
				void System.IDisposable.Dispose()
				{
				}

				private bool MoveNext()
				{
					//IL_002d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0032: Unknown result type (might be due to invalid IL or missing references)
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<i>5__2 = 0;
						break;
					case 1:
					{
						<>1__state = -1;
						int num = <i>5__2 + 1;
						<i>5__2 = num;
						break;
					}
					}
					if (<i>5__2 < <>4__this.Count)
					{
						<>2__current = <>4__this[<i>5__2];
						<>1__state = 1;
						return true;
					}
					return false;
				}

				bool System.Collections.IEnumerator.MoveNext()
				{
					//ILSpy generated this explicit interface implementation from .override directive in MoveNext
					return this.MoveNext();
				}

				[DebuggerHidden]
				void System.Collections.IEnumerator.Reset()
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					throw new NotSupportedException();
				}
			}

			public static readonly Func<LogValues<T0, T1>, System.Exception, string> Callback = (Func<LogValues<T0, T1>, System.Exception, string>)(object)(Func<LogValues<LogValues<T0, T1>, System.Exception>, System.Exception, string>)((LogValues<T0, T1> state, System.Exception exception) => ((object)state).ToString());

			private readonly LogValuesFormatter _formatter;

			private readonly T0 _value0;

			private readonly T1 _value1;

			public KeyValuePair<string, object> this[int index] => (KeyValuePair<string, object>)(index switch
			{
				0 => new KeyValuePair<string, object>(_formatter.ValueNames[0], (object)_value0), 
				1 => new KeyValuePair<string, object>(_formatter.ValueNames[1], (object)_value1), 
				2 => new KeyValuePair<string, object>("{OriginalFormat}", (object)_formatter.OriginalFormat), 
				_ => throw new IndexOutOfRangeException("index"), 
			});

			public int Count => 3;

			public LogValues(LogValuesFormatter formatter, T0 value0, T1 value1)
			{
				_formatter = formatter;
				_value0 = value0;
				_value1 = value1;
			}

			[IteratorStateMachine(typeof(LogValues<, >.<GetEnumerator>d__9))]
			public System.Collections.Generic.IEnumerator<KeyValuePair<string, object>> GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return this[i];
					int num = i + 1;
					i = num;
				}
			}

			public string ToString()
			{
				return _formatter.Format(_value0, _value1);
			}

			System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
			{
				return (System.Collections.IEnumerator)GetEnumerator();
			}
		}

		[DefaultMember("Item")]
		private readonly struct LogValues<T0, T1, T2> : System.Collections.Generic.IReadOnlyList<KeyValuePair<string, object>>, System.Collections.Generic.IEnumerable<KeyValuePair<string, object>>, System.Collections.IEnumerable, System.Collections.Generic.IReadOnlyCollection<KeyValuePair<string, object>>
		{
			[CompilerGenerated]
			private sealed class <GetEnumerator>d__11 : System.Collections.Generic.IEnumerator<KeyValuePair<string, object>>, System.Collections.IEnumerator, System.IDisposable
			{
				private int <>1__state;

				private KeyValuePair<string, object> <>2__current;

				public LogValues<T0, T1, T2> <>4__this;

				private int <i>5__2;

				KeyValuePair<string, object> System.Collections.Generic.IEnumerator<KeyValuePair<string, object>>.Current
				{
					[DebuggerHidden]
					get
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						return <>2__current;
					}
				}

				object System.Collections.IEnumerator.Current
				{
					[DebuggerHidden]
					get
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						return <>2__current;
					}
				}

				[DebuggerHidden]
				public <GetEnumerator>d__11(int <>1__state)
				{
					this.<>1__state = <>1__state;
				}

				[DebuggerHidden]
				void System.IDisposable.Dispose()
				{
				}

				private bool MoveNext()
				{
					//IL_002d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0032: Unknown result type (might be due to invalid IL or missing references)
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<i>5__2 = 0;
						break;
					case 1:
					{
						<>1__state = -1;
						int num = <i>5__2 + 1;
						<i>5__2 = num;
						break;
					}
					}
					if (<i>5__2 < <>4__this.Count)
					{
						<>2__current = <>4__this[<i>5__2];
						<>1__state = 1;
						return true;
					}
					return false;
				}

				bool System.Collections.IEnumerator.MoveNext()
				{
					//ILSpy generated this explicit interface implementation from .override directive in MoveNext
					return this.MoveNext();
				}

				[DebuggerHidden]
				void System.Collections.IEnumerator.Reset()
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					throw new NotSupportedException();
				}
			}

			public static readonly Func<LogValues<T0, T1, T2>, System.Exception, string> Callback = (Func<LogValues<T0, T1, T2>, System.Exception, string>)(object)(Func<LogValues<LogValues<T0, T1, T2>, System.Exception, string>, System.Exception, string>)((LogValues<T0, T1, T2> state, System.Exception exception) => ((object)state).ToString());

			private readonly LogValuesFormatter _formatter;

			private readonly T0 _value0;

			private readonly T1 _value1;

			private readonly T2 _value2;

			public int Count => 4;

			public KeyValuePair<string, object> this[int index] => (KeyValuePair<string, object>)(index switch
			{
				0 => new KeyValuePair<string, object>(_formatter.ValueNames[0], (object)_value0), 
				1 => new KeyValuePair<string, object>(_formatter.ValueNames[1], (object)_value1), 
				2 => new KeyValuePair<string, object>(_formatter.ValueNames[2], (object)_value2), 
				3 => new KeyValuePair<string, object>("{OriginalFormat}", (object)_formatter.OriginalFormat), 
				_ => throw new IndexOutOfRangeException("index"), 
			});

			public LogValues(LogValuesFormatter formatter, T0 value0, T1 value1, T2 value2)
			{
				_formatter = formatter;
				_value0 = value0;
				_value1 = value1;
				_value2 = value2;
			}

			public string ToString()
			{
				return _formatter.Format(_value0, _value1, _value2);
			}

			[IteratorStateMachine(typeof(LogValues<, , >.<GetEnumerator>d__11))]
			public System.Collections.Generic.IEnumerator<KeyValuePair<string, object>> GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return this[i];
					int num = i + 1;
					i = num;
				}
			}

			System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
			{
				return (System.Collections.IEnumerator)GetEnumerator();
			}
		}

		[DefaultMember("Item")]
		private readonly struct LogValues<T0, T1, T2, T3> : System.Collections.Generic.IReadOnlyList<KeyValuePair<string, object>>, System.Collections.Generic.IEnumerable<KeyValuePair<string, object>>, System.Collections.IEnumerable, System.Collections.Generic.IReadOnlyCollection<KeyValuePair<string, object>>
		{
			[CompilerGenerated]
			private sealed class <GetEnumerator>d__13 : System.Collections.Generic.IEnumerator<KeyValuePair<string, object>>, System.Collections.IEnumerator, System.IDisposable
			{
				private int <>1__state;

				private KeyValuePair<string, object> <>2__current;

				public LogValues<T0, T1, T2, T3> <>4__this;

				private int <i>5__2;

				KeyValuePair<string, object> System.Collections.Generic.IEnumerator<KeyValuePair<string, object>>.Current
				{
					[DebuggerHidden]
					get
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						return <>2__current;
					}
				}

				object System.Collections.IEnumerator.Current
				{
					[DebuggerHidden]
					get
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						return <>2__current;
					}
				}

				[DebuggerHidden]
				public <GetEnumerator>d__13(int <>1__state)
				{
					this.<>1__state = <>1__state;
				}

				[DebuggerHidden]
				void System.IDisposable.Dispose()
				{
				}

				private bool MoveNext()
				{
					//IL_002d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0032: Unknown result type (might be due to invalid IL or missing references)
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<i>5__2 = 0;
						break;
					case 1:
					{
						<>1__state = -1;
						int num = <i>5__2 + 1;
						<i>5__2 = num;
						break;
					}
					}
					if (<i>5__2 < <>4__this.Count)
					{
						<>2__current = <>4__this[<i>5__2];
						<>1__state = 1;
						return true;
					}
					return false;
				}

				bool System.Collections.IEnumerator.MoveNext()
				{
					//ILSpy generated this explicit interface implementation from .override directive in MoveNext
					return this.MoveNext();
				}

				[DebuggerHidden]
				void System.Collections.IEnumerator.Reset()
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					throw new NotSupportedException();
				}
			}

			public static readonly Func<LogValues<T0, T1, T2, T3>, System.Exception, string> Callback = (Func<LogValues<T0, T1, T2, T3>, System.Exception, string>)(object)(Func<LogValues<LogValues<T0, T1, T2, T3>, System.Exception, string, ?>, System.Exception, string>)((LogValues<T0, T1, T2, T3> state, System.Exception exception) => ((object)state).ToString());

			private readonly LogValuesFormatter _formatter;

			private readonly T0 _value0;

			private readonly T1 _value1;

			private readonly T2 _value2;

			private readonly T3 _value3;

			public int Count => 5;

			public KeyValuePair<string, object> this[int index] => (KeyValuePair<string, object>)(index switch
			{
				0 => new KeyValuePair<string, object>(_formatter.ValueNames[0], (object)_value0), 
				1 => new KeyValuePair<string, object>(_formatter.ValueNames[1], (object)_value1), 
				2 => new KeyValuePair<string, object>(_formatter.ValueNames[2], (object)_value2), 
				3 => new KeyValuePair<string, object>(_formatter.ValueNames[3], (object)_value3), 
				4 => new KeyValuePair<string, object>("{OriginalFormat}", (object)_formatter.OriginalFormat), 
				_ => throw new IndexOutOfRangeException("index"), 
			});

			public LogValues(LogValuesFormatter formatter, T0 value0, T1 value1, T2 value2, T3 value3)
			{
				_formatter = formatter;
				_value0 = value0;
				_value1 = value1;
				_value2 = value2;
				_value3 = value3;
			}

			private object[] ToArray()
			{
				return new object[4] { _value0, _value1, _value2, _value3 };
			}

			public string ToString()
			{
				return _formatter.FormatWithOverwrite(ToArray());
			}

			[IteratorStateMachine(typeof(LogValues<, , , >.<GetEnumerator>d__13))]
			public System.Collections.Generic.IEnumerator<KeyValuePair<string, object>> GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return this[i];
					int num = i + 1;
					i = num;
				}
			}

			System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
			{
				return (System.Collections.IEnumerator)GetEnumerator();
			}
		}

		[DefaultMember("Item")]
		private readonly struct LogValues<T0, T1, T2, T3, T4> : System.Collections.Generic.IReadOnlyList<KeyValuePair<string, object>>, System.Collections.Generic.IEnumerable<KeyValuePair<string, object>>, System.Collections.IEnumerable, System.Collections.Generic.IReadOnlyCollection<KeyValuePair<string, object>>
		{
			[CompilerGenerated]
			private sealed class <GetEnumerator>d__14 : System.Collections.Generic.IEnumerator<KeyValuePair<string, object>>, System.Collections.IEnumerator, System.IDisposable
			{
				private int <>1__state;

				private KeyValuePair<string, object> <>2__current;

				public LogValues<T0, T1, T2, T3, T4> <>4__this;

				private int <i>5__2;

				KeyValuePair<string, object> System.Collections.Generic.IEnumerator<KeyValuePair<string, object>>.Current
				{
					[DebuggerHidden]
					get
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						return <>2__current;
					}
				}

				object System.Collections.IEnumerator.Current
				{
					[DebuggerHidden]
					get
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						return <>2__current;
					}
				}

				[DebuggerHidden]
				public <GetEnumerator>d__14(int <>1__state)
				{
					this.<>1__state = <>1__state;
				}

				[DebuggerHidden]
				void System.IDisposable.Dispose()
				{
				}

				private bool MoveNext()
				{
					//IL_002d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0032: Unknown result type (might be due to invalid IL or missing references)
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<i>5__2 = 0;
						break;
					case 1:
					{
						<>1__state = -1;
						int num = <i>5__2 + 1;
						<i>5__2 = num;
						break;
					}
					}
					if (<i>5__2 < <>4__this.Count)
					{
						<>2__current = <>4__this[<i>5__2];
						<>1__state = 1;
						return true;
					}
					return false;
				}

				bool System.Collections.IEnumerator.MoveNext()
				{
					//ILSpy generated this explicit interface implementation from .override directive in MoveNext
					return this.MoveNext();
				}

				[DebuggerHidden]
				void System.Collections.IEnumerator.Reset()
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					throw new NotSupportedException();
				}
			}

			public static readonly Func<LogValues<T0, T1, T2, T3, T4>, System.Exception, string> Callback = (Func<LogValues<T0, T1, T2, T3, T4>, System.Exception, string>)(object)(Func<LogValues<LogValues<T0, T1, T2, T3, T4>, System.Exception, string, ?, ?>, System.Exception, string>)((LogValues<T0, T1, T2, T3, T4> state, System.Exception exception) => ((object)state).ToString());

			private readonly LogValuesFormatter _formatter;

			private readonly T0 _value0;

			private readonly T1 _value1;

			private readonly T2 _value2;

			private readonly T3 _value3;

			private readonly T4 _value4;

			public int Count => 6;

			public KeyValuePair<string, object> this[int index] => (KeyValuePair<string, object>)(index switch
			{
				0 => new KeyValuePair<string, object>(_formatter.ValueNames[0], (object)_value0), 
				1 => new KeyValuePair<string, object>(_formatter.ValueNames[1], (object)_value1), 
				2 => new KeyValuePair<string, object>(_formatter.ValueNames[2], (object)_value2), 
				3 => new KeyValuePair<string, object>(_formatter.ValueNames[3], (object)_value3), 
				4 => new KeyValuePair<string, object>(_formatter.ValueNames[4], (object)_value4), 
				5 => new KeyValuePair<string, object>("{OriginalFormat}", (object)_formatter.OriginalFormat), 
				_ => throw new IndexOutOfRangeException("index"), 
			});

			public LogValues(LogValuesFormatter formatter, T0 value0, T1 value1, T2 value2, T3 value3, T4 value4)
			{
				_formatter = formatter;
				_value0 = value0;
				_value1 = value1;
				_value2 = value2;
				_value3 = value3;
				_value4 = value4;
			}

			private object[] ToArray()
			{
				return new object[5] { _value0, _value1, _value2, _value3, _value4 };
			}

			public string ToString()
			{
				return _formatter.FormatWithOverwrite(ToArray());
			}

			[IteratorStateMachine(typeof(LogValues<, , , , >.<GetEnumerator>d__14))]
			public System.Collections.Generic.IEnumerator<KeyValuePair<string, object>> GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return this[i];
					int num = i + 1;
					i = num;
				}
			}

			System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
			{
				return (System.Collections.IEnumerator)GetEnumerator();
			}
		}

		[DefaultMember("Item")]
		private readonly struct LogValues<T0, T1, T2, T3, T4, T5> : System.Collections.Generic.IReadOnlyList<KeyValuePair<string, object>>, System.Collections.Generic.IEnumerable<KeyValuePair<string, object>>, System.Collections.IEnumerable, System.Collections.Generic.IReadOnlyCollection<KeyValuePair<string, object>>
		{
			[CompilerGenerated]
			private sealed class <GetEnumerator>d__15 : System.Collections.Generic.IEnumerator<KeyValuePair<string, object>>, System.Collections.IEnumerator, System.IDisposable
			{
				private int <>1__state;

				private KeyValuePair<string, object> <>2__current;

				public LogValues<T0, T1, T2, T3, T4, T5> <>4__this;

				private int <i>5__2;

				KeyValuePair<string, object> System.Collections.Generic.IEnumerator<KeyValuePair<string, object>>.Current
				{
					[DebuggerHidden]
					get
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						return <>2__current;
					}
				}

				object System.Collections.IEnumerator.Current
				{
					[DebuggerHidden]
					get
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						return <>2__current;
					}
				}

				[DebuggerHidden]
				public <GetEnumerator>d__15(int <>1__state)
				{
					this.<>1__state = <>1__state;
				}

				[DebuggerHidden]
				void System.IDisposable.Dispose()
				{
				}

				private bool MoveNext()
				{
					//IL_002d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0032: Unknown result type (might be due to invalid IL or missing references)
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<i>5__2 = 0;
						break;
					case 1:
					{
						<>1__state = -1;
						int num = <i>5__2 + 1;
						<i>5__2 = num;
						break;
					}
					}
					if (<i>5__2 < <>4__this.Count)
					{
						<>2__current = <>4__this[<i>5__2];
						<>1__state = 1;
						return true;
					}
					return false;
				}

				bool System.Collections.IEnumerator.MoveNext()
				{
					//ILSpy generated this explicit interface implementation from .override directive in MoveNext
					return this.MoveNext();
				}

				[DebuggerHidden]
				void System.Collections.IEnumerator.Reset()
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					throw new NotSupportedException();
				}
			}

			public static readonly Func<LogValues<T0, T1, T2, T3, T4, T5>, System.Exception, string> Callback = (Func<LogValues<T0, T1, T2, T3, T4, T5>, System.Exception, string>)(object)(Func<LogValues<LogValues<T0, T1, T2, T3, T4, T5>, System.Exception, string, ?, ?, ?>, System.Exception, string>)((LogValues<T0, T1, T2, T3, T4, T5> state, System.Exception exception) => ((object)state).ToString());

			private readonly LogValuesFormatter _formatter;

			private readonly T0 _value0;

			private readonly T1 _value1;

			private readonly T2 _value2;

			private readonly T3 _value3;

			private readonly T4 _value4;

			private readonly T5 _value5;

			public int Count => 7;

			public KeyValuePair<string, object> this[int index] => (KeyValuePair<string, object>)(index switch
			{
				0 => new KeyValuePair<string, object>(_formatter.ValueNames[0], (object)_value0), 
				1 => new KeyValuePair<string, object>(_formatter.ValueNames[1], (object)_value1), 
				2 => new KeyValuePair<string, object>(_formatter.ValueNames[2], (object)_value2), 
				3 => new KeyValuePair<string, object>(_formatter.ValueNames[3], (object)_value3), 
				4 => new KeyValuePair<string, object>(_formatter.ValueNames[4], (object)_value4), 
				5 => new KeyValuePair<string, object>(_formatter.ValueNames[5], (object)_value5), 
				6 => new KeyValuePair<string, object>("{OriginalFormat}", (object)_formatter.OriginalFormat), 
				_ => throw new IndexOutOfRangeException("index"), 
			});

			public LogValues(LogValuesFormatter formatter, T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5)
			{
				_formatter = formatter;
				_value0 = value0;
				_value1 = value1;
				_value2 = value2;
				_value3 = value3;
				_value4 = value4;
				_value5 = value5;
			}

			private object[] ToArray()
			{
				return new object[6] { _value0, _value1, _value2, _value3, _value4, _value5 };
			}

			public string ToString()
			{
				return _formatter.FormatWithOverwrite(ToArray());
			}

			[IteratorStateMachine(typeof(LogValues<, , , , , >.<GetEnumerator>d__15))]
			public System.Collections.Generic.IEnumerator<KeyValuePair<string, object>> GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return this[i];
					int num = i + 1;
					i = num;
				}
			}

			System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
			{
				return (System.Collections.IEnumerator)GetEnumerator();
			}
		}

		public static Func<ILogger, System.IDisposable?> DefineScope(string formatString)
		{
			LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, 0);
			LogValues logValues = new LogValues(formatter);
			return (ILogger logger) => logger.BeginScope(logValues);
		}

		public static Func<ILogger, T1, System.IDisposable?> DefineScope<T1>(string formatString)
		{
			LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, 1);
			return (ILogger logger, T1 arg1) => logger.BeginScope(new LogValues<T1>(formatter, arg1));
		}

		public static Func<ILogger, T1, T2, System.IDisposable?> DefineScope<T1, T2>(string formatString)
		{
			LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, 2);
			return (ILogger logger, T1 arg1, T2 arg2) => logger.BeginScope(new LogValues<T1, T2>(formatter, arg1, arg2));
		}

		public static Func<ILogger, T1, T2, T3, System.IDisposable?> DefineScope<T1, T2, T3>(string formatString)
		{
			LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, 3);
			return (ILogger logger, T1 arg1, T2 arg2, T3 arg3) => logger.BeginScope(new LogValues<T1, T2, T3>(formatter, arg1, arg2, arg3));
		}

		public static Func<ILogger, T1, T2, T3, T4, System.IDisposable?> DefineScope<T1, T2, T3, T4>(string formatString)
		{
			LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, 4);
			return (ILogger logger, T1 arg1, T2 arg2, T3 arg3, T4 arg4) => logger.BeginScope(new LogValues<T1, T2, T3, T4>(formatter, arg1, arg2, arg3, arg4));
		}

		public static Func<ILogger, T1, T2, T3, T4, T5, System.IDisposable?> DefineScope<T1, T2, T3, T4, T5>(string formatString)
		{
			LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, 5);
			return (ILogger logger, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5) => logger.BeginScope(new LogValues<T1, T2, T3, T4, T5>(formatter, arg1, arg2, arg3, arg4, arg5));
		}

		public static Func<ILogger, T1, T2, T3, T4, T5, T6, System.IDisposable?> DefineScope<T1, T2, T3, T4, T5, T6>(string formatString)
		{
			LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, 6);
			return (ILogger logger, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6) => logger.BeginScope(new LogValues<T1, T2, T3, T4, T5, T6>(formatter, arg1, arg2, arg3, arg4, arg5, arg6));
		}

		public static Action<ILogger, System.Exception?> Define(LogLevel logLevel, EventId eventId, string formatString)
		{
			return Define(logLevel, eventId, formatString, null);
		}

		public static Action<ILogger, System.Exception?> Define(LogLevel logLevel, EventId eventId, string formatString, LogDefineOptions? options)
		{
			LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, 0);
			if (options != null && options.SkipEnabledCheck)
			{
				return Log;
			}
			return delegate(ILogger logger, System.Exception exception)
			{
				if (logger.IsEnabled(logLevel))
				{
					Log(logger, exception);
				}
			};
			void Log(ILogger logger, System.Exception exception)
			{
				logger.Log(logLevel, eventId, new LogValues(formatter), exception, LogValues.Callback);
			}
		}

		public static Action<ILogger, T1, System.Exception?> Define<T1>(LogLevel logLevel, EventId eventId, string formatString)
		{
			return Define<T1>(logLevel, eventId, formatString, null);
		}

		public static Action<ILogger, T1, System.Exception?> Define<T1>(LogLevel logLevel, EventId eventId, string formatString, LogDefineOptions? options)
		{
			LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, 1);
			if (options != null && options.SkipEnabledCheck)
			{
				return Log;
			}
			return delegate(ILogger logger, T1 arg1, System.Exception exception)
			{
				if (logger.IsEnabled(logLevel))
				{
					Log(logger, arg1, exception);
				}
			};
			void Log(ILogger logger, T1 arg1, System.Exception exception)
			{
				logger.Log(logLevel, eventId, new LogValues<T1>(formatter, arg1), exception, LogValues<T1>.Callback);
			}
		}

		public static Action<ILogger, T1, T2, System.Exception?> Define<T1, T2>(LogLevel logLevel, EventId eventId, string formatString)
		{
			return Define<T1, T2>(logLevel, eventId, formatString, null);
		}

		public static Action<ILogger, T1, T2, System.Exception?> Define<T1, T2>(LogLevel logLevel, EventId eventId, string formatString, LogDefineOptions? options)
		{
			LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, 2);
			if (options != null && options.SkipEnabledCheck)
			{
				return Log;
			}
			return delegate(ILogger logger, T1 arg1, T2 arg2, System.Exception exception)
			{
				if (logger.IsEnabled(logLevel))
				{
					Log(logger, arg1, arg2, exception);
				}
			};
			void Log(ILogger logger, T1 arg1, T2 arg2, System.Exception exception)
			{
				logger.Log(logLevel, eventId, new LogValues<T1, T2>(formatter, arg1, arg2), exception, LogValues<T1, T2>.Callback);
			}
		}

		public static Action<ILogger, T1, T2, T3, System.Exception?> Define<T1, T2, T3>(LogLevel logLevel, EventId eventId, string formatString)
		{
			return Define<T1, T2, T3>(logLevel, eventId, formatString, null);
		}

		public static Action<ILogger, T1, T2, T3, System.Exception?> Define<T1, T2, T3>(LogLevel logLevel, EventId eventId, string formatString, LogDefineOptions? options)
		{
			LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, 3);
			if (options != null && options.SkipEnabledCheck)
			{
				return Log;
			}
			return delegate(ILogger logger, T1 arg1, T2 arg2, T3 arg3, System.Exception exception)
			{
				if (logger.IsEnabled(logLevel))
				{
					Log(logger, arg1, arg2, arg3, exception);
				}
			};
			void Log(ILogger logger, T1 arg1, T2 arg2, T3 arg3, System.Exception exception)
			{
				logger.Log(logLevel, eventId, new LogValues<T1, T2, T3>(formatter, arg1, arg2, arg3), exception, LogValues<T1, T2, T3>.Callback);
			}
		}

		public static Action<ILogger, T1, T2, T3, T4, System.Exception?> Define<T1, T2, T3, T4>(LogLevel logLevel, EventId eventId, string formatString)
		{
			return Define<T1, T2, T3, T4>(logLevel, eventId, formatString, null);
		}

		public static Action<ILogger, T1, T2, T3, T4, System.Exception?> Define<T1, T2, T3, T4>(LogLevel logLevel, EventId eventId, string formatString, LogDefineOptions? options)
		{
			LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, 4);
			if (options != null && options.SkipEnabledCheck)
			{
				return Log;
			}
			return delegate(ILogger logger, T1 arg1, T2 arg2, T3 arg3, T4 arg4, System.Exception exception)
			{
				if (logger.IsEnabled(logLevel))
				{
					Log(logger, arg1, arg2, arg3, arg4, exception);
				}
			};
			void Log(ILogger logger, T1 arg1, T2 arg2, T3 arg3, T4 arg4, System.Exception exception)
			{
				logger.Log(logLevel, eventId, new LogValues<T1, T2, T3, T4>(formatter, arg1, arg2, arg3, arg4), exception, LogValues<T1, T2, T3, T4>.Callback);
			}
		}

		public static Action<ILogger, T1, T2, T3, T4, T5, System.Exception?> Define<T1, T2, T3, T4, T5>(LogLevel logLevel, EventId eventId, string formatString)
		{
			return Define<T1, T2, T3, T4, T5>(logLevel, eventId, formatString, null);
		}

		public static Action<ILogger, T1, T2, T3, T4, T5, System.Exception?> Define<T1, T2, T3, T4, T5>(LogLevel logLevel, EventId eventId, string formatString, LogDefineOptions? options)
		{
			LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, 5);
			if (options != null && options.SkipEnabledCheck)
			{
				return Log;
			}
			return delegate(ILogger logger, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, System.Exception exception)
			{
				if (logger.IsEnabled(logLevel))
				{
					Log(logger, arg1, arg2, arg3, arg4, arg5, exception);
				}
			};
			void Log(ILogger logger, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, System.Exception exception)
			{
				logger.Log(logLevel, eventId, new LogValues<T1, T2, T3, T4, T5>(formatter, arg1, arg2, arg3, arg4, arg5), exception, LogValues<T1, T2, T3, T4, T5>.Callback);
			}
		}

		public static Action<ILogger, T1, T2, T3, T4, T5, T6, System.Exception?> Define<T1, T2, T3, T4, T5, T6>(LogLevel logLevel, EventId eventId, string formatString)
		{
			return Define<T1, T2, T3, T4, T5, T6>(logLevel, eventId, formatString, null);
		}

		public static Action<ILogger, T1, T2, T3, T4, T5, T6, System.Exception?> Define<T1, T2, T3, T4, T5, T6>(LogLevel logLevel, EventId eventId, string formatString, LogDefineOptions? options)
		{
			LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, 6);
			if (options != null && options.SkipEnabledCheck)
			{
				return Log;
			}
			return delegate(ILogger logger, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, System.Exception exception)
			{
				if (logger.IsEnabled(logLevel))
				{
					Log(logger, arg1, arg2, arg3, arg4, arg5, arg6, exception);
				}
			};
			void Log(ILogger logger, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, System.Exception exception)
			{
				logger.Log(logLevel, eventId, new LogValues<T1, T2, T3, T4, T5, T6>(formatter, arg1, arg2, arg3, arg4, arg5, arg6), exception, LogValues<T1, T2, T3, T4, T5, T6>.Callback);
			}
		}

		private static LogValuesFormatter CreateLogValuesFormatter(string formatString, int expectedNamedParameterCount)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			LogValuesFormatter logValuesFormatter = new LogValuesFormatter(formatString);
			int count = logValuesFormatter.ValueNames.Count;
			if (count != expectedNamedParameterCount)
			{
				throw new ArgumentException(System.SR.Format(System.SR.UnexpectedNumberOfNamedParameters, (object?)formatString, (object?)expectedNamedParameterCount, (object?)count));
			}
			return logValuesFormatter;
		}
	}
	[AttributeUsage(/*Could not decode attribute arguments.*/)]
	public sealed class LoggerMessageAttribute : System.Attribute
	{
		[field: CompilerGenerated]
		public int EventId
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			set;
		} = -1;


		[field: CompilerGenerated]
		public string? EventName
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			set;
		}

		[field: CompilerGenerated]
		public LogLevel Level
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			set;
		} = LogLevel.None;


		[field: CompilerGenerated]
		public string Message
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			set;
		} = "";


		[field: CompilerGenerated]
		public bool SkipEnabledCheck
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			set;
		}

		public LoggerMessageAttribute()
		{
		}

		public LoggerMessageAttribute(int eventId, LogLevel level, string message)
		{
			EventId = eventId;
			Level = level;
			Message = message;
		}

		public LoggerMessageAttribute(LogLevel level, string message)
		{
			Level = level;
			Message = message;
		}

		public LoggerMessageAttribute(LogLevel level)
		{
			Level = level;
		}

		public LoggerMessageAttribute(string message)
		{
			Message = message;
		}
	}
	[DebuggerDisplay("{DebuggerToString(),nq}")]
	public class Logger<T> : ILogger<T>, ILogger
	{
		[DebuggerBrowsable(/*Could not decode attribute arguments.*/)]
		private readonly ILogger _logger;

		public Logger(ILoggerFactory factory)
		{
			ThrowHelper.ThrowIfNull(factory, "factory");
			_logger = factory.CreateLogger(GetCategoryName());
		}

		System.IDisposable ILogger.BeginScope<TState>(TState state)
		{
			return _logger.BeginScope(state);
		}

		bool ILogger.IsEnabled(LogLevel logLevel)
		{
			return _logger.IsEnabled(logLevel);
		}

		void ILogger.Log<TState>(LogLevel logLevel, EventId eventId, TState state, System.Exception exception, Func<TState, System.Exception, string> formatter)
		{
			_logger.Log(logLevel, eventId, state, exception, formatter);
		}

		private static string GetCategoryName()
		{
			return TypeNameHelper.GetTypeDisplayName(typeof(T), fullName: true, includeGenericParameterNames: false, includeGenericParameters: false, '.');
		}

		internal string DebuggerToString()
		{
			return DebuggerDisplayFormatting.DebuggerToString(GetCategoryName(), this);
		}
	}
	public enum LogLevel
	{
		Trace,
		Debug,
		Information,
		Warning,
		Error,
		Critical,
		None
	}
	internal sealed class LogValuesFormatter
	{
		private const string NullValue = "(null)";

		private static readonly char[] FormatDelimiters = new char[2] { ',', ':' };

		private readonly List<string> _valueNames = new List<string>();

		private readonly CompositeFormat _format;

		[field: CompilerGenerated]
		public string OriginalFormat
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			private set;
		}

		public List<string> ValueNames => _valueNames;

		public LogValuesFormatter(string format)
		{
			ThrowHelper.ThrowIfNull(format, "format");
			OriginalFormat = format;
			System.Span<char> initialBuffer = stackalloc char[256];
			ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
			int num = 0;
			int length = format.Length;
			while (num < length)
			{
				int num2 = FindBraceIndex(format, '{', num, length);
				if (num == 0 && num2 == length)
				{
					_format = CompositeFormat.Parse(format);
					return;
				}
				int num3 = FindBraceIndex(format, '}', num2, length);
				if (num3 == length)
				{
					valueStringBuilder.Append(MemoryExtensions.AsSpan(format, num, length - num));
					num = length;
					continue;
				}
				int num4 = FindIndexOfAny(format, FormatDelimiters, num2, num3);
				valueStringBuilder.Append(MemoryExtensions.AsSpan(format, num, num2 - num + 1));
				valueStringBuilder.Append(_valueNames.Count.ToString());
				_valueNames.Add(format.Substring(num2 + 1, num4 - num2 - 1));
				valueStringBuilder.Append(MemoryExtensions.AsSpan(format, num4, num3 - num4 + 1));
				num = num3 + 1;
			}
			_format = CompositeFormat.Parse(((object)valueStringBuilder).ToString());
		}

		private static int FindBraceIndex(string format, char brace, int startIndex, int endIndex)
		{
			int result = endIndex;
			int i = startIndex;
			int num = 0;
			for (; i < endIndex; i++)
			{
				if (num > 0 && format[i] != brace)
				{
					if (num % 2 != 0)
					{
						break;
					}
					num = 0;
					result = endIndex;
				}
				else
				{
					if (format[i] != brace)
					{
						continue;
					}
					if (brace == '}')
					{
						if (num == 0)
						{
							result = i;
						}
					}
					else
					{
						result = i;
					}
					num++;
				}
			}
			return result;
		}

		private static int FindIndexOfAny(string format, char[] chars, int startIndex, int endIndex)
		{
			int num = format.IndexOfAny(chars, startIndex, endIndex - startIndex);
			if (num != -1)
			{
				return num;
			}
			return endIndex;
		}

		public string Format(object?[]? values)
		{
			object[] array = values;
			if (values != null)
			{
				for (int i = 0; i < values.Length; i++)
				{
					object obj = FormatArgument(values[i]);
					if (obj != values[i])
					{
						array = new object[values.Length];
						System.Array.Copy((System.Array)values, (System.Array)array, i);
						array[i++] = obj;
						for (; i < values.Length; i++)
						{
							array[i] = FormatArgument(values[i]);
						}
						break;
					}
				}
			}
			return string.Format((IFormatProvider)(object)CultureInfo.InvariantCulture, _format, array ?? System.Array.Empty<object>());
		}

		internal string FormatWithOverwrite(object?[]? values)
		{
			if (values != null)
			{
				for (int i = 0; i < values.Length; i++)
				{
					values[i] = FormatArgument(values[i]);
				}
			}
			return string.Format((IFormatProvider)(object)CultureInfo.InvariantCulture, _format, values ?? System.Array.Empty<object>());
		}

		internal string Format()
		{
			return _format.Format;
		}

		internal string Format<TArg0>(TArg0 arg0)
		{
			object stringValue = null;
			if (TryFormatArgumentIfNullOrEnumerable(arg0, ref stringValue))
			{
				return string.Format((IFormatProvider)(object)CultureInfo.InvariantCulture, _format, new object[1] { stringValue });
			}
			return string.Format<TArg0>((IFormatProvider)(object)CultureInfo.InvariantCulture, _format, arg0);
		}

		internal string Format<TArg0, TArg1>(TArg0 arg0, TArg1 arg1)
		{
			object stringValue = null;
			object stringValue2 = null;
			if (TryFormatArgumentIfNullOrEnumerable(arg0, ref stringValue) || TryFormatArgumentIfNullOrEnumerable(arg1, ref stringValue2))
			{
				return string.Format((IFormatProvider)(object)CultureInfo.InvariantCulture, _format, new object[2]
				{
					stringValue ?? ((object)arg0),
					stringValue2 ?? ((object)arg1)
				});
			}
			return string.Format<TArg0, TArg1>((IFormatProvider)(object)CultureInfo.InvariantCulture, _format, arg0, arg1);
		}

		internal string Format<TArg0, TArg1, TArg2>(TArg0 arg0, TArg1 arg1, TArg2 arg2)
		{
			object stringValue = null;
			object stringValue2 = null;
			object stringValue3 = null;
			if (TryFormatArgumentIfNullOrEnumerable(arg0, ref stringValue) || TryFormatArgumentIfNullOrEnumerable(arg1, ref stringValue2) || TryFormatArgumentIfNullOrEnumerable(arg2, ref stringValue3))
			{
				return string.Format((IFormatProvider)(object)CultureInfo.InvariantCulture, _format, new object[3]
				{
					stringValue ?? ((object)arg0),
					stringValue2 ?? ((object)arg1),
					stringValue3 ?? ((object)arg2)
				});
			}
			return string.Format<TArg0, TArg1, TArg2>((IFormatProvider)(object)CultureInfo.InvariantCulture, _format, arg0, arg1, arg2);
		}

		public KeyValuePair<string, object?> GetValue(object?[] values, int index)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (index < 0 || index > _valueNames.Count)
			{
				throw new IndexOutOfRangeException("index");
			}
			if (_valueNames.Count > index)
			{
				return new KeyValuePair<string, object>(_valueNames[index], values[index]);
			}
			return new KeyValuePair<string, object>("{OriginalFormat}", (object)OriginalFormat);
		}

		public System.Collections.Generic.IEnumerable<KeyValuePair<string, object?>> GetValues(object[] values)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			KeyValuePair<string, object>[] array = new KeyValuePair<string, object>[values.Length + 1];
			for (int i = 0; i != _valueNames.Count; i++)
			{
				array[i] = new KeyValuePair<string, object>(_valueNames[i], values[i]);
			}
			array[array.Length - 1] = new KeyValuePair<string, object>("{OriginalFormat}", (object)OriginalFormat);
			return array;
		}

		private static object FormatArgument(object value)
		{
			object stringValue = null;
			if (!TryFormatArgumentIfNullOrEnumerable(value, ref stringValue))
			{
				return value;
			}
			return stringValue;
		}

		private static bool TryFormatArgumentIfNullOrEnumerable<T>(T value, [NotNullWhen(true)] ref object stringValue)
		{
			if (value == null)
			{
				stringValue = "(null)";
				return true;
			}
			if (!(value is string) && (object)value is System.Collections.IEnumerable enumerable)
			{
				System.Span<char> initialBuffer = stackalloc char[256];
				ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
				bool flag = true;
				foreach (object item in enumerable)
				{
					if (!flag)
					{
						valueStringBuilder.Append(", ");
					}
					valueStringBuilder.Append((item != null) ? item.ToString() : "(null)");
					flag = false;
				}
				stringValue = ((object)valueStringBuilder).ToString();
				return true;
			}
			return false;
		}
	}
	internal sealed class NullExternalScopeProvider : IExternalScopeProvider
	{
		[field: CompilerGenerated]
		public static IExternalScopeProvider Instance
		{
			[CompilerGenerated]
			get;
		} = new NullExternalScopeProvider();


		private NullExternalScopeProvider()
		{
		}

		void IExternalScopeProvider.ForEachScope<TState>(Action<object, TState> callback, TState state)
		{
		}

		System.IDisposable IExternalScopeProvider.Push(object state)
		{
			return NullScope.Instance;
		}
	}
	internal sealed class NullScope : System.IDisposable
	{
		[field: CompilerGenerated]
		public static NullScope Instance
		{
			[CompilerGenerated]
			get;
		} = new NullScope();


		private NullScope()
		{
		}

		public void Dispose()
		{
		}
	}
	internal static class DebuggerDisplayFormatting
	{
		internal static string DebuggerToString(string name, ILogger logger)
		{
			LogLevel? logLevel = CalculateEnabledLogLevel(logger);
			string text = "Name = \"" + name + "\"";
			if (logLevel.HasValue)
			{
				return text + $", MinLevel = {logLevel}";
			}
			return text + ", Enabled = false";
		}

		internal unsafe static LogLevel? CalculateEnabledLogLevel(ILogger logger)
		{
			System.Span<LogLevel> span = stackalloc LogLevel[6]
			{
				LogLevel.Critical,
				LogLevel.Error,
				LogLevel.Warning,
				LogLevel.Information,
				LogLevel.Debug,
				LogLevel.Trace
			};
			System.ReadOnlySpan<LogLevel> readOnlySpan = System.Span<LogLevel>.op_Implicit(span);
			LogLevel? result = null;
			System.ReadOnlySpan<LogLevel> readOnlySpan2 = readOnlySpan;
			for (int i = 0; i < readOnlySpan2.Length; i++)
			{
				LogLevel logLevel = *(LogLevel*)readOnlySpan2[i];
				if (!logger.IsEnabled(logLevel))
				{
					break;
				}
				result = logLevel;
			}
			return result;
		}
	}
}
namespace Microsoft.Extensions.Logging.Abstractions
{
	public readonly struct LogEntry<TState>
	{
		public LogLevel LogLevel
		{
			[CompilerGenerated]
			get;
		}

		public string Category
		{
			[CompilerGenerated]
			get;
		}

		public EventId EventId
		{
			[CompilerGenerated]
			get;
		}

		public TState State
		{
			[CompilerGenerated]
			get;
		}

		public System.Exception? Exception
		{
			[CompilerGenerated]
			get;
		}

		public Func<TState, System.Exception?, string> Formatter
		{
			[CompilerGenerated]
			get;
		}

		public LogEntry(LogLevel logLevel, string category, EventId eventId, TState state, System.Exception? exception, Func<TState, System.Exception?, string> formatter)
		{
			LogLevel = logLevel;
			Category = category;
			EventId = eventId;
			State = state;
			Exception = exception;
			Formatter = formatter;
		}
	}
	public class NullLogger : ILogger
	{
		[field: CompilerGenerated]
		public static NullLogger Instance
		{
			[CompilerGenerated]
			get;
		} = new NullLogger();


		private NullLogger()
		{
		}

		public System.IDisposable BeginScope<TState>(TState state) where TState : notnull
		{
			return NullScope.Instance;
		}

		public bool IsEnabled(LogLevel logLevel)
		{
			return false;
		}

		public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, System.Exception? exception, Func<TState, System.Exception?, string> formatter)
		{
		}
	}
	public class NullLoggerFactory : ILoggerFactory, System.IDisposable
	{
		public static readonly NullLoggerFactory Instance = new NullLoggerFactory();

		public ILogger CreateLogger(string name)
		{
			return NullLogger.Instance;
		}

		public void AddProvider(ILoggerProvider provider)
		{
		}

		public void Dispose()
		{
		}
	}
	public class NullLoggerProvider : ILoggerProvider, System.IDisposable
	{
		[field: CompilerGenerated]
		public static NullLoggerProvider Instance
		{
			[CompilerGenerated]
			get;
		} = new NullLoggerProvider();


		private NullLoggerProvider()
		{
		}

		public ILogger CreateLogger(string categoryName)
		{
			return NullLogger.Instance;
		}

		public void Dispose()
		{
		}
	}
	public class NullLogger<T> : ILogger<T>, ILogger
	{
		public static readonly NullLogger<T> Instance = new NullLogger<T>();

		public System.IDisposable BeginScope<TState>(TState state) where TState : notnull
		{
			return NullScope.Instance;
		}

		public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, System.Exception? exception, Func<TState, System.Exception?, string> formatter)
		{
		}

		public bool IsEnabled(LogLevel logLevel)
		{
			return false;
		}
	}
}