using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using BuddyClimb.Compatibility;
using BuddyClimb.Configuration;
using BuddyClimb.Gameplay;
using BuddyClimb.Localization;
using BuddyClimb.Patches;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using UnityEngine;
using Zorro.Core;
using Zorro.Core.Serizalization;

[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.github.LandmineHQ.BuddyClimb")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.14.0")]
[assembly: AssemblyInformationalVersion("0.1.14+856bcfdbd6f7e9767fcd3fed11f04a7b02a0e27c")]
[assembly: AssemblyProduct("com.github.LandmineHQ.BuddyClimb")]
[assembly: AssemblyTitle("BuddyClimb")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/LandmineHQ/PeakPunch")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.14.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 BuddyClimb
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.github.LandmineHQ.BuddyClimb", "BuddyClimb", "0.1.14")]
	public class Plugin : BaseUnityPlugin
	{
		public const string Id = "com.github.LandmineHQ.BuddyClimb";

		internal static ManualLogSource Log { get; private set; }

		public static string Name => "BuddyClimb";

		public static string Version => "0.1.14";

		private void Awake()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BaseUnityPlugin)this).Logger;
			BuddyClimbConfig.Bind(((BaseUnityPlugin)this).Config);
			BuddyClimbConfig.EnableHotReload(((BaseUnityPlugin)this).Config);
			new Harmony("com.github.LandmineHQ.BuddyClimb").PatchAll(typeof(Plugin).Assembly);
			if (ModCompatibility.IsPiggybackLoaded)
			{
				Log.LogInfo((object)"Piggyback detected; BuddyClimb carry spectate patches are disabled.");
			}
			Log.LogInfo((object)("Plugin " + Name + " is loaded!"));
		}

		private void Update()
		{
			CarriedPlayerDropper.Update();
		}

		private void OnDestroy()
		{
			BuddyClimbConfig.DisableHotReload();
		}
	}
}
namespace BuddyClimb.Patches
{
	[HarmonyPatch]
	internal static class CarrySpectatePatch
	{
		[HarmonyPrepare]
		private static bool Prepare()
		{
			return !ModCompatibility.IsPiggybackLoaded;
		}

		[HarmonyPatch(typeof(MainCameraMovement), "LateUpdate")]
		[HarmonyPostfix]
		private static void LateUpdatePostfix(MainCameraMovement __instance)
		{
			if (TryGetBuddyClimbSpectateTarget(out Character spectateTarget) && !__instance.isGodCam && !__instance.isSpectating)
			{
				MainCamera cam = __instance.cam;
				if (!((Object)(object)cam == (Object)null) && !((Object)(object)cam.camOverride != (Object)null))
				{
					MainCameraMovement.specCharacter = spectateTarget;
					__instance.Spectate(false);
					__instance.isSpectating = true;
				}
			}
		}

		[HarmonyPatch(typeof(MainCameraMovement), "HandleSpecSelection")]
		[HarmonyPrefix]
		private static bool HandleSpecSelectionPrefix(MainCameraMovement __instance, ref bool __result)
		{
			if (!TryGetBuddyClimbSpectateTarget(out Character spectateTarget))
			{
				return true;
			}
			MainCameraMovement.specCharacter = spectateTarget;
			__result = true;
			return false;
		}

