using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Logging;
using ContractQueen.Behaviors;
using ContractQueen.ContractEvents;
using ContractQueen.ContractManager;
using ContractQueen.Contracts;
using ContractQueen.Patches;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.VisualScripting;
using UnityEngine;
using UnityEngine.SceneManagement;
using YAPYAP;
using YAPYAP.Npc.Frog;
using YapLocalizer;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("dev.mamallama.contractqueen")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.2.0.0")]
[assembly: AssemblyInformationalVersion("0.2.0+190d3d300fcdca8b0452b759a4747cc38a9e6db7")]
[assembly: AssemblyProduct("dev.mamallama.contractqueen")]
[assembly: AssemblyTitle("ContractQueen")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.2.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
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 BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	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")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace ContractQueen
{
	[BepInPlugin("dev.mamallama.contractqueen", "ContractQueen", "0.2.0")]
	public class ContractQueenPlugin : BaseUnityPlugin
	{
		public const string contractName = "CONTRACT_QUEEN_TEST_CONTRACT_NAME";

		public const string contractDesc = "CONTRACT_QUEEN_TEST_CONTRACT_DESC";

		private bool MainMenuSeen;

		public const string Id = "dev.mamallama.contractqueen";

		internal static ManualLogSource Log { get; private set; }

		public static string Name => "ContractQueen";

		public static string Version => "0.2.0";

		private void Awake()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			Log.LogMessage((object)"Loading localized contract data");
			ModLocalizedText val = new ModLocalizedText("CONTRACT_QUEEN_TEST_CONTRACT_NAME", "");
			val.SetLocalization((SystemLanguage)10, "Rescue Frogs");
			val = new ModLocalizedText("CONTRACT_QUEEN_TEST_CONTRACT_DESC", "");
			val.SetLocalization((SystemLanguage)10, "Rescued {0}/{1} Frogs");
			Harmony val2 = new Harmony("dev.mamallama.contractqueen");
			val2.PatchAll(typeof(DungeonTasksPatches));
			val2.PatchAll(typeof(NetworkPuppetPropPatches));
			val2.PatchAll(typeof(FrogStateMachinePatches));
			Log.LogInfo((object)$"Patch count: {val2.GetPatchedMethods().Count()}");
			SceneManager.sceneLoaded += OnSceneChange;
			ContractsModule contractsModule = new ContractsModule("dev.mamallama.contractqueen");
			contractsModule.RegisterContract("RescueFrogsQuest", (GameplayTaskSO)(object)RescueFrogsTask.Factory());
		}

		private void OnSceneChange(Scene arg0, LoadSceneMode arg1)
		{
			if (!MainMenuSeen && ((Scene)(ref arg0)).name.Equals("menu", StringComparison.OrdinalIgnoreCase))
			{
				ContractsRegistry.Lock();
				MainMenuSeen = true;
			}
		}
	}
}
namespace ContractQueen.Patches
{
	internal class DungeonTasksPatches
	{
		[HarmonyPatch(typeof(DungeonTasks), "Awake")]
		[HarmonyPostfix]
		internal static void AddContractsToRandomPool()
		{
			IReadOnlyList<GameplayTaskSO> lockedList = ContractsRegistry.LockedList;
			GameplayTaskSO[] constantTasks = DungeonTasks.Instance.constantTasks;
			GameplayTaskSO[] randomTasks = DungeonTasks.Instance.randomTasks;
			GameplayTaskSO[] collectableTasks = DungeonTasks.Instance.collectableTasks;
			int num = constantTasks.Length + randomTasks.Length + collectableTasks.Length;
			int num2 = 0;
			foreach (GameplayTaskSO item in lockedList)
			{
				item.TaskId = num + num2;
				num2++;
			}
			DungeonTasks instance = DungeonTasks.Instance;
			GameplayTaskSO[] array = randomTasks;
			IReadOnlyList<GameplayTaskSO> readOnlyList = lockedList;
			int num3 = 0;
			GameplayTaskSO[] array2 = (GameplayTaskSO[])(object)new GameplayTaskSO[array.Length + readOnlyList.Count];
			ReadOnlySpan<GameplayTaskSO> readOnlySpan = new ReadOnlySpan<GameplayTaskSO>(array);
			readOnlySpan.CopyTo(new Span<GameplayTaskSO>(array2).Slice(num3, readOnlySpan.Length));
			num3 += readOnlySpan.Length;
			foreach (GameplayTaskSO item2 in readOnlyList)
			{
				array2[num3] = item2;
				num3++;
			}
			instance.randomTasks = array2;
			DungeonTasks instance2 = DungeonTasks.Instance;
			GameplayTaskSO[] array3 = constantTasks;
			GameplayTaskSO[] array4 = randomTasks;
			GameplayTaskSO[] array5 = collectableTasks;
			int num4 = 0;
			GameplayTaskSO[] array6 = (GameplayTaskSO[])(object)new GameplayTaskSO[array3.Length + array4.Length + array5.Length];
			ReadOnlySpan<GameplayTaskSO> readOnlySpan2 = new ReadOnlySpan<GameplayTaskSO>(array3);
			readOnlySpan2.CopyTo(new Span<GameplayTaskSO>(array6).Slice(num4, readOnlySpan2.Length));
			num4 += readOnlySpan2.Length;
			ReadOnlySpan<GameplayTaskSO> readOnlySpan3 = new ReadOnlySpan<GameplayTaskSO>(array4);
			readOnlySpan3.CopyTo(new Span<GameplayTaskSO>(array6).Slice(num4, readOnlySpan3.Length));
			num4 += readOnlySpan3.Length;
			ReadOnlySpan<GameplayTaskSO> readOnlySpan4 = new ReadOnlySpan<GameplayTaskSO>(array5);
			readOnlySpan4.CopyTo(new Span<GameplayTaskSO>(array6).Slice(num4, readOnlySpan4.Length));
			num4 += readOnlySpan4.Length;
			instance2.allTasks = array6;
			ContractQueenPlugin.Log.LogMessage((object)$"Added {num2} contract(s) to pool starting from ID {num} to {num + num2 - 1}");
		}
	}
	internal static class FrogStateMachinePatches
	{
		[HarmonyPatch(typeof(FrogStateMachine), "Awake")]
		[HarmonyPostfix]
		internal static void AwakePatch(FrogStateMachine __instance)
		{
			ComponentHolderProtocol.AddComponent<FrogContractBehavior>((Object)(object)__instance);
		}
	}
	internal static class NetworkPuppetPropPatches
	{
		[HarmonyPatch(typeof(NetworkPuppetProp), "OnDropped")]
		[HarmonyPostfix]
		internal static void ServerSetInInventoryPatch(NetworkPuppetProp __instance)
		{
			FrogContractBehavior component = ((Component)__instance).GetComponent<FrogContractBehavior>();
			ContractQueenPlugin.Log.LogDebug((object)$"OnDropped: {((Object)((Component)__instance).gameObject).name} | {__instance.DisplayName}({((Object)__instance).GetInstanceID()}), isFrog: {(Object)(object)component != (Object)null}");
			if (!((Object)(object)component == (Object)null) && !component.HasBeenCounted)
			{
				ContractQueenPlugin.Log.LogDebug((object)$"New frog: {!component.HasBeenCounted}");
				Events.CountFrog(component);
			}
		}
	}
}
namespace ContractQueen.Contracts
{
	public class RescueFrogsTask : GameplayTaskSO
	{
		[SerializeField]
		private int frogCount = 5;

