using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using Md.PlayerGolfer;
using Microsoft.CodeAnalysis;
using Mirror;
using MonoDetour;
using MonoDetour.Cil;
using MonoDetour.DetourTypes;
using MonoDetour.HookGen;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("GameAssembly")]
[assembly: IgnoresAccessChecksTo("SharedAssembly")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.github.LyricLy.MoveAfterScoring")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0+1af8d30f3cbeadfe3904329c24d7831c2b809ca5")]
[assembly: AssemblyProduct("com.github.LyricLy.MoveAfterScoring")]
[assembly: AssemblyTitle("Move After Scoring")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace System.Runtime.CompilerServices
{
	[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;
		}
	}
}
namespace Md.PlayerGolfer
{
	internal static class ServerTrySetMatchResolution
	{
		public delegate void PrefixSignature(PlayerGolfer self, ref PlayerMatchResolution resolution);

		public delegate ReturnFlow ControlFlowPrefixSignature(PlayerGolfer self, ref PlayerMatchResolution resolution, ref bool returnValue);

		public delegate void PostfixSignature(PlayerGolfer self, ref PlayerMatchResolution resolution, ref bool returnValue);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ControlFlowPrefix(ControlFlowPrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(PlayerGolfer);
			MethodInfo method = typeFromHandle.GetMethod("ServerTrySetMatchResolution", (BindingFlags)(-1), null, new Type[1] { typeof(PlayerMatchResolution) }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("PlayerGolfer", "ServerTrySetMatchResolution");
			}
			return method;
		}
	}
	internal static class get_PlayerInfo
	{
	}
	internal static class set_PlayerInfo
	{
	}
	internal static class get_IsInitialized
	{
	}
	internal static class get_OwnBall
	{
	}
	internal static class get_LocalPlayerLatestImmediateEliminationReason
	{
	}
	internal static class set_LocalPlayerLatestImmediateEliminationReason
	{
	}
	internal static class get_LocalPlayerLatestEliminationPosition
	{
	}
	internal static class set_LocalPlayerLatestEliminationPosition
	{
	}
	internal static class get_LocalPlayerEliminationTimestamp
	{
	}
	internal static class set_LocalPlayerEliminationTimestamp
	{
	}
	internal static class get_SwingNormalizedPower
	{
	}
	internal static class set_SwingNormalizedPower
	{
	}
	internal static class get_SwingPitch
	{
	}
	internal static class set_SwingPitch
	{
	}
	internal static class get_ServerOutOfBoundsTimerEliminationTimestamp
	{
	}
	internal static class set_ServerOutOfBoundsTimerEliminationTimestamp
	{
	}
	internal static class get_IsAimingSwing
	{
	}
	internal static class set_IsAimingSwing
	{
	}
	internal static class get_IsChargingSwing
	{
	}
	internal static class set_IsChargingSwing
	{
	}
	internal static class get_IsSwinging
	{
	}
	internal static class set_IsSwinging
	{
	}
	internal static class get_LockOnTarget
	{
	}
	internal static class set_LockOnTarget
	{
	}
	internal static class get_IsActiveOnGreen
	{
	}
	internal static class set_IsActiveOnGreen
	{
	}
	internal static class get_IsAheadOfBall
	{
	}
	internal static class get_MatchResolution
	{
	}
	internal static class get_IsMatchResolved
	{
	}
	internal static class get_ClubVfxSettings
	{
	}
	internal static class add_Initialized
	{
	}
	internal static class remove_Initialized
	{
	}
	internal static class add_MatchResolutionChanged
	{
	}
	internal static class remove_MatchResolutionChanged
	{
	}
	internal static class add_LocalPlayerOwnBallChanged
	{
	}
	internal static class remove_LocalPlayerOwnBallChanged
	{
	}
	internal static class add_LocalPlayerIsAimingSwingChanged
	{
	}
	internal static class remove_LocalPlayerIsAimingSwingChanged
	{
	}
	internal static class add_LocalPlayerStartedChargingSwing
	{
	}
	internal static class remove_LocalPlayerStartedChargingSwing
	{
	}
	internal static class add_LocalPlayerStoppedChargingSwing
	{
	}
	internal static class remove_LocalPlayerStoppedChargingSwing
	{
	}
	internal static class add_LocalPlayerMatchResolutionChanged
	{
	}
	internal static class remove_LocalPlayerMatchResolutionChanged
	{
	}
	internal static class add_PlayerHitOwnBall
	{
	}
	internal static class remove_PlayerHitOwnBall
	{
	}
	internal static class add_AnyPlayerMatchResolutionChanged
	{
	}
	internal static class remove_AnyPlayerMatchResolutionChanged
	{
	}
	internal static class add_AnyPlayerEliminated
	{
	}
	internal static class remove_AnyPlayerEliminated
	{
	}
	internal static class ReturnButtonPrompts
	{
	}
	internal static class ReturnBallToPlayer
	{
	}
	internal static class FinishHole
	{
	}
	internal static class CmdReturnBallToPlayerFromConsole
	{
	}
	internal static class CmdRestartBall
	{
	}
	internal static class ServerReturnBallToPlayer
	{
	}
	internal static class CmdFinishHole
	{
	}
	internal static class InitializeStatics
	{
	}
	internal static class Awake
	{
	}
	internal static class OnWillBeDestroyed
	{
	}
	internal static class OnStartServer
	{
	}
	internal static class OnStopServer
	{
	}
	internal static class OnStartLocalPlayer
	{
	}
	internal static class OnStopLocalPlayer
	{
	}
	internal static class OnBUpdate
	{
	}
	internal static class ServerInitializeAsParticipant
	{
	}
	internal static class ServerInitializeAsSpectator
	{
	}
	internal static class ServerSpawnBall
	{
	}
	internal static class InformIsSpectatingChanged
	{
	}
	internal static class InformEnteredGolfCart
	{
	}
	internal static class TryReactToBlownAirhorn
	{
	}
	internal static class InformScored
	{
	}
	internal static class InformCourseStateChanged
	{
	}
	internal static class InformLocalPlayerIsHoldingAimChanged
	{
	}
	internal static class InformLocalPlayerIsRespawningChanged
	{
	}
	internal static class InformLocalPlayerKnockedOut
	{
	}
	internal static class InformLocalPlayerStartedDiving
	{
	}
	internal static class ServerEliminate
	{
	}
	internal static class RpcInformWillBeEliminated
	{
	}
	internal static class OnLocalPlayerWillBeEliminated
	{
	}
	internal static class GetEliminationReason
	{
	}
	internal static class CmdSetPotentialEliminationReason
	{
	}
	internal static class ServerSetPotentialEliminationReason
	{
	}
	internal static class ServerClearPotentialEliminationResponsibility
	{
	}
	internal static class SetPitch
	{
	}
	internal static class ApplySwingPitchPreset
	{
	}
	internal static class GetSwingPreset
	{
	}
	internal static class CycleSwingPitchPreset
	{
	}
	internal static class TryStartChargingSwing
	{
	}
	internal static class ReleaseSwingCharge
	{
	}
	internal static class ReleaseSwingChargeInternal
	{
	}
	internal static class SwingRoutine
	{
	}
	internal static class CmdPlaySwingVfxForAllClients
	{
	}
	internal static class RpcPlaySwingVfx
	{
	}
	internal static class PlaySwingVfxInternal
	{
	}
	internal static class CancelAllActions
	{
	}
	internal static class TryCancelSwingCharge
	{
	}
	internal static class CancelSwing
	{
	}
	internal static class OnFinishedSwinging
	{
	}
	internal static class CmdInformHitOwnBall
	{
	}
	internal static class OnPlayerHitOwnBall
	{
	}
	internal static class TryGetBestLockOnTarget
	{
	}
	internal static class CanHitCollider
	{
	}
	internal static class SetPitchInternal
	{
	}
	internal static class GetPitchPresetIndex
	{
	}
	internal static class UpdateIsAimingSwing
	{
	}
	internal static class CanAimSwing
	{
	}
	internal static class SetIsChargingSwing
	{
	}
	internal static class SetLockOnTarget
	{
	}
	internal static class UpdateSwingNormalizedPower
	{
	}
	internal static class GetSwingHitBox
	{
	}
	internal static class GetSwingDirection
	{
	}
	internal static class GetSwingHittablePriority
	{
	}
	internal static class UpdateOverchargedVfx
	{
	}
	internal static class SetIsPlayingOverchargedVfx
	{
	}
	internal static class ClearOverchargedVfx
	{
	}
	internal static class ServerUpdateIsActiveOnGreen
	{
	}
	internal static class IsAimingSwingNetworked
	{
	}
	internal static class CanRotate
	{
	}
	internal static class CanMove
	{
	}
	internal static class CanInterruptSwing
	{
	}
	internal static class OnServerWasHitByItem
	{
	}
	internal static class OnServerWasHitByRocketLauncherBackBlast
	{
	}
	internal static class OnServerWasHitByDive
	{
	}
	internal static class OnServerIsOnGreenChanged
	{
	}
	internal static class OnServerBoundsStateChanged
	{
	}
	internal static class OnServerMatchStateChanged
	{
	}
	internal static class OnLocalPlayerIsGroundedChanged
	{
	}
	internal static class OnLocalPlayerIsKnockedOutChanged
	{
	}
	internal static class OnLocalPlayerEquippedItemChanged
	{
	}
	internal static class OnLockOnTargetWillBeDestroyed
	{
	}
	internal static class OnLockOnTargetPlayerIsVisibleChanged
	{
	}
	internal static class OnLockOnTargetPlayerMatchResolutionChanged
	{
	}
	internal static class OnIsInitializedChanged
	{
	}
	internal static class OnOwnBallChanged
	{
	}
	internal static class OnMatchResolutionChanged
	{
	}
	internal static class OnIsAheadOfBallChanged
	{
	}
	internal static class UpdateSwingStanceButtonPrompt
	{
	}
	internal static class UpdateAdjustAnglePrompt
	{
	}
	internal static class _ctor
	{
	}
	internal static class _cctor
	{
	}
	internal static class Weaved
	{
	}
	internal static class get_NetworkisInitialized
	{
	}
	internal static class set_NetworkisInitialized
	{
	}
	internal static class get_NetworkownTee
	{
	}
	internal static class set_NetworkownTee
	{
	}
	internal static class get_NetworkownBall
	{
	}
	internal static class set_NetworkownBall
	{
	}
	internal static class get_NetworkmatchResolution
	{
	}
	internal static class set_NetworkmatchResolution
	{
	}
	internal static class get_NetworkisAheadOfBall
	{
	}
	internal static class set_NetworkisAheadOfBall
	{
	}
	internal static class UserCode_CmdReturnBallToPlayerFromConsole
	{
	}
	internal static class InvokeUserCode_CmdReturnBallToPlayerFromConsole
	{
	}
	internal static class UserCode_CmdRestartBall
	{
	}
	internal static class InvokeUserCode_CmdRestartBall
	{
	}
	internal static class UserCode_CmdFinishHole
	{
	}
	internal static class InvokeUserCode_CmdFinishHole
	{
	}
	internal static class UserCode_RpcInformWillBeEliminated__EliminationReason__Vector3
	{
	}
	internal static class InvokeUserCode_RpcInformWillBeEliminated__EliminationReason__Vector3
	{
	}
	internal static class UserCode_CmdSetPotentialEliminationReason__PlayerGolfer__EliminationReason
	{
	}
	internal static class InvokeUserCode_CmdSetPotentialEliminationReason__PlayerGolfer__EliminationReason
	{
	}
	internal static class UserCode_CmdPlaySwingVfxForAllClients__Single__Boolean__Boolean__NetworkConnectionToClient
	{
	}
	internal static class InvokeUserCode_CmdPlaySwingVfxForAllClients__Single__Boolean__Boolean__NetworkConnectionToClient
	{
	}
	internal static class UserCode_RpcPlaySwingVfx__NetworkConnectionToClient__Single__Boolean__Boolean
	{
	}
	internal static class InvokeUserCode_RpcPlaySwingVfx__NetworkConnectionToClient__Single__Boolean__Boolean
	{
	}
	internal static class UserCode_CmdInformHitOwnBall
	{
	}
	internal static class InvokeUserCode_CmdInformHitOwnBall
	{
	}
	internal static class SerializeSyncVars
	{
	}
	internal static class DeserializeSyncVars
	{
	}
	internal static class SwingDistanceEstimation
	{
		internal static class _ctor
		{
		}