		private static bool TryGetBuddyClimbSpectateTarget(out Character spectateTarget)
		{
			spectateTarget = null;
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null || (Object)(object)localCharacter.data == (Object)null || !localCharacter.data.isCarried || (Object)(object)localCharacter.data.carrier == (Object)null || localCharacter.data.dead || localCharacter.data.fullyPassedOut || !CharacterCarryingPatch.IsBuddyClimbCarried(localCharacter))
			{
				return false;
			}
			spectateTarget = localCharacter;
			return true;
		}
	}
	[HarmonyPatch(typeof(CharacterBackpackHandler))]
	internal static class CharacterBackpackHandlerPatch
	{
		[HarmonyPatch("LateUpdate")]
		[HarmonyPostfix]
		private static void LateUpdatePostfix(CharacterBackpackHandler __instance)
		{
			CarriedBackpackVisuals.Update(__instance);
		}
	}
	[HarmonyPatch(typeof(CharacterCarrying))]
	internal static class CharacterCarryingPatch
	{
		private static readonly HashSet<int> BuddyClimbCarriedViewIds = new HashSet<int>();

		internal static bool IsBuddyClimbCarried(Character character)
		{
			if ((Object)(object)((character != null) ? ((MonoBehaviourPun)character).photonView : null) != (Object)null)
			{
				return BuddyClimbCarriedViewIds.Contains(((MonoBehaviourPun)character).photonView.ViewID);
			}
			return false;
		}

		[HarmonyPatch("Update")]
		[HarmonyPrefix]
		private static bool UpdatePrefix(CharacterCarrying __instance)
		{
			Character val = __instance.character ?? ((Component)__instance).GetComponent<Character>();
			if ((Object)(object)val == (Object)null || (Object)(object)((MonoBehaviourPun)val).photonView == (Object)null)
			{
				return true;
			}
			Character carriedPlayer = val.data.carriedPlayer;
			if ((Object)(object)carriedPlayer == (Object)null || !IsBuddyClimbCarried(carriedPlayer))
			{
				return true;
			}
			if ((carriedPlayer.data.dead || val.data.fullyPassedOut || val.data.dead) && val.refs.view.IsMine)
			{
				BuddyClimbDiagnostics.LogCarry("CharacterCarrying.Update dropping BuddyClimb carried player because carry state became invalid: " + BuddyClimbDiagnostics.DescribeViews(val, carriedPlayer));
				__instance.Drop(carriedPlayer);
			}
			return false;
		}

		[HarmonyPatch("RPCA_Drop")]
		[HarmonyPrefix]
		private static bool RPCA_DropPrefix(PhotonView targetView)
		{
			BuddyClimbDiagnostics.LogCarry($"RPCA_Drop prefix received targetView={(((Object)(object)targetView != (Object)null) ? targetView.ViewID : (-1))}");
			if ((Object)(object)targetView == (Object)null)
			{
				return true;
			}
			Character component = ((Component)targetView).GetComponent<Character>();
			if ((Object)(object)component != (Object)null && IsBuddyClimbCarried(component))
			{
				BuddyClimbRemotePassOutSync.RestoreRemoteCarryDrop(component, "incoming RPCA_Drop");
			}
			BuddyClimbCarriedViewIds.Remove(targetView.ViewID);
			return true;
		}

		[HarmonyPatch("RPCA_Drop")]
		[HarmonyPostfix]
		private static void RPCA_DropPostfix(PhotonView targetView)
		{
			if ((Object)(object)targetView != (Object)null)
			{
				Character component = ((Component)targetView).GetComponent<Character>();
				BuddyClimbDiagnostics.LogCarry("RPCA_Drop postfix target: " + BuddyClimbDiagnostics.Describe(component));
				CarryInteractionProxy.Disable(component);
				CarriedBackpackVisuals.HideIfForcedVisible(component);
			}
		}

		[HarmonyPatch("RPCA_StartCarry")]
		[HarmonyPrefix]
		private static bool RPCA_StartCarryPrefix(CharacterCarrying __instance, PhotonView targetView)
		{
			Character val = __instance.character ?? ((Component)__instance).GetComponent<Character>();
			Character val2 = (((Object)(object)targetView != (Object)null) ? ((Component)targetView).GetComponent<Character>() : null);
			BuddyClimbDiagnostics.LogCarry($"RPCA_StartCarry prefix received targetView={(((Object)(object)targetView != (Object)null) ? targetView.ViewID : (-1))}: {BuddyClimbDiagnostics.DescribeViews(val, val2)}");
			if ((Object)(object)targetView == (Object)null)
			{
				BuddyClimbDiagnostics.LogCarry("RPCA_StartCarry prefix returning false because targetView is null.");
				return false;
			}
			Character val3 = val;
			if ((Object)(object)val3 == (Object)null)
			{
				BuddyClimbDiagnostics.LogCarry("RPCA_StartCarry prefix returning false because carrierCharacter is null.");
				return false;
			}
			Character val4 = val2;
			if ((Object)(object)val4 == (Object)null)
			{
				BuddyClimbDiagnostics.LogCarry("RPCA_StartCarry prefix returning false because carriedCharacter is null.");
				return false;
			}
			if (val4.data.fullyPassedOut || val4.data.dead)
			{
				BuddyClimbDiagnostics.LogCarry("RPCA_StartCarry prefix allowing vanilla path for unconscious/dead carried character: " + BuddyClimbDiagnostics.Describe(val4));
				return true;
			}
			Character carriedPlayer = val3.data.carriedPlayer;
			if ((Object)(object)carriedPlayer == (Object)(object)val4)
			{
				BuddyClimbDiagnostics.LogCarry("RPCA_StartCarry prefix applying idempotent same-link state: " + BuddyClimbDiagnostics.DescribeViews(val3, val4));
				ApplyBuddyClimbCarryState(val3, val4);
				return false;
			}
			if ((Object)(object)carriedPlayer != (Object)null)
			{
				BuddyClimbDiagnostics.LogCarry("RPCA_StartCarry prefix found existing carriedPlayer=" + BuddyClimbDiagnostics.Describe(carriedPlayer) + " before applying new state.");
				if (!TryClearExistingBuddyClimbCarry(val3, carriedPlayer, val4))
				{
					BuddyClimbDiagnostics.LogCarry("RPCA_StartCarry prefix returning false because existing carried player is not BuddyClimb-owned stale state: " + BuddyClimbDiagnostics.DescribeViews(val3, val4));
					return false;
				}
			}
			BuddyClimbDiagnostics.LogCarry("RPCA_StartCarry prefix applying BuddyClimb carry state: " + BuddyClimbDiagnostics.DescribeViews(val3, val4));
			ApplyBuddyClimbCarryState(val3, val4);
			return false;
		}

		private static bool TryClearExistingBuddyClimbCarry(Character carrierCharacter, Character existingCarriedPlayer, Character nextCarriedCharacter)
		{
			if (!IsBuddyClimbCarried(existingCarriedPlayer) || (Object)(object)existingCarriedPlayer.data.carrier != (Object)(object)carrierCharacter)
			{
				Plugin.Log.LogDebug((object)("Ignoring BuddyClimb start carry for " + nextCarriedCharacter.characterName + " because " + carrierCharacter.characterName + " is already carrying " + existingCarriedPlayer.characterName + "."));
				return false;
			}
			Plugin.Log.LogDebug((object)("Clearing stale BuddyClimb carry state for " + existingCarriedPlayer.characterName + " before carrying " + nextCarriedCharacter.characterName + "."));
			existingCarriedPlayer.refs.carriying.ToggleCarryPhysics(false);
			existingCarriedPlayer.data.isCarried = false;
			existingCarriedPlayer.data.carrier = null;
			carrierCharacter.data.carriedPlayer = null;
			BuddyClimbRemotePassOutSync.RestoreRemoteCarryDrop(existingCarriedPlayer, "stale BuddyClimb carry cleanup");
			BuddyClimbCarriedViewIds.Remove(((MonoBehaviourPun)existingCarriedPlayer).photonView.ViewID);
			CarryInteractionProxy.Disable(existingCarriedPlayer);
			CarriedBackpackVisuals.HideIfForcedVisible(existingCarriedPlayer);
			foreach (Character allPlayerCharacter in PlayerHandler.GetAllPlayerCharacters())
			{
				allPlayerCharacter.refs.afflictions.UpdateWeight();
			}
			return true;
		}

		private static void ApplyBuddyClimbCarryState(Character carrierCharacter, Character carriedCharacter)
		{
			carriedCharacter.refs.carriying.ToggleCarryPhysics(true);
			carriedCharacter.data.isCarried = true;
			carrierCharacter.data.carriedPlayer = carriedCharacter;
			carriedCharacter.data.carrier = carrierCharacter;
			BuddyClimbCarriedViewIds.Add(((MonoBehaviourPun)carriedCharacter).photonView.ViewID);
			foreach (Character allPlayerCharacter in PlayerHandler.GetAllPlayerCharacters())
			{
				allPlayerCharacter.refs.afflictions.UpdateWeight();
			}
			BuddyClimbDiagnostics.LogCarry("Applied BuddyClimb carry state: " + BuddyClimbDiagnostics.DescribeViews(carrierCharacter, carriedCharacter));
		}

		[HarmonyPatch("RPCA_StartCarry")]
		[HarmonyPostfix]
		private static void RPCA_StartCarryPostfix(PhotonView targetView)
		{
			if (!((Object)(object)targetView != (Object)null))
			{
				return;
			}
			Character component = ((Component)targetView).GetComponent<Character>();
			if (component != null && component.data.isCarried)
			{
				BuddyClimbDiagnostics.LogCarry("RPCA_StartCarry postfix sees carried state true: " + BuddyClimbDiagnostics.Describe(component));
				CarryInteractionProxy.Enable(component);
				if (component.IsLocal)
				{
					CarriedBackpackVisuals.Update(((Component)component).GetComponent<CharacterBackpackHandler>());
				}
			}
		}
	}
	[HarmonyPatch(typeof(CharacterInteractible))]
	internal static class CharacterInteractiblePatch
	{
		[HarmonyPatch("GetInteractionText")]
		[HarmonyPostfix]
		private static void GetInteractionTextPatch(ref string __result, CharacterInteractible __instance)
		{
			Character localCharacter = Character.localCharacter;
			if (IsBuddyClimbDropInteraction(__instance.character, localCharacter))
			{
				__result = string.Empty;
			}
			else if (!(__result != string.Empty) && CanStartClimb(__instance.character, localCharacter))
			{
				BuddyClimbTextKey key = (BackpackCarryTransfer.WillDropCarriedBackpack(__instance.character, localCharacter) ? BuddyClimbTextKey.ClimbOnTeammateDropBackpack : BuddyClimbTextKey.ClimbOnTeammate);
				__result = BuddyClimbLocalization.Get(key);
			}
		}

		[HarmonyPatch("Interact")]
		[HarmonyPrefix]
		private static bool InteractPatch(CharacterInteractible __instance, ref Character interactor)
		{
			if (IsBuddyClimbDropInteraction(__instance.character, interactor))
			{
				return false;
			}
			if (__instance.CarriedByLocalCharacter() || __instance.IsCannibal() || __instance.CanBeCarried())
			{
				return true;
			}
			return !TryStartClimb(__instance.character, interactor);
		}

		[HarmonyPatch("IsInteractible")]
		[HarmonyPostfix]
		private static void IsInteractiblePatch(CharacterInteractible __instance, ref bool __result, ref Character interactor)
		{
			if (IsBuddyClimbDropInteraction(__instance.character, interactor))
			{
				__result = false;
			}
			else if (!__result && CanStartClimb(__instance.character, interactor))
			{
				__result = true;
			}
		}

		[HarmonyPatch("IsPrimaryInteractible")]
		[HarmonyPostfix]
		private static void IsPrimaryInteractiblePatch(CharacterInteractible __instance, ref bool __result, ref Character interactor)
		{
			if (IsBuddyClimbDropInteraction(__instance.character, interactor))
			{
				__result = false;
			}
			else if (!__result && CanStartClimb(__instance.character, interactor))
			{
				__result = true;
			}
		}

		private static bool CanBeClimbed(Character character)
		{
			if ((Object)(object)character == (Object)null)
			{
				return false;
			}
			if (character.isBot)
			{
				return false;
			}
			if (character.IsLocal)
			{
				return false;
			}
			if (character.data.dead)
			{
				return false;
			}
			if (!((ItemSlot)character.player.backpackSlot).IsEmpty() && !BackpackCarryTransfer.AllowsCarrierBackpack)
			{
				return false;
			}
			if (IsCharacterDoingIllegalCarryActions(character))
			{
				return false;
			}
			if (character.data.IsCarryingCharacter)
			{
				return false;
			}
			if (character.refs.customization.isCannibalizable)
			{
				return false;
			}
			return true;
		}

		private static bool CanClimb(Character character)
		{
			if ((Object)(object)character == (Object)null)
			{
				return false;
			}
			if (character.refs.interactible.CanBeCarried())
			{
				return true;
			}
			if (!character.IsLocal)
			{
				return false;
			}
			if (character.data.dead)
			{
				return false;
			}
			if (Object.op_Implicit((Object)(object)character.data.currentItem))
			{
				return false;
			}
			if (character.data.isCarried)
			{
				return false;
			}
			if (character.refs.customization.isCannibalizable)
			{
				return false;
			}
			return true;
		}

		private static bool IsCharacterDoingIllegalCarryActions(Character character)
		{
			if (!character.data.isSprinting && !character.data.isJumping && !character.data.isClimbingAnything && !character.data.isCrouching)
			{
				return character.data.isReaching;
			}
			return true;
		}

		private static bool TryStartClimb(Character character, Character interactor)
		{
			BuddyClimbDiagnostics.LogCarry("TryStartClimb entered: " + BuddyClimbDiagnostics.DescribeViews(character, interactor));
			if (!CanStartClimb(character, interactor))
			{
				BuddyClimbDiagnostics.LogCarry("TryStartClimb blocked by CanStartClimb=false: " + BuddyClimbDiagnostics.DescribeViews(character, interactor));
				return false;
			}
			BackpackPreparationResult backpackPreparationResult = BackpackCarryTransfer.PrepareBackpacksForClimb(character, interactor);
			BuddyClimbDiagnostics.LogCarry($"Backpack preparation result={backpackPreparationResult}: {BuddyClimbDiagnostics.DescribeViews(character, interactor)}");
			switch (backpackPreparationResult)
			{
			case BackpackPreparationResult.Failed:
				BuddyClimbDiagnostics.LogCarry("TryStartClimb consumed interaction because backpack preparation failed.");
				return true;
			case BackpackPreparationResult.Deferred:
				BuddyClimbDiagnostics.LogCarry("TryStartClimb is waiting for MasterClient backpack removal confirmation.");
				return true;
			case BackpackPreparationResult.Ready:
			{
				bool flag = BuddyClimbCarryStarter.TryStartCarry(character, interactor);
				BuddyClimbDiagnostics.LogCarry($"TryStartClimb called TryStartCarry, sent={flag}: {BuddyClimbDiagnostics.DescribeViews(character, interactor)}");
				break;
			}
			}
			return true;
		}

		private static bool CanStartClimb(Character carrier, Character carried)
		{
			if (CanBeClimbed(carrier) && CanClimb(carried))
			{
				return BuddyClimbCarryStarter.CanCreateCarryLink(carrier, carried);
			}
			return false;
		}

		private static bool IsBuddyClimbDropInteraction(Character character, Character interactor)
		{
			if ((Object)(object)character != (Object)null && (Object)(object)interactor != (Object)null && (Object)(object)character.data.carrier == (Object)(object)interactor)
			{
				return CharacterCarryingPatch.IsBuddyClimbCarried(character);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(CharacterMovement))]
	internal static class CharacterMovementPatch
	{
		[HarmonyPatch("TryToJump")]
		[HarmonyPrefix]
		private static bool TryToJumpPrefix(CharacterMovement __instance)
		{
			return !CarriedPlayerDropper.HandleJumpAttempt(__instance.character);
		}
	}
	[HarmonyPatch(typeof(Item))]
	internal static class ItemBackpackVisualPatch
	{
		[HarmonyPatch("PutInBackpackRPC")]
		[HarmonyPostfix]
		private static void PutInBackpackRPCPostfix(Item __instance, BackpackReference backpackReference)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			CarriedBackpackVisuals.ShowIfCarriedLocalBackpackItem(__instance, backpackReference);
		}
	}
	[HarmonyPatch(typeof(Player))]
	internal static class PlayerInventoryPatch
	{
		[HarmonyPatch("SyncInventoryRPC")]
		[HarmonyPostfix]
		private static void SyncInventoryRPCPostfix(Player __instance, byte[] data, bool forceSync)
		{
			BackpackCarryTransfer.HandleInventorySync(__instance, data, forceSync);
		}
	}
}
namespace BuddyClimb.Localization
{
	internal enum BuddyClimbTextKey
	{
		ClimbOnTeammate,
		ClimbOnTeammateDropBackpack
	}
	internal static class BuddyClimbLocalization
	{
		private enum SupportedLanguage
		{
			English,
			Chinese
		}