		public static RescueFrogsTask Factory()
		{
			return new RescueFrogsTask
			{
				nameLocalisationKey = "CONTRACT_QUEEN_TEST_CONTRACT_NAME",
				descriptionLocalisationKey = "CONTRACT_QUEEN_TEST_CONTRACT_DESC",
				pointValue = 200
			};
		}

		public override bool CanBeCreated()
		{
			return true;
		}

		protected override int CalculateTargetProgress()
		{
			return frogCount;
		}

		public override void SubscribeToProgressEvents(GameplayTask runtimeTask)
		{
			GameplayTask runtimeTask2 = runtimeTask;
			Action<FrogContractBehavior> action = delegate
			{
				ContractQueenPlugin.Log.LogDebug((object)"Counted a frog for a quest");
				runtimeTask2.AdvanceProgress(1);
			};
			runtimeTask2.SetProgressHandler((Delegate)action);
			Events.FrogCountedEvent += action;
		}

		public override void UnsubscribeFromProgressEvents(GameplayTask runtimeTask)
		{
			if (runtimeTask.GetProgressHandler() is Action<FrogContractBehavior> value)
			{
				Events.FrogCountedEvent -= value;
				runtimeTask.SetProgressHandler((Delegate)null);
			}
		}
	}
}
namespace ContractQueen.ContractManager
{
	public class ContractBundle
	{
		public readonly string Name;

		public readonly GameplayTaskSO Contract;

		public ContractBundle(string name, GameplayTaskSO contract)
		{
			Name = name;
			Contract = contract;
			base..ctor();
		}
	}
	public class ContractBundleComparer : IComparer<ContractBundle>
	{
		public static readonly IComparer<ContractBundle> NameOrdinal = new ContractBundleComparer();

		public int Compare(ContractBundle x, ContractBundle y)
		{
			if (x == y)
			{
				return 0;
			}
			if (x == null)
			{
				return -1;
			}
			if (y == null)
			{
				return 1;
			}
			return StringComparer.Ordinal.Compare(x.Name, y.Name);
		}
	}
	public sealed class ContractsModule
	{
		private readonly string GUID;

		private readonly SortedSet<ContractBundle> _contracts;

		public ContractsModule(string guid)
		{
			GUID = guid;
			_contracts = ContractsRegistry.EnsureGUID(GUID);
		}

