using System;
using System.Collections.Generic;
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.Logging;
using ExitGames.Client.Photon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Peak;
using Peak.Afflictions;
using Photon.Pun;
using Photon.Realtime;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("coolmanboy456.awesomeritualdaggerrework")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0")]
[assembly: AssemblyProduct("coolmanboy456.awesomeritualdaggerrework")]
[assembly: AssemblyTitle("AwesomeRitualDaggerRework")]
[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 AwesomeRitualDaggerRework
{
	[BepInPlugin("coolmanboy456.awesomeritualdaggerrework", "AwesomeRitualDaggerRework", "0.1.0")]
	public class Plugin : BaseUnityPlugin
	{
		public const string Id = "coolmanboy456.awesomeritualdaggerrework";

		internal static ManualLogSource Log { get; private set; }

		public static string Name => "AwesomeRitualDaggerRework";

		public static string Version => "0.1.0";

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			Log.LogInfo((object)"AwesomeRitualDaggerRework starting...");
			ApplyPatch(typeof(RitualDaggerPatch), "Ritual Dagger Rework");
			DaggerNetwork.Initialize();
			Log.LogInfo((object)"AwesomeRitualDaggerRework loaded!");
		}

		private void OnDestroy()
		{
			DaggerNetwork.Shutdown();
		}

		private static void ApplyPatch(Type patchType, string name)
		{
			try
			{
				Harmony.CreateAndPatchAll(patchType, (string)null);
				Log.LogInfo((object)("[PATCH OK] " + name));
			}
			catch (Exception ex)
			{
				Log.LogError((object)("[PATCH FAILED] " + name));
				Log.LogError((object)ex);
			}
		}
	}
	[HarmonyPatch]
	internal static class RitualDaggerPatch
	{
		private const float RewardRadius = 100f;

		private const float VictimInjury = 0.6f;

		private const float VictimPetrify = 0.9f;

		private const float SurviveInjuryHeal = 0.6f;

		private const float SurviveCurseHeal = 0.1f;

		private const float SurviveRegularHeal = 0.4f;

		private const float SurviveBonusStamina = 0.7f;

		private const float DeathRegularHeal = 2f;

		private const float DeathCurseHeal = 0.2f;

		private const float DeathBonusStamina = 1f;

		private const float DeathInfiniteStamina = 12f;

		private const float DeathPetrify = 0.4f;

		private static bool allowRitualDaggerDeath;

		private static readonly Dictionary<int, EmbeddedRitualDagger> EmbeddedDaggers = new Dictionary<int, EmbeddedRitualDagger>();

		private static readonly HashSet<int> PullLockedVictims = new HashSet<int>();

		[HarmonyPatch(typeof(CharacterAfflictions), "DieToRitualDagger")]
		[HarmonyPrefix]
		private static bool DieToRitualDaggerPrefix()
		{
			return allowRitualDaggerDeath;
		}

		[HarmonyPatch(typeof(RitualDaggerFeedBehavior), "FeedeeAction")]
		[HarmonyPrefix]
		private static bool FeedeeActionPrefix(Character fedCharacter, Character feeder)
		{
			if ((Object)(object)fedCharacter == (Object)null)
			{
				return false;
			}
			if (!fedCharacter.IsLocal)
			{
				return false;
			}
			if (fedCharacter.data.dead)
			{
				return false;
			}
			int viewID = ((MonoBehaviourPun)fedCharacter).photonView.ViewID;
			int petrifyAmount = fedCharacter.data.petrifyAmount;
			int num = Mathf.RoundToInt(90f);
			bool flag = petrifyAmount + num >= 100;
			bool flag2 = false;
			if (flag)
			{
				CheckpointFlag val = default(CheckpointFlag);
				flag2 = fedCharacter.WillDoCheckpoint(ref val);
			}
			fedCharacter.refs.afflictions.AddStatus((STATUSTYPE)0, 0.6f, false, true, true, false);
			if (!flag)
			{
				fedCharacter.refs.afflictions.AddStatus((STATUSTYPE)13, 0.9f, false, true, true, false);
				Plugin.Log.LogInfo((object)($"[DAGGER] Victim {viewID} survived: " + $"{petrifyAmount} + {num}"));
				return false;
			}
			if (flag2)
			{
				fedCharacter.refs.afflictions.AddStatus((STATUSTYPE)13, 0.9f, false, true, true, false);
				Plugin.Log.LogInfo((object)($"[DAGGER] Victim {viewID} reached " + "fatal Petrify but checkpointed."));
				return false;
			}
			KillVictimWithDagger(fedCharacter);
			Plugin.Log.LogInfo((object)$"[DAGGER] Victim {viewID} killed by Petrify.");
			return false;
		}

		[HarmonyPatch(typeof(RitualDaggerFeedBehavior), "FeederAction")]
		[HarmonyPrefix]
		private static bool FeederActionPrefix(RitualDaggerFeedBehavior __instance, Character feeder, Character fedCharacter)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return false;
			}
			if ((Object)(object)feeder == (Object)null)
			{
				return false;
			}
			if ((Object)(object)fedCharacter == (Object)null)
			{
				return false;
			}
			if (!feeder.IsLocal)
			{
				return false;
			}
			int viewID = ((MonoBehaviourPun)fedCharacter).photonView.ViewID;
			int petrifyAmount = fedCharacter.data.petrifyAmount;
			int num = Mathf.RoundToInt(90f);
			bool flag = petrifyAmount + num >= 100;
			bool flag2 = false;
			if (flag)
			{
				CheckpointFlag val = default(CheckpointFlag);
				flag2 = fedCharacter.WillDoCheckpoint(ref val);
			}
			int num2 = ((flag && !flag2) ? (-viewID) : viewID);
			((MonoBehaviourPun)__instance).photonView.RPC("RPC_RitualDaggerBuff", (RpcTarget)0, new object[1] { num2 });
			if ((Object)(object)((ItemComponent)__instance).item != (Object)null)
			{
				((MonoBehaviour)((ItemComponent)__instance).item).StartCoroutine(((ItemComponent)__instance).item.ConsumeDelayed(false));
			}
			return false;
		}

		[HarmonyPatch(typeof(RitualDaggerFeedBehavior), "RPC_RitualDaggerBuff")]
		[HarmonyPrefix]
		private static bool RitualDaggerBuffPrefix(RitualDaggerFeedBehavior __instance, int excludeID)
		{
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			bool flag = excludeID < 0;
			int num = Math.Abs(excludeID);
			Character val = FindCharacter(num);
			Character playerCharacter = PlayerHandler.GetPlayerCharacter(((MonoBehaviourPun)__instance).photonView.Owner);
			if (flag)
			{
				RemoveEmbeddedDagger(num);
			}
			else if ((Object)(object)val != (Object)null && !val.data.dead && (Object)(object)((ItemComponent)__instance).item != (Object)null)
			{
				string daggerPrefabName = GetDaggerPrefabName(__instance, playerCharacter);
				CreateEmbeddedDagger(val, ((ItemComponent)__instance).item, daggerPrefabName);
			}
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null)
			{
				return false;
			}
			if (localCharacter.data.dead)
			{
				return false;
			}
			if (((MonoBehaviourPun)localCharacter).photonView.ViewID == num)
			{
				return false;
			}
			if ((Object)(object)playerCharacter == (Object)null)
			{
				return false;
			}
			float num2 = Vector3.Distance(((Component)localCharacter).transform.position, ((Component)playerCharacter).transform.position);
			if (num2 > 100f)
			{
				return false;
			}
			if (flag && ((MonoBehaviourPun)localCharacter).photonView.ViewID == ((MonoBehaviourPun)playerCharacter).photonView.ViewID)
			{
				ApplyDeathReward(localCharacter);
			}
			else
			{
				ApplyAllyReward(localCharacter);
			}
			return false;
		}

		private static void KillVictimWithDagger(Character victim)
		{
			if ((Object)(object)victim == (Object)null || !victim.IsLocal || victim.data.dead)
			{
				return;
			}
			allowRitualDaggerDeath = true;
			try
			{
				victim.refs.afflictions.DieToRitualDagger();
			}
			finally
			{
				allowRitualDaggerDeath = false;
			}
		}

		private static string GetDaggerPrefabName(RitualDaggerFeedBehavior behavior, Character feeder)
		{
			if ((Object)(object)feeder != (Object)null && (Object)(object)feeder.player != (Object)null && feeder.refs != null && (Object)(object)feeder.refs.items != (Object)null && feeder.refs.items.currentSelectedSlot.IsSome)
			{
				byte value = feeder.refs.items.currentSelectedSlot.Value;
				ItemSlot itemSlot = feeder.player.GetItemSlot(value);
				if (itemSlot != null && !itemSlot.IsEmpty())
				{
					string prefabName = itemSlot.GetPrefabName();
					if (!string.IsNullOrEmpty(prefabName))
					{
						return CleanPrefabName(prefabName);
					}
				}
			}
			if ((Object)(object)behavior != (Object)null && (Object)(object)((ItemComponent)behavior).item != (Object)null)
			{
				return CleanPrefabName(((Object)((Component)((ItemComponent)behavior).item).gameObject).name);
			}
			return "RitualDagger";
		}

		internal static string CleanPrefabName(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return "RitualDagger";
			}
			name = name.Replace("(Clone)", "").Trim();
			if (name.StartsWith("0_Items/", StringComparison.OrdinalIgnoreCase))
			{
				name = name.Substring("0_Items/".Length);
			}
			int num = name.LastIndexOf('/');
			if (num >= 0 && num + 1 < name.Length)
			{
				name = name.Substring(num + 1);
			}
			return name;
		}

		internal static Character FindCharacter(int viewID)
		{
			PhotonView val = PhotonView.Find(viewID);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Character val2 = ((Component)val).GetComponent<Character>();
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = ((Component)val).GetComponentInParent<Character>();
			}
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = ((Component)val).GetComponentInChildren<Character>();
			}
			return val2;
		}

		internal static bool HasEmbeddedDagger(int victimID)
		{
			EmbeddedRitualDagger value;
			return EmbeddedDaggers.TryGetValue(victimID, out value) && (Object)(object)value != (Object)null;
		}

		internal static bool TryLockPull(int victimID)
		{
			if (PullLockedVictims.Contains(victimID))
			{
				return false;
			}
			PullLockedVictims.Add(victimID);
			return true;
		}

		internal static void UnlockPull(int victimID)
		{
			PullLockedVictims.Remove(victimID);
		}

		internal static void ResetEmbeddedPullRequest(int victimID)
		{
			if (EmbeddedDaggers.TryGetValue(victimID, out EmbeddedRitualDagger value) && (Object)(object)value != (Object)null)
			{
				value.ResetPullRequest();
			}
		}

		internal static void CreateEmbeddedDagger(Character victim, Item sourceItem, string prefabName)
		{
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Expected O, but got Unknown
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)victim == (Object)null) && !((Object)(object)sourceItem == (Object)null))
			{
				int viewID = ((MonoBehaviourPun)victim).photonView.ViewID;
				UnlockPull(viewID);
				DaggerNetwork.ResetVictim(viewID);
				RemoveEmbeddedDagger(viewID);
				Transform val = null;
				Bodypart bodypart = victim.GetBodypart((BodypartType)2);
				if ((Object)(object)bodypart != (Object)null)
				{
					val = bodypart.transform;
				}
				if ((Object)(object)val == (Object)null && victim.refs != null && (Object)(object)victim.refs.backpackTransform != (Object)null)
				{
					val = victim.refs.backpackTransform;
				}
				if ((Object)(object)val == (Object)null && victim.refs != null && (Object)(object)victim.refs.hip != (Object)null)
				{
					val = victim.refs.hip.transform;
				}
				if ((Object)(object)val == (Object)null)
				{
					val = ((Component)victim).transform;
				}
				GameObject val2 = new GameObject("EmbeddedRitualDagger");
				val2.layer = ((Component)sourceItem).gameObject.layer;
				val2.transform.SetParent(val, false);
				val2.transform.localPosition = EmbeddedRitualDagger.BackPosition;
				val2.transform.localRotation = Quaternion.Euler(EmbeddedRitualDagger.BackRotation);
				SetWorldScale(val2.transform, sourceItem.transform.lossyScale);
				Dictionary<Transform, Transform> dictionary = new Dictionary<Transform, Transform>();
				dictionary[sourceItem.transform] = val2.transform;
				CloneChildren(sourceItem.transform, val2.transform, dictionary);
				CopyAllVisuals(dictionary);
				BoxCollider val3 = val2.AddComponent<BoxCollider>();
				Vector3 lossyScale = val2.transform.lossyScale;
				val3.size = new Vector3(SafeDivide(0.3f, Mathf.Abs(lossyScale.x)), SafeDivide(0.4f, Mathf.Abs(lossyScale.y)), SafeDivide(0.3f, Mathf.Abs(lossyScale.z)));
				val3.center = Vector3.zero;
				((Collider)val3).isTrigger = true;
				EmbeddedRitualDagger embeddedRitualDagger = val2.AddComponent<EmbeddedRitualDagger>();
				embeddedRitualDagger.Initialize(victim, prefabName, val);
				EmbeddedDaggers[viewID] = embeddedRitualDagger;
				PullLockedVictims.Remove(viewID);
				Plugin.Log.LogInfo((object)("[DAGGER] Embedded visual created on " + $"{viewID}, prefab {prefabName}"));
			}
		}

		private static void CloneChildren(Transform source, Transform destination, Dictionary<Transform, Transform> transformMap)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_0054: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < source.childCount; i++)
			{
				Transform child = source.GetChild(i);
				if (!ShouldSkipVisual(child))
				{
					GameObject val = new GameObject(((Object)((Component)child).gameObject).name);
					val.layer = ((Component)child).gameObject.layer;
					Transform transform = val.transform;
					transform.SetParent(destination, false);
					transform.localPosition = child.localPosition;
					transform.localRotation = child.localRotation;
					transform.localScale = child.localScale;
					transformMap[child] = transform;
					CloneChildren(child, transform, transformMap);
				}
			}
		}

		private static bool ShouldSkipVisual(Transform source)
		{
			if ((Object)(object)source == (Object)null)
			{
				return true;
			}
			string text = ((Object)((Component)source).gameObject).name.ToLowerInvariant();
			if (text.Contains("hand"))
			{
				return true;
			}
			if (text.Contains("finger"))
			{
				return true;
			}
			if (text.Contains("arm"))
			{
				return true;
			}
			if (text.Contains("glove"))
			{
				return true;
			}
			if (text.Contains("wrist"))
			{
				return true;
			}
			return false;
		}

		private static void CopyAllVisuals(Dictionary<Transform, Transform> transformMap)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<Transform, Transform> item in transformMap)
			{
				Transform key = item.Key;
				Transform value = item.Value;
				MeshFilter component = ((Component)key).GetComponent<MeshFilter>();
				if ((Object)(object)component != (Object)null)
				{
					MeshFilter val = ((Component)value).gameObject.AddComponent<MeshFilter>();
					val.sharedMesh = component.sharedMesh;
				}
				MeshRenderer component2 = ((Component)key).GetComponent<MeshRenderer>();
				if ((Object)(object)component2 != (Object)null)
				{
					MeshRenderer val2 = ((Component)value).gameObject.AddComponent<MeshRenderer>();
					((Renderer)val2).sharedMaterials = ((Renderer)component2).sharedMaterials;
					((Renderer)val2).shadowCastingMode = ((Renderer)component2).shadowCastingMode;
					((Renderer)val2).receiveShadows = ((Renderer)component2).receiveShadows;
					((Renderer)val2).lightProbeUsage = ((Renderer)component2).lightProbeUsage;
					((Renderer)val2).reflectionProbeUsage = ((Renderer)component2).reflectionProbeUsage;
				}
				SpriteRenderer component3 = ((Component)key).GetComponent<SpriteRenderer>();
				if ((Object)(object)component3 != (Object)null)
				{
					SpriteRenderer val3 = ((Component)value).gameObject.AddComponent<SpriteRenderer>();
					val3.sprite = component3.sprite;
					((Renderer)val3).sharedMaterial = ((Renderer)component3).sharedMaterial;
					val3.flipX = component3.flipX;
					val3.flipY = component3.flipY;
					((Renderer)val3).sortingLayerID = ((Renderer)component3).sortingLayerID;
					((Renderer)val3).sortingOrder = ((Renderer)component3).sortingOrder;
				}
			}
		}

		private static void SetWorldScale(Transform transform, Vector3 worldScale)
		{
			//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)
			//IL_0026: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			Transform parent = transform.parent;
			if ((Object)(object)parent == (Object)null)
			{
				transform.localScale = worldScale;
				return;
			}
			Vector3 lossyScale = parent.lossyScale;
			transform.localScale = new Vector3(SafeDivide(worldScale.x, lossyScale.x), SafeDivide(worldScale.y, lossyScale.y), SafeDivide(worldScale.z, lossyScale.z));
		}

		private static float SafeDivide(float value, float divisor)
		{
			if (Mathf.Abs(divisor) < 0.0001f)
			{
				return value;
			}
			return value / divisor;
		}

		internal static void RemoveEmbeddedDagger(int victimID)
		{
			PullLockedVictims.Remove(victimID);
			if (EmbeddedDaggers.TryGetValue(victimID, out EmbeddedRitualDagger value))
			{
				EmbeddedDaggers.Remove(victimID);
				if ((Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)value).gameObject);
				}
			}
		}

		internal static void ApplyPullEffects(Character victim)
		{
			if (!((Object)(object)victim == (Object)null) && victim.IsLocal && !victim.data.dead)
			{
				victim.refs.afflictions.AddStatus((STATUSTYPE)0, 0.4f, false, true, true, false);
				victim.refs.afflictions.SubtractStatus((STATUSTYPE)13, 0.2f, false, false);
				Plugin.Log.LogInfo((object)"[DAGGER] Pullout applied +40 Injury, -20 Petrify.");
			}
		}

		private static void ApplyAllyReward(Character character)
		{
			CharacterAfflictions afflictions = character.refs.afflictions;
			afflictions.SubtractStatus((STATUSTYPE)0, 0.6f, false, false);
			afflictions.SubtractStatus((STATUSTYPE)5, 0.1f, false, false);
			HealRegularStatuses(afflictions, 0.4f);
			character.AddExtraStamina(0.7f);
			Plugin.Log.LogInfo((object)"[DAGGER] Applied ally reward.");
		}

		private static void ApplyDeathReward(Character character)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			CharacterAfflictions afflictions = character.refs.afflictions;
			afflictions.SubtractStatus((STATUSTYPE)0, 2f, false, false);
			afflictions.SubtractStatus((STATUSTYPE)5, 0.2f, false, false);
			HealRegularStatuses(afflictions, 2f);
			character.AddExtraStamina(1f);
			afflictions.AddAffliction((Affliction)new Affliction_InfiniteStamina(12f), false);
			afflictions.AddStatus((STATUSTYPE)13, 0.4f, false, true, true, false);
			Plugin.Log.LogInfo((object)"[DAGGER] Applied dagger-user death reward.");
		}

		private static void HealRegularStatuses(CharacterAfflictions afflictions, float amount)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			STATUSTYPE[] array = new STATUSTYPE[7];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			STATUSTYPE[] array2 = (STATUSTYPE[])(object)array;
			STATUSTYPE[] array3 = array2;
			foreach (STATUSTYPE val in array3)
			{
				afflictions.SubtractStatus(val, amount, false, false);
			}
		}
	}
	internal sealed class EmbeddedRitualDagger : MonoBehaviour, IInteractible, IInteractibleConstant
	{
		internal static readonly Vector3 BackPosition = new Vector3(0f, 0.08f, -0.14f);

		internal static readonly Vector3 BackRotation = new Vector3(90f, 0f, 180f);

		private const float PullTime = 3f;

		private Character victim;

		private Transform torso;

		private int victimID;

		private string daggerPrefabName;

		private bool requestedPull;

		public bool holdOnFinish => false;

		internal void Initialize(Character setVictim, string prefabName, Transform setTorso)
		{
			victim = setVictim;
			victimID = ((MonoBehaviourPun)setVictim).photonView.ViewID;
			torso = setTorso;
			daggerPrefabName = RitualDaggerPatch.CleanPrefabName(prefabName);
			requestedPull = false;
			ForcePosition();
		}

		private void LateUpdate()
		{
			if ((Object)(object)victim == (Object)null)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			if (victim.data.dead)
			{
				RitualDaggerPatch.RemoveEmbeddedDagger(victimID);
				return;
			}
			if ((Object)(object)torso == (Object)null)
			{
				Bodypart bodypart = victim.GetBodypart((BodypartType)2);
				if ((Object)(object)bodypart != (Object)null)
				{
					torso = bodypart.transform;
				}
			}
			if (!((Object)(object)torso == (Object)null))
			{
				ForcePosition();
			}
		}

		private void ForcePosition()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//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)
			if (!((Object)(object)torso == (Object)null))
			{
				if ((Object)(object)((Component)this).transform.parent != (Object)(object)torso)
				{
					((Component)this).transform.SetParent(torso, false);
				}
				((Component)this).transform.localPosition = BackPosition;
				((Component)this).transform.localRotation = Quaternion.Euler(BackRotation);
			}
		}

		public Vector3 Center()
		{
			//IL_0007: 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_000f: Unknown result type (might be due to invalid IL or missing references)
			return ((Component)this).transform.position;
		}

		public string GetName()
		{
			return "Ritual Dagger";
		}

		public string GetInteractionText()
		{
			return "Pull Out Ritual Dagger";
		}

		public string GetSecondaryInteractionText()
		{
			return "";
		}

		public Transform GetTransform()
		{
			return ((Component)this).transform;
		}

		public void HoverEnter()
		{
		}

		public void HoverExit()
		{
		}

		public bool IsInteractible(Character interactor)
		{
			if (requestedPull)
			{
				return false;
			}
			if ((Object)(object)victim == (Object)null)
			{
				return false;
			}
			if (victim.data.dead)
			{
				return false;
			}
			if ((Object)(object)interactor == (Object)null)
			{
				return false;
			}
			if (interactor.data.dead)
			{
				return false;
			}
			if (((MonoBehaviourPun)interactor).photonView.ViewID == victimID)
			{
				return false;
			}
			return true;
		}

		public bool IsPrimaryInteractible(Character interactor)
		{
			return IsInteractible(interactor);
		}

		public bool IsSecondaryInteractible(Character interactor)
		{
			return false;
		}

		public void Interact(Character interactor)
		{
		}

		public bool IsConstantlyInteractable(Character interactor)
		{
			return IsInteractible(interactor);
		}

		public float GetInteractTime(Character interactor)
		{
			return 3f;
		}

		public void Interact_CastFinished(Character interactor)
		{
			if (IsInteractible(interactor) && !requestedPull)
			{
				requestedPull = true;
				Plugin.Log.LogInfo((object)("[DAGGER] Pull hold finished | " + $"victim={victimID} " + $"puller={((MonoBehaviourPun)interactor).photonView.ViewID}"));
				DaggerNetwork.RequestPull(victimID, ((MonoBehaviourPun)interactor).photonView.ViewID, daggerPrefabName);
			}
		}

		internal void ResetPullRequest()
		{
			requestedPull = false;
		}

		public void CancelCast(Character interactor)
		{
		}

		public void ReleaseInteract(Character interactor)
		{
		}
	}
	internal static class DaggerNetwork
	{
		private const byte NetworkEvent = 71;

		private const string PullRequest = "ARR_PULL_REQUEST";

		private const string PullResolved = "ARR_PULL_RESOLVED";

		private const string PullRejected = "ARR_PULL_REJECTED";

		private const float MaxPullDistance = 3f;

		private static bool initialized;

		private static MethodInfo spawnItemInHandMethod;

		private static readonly HashSet<int> ResolvedVictims = new HashSet<int>();

		internal static void Initialize()
		{
			if (!initialized)
			{
				initialized = true;
				PhotonNetwork.NetworkingClient.EventReceived += OnEvent;
				FindSpawnMethod();
			}
		}

		internal static void Shutdown()
		{
			if (initialized)
			{
				initialized = false;
				PhotonNetwork.NetworkingClient.EventReceived -= OnEvent;
				ResolvedVictims.Clear();
			}
		}

		internal static void ResetVictim(int victimID)
		{
			ResolvedVictims.Remove(victimID);
		}

		internal static void RequestPull(int victimID, int pullerID, string prefabName)
		{
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Expected O, but got Unknown
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			prefabName = RitualDaggerPatch.CleanPrefabName(prefabName);
			if (victimID <= 0 || pullerID <= 0)
			{
				RitualDaggerPatch.ResetEmbeddedPullRequest(victimID);
				return;
			}
			if (!PhotonNetwork.InRoom)
			{
				Character victim = RitualDaggerPatch.FindCharacter(victimID);
				Character puller = RitualDaggerPatch.FindCharacter(pullerID);
				if (!ValidatePull(victim, puller, victimID, pullerID, -1, validateOwner: false, out string reason))
				{
					Plugin.Log.LogWarning((object)("[DAGGER] Local pull rejected: " + reason));
					RitualDaggerPatch.ResetEmbeddedPullRequest(victimID);
				}
				else
				{
					ResolvePull(victimID, pullerID, prefabName);
				}
				return;
			}
			if (PhotonNetwork.IsMasterClient)
			{
				int num = ((PhotonNetwork.LocalPlayer != null) ? PhotonNetwork.LocalPlayer.ActorNumber : (-1));
				Plugin.Log.LogInfo((object)("[DAGGER] Puller is Master; resolving request locally | " + $"victim={victimID} puller={pullerID} sender={num}"));
				ValidateAndResolvePull(num, victimID, pullerID, prefabName);
				return;
			}
			if (PhotonNetwork.MasterClient == null)
			{
				Plugin.Log.LogWarning((object)("[DAGGER] Pull request failed: no MasterClient | " + $"victim={victimID} puller={pullerID}"));
				RitualDaggerPatch.ResetEmbeddedPullRequest(victimID);
				return;
			}
			object[] array = new object[4] { "ARR_PULL_REQUEST", victimID, pullerID, prefabName };
			RaiseEventOptions val = new RaiseEventOptions();
			val.TargetActors = new int[1] { PhotonNetwork.MasterClient.ActorNumber };
			RaiseEventOptions val2 = val;
			bool flag = PhotonNetwork.RaiseEvent((byte)71, (object)array, val2, SendOptions.SendReliable);
			ManualLogSource log = Plugin.Log;
			string text = $"[DAGGER] Pull request sent={flag} | ";
			string text2 = $"victim={victimID} puller={pullerID} ";
			string text3 = $"master={PhotonNetwork.MasterClient.ActorNumber} ";
			Player localPlayer = PhotonNetwork.LocalPlayer;
			log.LogInfo((object)(text + text2 + text3 + $"local={((localPlayer != null) ? localPlayer.ActorNumber : (-1))}"));
			if (!flag)
			{
				RitualDaggerPatch.ResetEmbeddedPullRequest(victimID);
			}
		}

		private static void OnEvent(EventData photonEvent)
		{
			if (photonEvent.Code != 71 || !(photonEvent.CustomData is object[] array) || array.Length < 3)
			{
				return;
			}
			switch (array[0] as string)
			{
			case "ARR_PULL_REQUEST":
				if (PhotonNetwork.IsMasterClient && array.Length >= 4)
				{
					int victimID2 = Convert.ToInt32(array[1]);
					int pullerID = Convert.ToInt32(array[2]);
					string prefabName = RitualDaggerPatch.CleanPrefabName(array[3] as string);
					ValidateAndResolvePull(photonEvent.Sender, victimID2, pullerID, prefabName);
				}
				break;
			case "ARR_PULL_RESOLVED":
				if (array.Length >= 4)
				{
					int victimID3 = Convert.ToInt32(array[1]);
					int pullerID2 = Convert.ToInt32(array[2]);
					string prefabName2 = RitualDaggerPatch.CleanPrefabName(array[3] as string);
					ResolvePull(victimID3, pullerID2, prefabName2);
				}
				break;
			case "ARR_PULL_REJECTED":
			{
				int victimID = Convert.ToInt32(array[1]);
				int num = Convert.ToInt32(array[2]);
				string text = ((array.Length > 3) ? (array[3] as string) : "unknown");
				Character localCharacter = Character.localCharacter;
				if ((Object)(object)localCharacter != (Object)null && (Object)(object)((MonoBehaviourPun)localCharacter).photonView != (Object)null && ((MonoBehaviourPun)localCharacter).photonView.ViewID == num)
				{
					Plugin.Log.LogWarning((object)("[DAGGER] Pull rejected by master: " + text));
					RitualDaggerPatch.ResetEmbeddedPullRequest(victimID);
				}
				break;
			}
			}
		}

		private static void ValidateAndResolvePull(int senderActor, int victimID, int pullerID, string prefabName)
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: 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)
			//IL_00ba: Expected O, but got Unknown
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			Character victim = RitualDaggerPatch.FindCharacter(victimID);
			Character puller = RitualDaggerPatch.FindCharacter(pullerID);
			if (!ValidatePull(victim, puller, victimID, pullerID, senderActor, validateOwner: true, out string reason))
			{
				Plugin.Log.LogWarning((object)("[DAGGER] Master rejected pull | " + $"victim={victimID} puller={pullerID} " + "reason=" + reason));
				SendRejected(victimID, pullerID, reason);
				return;
			}
			if (!RitualDaggerPatch.TryLockPull(victimID))
			{
				SendRejected(victimID, pullerID, "pull already resolved");
				return;
			}
			object[] array = new object[4] { "ARR_PULL_RESOLVED", victimID, pullerID, prefabName };
			RaiseEventOptions val = new RaiseEventOptions
			{
				Receivers = (ReceiverGroup)1
			};
			bool flag = PhotonNetwork.RaiseEvent((byte)71, (object)array, val, SendOptions.SendReliable);
			Plugin.Log.LogInfo((object)("[DAGGER] Master approved pull | " + $"victim={victimID} puller={pullerID} " + $"broadcast={flag}"));
			if (!flag)
			{
				RitualDaggerPatch.UnlockPull(victimID);
				SendRejected(victimID, pullerID, "master broadcast failed");
			}
		}

		private static bool ValidatePull(Character victim, Character puller, int victimID, int pullerID, int senderActor, bool validateOwner, out string reason)
		{
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)victim == (Object)null || (Object)(object)puller == (Object)null)
			{
				reason = "character missing";
				return false;
			}
			if (victim.data.dead || puller.data.dead)
			{
				reason = "dead character";
				return false;
			}
			if (victimID == pullerID)
			{
				reason = "victim cannot pull own dagger";
				return false;
			}
			if (validateOwner && ((Object)(object)((MonoBehaviourPun)puller).photonView == (Object)null || ((MonoBehaviourPun)puller).photonView.OwnerActorNr != senderActor))
			{
				object arg = senderActor;
				PhotonView photonView = ((MonoBehaviourPun)puller).photonView;
				reason = "sender does not own puller " + $"(sender={arg}, owner={((photonView != null) ? photonView.OwnerActorNr : (-1))})";
				return false;
			}
			float num = Vector3.Distance(puller.Center, victim.Center);
			if (num > 3f)
			{
				reason = $"too far ({num:F2}m)";
				return false;
			}
			reason = "";
			return true;
		}

		private static void SendRejected(int victimID, int pullerID, string reason)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			object[] array = new object[4] { "ARR_PULL_REJECTED", victimID, pullerID, reason };
			RaiseEventOptions val = new RaiseEventOptions
			{
				Receivers = (ReceiverGroup)1
			};
			PhotonNetwork.RaiseEvent((byte)71, (object)array, val, SendOptions.SendReliable);
		}

		private static void ResolvePull(int victimID, int pullerID, string prefabName)
		{
			if (!ResolvedVictims.Contains(victimID))
			{
				ResolvedVictims.Add(victimID);
				Character val = RitualDaggerPatch.FindCharacter(victimID);
				Character val2 = RitualDaggerPatch.FindCharacter(pullerID);
				Plugin.Log.LogInfo((object)("[DAGGER] Resolving approved pull | " + $"victim={victimID} puller={pullerID}"));
				RitualDaggerPatch.RemoveEmbeddedDagger(victimID);
				if ((Object)(object)val != (Object)null && val.IsLocal && !val.data.dead)
				{
					RitualDaggerPatch.ApplyPullEffects(val);
				}
				if ((Object)(object)val2 != (Object)null && val2.IsLocal && !val2.data.dead)
				{
					SpawnDaggerInHand(val2, prefabName);
				}
			}
		}

		private static void FindSpawnMethod()
		{
			spawnItemInHandMethod = AccessTools.Method(typeof(CharacterItems), "SpawnItemInHand", new Type[1] { typeof(string) }, (Type[])null);
			if (spawnItemInHandMethod == null)
			{
				Plugin.Log.LogError((object)"[DAGGER] Could not find CharacterItems.SpawnItemInHand.");
			}
		}

		private static void SpawnDaggerInHand(Character puller, string prefabName)
		{
			if ((Object)(object)puller == (Object)null || puller.refs == null || (Object)(object)puller.refs.items == (Object)null)
			{
				Plugin.Log.LogError((object)"[DAGGER] Cannot spawn pulled dagger: puller items missing.");
				return;
			}
			prefabName = RitualDaggerPatch.CleanPrefabName(prefabName);
			if (spawnItemInHandMethod == null)
			{
				FindSpawnMethod();
			}
			if (spawnItemInHandMethod == null)
			{
				return;
			}
			try
			{
				Plugin.Log.LogInfo((object)("[DAGGER] Spawning pulled dagger '" + prefabName + "' " + $"for {pullerIDSafe(puller)}."));
				spawnItemInHandMethod.Invoke(puller.refs.items, new object[1] { prefabName });
				Plugin.Log.LogInfo((object)("[DAGGER] SpawnItemInHand invoked for '" + prefabName + "'."));
			}
			catch (Exception arg)
			{
				Plugin.Log.LogError((object)$"[DAGGER] Failed to spawn pulled dagger: {arg}");
			}
		}

		private static int pullerIDSafe(Character puller)
		{
			if ((Object)(object)puller == (Object)null || (Object)(object)((MonoBehaviourPun)puller).photonView == (Object)null)
			{
				return -1;
			}
			return ((MonoBehaviourPun)puller).photonView.ViewID;
		}
	}
}
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
	{
	}
}