		private static readonly IReadOnlyDictionary<BuddyClimbTextKey, string> EnglishText = new Dictionary<BuddyClimbTextKey, string>
		{
			[BuddyClimbTextKey.ClimbOnTeammate] = "Climb on!",
			[BuddyClimbTextKey.ClimbOnTeammateDropBackpack] = "Climb on! (drop backpack)"
		};

		private static readonly IReadOnlyDictionary<BuddyClimbTextKey, string> ChineseText = new Dictionary<BuddyClimbTextKey, string>
		{
			[BuddyClimbTextKey.ClimbOnTeammate] = "爬上去!",
			[BuddyClimbTextKey.ClimbOnTeammateDropBackpack] = "爬上去！（丢弃背包）"
		};

		internal static string Get(BuddyClimbTextKey key)
		{
			SupportedLanguage currentLanguage = GetCurrentLanguage();
			IReadOnlyDictionary<BuddyClimbTextKey, string> readOnlyDictionary = ((currentLanguage != SupportedLanguage.Chinese) ? EnglishText : ChineseText);
			IReadOnlyDictionary<BuddyClimbTextKey, string> readOnlyDictionary2 = readOnlyDictionary;
			if (readOnlyDictionary2.TryGetValue(key, out var value))
			{
				return value;
			}
			return EnglishText[key];
		}

		private static SupportedLanguage GetCurrentLanguage()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			Language cURRENT_LANGUAGE = LocalizedText.CURRENT_LANGUAGE;
			if ((int)cURRENT_LANGUAGE != 9)
			{
				if ((int)cURRENT_LANGUAGE == 10)
				{
					return SupportedLanguage.Chinese;
				}
				return SupportedLanguage.English;
			}
			return SupportedLanguage.Chinese;
		}
	}
}
namespace BuddyClimb.Gameplay
{
	internal enum BackpackPreparationResult
	{
		Failed,
		Ready,
		Deferred
	}
	internal static class BackpackCarryTransfer
	{
		private sealed class PendingBackpackTransfer
		{
			internal Character Carrier { get; }

			internal Character Carried { get; }

			internal BackpackSlot CarrierBackpack { get; }

			internal float ExpiresAt { get; }