		internal static class _ctor_System_Single_TerrainLayer_OutOfBoundsHazard
		{
		}
	}
	internal static class TerrainLayerNormalizedSwingPower
	{
		internal static class _ctor
		{
		}

		internal static class get_Invalid
		{
		}

		internal static class IsInvalid
		{
		}
	}
	internal static class TerrainLayerNormalizedSwingPowerComparer
	{
		internal static class _ctor
		{
		}

		internal static class Compare
		{
		}
	}
	internal static class __c__DisplayClass166_0
	{
		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass180_0
	{
		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass198_0
	{
		internal static class _ctor
		{
		}
	}
	internal static class _SwingRoutine_d__180
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
}
namespace MonoDetour.HookGen
{
	internal static class DefaultMonoDetourManager
	{
		internal static MonoDetourManager Instance { get; } = New();


		internal static MonoDetourManager New()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			return new MonoDetourManager(typeof(DefaultMonoDetourManager).Assembly.GetName().Name);
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class, AllowMultiple = true, Inherited = false)]
	internal class MonoDetourTargetsAttribute : Attribute, IMonoDetourTargets
	{
		public Type? TargetType { get; }

		public bool IncludeNestedTypes { get; set; }

		public string[]? Members { get; set; }

		public string[]? MemberNamePrefixes { get; set; }