		public bool RegisterContract(ContractBundle contract)
		{
			return _contracts.Add(contract);
		}

		public bool RegisterContract(string name, GameplayTaskSO contract)
		{
			return _contracts.Add(new ContractBundle(name, contract));
		}

		public void RegisterMany(IEnumerable<ContractBundle> items)
		{
			LinqUtility.AddRange<ContractBundle>((ICollection<ContractBundle>)_contracts, items);
		}
	}
	internal static class ContractsRegistry
	{
		private static readonly SortedDictionary<string, SortedSet<ContractBundle>> Registry = new SortedDictionary<string, SortedSet<ContractBundle>>(StringComparer.Ordinal);

		private static bool Finalized = false;

		private static IReadOnlyList<GameplayTaskSO> _cachedLockedList = Array.Empty<GameplayTaskSO>();

		public static IReadOnlyList<GameplayTaskSO> LockedList => _cachedLockedList;

		internal static SortedSet<ContractBundle> EnsureGUID(string GUID)
		{
			if (Finalized)
			{
				throw new InvalidOperationException("Cannot add quests after main menu is reached");
			}
			if (Registry.TryGetValue(GUID, out SortedSet<ContractBundle> value))
			{
				return value;
			}
			SortedSet<ContractBundle> sortedSet = new SortedSet<ContractBundle>(ContractBundleComparer.NameOrdinal);
			Registry[GUID] = sortedSet;
			return sortedSet;
		}

		internal static void Lock()
		{
			List<GameplayTaskSO> list = new List<GameplayTaskSO>();
			foreach (SortedSet<ContractBundle> value in Registry.Values)
			{
				foreach (ContractBundle item in value)
				{
					list.Add(item.Contract);
				}
			}
			ContractQueenPlugin.Log.LogMessage((object)ListContracts());
			_cachedLockedList = list.AsReadOnly();
			Finalized = true;
		}

		public static string ListContracts()
		{
			StringBuilder stringBuilder = new StringBuilder("Contracts Loaded:\n");
			foreach (KeyValuePair<string, SortedSet<ContractBundle>> item in Registry)
			{
				stringBuilder.AppendLine("  [" + item.Key + "]");
				foreach (ContractBundle item2 in item.Value)
				{
					stringBuilder.AppendLine("    -" + item2.Name);
				}
			}
			return stringBuilder.ToString();
		}
	}
}
namespace ContractQueen.ContractEvents
{
	public static class Events
	{
		public static event Action<FrogContractBehavior>? FrogCountedEvent;

		internal static void CountFrog(FrogContractBehavior frog)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if ((int)GameManager.Instance.CurrentGameState == 0)
			{
				Events.FrogCountedEvent?.Invoke(frog);
			}
			frog.Count();
		}
	}
}
namespace ContractQueen.Behaviors
{
	public class FrogContractBehavior : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <DelayedFrogCheck>d__9 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public FrogContractBehavior <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Expected O, but got Unknown
				//IL_0059: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				FrogContractBehavior frogContractBehavior = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					ContractQueenPlugin.Log.LogDebug((object)$"Check valid status for a frog: {((Object)((Component)frogContractBehavior).gameObject).GetInstanceID()} | State | {frogContractBehavior.Owner.CurrentState.state}");
					if (((Object)((Component)frogContractBehavior).gameObject).name == "NpcFrog (1)" || ((Object)((Component)frogContractBehavior).gameObject).name == "NpcFrog (2)")
					{
						ContractQueenPlugin.Log.LogDebug((object)("Invalidating a unique frog: " + ((Object)((Component)frogContractBehavior).gameObject).name));
						frogContractBehavior.Count();
						return false;
					}
					if ((int)GameManager.Instance.currentGameState != 0)
					{
						return false;
					}
					if ((int)frogContractBehavior.Owner.CurrentState.state == 0)
					{
						ContractQueenPlugin.Log.LogDebug((object)$"Invalidating an IDLE frog: {((Object)frogContractBehavior.Owner).GetInstanceID()}");
						frogContractBehavior.Count();
					}
					return false;
				}
			}

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

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public NetworkPuppetProp Owner { get; protected set; }

		public bool HasBeenCounted { get; protected set; }

		private void Awake()
		{
			Owner = ((Component)this).gameObject.GetComponent<NetworkPuppetProp>();
			if ((Object)(object)Owner == (Object)null)
			{
				ContractQueenPlugin.Log.LogError((object)"Unable to establish owner in FrogContractBehavior");
			}
		}

		[IteratorStateMachine(typeof(<DelayedFrogCheck>d__9))]
		private IEnumerator DelayedFrogCheck()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedFrogCheck>d__9(0)
			{
				<>4__this = this
			};
		}

		private void OnEnable()
		{
			if (!HasBeenCounted)
			{
				((MonoBehaviour)this).StartCoroutine(DelayedFrogCheck());
			}
		}

		public void Count()
		{
			HasBeenCounted = true;
		}
	}
}
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
	{
		internal 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
	{
	}
}