			internal bool NeedsCarriedDrop { get; }

			internal bool CarriedSlotCleared { get; set; }

			internal bool CarrierRemovalRequested { get; set; }

			internal bool CarrierSlotCleared { get; set; }

			internal PendingBackpackTransfer(Character carrier, Character carried, BackpackSlot carrierBackpack, bool needsCarriedDrop, float expiresAt)
			{
				Carrier = carrier;
				Carried = carried;
				CarrierBackpack = carrierBackpack;
				NeedsCarriedDrop = needsCarriedDrop;
				ExpiresAt = expiresAt;
			}
		}

		private const float PendingTransferTimeoutSeconds = 5f;

		private static readonly byte BackpackSlotIndex = 3;

		private static readonly Dictionary<int, PendingBackpackTransfer> PendingTransfers = new Dictionary<int, PendingBackpackTransfer>();

		internal static bool AllowsCarrierBackpack => BuddyClimbConfig.EnableBackpackTransfer.Value;

		internal static bool WillDropCarriedBackpack(Character carrier, Character carried)
		{
			if (AllowsCarrierBackpack && (Object)(object)carrier != (Object)null && (Object)(object)carried != (Object)null && HasBackpack(carrier))
			{
				return HasBackpack(carried);
			}
			return false;
		}

		internal static bool CanTransferCarrierBackpack(Character carrier, Character carried)
		{
			if (!AllowsCarrierBackpack || (Object)(object)carrier == (Object)null || (Object)(object)carried == (Object)null || !HasBackpack(carrier))
			{
				return true;
			}
			Player player = carrier.player;
			Player player2 = carried.player;
			if (CanSyncInventory(player) && CanSyncInventory(player2) && IsLocallyOwnedPlayer(player2))
			{
				if (HasBackpack(carried))
				{
					return CanDropBackpackWithVanillaSlotDrop(carried);
				}
				return true;
			}
			return false;
		}

		internal static BackpackPreparationResult PrepareBackpacksForClimb(Character carrier, Character carried)
		{
			BuddyClimbDiagnostics.LogCarry("PrepareBackpacksForClimb entered: " + BuddyClimbDiagnostics.DescribeViews(carrier, carried));
			PruneExpiredTransfers();
			if (!AllowsCarrierBackpack || (Object)(object)carrier == (Object)null || (Object)(object)carried == (Object)null || !HasBackpack(carrier))
			{
				BuddyClimbDiagnostics.LogCarry($"PrepareBackpacksForClimb returning Ready without transfer: allows={AllowsCarrierBackpack} {BuddyClimbDiagnostics.DescribeViews(carrier, carried)}");
				return BackpackPreparationResult.Ready;
			}
			if (TryGetPendingTransfer(carried, out PendingBackpackTransfer pendingTransfer))
			{
				if ((Object)(object)pendingTransfer.Carrier == (Object)(object)carrier)
				{
					BuddyClimbDiagnostics.LogCarry("Ignoring duplicate BuddyClimb backpack transfer request while the first request is pending: " + BuddyClimbDiagnostics.DescribeViews(carrier, carried));
					return BackpackPreparationResult.Deferred;
				}
				Plugin.Log.LogWarning((object)("Ignoring BuddyClimb backpack transfer to " + carrier.characterName + " because another transfer is already pending for " + carried.characterName + "."));
				return BackpackPreparationResult.Failed;
			}
			if (!CanTransferCarrierBackpack(carrier, carried))
			{
				BuddyClimbDiagnostics.LogCarry("PrepareBackpacksForClimb returning Failed because CanTransferCarrierBackpack=false: " + BuddyClimbDiagnostics.DescribeViews(carrier, carried));
				return BackpackPreparationResult.Failed;
			}
			if (!HasBackpack(carried))
			{
				return BeginCarrierBackpackTransfer(carrier, carried, dropCarriedBackpack: false);
			}
			return BeginCarrierBackpackTransfer(carrier, carried, dropCarriedBackpack: true);
		}

		internal static void HandleInventorySync(Player player, byte[] data, bool forceSync)
		{
			//IL_006d: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			if (forceSync || (Object)(object)player == (Object)null || (Object)(object)((MonoBehaviourPun)player).photonView == (Object)null || data == null)
			{
				return;
			}
			PendingBackpackTransfer pendingBackpackTransfer = FindPendingTransfer(player);
			if (pendingBackpackTransfer == null)
			{
				return;
			}
			if (Time.realtimeSinceStartup > pendingBackpackTransfer.ExpiresAt)
			{
				RemovePendingTransfer(pendingBackpackTransfer.Carried);
				RestoreCarrierBackpackAfterTimeout(pendingBackpackTransfer);
				Plugin.Log.LogWarning((object)("Timed out waiting for BuddyClimb backpack transfer confirmation for " + pendingBackpackTransfer.Carried.characterName + "."));
				return;
			}
			InventorySyncData fromManagedArray = IBinarySerializable.GetFromManagedArray<InventorySyncData>(data);
			if (fromManagedArray.backpackType != 0 || fromManagedArray.backpackSlot.ItemID != ushort.MaxValue)
			{
				return;
			}
			if ((Object)(object)pendingBackpackTransfer.Carried.player == (Object)(object)player)
			{
				if (!pendingBackpackTransfer.NeedsCarriedDrop)
				{
					return;
				}
				pendingBackpackTransfer.CarriedSlotCleared = true;
				if (!pendingBackpackTransfer.CarrierRemovalRequested && !pendingBackpackTransfer.CarrierSlotCleared)
				{
					if (!TryRequestCarrierBackpackRemoval(pendingBackpackTransfer.Carrier))
					{
						RemovePendingTransfer(pendingBackpackTransfer.Carried);
						Plugin.Log.LogWarning((object)("Unable to request the next BuddyClimb backpack transfer phase for " + pendingBackpackTransfer.Carried.characterName + "."));
						return;
					}
					pendingBackpackTransfer.CarrierRemovalRequested = true;
				}
			}
			else
			{
				if (!((Object)(object)pendingBackpackTransfer.Carrier.player == (Object)(object)player) || !pendingBackpackTransfer.CarrierRemovalRequested)
				{
					return;
				}
				pendingBackpackTransfer.CarrierSlotCleared = true;
			}
			if ((!pendingBackpackTransfer.NeedsCarriedDrop || pendingBackpackTransfer.CarriedSlotCleared) && pendingBackpackTransfer.CarrierSlotCleared)
			{
				RemovePendingTransfer(pendingBackpackTransfer.Carried);
				if (!TryApplyTransferredBackpack(pendingBackpackTransfer.Carrier, pendingBackpackTransfer.Carried, pendingBackpackTransfer.CarrierBackpack, syncInventory: true))
				{
					Plugin.Log.LogWarning((object)("Unable to apply the deferred BuddyClimb backpack transfer for " + pendingBackpackTransfer.Carried.characterName + "."));
				}
				else
				{
					BuddyClimbCarryStarter.TryStartCarry(pendingBackpackTransfer.Carrier, pendingBackpackTransfer.Carried);
				}
			}
		}