		public string[]? MemberNameSuffixes { get; set; }

		public bool GenerateControlFlowVariants { get; set; }

		public MonoDetourTargetsAttribute(Type? targetType = null)
		{
			TargetType = targetType;
			IncludeNestedTypes = true;
			base..ctor();
		}
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace MoveAfterScoring
{
	[MonoDetourTargets(typeof(PlayerGolfer), GenerateControlFlowVariants = true)]
	public class PlayerGolferHooks
	{
		private static ConditionalWeakTable<PlayerGolfer, object?> HasScored = new ConditionalWeakTable<PlayerGolfer, object>();

		[MonoDetourHookInitialize]
		private static void Init()
		{
			ServerTrySetMatchResolution.ControlFlowPrefix(ControlFlowPrefix_DoNotSetScored);
		}

		private static ReturnFlow ControlFlowPrefix_DoNotSetScored(PlayerGolfer self, ref PlayerMatchResolution resolution, ref bool returnValue)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			if ((int)resolution == 2 && HasScored.TryGetValue(self, out object _))
			{
				resolution = (PlayerMatchResolution)1;
				return (ReturnFlow)0;
			}
			if (((NetworkBehaviour)self).isServer && Plugin.Enabled.Value && (int)resolution == 1)
			{
				HasScored.AddOrUpdate(self, null);
				PlayerMatchResolution matchResolution = self.matchResolution;
				self.matchResolution = resolution;
				SingletonNetworkBehaviour<CourseManager>.Instance.OnServerAnyPlayerMatchResolutionChanged(self, matchResolution, resolution);
				self.matchResolution = matchResolution;
				returnValue = false;
				return (ReturnFlow)2;
			}
			return (ReturnFlow)0;
		}
	}
	[BepInPlugin("com.github.LyricLy.MoveAfterScoring", "Move After Scoring", "0.1.0")]
	public class Plugin : BaseUnityPlugin
	{
		public static ConfigEntry<bool> Enabled;

