using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using ExitGames.Client.Photon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using Photon.Realtime;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.atomic.coloredmarshmallow")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0")]
[assembly: AssemblyProduct("com.atomic.coloredmarshmallow")]
[assembly: AssemblyTitle("Colored_Marshmallows")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class 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")]
	[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")]
	[Embedded]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace Colored_Marshmallows
{
	[BepInPlugin("com.atomic.coloredmarshmallow", "Colored_Marshmallows", "0.1.0")]
	public class Plugin : BaseUnityPlugin
	{
		private static Harmony harmony;

		public const string Id = "com.atomic.coloredmarshmallow";

		internal static ManualLogSource Log { get; private set; }

		public static string Name => "Colored_Marshmallows";

		public static string Version => "0.1.0";

		private void Awake()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			Log.LogInfo((object)("Plugin " + Name + " is loaded!"));
			harmony = new Harmony("com.atomic.coloredmarshmallow");
			harmony.PatchAll();
			GameObject val = new GameObject("MarshmallowNetworking");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.AddComponent<MarshmallowNetworking>();
		}
	}
	public class MarshmallowNetworking : MonoBehaviourPunCallbacks, IOnEventCallback
	{
		private const byte ModPresenceEvent = 101;

		private const byte SyncColorsEvent = 102;

		private const byte AddVariantEvent = 103;

		public static List<int> ActorsWithMod = new List<int>();

		public override void OnEnable()
		{
			((MonoBehaviourPunCallbacks)this).OnEnable();
			PhotonNetwork.AddCallbackTarget((object)this);
		}

		public override void OnDisable()
		{
			((MonoBehaviourPunCallbacks)this).OnDisable();
			PhotonNetwork.RemoveCallbackTarget((object)this);
		}

		public static Player CallingPlayer(out bool wasLocalPlayer)
		{
			wasLocalPlayer = false;
			if (ActorsWithMod.Count <= 1)
			{
				wasLocalPlayer = true;
				return PhotonNetwork.LocalPlayer;
			}
			ActorsWithMod.Sort();
			Player val = ((IEnumerable<Player>)PhotonNetwork.PlayerList).FirstOrDefault((Func<Player, bool>)((Player p) => p.ActorNumber == ActorsWithMod[0]));
			wasLocalPlayer = val == PhotonNetwork.LocalPlayer;
			return val;
		}

		public override void OnJoinedRoom()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			ActorsWithMod.Add(PhotonNetwork.LocalPlayer.ActorNumber);
			PhotonNetwork.RaiseEvent((byte)101, (object)PhotonNetwork.LocalPlayer.ActorNumber, new RaiseEventOptions
			{
				Receivers = (ReceiverGroup)0
			}, SendOptions.SendReliable);
			((MonoBehaviourPunCallbacks)this).OnJoinedRoom();
		}

		public override void OnPlayerEnteredRoom(Player newPlayer)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			object obj = PhotonNetwork.LocalPlayer.ActorNumber;
			RaiseEventOptions val = new RaiseEventOptions();
			val.TargetActors = new int[1] { newPlayer.ActorNumber };
			PhotonNetwork.RaiseEvent((byte)101, obj, val, SendOptions.SendReliable);
			CallingPlayer(out var wasLocalPlayer);
			if (wasLocalPlayer)
			{
				Dictionary<string, int> dictionary = MarshPatches.PersistedColors.ToDictionary((KeyValuePair<Guid, int> kvp) => kvp.Key.ToString(), (KeyValuePair<Guid, int> kvp) => kvp.Value);
				val = new RaiseEventOptions();
				val.TargetActors = new int[1] { newPlayer.ActorNumber };
				PhotonNetwork.RaiseEvent((byte)102, (object)dictionary, val, SendOptions.SendReliable);
			}
			((MonoBehaviourPunCallbacks)this).OnPlayerEnteredRoom(newPlayer);
		}

		public override void OnPlayerLeftRoom(Player otherPlayer)
		{
			ActorsWithMod.Remove(otherPlayer.ActorNumber);
			((MonoBehaviourPunCallbacks)this).OnPlayerLeftRoom(otherPlayer);
		}

		public override void OnLeftRoom()
		{
			ActorsWithMod.Clear();
			((MonoBehaviourPunCallbacks)this).OnLeftRoom();
		}

		public static void AddNewVariantCall(Guid guid, string color)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			object[] array = new object[2]
			{
				guid.ToString(),
				color
			};
			PhotonNetwork.RaiseEvent((byte)103, (object)array, new RaiseEventOptions
			{
				Receivers = (ReceiverGroup)0
			}, SendOptions.SendReliable);
		}

		public void OnEvent(EventData photonEvent)
		{
			switch (photonEvent.Code)
			{
			case 101:
				if (!(photonEvent.CustomData is int item))
				{
					Plugin.Log.LogError((object)"ModPresenceEvent received invalid data. Expected an integer.");
				}
				else if (!ActorsWithMod.Contains(item))
				{
					ActorsWithMod.Add(item);
				}
				break;
			case 102:
				if (!(photonEvent.CustomData is Dictionary<string, int> dictionary))
				{
					Plugin.Log.LogError((object)"SyncColorsEvent received invalid data. Expected Dictionary<string, int>.");
					break;
				}
				Plugin.Log.LogInfo((object)"Syncing persisted colors for newly joined player.");
				MarshPatches.PersistedColors.Clear();
				foreach (KeyValuePair<string, int> item2 in dictionary)
				{
					if (Guid.TryParse(item2.Key, out var result2))
					{
						MarshPatches.PersistedColors[result2] = item2.Value;
					}
					else
					{
						Plugin.Log.LogWarning((object)("Failed to parse Guid during sync: " + item2.Key));
					}
				}
				{
					foreach (Item aLL_ACTIVE_ITEM in Item.ALL_ACTIVE_ITEMS)
					{
						if (!((Object)(object)aLL_ACTIVE_ITEM == (Object)null) && aLL_ACTIVE_ITEM.data != null && aLL_ACTIVE_ITEM.itemID == MarshPatches.MarshmallowID && MarshPatches.PersistedColors.TryGetValue(aLL_ACTIVE_ITEM.data.guid, out var value2))
						{
							MarshPatches.InitMaterials(aLL_ACTIVE_ITEM);
							if (value2 >= 0 && value2 < MarshPatches.Variants.Count)
							{
								aLL_ACTIVE_ITEM.mainRenderer.material = MarshPatches.Variants[value2];
								aLL_ACTIVE_ITEM.cooking.UpdateCookedBehavior();
							}
							else
							{
								Plugin.Log.LogWarning((object)$"Synced variant index {value2} is out of bounds for item {aLL_ACTIVE_ITEM.data.guid}");
							}
						}
					}
					break;
				}
			case 103:
			{
				if (!(photonEvent.CustomData is object[] array) || array.Length < 2)
				{
					Plugin.Log.LogError((object)"AddVariantEvent received malformed array data.");
					break;
				}
				if (!(array[0] is string text) || !(array[1] is string text2))
				{
					Plugin.Log.LogError((object)"AddVariantEvent received invalid string types inside the payload.");
					break;
				}
				if (!Guid.TryParse(text, out var result))
				{
					Plugin.Log.LogError((object)("Couldn't parse " + text + " to a valid Guid."));
					break;
				}
				Plugin.Log.LogInfo((object)$"Received event to make {result} {text2}");
				if (MarshPatches.VariantIndexes.TryGetValue(text2, out var value))
				{
					MarshPatches.PersistedColors[result] = value;
					{
						foreach (Item aLL_ACTIVE_ITEM2 in Item.ALL_ACTIVE_ITEMS)
						{
							if ((Object)(object)aLL_ACTIVE_ITEM2 != (Object)null && aLL_ACTIVE_ITEM2.data != null && aLL_ACTIVE_ITEM2.data.guid == result)
							{
								aLL_ACTIVE_ITEM2.mainRenderer.material = MarshPatches.GetMaterialFromName(text2);
								aLL_ACTIVE_ITEM2.cooking.UpdateCookedBehavior();
							}
						}
						break;
					}
				}
				Plugin.Log.LogWarning((object)("Color variant '" + text2 + "' not found in registry."));
				break;
			}
			}
		}
	}
	[HarmonyPatch]
	public static class MarshPatches
	{
		public static readonly int MarshmallowID = 46;

		public static readonly List<Material> Variants = new List<Material>();

		public static readonly Dictionary<string, int> VariantIndexes = new Dictionary<string, int>();

		public static readonly Dictionary<int, string> VariantNames = new Dictionary<int, string>();

		public static readonly Dictionary<string, Color> Registry = new Dictionary<string, Color>
		{
			{
				"default",
				Color.white
			},
			{
				"green",
				new Color(0.675f, 1f, 0.675f)
			},
			{
				"pink",
				new Color(0.945f, 0.8f, 0.909f)
			},
			{
				"yellow",
				new Color(0.976f, 0.941f, 0.607f)
			}
		};

		public static Dictionary<Guid, int> PersistedColors = new Dictionary<Guid, int>();

		public static Color DefaultCookColorMultiplier = new Color(0.66f, 0.47f, 0.25f);

		public static Color BurntCookColorMultiplier = new Color(0.05f, 0.05f, 0.1f);

		public static Material GetMaterialFromName(string name)
		{
			return Variants.Where((Material x) => ((Object)x).name.Remove(0, 8).Equals(name)).First();
		}

		private static Texture GetTexture(string variantName)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string text = "Colored_Marshmallows.Variants." + variantName + ".png";
			using (Stream stream = executingAssembly.GetManifestResourceStream(text))
			{
				if (stream == null)
				{
					Plugin.Log.LogError((object)("The resource doesnt exist dummy. Make it an embedded resource or a .png (" + text + ")"));
					return null;
				}
				byte[] array = new byte[stream.Length];
				stream.Read(array, 0, array.Length);
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
				if (ImageConversion.LoadImage(val, array))
				{
					((Object)val).name = variantName;
					return (Texture)(object)val;
				}
			}
			return null;
		}

		public static void InitMaterials(Item marshmallow)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			if (Variants.Count != 0)
			{
				return;
			}
			Material material = marshmallow.mainRenderer.material;
			foreach (string key in Registry.Keys)
			{
				Material val = new Material(material);
				val.SetTexture("_BaseTexture", GetTexture(key));
				((Object)val).name = "Variant_" + key;
				Variants.Add(val);
				VariantIndexes[key] = Variants.Count - 1;
				VariantNames[Variants.Count - 1] = key;
			}
		}

		public static Material SelectRandomMaterial(out int index)
		{
			index = 0;
			if (Variants.Count == 0)
			{
				Plugin.Log.LogWarning((object)"The materials have not been initialized first!!");
				return null;
			}
			int index2 = (index = Random.Range(0, Variants.Count));
			return Variants[index2];
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Item), "Start")]
		public static void GiveTexture(Item __instance)
		{
			if (__instance.itemID != MarshmallowID)
			{
				return;
			}
			InitMaterials(__instance);
			bool wasLocalPlayer;
			Player val = MarshmallowNetworking.CallingPlayer(out wasLocalPlayer);
			Guid guid = __instance.data.guid;
			if (PersistedColors.TryGetValue(guid, out var value))
			{
				__instance.mainRenderer.material = Variants[value];
				__instance.cooking.UpdateCookedBehavior();
				Plugin.Log.LogInfo((object)("Restored persisted color for " + ((Object)__instance).name + ": " + ((Object)Variants[value]).name));
			}
			else if (wasLocalPlayer && !((Object)__instance.mainRenderer.materials[0]).name.Contains("Variant"))
			{
				int index;
				Material val2 = SelectRandomMaterial(out index);
				if ((Object)(object)val2 != (Object)null)
				{
					__instance.mainRenderer.material = val2;
					__instance.cooking.UpdateCookedBehavior();
					PersistedColors[guid] = index;
				}
				if (MarshmallowNetworking.ActorsWithMod.Count > 1)
				{
					MarshmallowNetworking.AddNewVariantCall(guid, VariantNames[index]);
				}
				Plugin.Log.LogInfo((object)$"Gave {((Object)__instance).name} ({__instance.itemID}) the material: {((Object)__instance.mainRenderer.material).name}");
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Item), "Consume")]
		public static void RemoveItem(Item __instance)
		{
			Guid guid = __instance.data.guid;
			if (PersistedColors.ContainsKey(guid))
			{
				PersistedColors.Remove(guid);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(RunManager), "StartRun")]
		public static void Reset()
		{
			PersistedColors.Clear();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(InventoryItemUI), "SetItem")]
		public static void SetColor(InventoryItemUI __instance)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			if (__instance._itemData != null && !((Object)(object)__instance._itemPrefab == (Object)null) && __instance._itemPrefab.itemID == MarshmallowID)
			{
				int index = PersistedColors[__instance._itemData.guid];
				Material val = Variants[index];
				Color baseColor = Registry[((Object)val).name.Remove(0, 8)];
				IntItemData val2 = default(IntItemData);
				__instance._itemData.TryGetDataEntry<IntItemData>((DataEntryKey)1, ref val2);
				((Graphic)__instance.icon).color = GetCookColor(val2.Value, baseColor);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(BackpackWheelSlice), "UpdateCookedAmount")]
		public static bool SetBackpackColor(BackpackWheelSlice __instance, Item item, ItemInstanceData itemInstanceData)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			if (itemInstanceData == null || (Object)(object)item == (Object)null)
			{
				return true;
			}
			if (item.itemID != MarshmallowID)
			{
				((Graphic)__instance.image).color = Color.white;
				return true;
			}
			int index = PersistedColors[itemInstanceData.guid];
			Material val = Variants[index];
			Color color = Registry[((Object)val).name.Remove(0, 8)];
			((Graphic)__instance.image).color = color;
			IntItemData val2 = default(IntItemData);
			if ((Object)(object)item == (Object)null || itemInstanceData == null)
			{
				__instance.cookedAmount = 0;
			}
			else if (itemInstanceData.TryGetDataEntry<IntItemData>((DataEntryKey)1, ref val2) && __instance.cookedAmount != val2.Value)
			{
				((Graphic)__instance.image).color = GetCookColor(val2.Value, ((Graphic)__instance.image).color);
				__instance.cookedAmount = val2.Value;
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(BackpackWheel), "UpdateCookedAmount")]
		public static bool SetBackpackHeldColor(BackpackWheel __instance, Item item)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)item == (Object)null || item.data == null)
			{
				return true;
			}
			if (item.itemID != MarshmallowID)
			{
				((Graphic)__instance.currentlyHeldItem).color = Color.white;
				return true;
			}
			int index = PersistedColors[item.data.guid];
			Material val = Variants[index];
			Color color = Registry[((Object)val).name.Remove(0, 8)];
			((Graphic)__instance.currentlyHeldItem).color = color;
			IntItemData val2 = default(IntItemData);
			if ((Object)(object)item == (Object)null || item.data == null)
			{
				__instance.currentlyHeldItemCookedAmount = 0;
			}
			else if (item.data.TryGetDataEntry<IntItemData>((DataEntryKey)1, ref val2) && __instance.currentlyHeldItemCookedAmount != val2.Value)
			{
				((Graphic)__instance.currentlyHeldItem).color = GetCookColor(val2.Value, ((Graphic)__instance.currentlyHeldItem).color);
				__instance.currentlyHeldItemCookedAmount = val2.Value;
			}
			return false;
		}

		private static Color GetCookColor(int cookAmount, Color baseColor)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: 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)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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)
			//IL_0033: 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)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (cookAmount <= 0)
			{
				return baseColor;
			}
			Color val = baseColor;
			if (cookAmount == 1)
			{
				val *= DefaultCookColorMultiplier;
			}
			else if (cookAmount == 2)
			{
				val *= DefaultCookColorMultiplier * 0.5f;
			}
			else if (cookAmount > 2)
			{
				val *= BurntCookColorMultiplier;
			}
			val.a = 1f;
			return val;
		}
	}
}
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
	{
	}
}