		private static BackpackPreparationResult BeginCarrierBackpackTransfer(Character carrier, Character carried, bool dropCarriedBackpack)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			Player player = carrier.player;
			Player player2 = carried.player;
			if (!CanSyncInventory(player) || !CanSyncInventory(player2) || !IsLocallyOwnedPlayer(player2) || (dropCarriedBackpack && !CanDropBackpackWithVanillaSlotDrop(carried)))
			{
				return BackpackPreparationResult.Failed;
			}
			BackpackSlot val = CloneBackpackSlot(player.backpackSlot);
			if (((ItemSlot)val).IsEmpty())
			{
				return BackpackPreparationResult.Failed;
			}
			ClearCarrierHeldBackpack(carrier);
			if (PhotonNetwork.IsMasterClient)
			{
				try
				{
					if (dropCarriedBackpack)
					{
						carried.refs.items.DropItemFromSlotRPC(BackpackSlotIndex, GetBackpackDropPosition(carried));
					}
					player.EmptySlot(Optionable<byte>.Some(BackpackSlotIndex), true);
				}
				catch (Exception arg)
				{
					Plugin.Log.LogWarning((object)$"Unable to drop the old carried backpack on the MasterClient: {arg}");
					return BackpackPreparationResult.Failed;
				}
				if (!TryApplyTransferredBackpack(carrier, carried, val, syncInventory: true))
				{
					return BackpackPreparationResult.Failed;
				}
				return BackpackPreparationResult.Ready;
			}
			try
			{
				if (dropCarriedBackpack)
				{
					RequestCarriedBackpackDrop(carried);
				}
				if (!dropCarriedBackpack && !TryRequestCarrierBackpackRemoval(carrier))
				{
					return BackpackPreparationResult.Failed;
				}
			}
			catch (Exception arg2)
			{
				Plugin.Log.LogWarning((object)$"Unable to request the BuddyClimb backpack preparation from the MasterClient: {arg2}");
				return BackpackPreparationResult.Failed;
			}
			PendingTransfers[((MonoBehaviourPun)carried).photonView.ViewID] = new PendingBackpackTransfer(carrier, carried, val, dropCarriedBackpack, Time.realtimeSinceStartup + 5f);
			PendingTransfers[((MonoBehaviourPun)carried).photonView.ViewID].CarrierRemovalRequested = !dropCarriedBackpack;
			BuddyClimbDiagnostics.LogCarry("Waiting for the MasterClient to clear the required backpack slots: " + BuddyClimbDiagnostics.DescribeViews(carrier, carried));
			return BackpackPreparationResult.Deferred;
		}