		public const string Id = "com.github.LyricLy.MoveAfterScoring";

		public static string Name => "Move After Scoring";

		public static string Version => "0.1.0";

		private void Awake()
		{
			Enabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enable", true, "Allow players to move after scoring");
			MonoDetourManager.InvokeHookInitializers(Assembly.GetExecutingAssembly());
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ConstantExpectedAttribute : Attribute
	{
		public object? Min { get; set; }

		public object? Max { get; set; }
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ExperimentalAttribute : Attribute
	{
		public string DiagnosticId { get; }

		public string? UrlFormat { get; set; }

		public ExperimentalAttribute(string diagnosticId)
		{
			DiagnosticId = diagnosticId;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	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)]
	[ExcludeFromCodeCoverage]
	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;
		}
	}
	[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class SetsRequiredMembersAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class StringSyntaxAttribute : Attribute
	{
		public const string CompositeFormat = "CompositeFormat";

		public const string DateOnlyFormat = "DateOnlyFormat";

		public const string DateTimeFormat = "DateTimeFormat";

		public const string EnumFormat = "EnumFormat";

		public const string GuidFormat = "GuidFormat";

		public const string Json = "Json";

		public const string NumericFormat = "NumericFormat";

		public const string Regex = "Regex";

		public const string TimeOnlyFormat = "TimeOnlyFormat";

		public const string TimeSpanFormat = "TimeSpanFormat";

		public const string Uri = "Uri";

		public const string Xml = "Xml";

		public string Syntax { get; }

		public object?[] Arguments { get; }

		public StringSyntaxAttribute(string syntax)
		{
			Syntax = syntax;
			Arguments = new object[0];
		}

		public StringSyntaxAttribute(string syntax, params object?[] arguments)
		{
			Syntax = syntax;
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class UnscopedRefAttribute : Attribute
	{
	}
}
namespace System.Runtime.Versioning
{
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiresPreviewFeaturesAttribute : Attribute
	{
		public string? Message { get; }

		public string? Url { get; set; }

		public RequiresPreviewFeaturesAttribute()
		{
		}

		public RequiresPreviewFeaturesAttribute(string? message)
		{
			Message = message;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CallerArgumentExpressionAttribute : Attribute
	{
		public string ParameterName { get; }

		public CallerArgumentExpressionAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CollectionBuilderAttribute : Attribute
	{
		public Type BuilderType { get; }

		public string MethodName { get; }

		public CollectionBuilderAttribute(Type builderType, string methodName)
		{
			BuilderType = builderType;
			MethodName = methodName;
		}
	}
	[AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CompilerFeatureRequiredAttribute : Attribute
	{
		public const string RefStructs = "RefStructs";

		public const string RequiredMembers = "RequiredMembers";

		public string FeatureName { get; }

		public bool IsOptional { get; set; }

		public CompilerFeatureRequiredAttribute(string featureName)
		{
			FeatureName = featureName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class InterpolatedStringHandlerArgumentAttribute : Attribute
	{
		public string[] Arguments { get; }

		public InterpolatedStringHandlerArgumentAttribute(string argument)
		{
			Arguments = new string[1] { argument };
		}

		public InterpolatedStringHandlerArgumentAttribute(params string[] arguments)
		{
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class InterpolatedStringHandlerAttribute : Attribute
	{
	}
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	internal static class IsExternalInit
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ModuleInitializerAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class OverloadResolutionPriorityAttribute : Attribute
	{
		public int Priority { get; }

		public OverloadResolutionPriorityAttribute(int priority)
		{
			Priority = priority;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = true, AllowMultiple = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ParamCollectionAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiredMemberAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiresLocationAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class SkipLocalsInitAttribute : Attribute
	{
	}
}