		private static void RequestCarriedBackpackDrop(Character carried)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			carried.refs.items.photonView.RPC("DropItemFromSlotRPC", (RpcTarget)2, new object[2]
			{
				BackpackSlotIndex,
				GetBackpackDropPosition(carried)
			});
		}

		private static bool TryRequestCarrierBackpackRemoval(Character carrier)
		{
			if (!CanSyncInventory(carrier.player))
			{
				return false;
			}
			try
			{
				((MonoBehaviourPun)carrier.player).photonView.RPC("RPCRemoveItemFromSlot", (RpcTarget)2, new object[1] { BackpackSlotIndex });
				return true;
			}
			catch (Exception arg)
			{
				Plugin.Log.LogWarning((object)$"Unable to request removal of {carrier.characterName}'s backpack: {arg}");
				return false;
			}
		}

		private static bool TryApplyTransferredBackpack(Character carrier, Character carried, BackpackSlot carrierBackpack, bool syncInventory)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			if ((Object)(object)carrier == (Object)null || (Object)(object)carried == (Object)null || carrierBackpack == null || ((ItemSlot)carrierBackpack).IsEmpty() || !CanSyncInventory(carrier.player) || !CanSyncInventory(carried.player) || !IsLocallyOwnedPlayer(carried.player))
			{
				return false;
			}
			AssignBackpack(carried.player, carrierBackpack);
			carrier.player.backpackSlot = new BackpackSlot(BackpackSlotIndex);
			carried.refs.afflictions.UpdateWeight();
			carrier.refs.afflictions.UpdateWeight();
			if (syncInventory)
			{
				SyncInventory(carried.player);
				SyncInventory(carrier.player);
			}
			return true;
		}

		internal static void ClearHeldBackpackAfterTransfer(Character carrier)
		{
			//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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)carrier == (Object)null)
			{
				return;
			}
			CharacterItems items = carrier.refs.items;
			if ((Object)(object)items == (Object)null)
			{
				return;
			}
			bool flag = IsBackpackSlotSelected(items);
			bool flag2 = carrier.data.currentItem is Backpack;
			if (flag || flag2)
			{
				if (items.currentSelectedSlot.IsSome)
				{
					items.lastSelectedSlot = items.currentSelectedSlot;
				}
				items.currentSelectedSlot = Optionable<byte>.None;
				if (flag2)
				{
					items.DestroyHeldItemRpc();
				}
				carrier.player.itemsChangedAction?.Invoke(carrier.player.itemSlots);
				items.onSlotEquipped?.Invoke();
			}
		}

		private static void ClearCarrierHeldBackpack(Character carrier)
		{
			ClearHeldBackpackAfterTransfer(carrier);
			CharacterItems items = carrier.refs.items;
			if (!((Object)(object)items?.photonView == (Object)null))
			{
				items.photonView.RPC("DestroyHeldItemRpc", (RpcTarget)1, Array.Empty<object>());
				items.photonView.RPC("EquipSlotRpc", (RpcTarget)1, new object[2] { -1, -1 });
			}
		}

		private static void AssignBackpack(Player player, BackpackSlot source)
		{
			player.backpackSlot = CloneBackpackSlot(source);
		}

		private static BackpackSlot CloneBackpackSlot(BackpackSlot source)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: 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_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			BackpackSlot val = new BackpackSlot(BackpackSlotIndex)
			{
				backpackType = source.backpackType
			};
			if (!((ItemSlot)source).IsEmpty())
			{
				((ItemSlot)val).SetItem(((ItemSlot)source).prefab, ((ItemSlot)source).data);
			}
			else
			{
				((ItemSlot)val).EmptyOut();
			}
			return val;
		}

		private static void SyncInventory(Player player)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			byte[] array = IBinarySerializable.ToManagedArray<InventorySyncData>(new InventorySyncData(player.itemSlots, player.backpackSlot, player.tempFullSlot));
			((MonoBehaviourPun)player).photonView.RPC("SyncInventoryRPC", (RpcTarget)0, new object[2] { array, true });
		}

		private static bool IsBackpackSlotSelected(CharacterItems characterItems)
		{
			if (characterItems.currentSelectedSlot.IsSome)
			{
				return characterItems.currentSelectedSlot.Value == BackpackSlotIndex;
			}
			return false;
		}

		private static bool HasBackpack(Character character)
		{
			if ((Object)(object)character.player != (Object)null)
			{
				return !((ItemSlot)character.player.backpackSlot).IsEmpty();
			}
			return false;
		}

		private static bool CanDropBackpackWithVanillaSlotDrop(Character character)
		{
			if ((Object)(object)character.refs.items != (Object)null)
			{
				return (Object)(object)character.refs.items.photonView != (Object)null;
			}
			return false;
		}

		private static Vector3 GetBackpackDropPosition(Character character)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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)
			//IL_001a: 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_0029: 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_0038: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return character.Center + Vector3.up * 0.5f;
			}
			catch
			{
				return ((Component)character).transform.position + Vector3.up * 0.5f;
			}
		}

		private static bool CanSyncInventory(Player player)
		{
			if ((Object)(object)player != (Object)null && (Object)(object)((MonoBehaviourPun)player).photonView != (Object)null && player.itemSlots != null && player.backpackSlot != null)
			{
				return player.tempFullSlot != null;
			}
			return false;
		}

		private static bool IsLocallyOwnedPlayer(Player player)
		{
			if ((Object)(object)player != (Object)null && (Object)(object)((MonoBehaviourPun)player).photonView != (Object)null)
			{
				return ((MonoBehaviourPun)player).photonView.IsMine;
			}
			return false;
		}

		private static PendingBackpackTransfer? FindPendingTransfer(Player player)
		{
			foreach (PendingBackpackTransfer value in PendingTransfers.Values)
			{
				if ((Object)(object)value.Carrier.player == (Object)(object)player || (Object)(object)value.Carried.player == (Object)(object)player)
				{
					return value;
				}
			}
			return null;
		}

		private static bool TryGetPendingTransfer(Character carried, out PendingBackpackTransfer pendingTransfer)
		{
			pendingTransfer = null;
			if ((Object)(object)((carried != null) ? ((MonoBehaviourPun)carried).photonView : null) == (Object)null || !PendingTransfers.TryGetValue(((MonoBehaviourPun)carried).photonView.ViewID, out PendingBackpackTransfer value))
			{
				return false;
			}
			pendingTransfer = value;
			if (Time.realtimeSinceStartup <= pendingTransfer.ExpiresAt)
			{
				return true;
			}
			RemovePendingTransfer(carried);
			RestoreCarrierBackpackAfterTimeout(pendingTransfer);
			pendingTransfer = null;
			return false;
		}

		private static void RemovePendingTransfer(Character carried)
		{
			if ((Object)(object)((carried != null) ? ((MonoBehaviourPun)carried).photonView : null) != (Object)null)
			{
				PendingTransfers.Remove(((MonoBehaviourPun)carried).photonView.ViewID);
			}
		}

		private static void PruneExpiredTransfers()
		{
			List<int> list = null;
			foreach (KeyValuePair<int, PendingBackpackTransfer> pendingTransfer in PendingTransfers)
			{
				if (!(Time.realtimeSinceStartup <= pendingTransfer.Value.ExpiresAt))
				{
					if (list == null)
					{
						list = new List<int>();
					}
					list.Add(pendingTransfer.Key);
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (int item in list)
			{
				if (PendingTransfers.Remove(item, out PendingBackpackTransfer value))
				{
					RestoreCarrierBackpackAfterTimeout(value);
				}
			}
		}

		private static void RestoreCarrierBackpackAfterTimeout(PendingBackpackTransfer pendingTransfer)
		{
			if (pendingTransfer.CarrierRemovalRequested && !pendingTransfer.CarrierSlotCleared && CanSyncInventory(pendingTransfer.Carrier.player))
			{
				AssignBackpack(pendingTransfer.Carrier.player, pendingTransfer.CarrierBackpack);
				SyncInventory(pendingTransfer.Carrier.player);
			}
		}
	}
	internal static class BuddyClimbCarryStarter
	{
		internal static bool TryStartCarry(Character carrier, Character carried)
		{
			BuddyClimbDiagnostics.LogCarry("TryStartCarry requested: " + BuddyClimbDiagnostics.DescribeViews(carrier, carried));
			if (!CanStartCarryRpc(carrier, carried))
			{
				BuddyClimbDiagnostics.LogCarry("TryStartCarry blocked by CanStartCarryRpc=false: " + BuddyClimbDiagnostics.DescribeViews(carrier, carried));
				return false;
			}
			BuddyClimbDiagnostics.LogCarry(string.Format("Sending Photon RPC {0} target=All carrierView={1} carriedView={2}: {3}", "RPCA_StartCarry", ((MonoBehaviourPun)carrier).photonView.ViewID, ((MonoBehaviourPun)carried).photonView.ViewID, BuddyClimbDiagnostics.DescribeViews(carrier, carried)));
			BuddyClimbRemotePassOutSync.PrepareRemoteCarryStart(carried);
			((MonoBehaviourPun)carrier).photonView.RPC("RPCA_StartCarry", (RpcTarget)0, new object[1] { ((MonoBehaviourPun)carried).photonView });
			BuddyClimbDiagnostics.LogCarry(string.Format("Sent Photon RPC {0} carrierView={1} carriedView={2}", "RPCA_StartCarry", ((MonoBehaviourPun)carrier).photonView.ViewID, ((MonoBehaviourPun)carried).photonView.ViewID));
			return true;
		}

		internal static bool CanCreateCarryLink(Character carrier, Character carried)
		{
			if ((Object)(object)carrier == (Object)null || (Object)(object)carried == (Object)null)
			{
				return false;
			}
			Character val = carrier;
			while (true)
			{
				if ((Object)(object)val == (Object)(object)carried)
				{
					return false;
				}
				Character val2 = val.data?.carrier;
				if (val2 == null)
				{
					break;
				}
				val = val2;
			}
			return true;
		}

		private static bool CanStartCarryRpc(Character carrier, Character carried)
		{
			if ((Object)(object)carrier == (Object)null || (Object)(object)carried == (Object)null || (Object)(object)carrier == (Object)(object)carried || (Object)(object)((MonoBehaviourPun)carrier).photonView == (Object)null || (Object)(object)((MonoBehaviourPun)carried).photonView == (Object)null)
			{
				BuddyClimbDiagnostics.LogCarry("CanStartCarryRpc basic validation failed: " + BuddyClimbDiagnostics.DescribeViews(carrier, carried));
				return false;
			}
			if (!CanCreateCarryLink(carrier, carried))
			{
				Plugin.Log.LogDebug((object)("Skipping BuddyClimb start carry because it would create a carry cycle between " + carrier.characterName + " and " + carried.characterName + "."));
				return false;
			}
			if (carrier.data.dead || carried.data.dead || carried.data.fullyPassedOut)
			{
				Plugin.Log.LogDebug((object)("Skipping BuddyClimb start carry for " + carried.characterName + " because the carry state is no longer valid."));
				return false;
			}
			return true;
		}
	}
	internal static class BuddyClimbDiagnostics
	{
		internal static void LogCarry(string message)
		{
			Plugin.Log.LogDebug((object)("[BuddyClimb carry] " + message));
		}

		internal static string Describe(Character? character)
		{
			if ((Object)(object)character == (Object)null)
			{
				return "<null character>";
			}
			Character character2 = character.data?.carrier;
			Character character3 = character.data?.carriedPlayer;
			CharacterData data = character.data;
			string text = (((Object)(object)((data != null) ? data.currentItem : null) != (Object)null) ? ((object)character.data.currentItem).GetType().Name : "none");
			string[] obj = new string[17]
			{
				GetName(character),
				$" charView={GetCharacterViewId(character)}",
				$" playerView={GetPlayerViewId(character)}",
				$" isLocal={character.IsLocal}",
				$" isBot={character.isBot}",
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null
			};
			CharacterData data2 = character.data;
			obj[5] = $" dead={((data2 != null) ? new bool?(data2.dead) : ((bool?)null))}";
			obj[6] = $" passedOut={character.data?.passedOut}";
			obj[7] = $" fullyPassedOut={character.data?.fullyPassedOut}";
			obj[8] = $" isCarried={character.data?.isCarried}";
			obj[9] = " carrier=";
			obj[10] = GetName(character2);
			obj[11] = " carriedPlayer=";
			obj[12] = GetName(character3);
			CharacterData data3 = character.data;
			obj[13] = $" isCarryingCharacter={((data3 != null) ? new bool?(data3.IsCarryingCharacter) : ((bool?)null))}";
			obj[14] = $" hasBackpack={HasBackpack(character)}";
			obj[15] = " currentItem=";
			obj[16] = text;
			return string.Concat(obj);
		}

		internal static string DescribeViews(Character? carrier, Character? carried)
		{
			return "carrier=[" + Describe(carrier) + "], carried=[" + Describe(carried) + "]";
		}

		private static string GetName(Character? character)
		{
			if ((Object)(object)character == (Object)null)
			{
				return "null";
			}
			return $"{character.characterName ?? ((Object)character).name}#{GetCharacterViewId(character)}";
		}

		private static int GetCharacterViewId(Character? character)
		{
			if (!((Object)(object)((character != null) ? ((MonoBehaviourPun)character).photonView : null) != (Object)null))
			{
				return -1;
			}
			return ((MonoBehaviourPun)character).photonView.ViewID;
		}

		private static int GetPlayerViewId(Character? character)
		{
			object obj;
			if (character == null)
			{
				obj = null;
			}
			else
			{
				Player player = character.player;
				obj = ((player != null) ? ((MonoBehaviourPun)player).photonView : null);
			}
			if (!((Object)obj != (Object)null))
			{
				return -1;
			}
			return ((MonoBehaviourPun)character.player).photonView.ViewID;
		}

		private static bool HasBackpack(Character? character)
		{
			if ((Object)(object)character != (Object)null && (Object)(object)character.player != (Object)null)
			{
				return !((ItemSlot)character.player.backpackSlot).IsEmpty();
			}
			return false;
		}
	}
	internal static class BuddyClimbRemotePassOutSync
	{
		private static readonly HashSet<int> RemotePassOutViewIds = new HashSet<int>();

		internal static void PrepareRemoteCarryStart(Character carried)
		{
			if (!CanSyncLocalConsciousCharacter(carried))
			{
				BuddyClimbDiagnostics.LogCarry("Skipping remote-only pass-out sync before carry start: " + BuddyClimbDiagnostics.Describe(carried));
				return;
			}
			int viewID = ((MonoBehaviourPun)carried).photonView.ViewID;
			RemotePassOutViewIds.Add(viewID);
			BuddyClimbDiagnostics.LogCarry("Sending remote-only RPCA_PassOut before carry start: " + BuddyClimbDiagnostics.Describe(carried));
			((MonoBehaviourPun)carried).photonView.RPC("RPCA_PassOut", (RpcTarget)1, Array.Empty<object>());
		}

		internal static void RestoreRemoteCarryDrop(Character carried, string reason)
		{
			if ((Object)(object)((carried != null) ? ((MonoBehaviourPun)carried).photonView : null) == (Object)null)
			{
				return;
			}
			int viewID = ((MonoBehaviourPun)carried).photonView.ViewID;
			if (RemotePassOutViewIds.Contains(viewID))
			{
				if (!CanSyncLocalConsciousCharacter(carried))
				{
					BuddyClimbDiagnostics.LogCarry("Skipping remote-only un-pass-out sync for " + reason + ": " + BuddyClimbDiagnostics.Describe(carried));
					return;
				}
				BuddyClimbDiagnostics.LogCarry("Sending remote-only RPCA_UnPassOut for " + reason + ": " + BuddyClimbDiagnostics.Describe(carried));
				((MonoBehaviourPun)carried).photonView.RPC("RPCA_UnPassOut", (RpcTarget)1, Array.Empty<object>());
				RemotePassOutViewIds.Remove(viewID);
			}
		}

		private static bool CanSyncLocalConsciousCharacter(Character character)
		{
			if ((Object)(object)character != (Object)null && character.IsLocal && (Object)(object)((MonoBehaviourPun)character).photonView != (Object)null && (Object)(object)character.data != (Object)null && !character.data.dead && !character.data.passedOut)
			{
				return !character.data.fullyPassedOut;
			}
			return false;
		}
	}
	internal static class CarriedBackpackVisuals
	{
		private static readonly byte BackpackSlotIndex = 3;

		private static readonly MethodInfo HideRenderersMethod = AccessTools.Method(typeof(Item), "HideRenderers", (Type[])null, (Type[])null);

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

		internal static void Update(CharacterBackpackHandler handler)
		{
			if ((Object)(object)handler == (Object)null || (Object)(object)handler.character == (Object)null || (Object)(object)((MonoBehaviourPun)handler.character).photonView == (Object)null)
			{
				return;
			}
			Character character = handler.character;
			int viewID = ((MonoBehaviourPun)character).photonView.ViewID;
			if (ShouldForceBackpackItemRender(character))
			{
				bool flag = ForcedVisibleItemCharacterViewIds.Contains(viewID);
				if (ShowBackpackItems(handler, !flag))
				{
					ForcedVisibleItemCharacterViewIds.Add(viewID);
				}
			}
			else if (ForcedVisibleItemCharacterViewIds.Remove(viewID))
			{
				HideBackpackItems(handler);
			}
		}

		internal static void ShowIfCarriedLocalBackpackItem(Item item, BackpackReference backpackReference)
		{
			if (!((Object)(object)item == (Object)null) && ((BackpackReference)(ref backpackReference)).IsOnMyBack())
			{
				Character localCharacter = Character.localCharacter;
				if (ShouldForceBackpackItemRender(localCharacter))
				{
					ShowItem(item);
				}
			}
		}

		internal static void HideIfForcedVisible(Character character)
		{
			if (!((Object)(object)character == (Object)null) && !((Object)(object)((MonoBehaviourPun)character).photonView == (Object)null) && ForcedVisibleItemCharacterViewIds.Remove(((MonoBehaviourPun)character).photonView.ViewID))
			{
				CharacterBackpackHandler component = ((Component)character).GetComponent<CharacterBackpackHandler>();
				if ((Object)(object)component != (Object)null)
				{
					HideBackpackItems(component);
				}
			}
		}

		private static bool ShouldForceBackpackItemRender(Character character)
		{
			if ((Object)(object)character != (Object)null && character.IsLocal && (Object)(object)character.data != (Object)null && character.data.isCarried && !character.data.dead && !character.data.fullyPassedOut && MainCameraMovement.IsSpectating && (Object)(object)MainCameraMovement.specCharacter == (Object)(object)character && HasOnBackBackpack(character))
			{
				return CharacterCarryingPatch.IsBuddyClimbCarried(character);
			}
			return false;
		}

		private static bool ShowBackpackItems(CharacterBackpackHandler handler, bool refreshItems)
		{
			if (!HasOnBackBackpack(handler.character))
			{
				return false;
			}
			if (!refreshItems)
			{
				return true;
			}
			BackpackOnBackVisuals backpackVisuals = handler.backpackVisuals;
			if ((Object)(object)backpackVisuals == (Object)null)
			{
				return false;
			}
			((BackpackVisuals)backpackVisuals).RefreshVisuals();
			SetSpawnedItemsVisible(backpackVisuals, visible: true);
			return true;
		}

		private static void HideBackpackItems(CharacterBackpackHandler handler)
		{
			SetSpawnedItemsVisible(handler.backpackVisuals, visible: false);
		}

		private static void SetSpawnedItemsVisible(BackpackOnBackVisuals backpackVisuals, bool visible)
		{
			if ((Object)(object)backpackVisuals == (Object)null)
			{
				return;
			}
			BackpackData backpackData = ((BackpackVisuals)backpackVisuals).GetBackpackData();
			if (backpackData?.itemSlots == null)
			{
				return;
			}
			Item val2 = default(Item);
			for (byte b = 0; b < backpackData.itemSlots.Length; b++)
			{
				ItemSlot val = backpackData.itemSlots[b];
				if (val != null && !val.IsEmpty() && ((BackpackVisuals)backpackVisuals).TryGetSpawnedItem(b, ref val2) && !((Object)(object)val2 == (Object)null))
				{
					if (visible)
					{
						ShowItem(val2);
					}
					else
					{
						HideItem(val2);
					}
				}
			}
		}

		private static bool HasOnBackBackpack(Character character)
		{
			if ((Object)(object)character != (Object)null && (Object)(object)character.player != (Object)null && !((ItemSlot)character.player.backpackSlot).IsEmpty())
			{
				return !IsBackpackSlotSelected(character);
			}
			return false;
		}

		private static bool IsBackpackSlotSelected(Character character)
		{
			CharacterItems items = character.refs.items;
			if ((Object)(object)items != (Object)null && items.currentSelectedSlot.IsSome)
			{
				return items.currentSelectedSlot.Value == BackpackSlotIndex;
			}
			return false;
		}

		private static void ShowItem(Item item)
		{
			Renderer[] componentsInChildren = ((Component)item).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				val.enabled = true;
			}
		}

		private static void HideItem(Item item)
		{
			HideRenderersMethod.Invoke(item, null);
		}
	}
	internal static class CarriedPlayerDropper
	{
		private static int dropInputConsumedFrame = -1;

		internal static void Update()
		{
			if (dropInputConsumedFrame != Time.frameCount && Input.GetKeyDown((KeyCode)32))
			{
				TryDropLocalPlayer(Character.localCharacter);
			}
		}

		internal static bool HandleJumpAttempt(Character character)
		{
			if ((Object)(object)character == (Object)null || !character.IsLocal)
			{
				return false;
			}
			if (dropInputConsumedFrame == Time.frameCount)
			{
				ClearJumpInput(character);
				return true;
			}
			return TryDropLocalPlayer(character);
		}

		private static bool TryDropLocalPlayer(Character localCharacter)
		{
			if (!CanRequestDrop(localCharacter))
			{
				return false;
			}
			CharacterCarrying carriying = localCharacter.data.carrier.refs.carriying;
			if ((Object)(object)carriying == (Object)null)
			{
				return false;
			}
			ClearJumpInput(localCharacter);
			BuddyClimbRemotePassOutSync.RestoreRemoteCarryDrop(localCharacter, "local Space drop request");
			carriying.Drop(localCharacter);
			ClearJumpInput(localCharacter);
			dropInputConsumedFrame = Time.frameCount;
			return true;
		}

		private static bool CanRequestDrop(Character character)
		{
			if ((Object)(object)character != (Object)null && character.data.isCarried && (Object)(object)character.data.carrier != (Object)null && !character.data.dead && !character.data.passedOut && !character.data.fullyPassedOut)
			{
				return CharacterCarryingPatch.IsBuddyClimbCarried(character);
			}
			return false;
		}

		private static void ClearJumpInput(Character character)
		{
			if (!((Object)(object)character.input == (Object)null))
			{
				character.input.jumpWasPressed = false;
				character.input.jumpIsPressed = false;
			}
		}
	}
	internal static class CarryInteractionProxy
	{
		private const string ProxyName = "BuddyClimbInteractionProxy";

		private const float ProxyRadius = 0.75f;

		internal static void Enable(Character character)
		{
			//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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)character == (Object)null)
			{
				return;
			}
			Transform proxyParent = GetProxyParent(character);
			if (!((Object)(object)proxyParent == (Object)null))
			{
				Transform val = proxyParent.Find("BuddyClimbInteractionProxy");
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).gameObject.SetActive(true);
					return;
				}
				GameObject val2 = new GameObject("BuddyClimbInteractionProxy");
				val2.transform.SetParent(proxyParent, false);
				val2.transform.localPosition = Vector3.zero;
				val2.transform.localRotation = Quaternion.identity;
				val2.transform.localScale = Vector3.one;
				int num = LayerMask.NameToLayer("Character");
				val2.layer = ((num >= 0) ? num : ((Component)character).gameObject.layer);
				SphereCollider val3 = val2.AddComponent<SphereCollider>();
				((Collider)val3).isTrigger = true;
				val3.radius = 0.75f;
			}
		}

		internal static void Disable(Character character)
		{
			if (!((Object)(object)character == (Object)null))
			{
				Transform proxyParent = GetProxyParent(character);
				Transform val = proxyParent.Find("BuddyClimbInteractionProxy");
				if (val != null)
				{
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
		}

		private static Transform GetProxyParent(Character character)
		{
			Bodypart bodypart = character.GetBodypart((BodypartType)2);
			if ((Object)(object)bodypart != (Object)null)
			{
				return bodypart.transform;
			}
			return ((Component)character).transform;
		}
	}
}
namespace BuddyClimb.Configuration
{
	internal static class BuddyClimbConfig
	{
		private const int HotReloadDebounceMilliseconds = 250;

		private static readonly object HotReloadLock = new object();

		private static FileSystemWatcher? configWatcher;

		private static ConfigFile? configFile;

		private static Timer? reloadTimer;

		internal static ConfigEntry<bool> EnableBackpackTransfer { get; private set; } = null;

		internal static void Bind(ConfigFile config)
		{
			EnableBackpackTransfer = config.Bind<bool>("Backpack", "EnableBackpackTransfer", false, "Allow climbing onto players who are wearing a backpack. When enabled, the carrier's backpack is moved to the carried player; if the carried player already has a backpack, their old backpack is dropped first.");
		}

		internal static void EnableHotReload(ConfigFile config)
		{
			DisableHotReload();
			configFile = config;
			string directoryName = Path.GetDirectoryName(config.ConfigFilePath);
			string fileName = Path.GetFileName(config.ConfigFilePath);
			if (string.IsNullOrEmpty(directoryName) || string.IsNullOrEmpty(fileName) || !Directory.Exists(directoryName))
			{
				Plugin.Log.LogWarning((object)("Config hot reload is disabled because the config directory is unavailable: " + config.ConfigFilePath));
				return;
			}
			reloadTimer = new Timer(ReloadConfigFromTimer);
			configWatcher = new FileSystemWatcher(directoryName, fileName)
			{
				IncludeSubdirectories = false,
				NotifyFilter = (NotifyFilters.FileName | NotifyFilters.Size | NotifyFilters.LastWrite | NotifyFilters.CreationTime)
			};
			configWatcher.Changed += OnConfigFileChanged;
			configWatcher.Created += OnConfigFileChanged;
			configWatcher.Renamed += OnConfigFileChanged;
			configWatcher.EnableRaisingEvents = true;
		}

		internal static void DisableHotReload()
		{
			if (configWatcher != null)
			{
				configWatcher.EnableRaisingEvents = false;
				configWatcher.Changed -= OnConfigFileChanged;
				configWatcher.Created -= OnConfigFileChanged;
				configWatcher.Renamed -= OnConfigFileChanged;
				configWatcher.Dispose();
				configWatcher = null;
			}
			lock (HotReloadLock)
			{
				reloadTimer?.Dispose();
				reloadTimer = null;
				configFile = null;
			}
		}

		private static void OnConfigFileChanged(object sender, FileSystemEventArgs args)
		{
			lock (HotReloadLock)
			{
				reloadTimer?.Change(250, -1);
			}
		}

		private static void ReloadConfigFromTimer(object? state)
		{
			ConfigFile val;
			lock (HotReloadLock)
			{
				val = configFile;
			}
			if (val == null)
			{
				return;
			}
			try
			{
				val.Reload();
				Plugin.Log.LogInfo((object)"Reloaded BuddyClimb config from disk.");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Failed to reload BuddyClimb config: " + ex.Message));
			}
		}
	}
}
namespace BuddyClimb.Compatibility
{
	internal static class ModCompatibility
	{
		internal const string PiggybackPluginId = "nakazora.peak.piggyback";

		internal static bool IsPiggybackLoaded => Chainloader.PluginInfos.ContainsKey("nakazora.peak.piggyback");
	}
}
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
	{
	}
}