using System;
using System.CodeDom.Compiler;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using CellMenu;
using GameData;
using HarmonyLib;
using Il2CppSystem.Collections.Generic;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("FixedRundownExtension")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("FixedRundownExtension")]
[assembly: AssemblyTitle("FixedRundownExtension")]
[assembly: TargetPlatform("Windows7.0")]
[assembly: SupportedOSPlatform("Windows7.0")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace FixedRundownExtension
{
	[BepInPlugin("FixedRundownExtension.GUID", "FixedRundownExtension", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	internal class EntryPoint : BasePlugin
	{
		private Harmony _Harmony = null;

		public override void Load()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			_Harmony = new Harmony("FixedRundownExtension.Harmony");
			_Harmony.PatchAll();
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(32, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Plugin has loaded with ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(_Harmony.GetPatchedMethods().Count());
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" patches!");
			}
			Logger.Info(val);
		}

		public override bool Unload()
		{
			_Harmony.UnpatchSelf();
			return ((BasePlugin)this).Unload();
		}
	}
	[HarmonyPatch]
	internal class Patches
	{
		[HarmonyPatch(typeof(CM_PageRundown_New), "_Setup_b__102_3")]
		[HarmonyPrefix]
		public static void SelectRundownButtonClickPrefix(CM_PageRundown_New __instance, int id)
		{
			ClearExtIcons(__instance);
		}

		[HarmonyPatch(typeof(CM_PageRundown_New), "PlaceRundown")]
		[HarmonyPrefix]
		public static void PlaceRundownPrefix(CM_PageRundown_New __instance, RundownDataBlock data)
		{
			ClearExtIcons(__instance);
		}

		public static void ClearExtIcons(CM_PageRundown_New __instance)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			if (__instance.m_expIconsTierExt == null)
			{
				return;
			}
			Enumerator<CM_ExpeditionIcon_New> enumerator = __instance.m_expIconsTierExt.GetEnumerator();
			bool flag = default(bool);
			while (enumerator.MoveNext())
			{
				CM_ExpeditionIcon_New current = enumerator.Current;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(11, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Destroying ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(current.FullName);
				}
				Logger.Warn(val);
				Object.Destroy((Object)(object)((Component)current).gameObject);
			}
			__instance.m_expIconsTierExt.Clear();
		}
	}
	internal static class Logger
	{
		private static readonly ManualLogSource _Logger;

		static Logger()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			_Logger = new ManualLogSource("FixedRundownExtension");
			Logger.Sources.Add((ILogSource)(object)_Logger);
		}

		private static string Format(object msg)
		{
			return msg.ToString();
		}

		public static void Info(BepInExInfoLogInterpolatedStringHandler handler)
		{
			_Logger.LogInfo(handler);
		}

		public static void Info(string str)
		{
			_Logger.LogMessage((object)str);
		}

		public static void Info(object data)
		{
			_Logger.LogMessage((object)Format(data));
		}

		public static void Debug(BepInExDebugLogInterpolatedStringHandler handler)
		{
			_Logger.LogDebug(handler);
		}

		public static void Debug(string str)
		{
			_Logger.LogDebug((object)str);
		}

		public static void Debug(object data)
		{
			_Logger.LogDebug((object)Format(data));
		}

		public static void Error(BepInExErrorLogInterpolatedStringHandler handler)
		{
			_Logger.LogError(handler);
		}

		public static void Error(string str)
		{
			_Logger.LogError((object)str);
		}

		public static void Error(object data)
		{
			_Logger.LogError((object)Format(data));
		}

		public static void Fatal(BepInExFatalLogInterpolatedStringHandler handler)
		{
			_Logger.LogFatal(handler);
		}

		public static void Fatal(string str)
		{
			_Logger.LogFatal((object)str);
		}

		public static void Fatal(object data)
		{
			_Logger.LogFatal((object)Format(data));
		}

		public static void Warn(BepInExWarningLogInterpolatedStringHandler handler)
		{
			_Logger.LogWarning(handler);
		}

		public static void Warn(string str)
		{
			_Logger.LogWarning((object)str);
		}

		public static void Warn(object data)
		{
			_Logger.LogWarning((object)Format(data));
		}

		[Conditional("DEBUG")]
		public static void DebugOnly(object data)
		{
			_Logger.LogDebug((object)Format(data));
		}
	}
	[GeneratedCode("VersionInfoGenerator", "2.1.3+git35c0c2a-master")]
	[CompilerGenerated]
	internal static class VersionInfo
	{
		public const string RootNamespace = "FixedRundownExtension";

		public const string Version = "1.0.0";

		public const string VersionPrerelease = null;

		public const string VersionMetadata = null;

		public const string SemVer = "1.0.0";

		public const string GitRevShort = null;

		public const string GitRevLong = null;

		public const string GitBranch = null;

		public const string GitTag = null;

		public const int GitCommitsSinceTag = 0;

		public const bool GitIsDirty = false;
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using AK;
using BepInEx;
using BepInEx.Unity.IL2CPP;
using CellMenu;
using GTFO.API;
using GameData;
using Gear;
using HarmonyLib;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using LevelGeneration;
using Localization;
using Microsoft.CodeAnalysis;
using Player;
using QuixoticPlugin.Modules.LevelBehavior;
using TMPro;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("QuixoticPlugin")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("QuixoticPlugin")]
[assembly: AssemblyTitle("QuixoticPlugin")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace QuixoticPlugin
{
	[BepInPlugin("Amor.QTP", "QuixoticPlugin", "1.0.4")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	internal class EntryPoint : BasePlugin
	{
		public override void Load()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			new Harmony("Amor.QTP").PatchAll();
			LevelAPI.OnEnterLevel += C3_SelectHSUActivatorCore.OnEnterLevel;
			((BasePlugin)this).Log.LogMessage((object)"QuixoticPlugin is now loaded!");
		}
	}
}
namespace QuixoticPlugin.Modules.Patches
{
	[HarmonyPatch]
	internal static class FixChainedObjectiveAlarmOnLand
	{
		[HarmonyPatch(typeof(ElevatorShaftLanding), "OnBuildDone")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void PostBuildDone(ElevatorShaftLanding __instance)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if (MainLayerHasChainedObjectiveWithAlarm(out WardenObjectiveDataBlock mainObjDB))
			{
				__instance.m_sound.Post(EVENTS.ALARM_AMBIENT_LOOP, true);
				__instance.m_sound.SetRTPCValue(GAME_PARAMETERS.ALARM_AMBIENT_MIX, 100f);
				if (!string.IsNullOrEmpty(LocalizedText.op_Implicit(mainObjDB.WaveOnElevatorWardenIntel)))
				{
					GuiManager.PlayerLayer.m_wardenIntel.ShowSubObjectiveMessage(string.Empty, LocalizedText.op_Implicit(mainObjDB.WaveOnElevatorWardenIntel), false, 200f, 8f, (Action)null);
				}
			}
		}

		private static bool MainLayerHasChainedObjectiveWithAlarm([NotNullWhen(true)] out WardenObjectiveDataBlock? mainObjDB)
		{
			if (RundownManager.Current.m_activeExpedition.MainLayerData.ChainedObjectiveData.Count == 0)
			{
				mainObjDB = null;
				return false;
			}
			mainObjDB = WardenObjectiveManager.Current.m_activeWardenObjectives[(LG_LayerType)0];
			return WardenObjectiveManager.HasValidWaveSettings(mainObjDB.WavesOnElevatorLand) && WardenObjectiveManager.WaveSettingsHasAlarm(mainObjDB.WavesOnElevatorLand);
		}
	}
	[HarmonyPatch]
	internal static class FixLevelButtonCollider
	{
		[HarmonyPatch(typeof(CM_PageRundown_New), "Update")]
		[HarmonyPostfix]
		private static void FixThroughClicks(CM_PageRundown_New __instance)
		{
			Transform child = ((Component)__instance.m_popupMovement).transform.GetChild(0);
			bool flag = child != null && ((Component)child).gameObject.active;
			Enumerator<CM_ExpeditionIcon_New> enumerator = __instance.m_expIconsAll.GetEnumerator();
			while (enumerator.MoveNext())
			{
				CM_ExpeditionIcon_New current = enumerator.Current;
				((Behaviour)((CM_Item)current).m_collider).enabled = !flag;
			}
		}
	}
	[HarmonyPatch]
	internal static class FixMultipleBPUDistribution
	{
		private static int _seed;

		[HarmonyPatch(typeof(RundownManager), "SetActiveExpedition")]
		[HarmonyPostfix]
		private static void SetActiveExp()
		{
			_seed = RundownManager.GetActiveExpeditionData().sessionSeed;
		}

		[HarmonyPatch(typeof(LG_PickupItem), "SetupAsBigPickupItem", new Type[]
		{
			typeof(int),
			typeof(BigPickupDistributionDataBlock),
			typeof(bool),
			typeof(int)
		})]
		[HarmonyPrefix]
		private static bool SpawnPatch(LG_PickupItem __instance, ref BigPickupDistributionDataBlock data, ref bool isWardenObjectiveItem, ref int objectiveChainIndex)
		{
			__instance.SetupCommon();
			uint itemID = data.SpawnData[_seed % data.SpawnsPerZone].ItemID;
			__instance.SetupBigPickupItemWithItemId(itemID, isWardenObjectiveItem, objectiveChainIndex);
			Debug.Log(Object.op_Implicit(Deb.Purple($"SetupAsBigPickupItem, spawning item with id: {itemID}, isWardenObjectiveItem: {isWardenObjectiveItem}", 0f)));
			_seed++;
			return false;
		}
	}
	[HarmonyPatch]
	internal static class RemoveArtifactHeat
	{
		private static readonly Vector3 _space = new Vector3(99999f, 99999f, 99999f);

		[HarmonyPatch(typeof(CM_ExpeditionIcon_New), "SetArtifactHeat")]
		[HarmonyPostfix]
		private static void HideRundownHeat(CM_ExpeditionIcon_New __instance)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			__instance.HideArtifactHeat();
			__instance.m_statusText.transform.SetPositionAndRotation(__instance.m_artifactHeatText.transform.position, __instance.m_artifactHeatText.transform.rotation);
		}

		[HarmonyPatch(typeof(CM_MenuBar), "SetExpIconArtifactHeat")]
		[HarmonyPrefix]
		private static bool ReplaceMenuBarHeat(CM_MenuBar __instance)
		{
			TextMeshPro publicName = __instance.m_expIcon.m_publicName;
			((Component)publicName).gameObject.SetActive(true);
			((TMP_Text)publicName).autoSizeTextContainer = true;
			((TMP_Text)publicName).fontSizeMax = 60f;
			((TMP_Text)publicName).fontSize = 60f;
			return false;
		}

		[HarmonyPatch(typeof(CM_PageExpeditionSuccess), "OnEnable")]
		[HarmonyPostfix]
		private static void YeetSuccessScreenHeat(CM_PageExpeditionSuccess __instance)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			((Component)__instance.m_ArtifactInventoryDisplay).transform.localPosition = _space;
			__instance.m_artifactInfo_text.transform.localPosition = _space;
		}

		[HarmonyPatch(typeof(CM_PageExpeditionFail), "OnEnable")]
		[HarmonyPostfix]
		private static void YeetDefeatScreenHeat(CM_PageExpeditionFail __instance)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			((Component)__instance.m_ArtifactInventoryDisplay).transform.localPosition = _space;
			__instance.m_artifactInfo_text.transform.localPosition = _space;
		}

		[HarmonyPatch(typeof(CM_ExpeditionWindow), "SetExpeditionInfo")]
		[HarmonyPostfix]
		private static void RundownLevelIntelPopupHeat(CM_ExpeditionWindow __instance)
		{
			((TMP_Text)__instance.m_artifactHeatTitle).text = Text.Get(42u);
		}
	}
}
namespace QuixoticPlugin.Modules.LevelBehavior
{
	internal static class C3_SelectHSUActivatorCore
	{
		internal static void OnEnterLevel()
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Invalid comparison between Unknown and I4
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Invalid comparison between Unknown and I4
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Expected O, but got Unknown
			//IL_0161: Expected O, but got Unknown
			if (RundownManager.Current.m_activeExpedition.LevelLayoutData != 100301)
			{
				return;
			}
			int num = -1;
			foreach (LG_WardenObjective_HSUActivator_Room room in Object.FindObjectsOfType<LG_WardenObjective_HSUActivator_Room>())
			{
				if ((Object)(object)room == (Object)null || (int)room.m_roomArea.m_zone.DimensionIndex != 3 || (int)room.m_roomArea.m_zone.LocalIndex != 2)
				{
					continue;
				}
				List<LG_HSUActivator_Core> list = ((IEnumerable<LG_HSUActivator_Core>)((Component)room).GetComponentsInChildren<LG_HSUActivator_Core>()).OrderByDescending((LG_HSUActivator_Core go) => ((Component)go).transform.position.y).ToList();
				if (list.Any())
				{
					num = 10 + list.FindIndex((LG_HSUActivator_Core core) => ((Component)core).transform.position.y == ((Component)room.m_core).transform.position.y);
				}
			}
			if (num > 9 && num < 13)
			{
				WorldEventManager.ExecuteEvent(new WardenObjectiveEventData
				{
					Type = (eWardenObjectiveEventType)19,
					Delay = 1f,
					Condition = new WorldEventConditionPair
					{
						ConditionIndex = num,
						IsTrue = true
					}
				}, 0f);
			}
		}
	}
	[HarmonyPatch]
	internal static class DX_DeactivateAlarms
	{
		[HarmonyPatch(typeof(LG_ComputerTerminalCommandInterpreter), "DisableAlarmsCommand")]
		[HarmonyPrefix]
		private static bool PersistentTankErrorAlarm(LG_ComputerTerminalCommandInterpreter __instance)
		{
			if (RundownManager.Current.m_activeExpedition.LevelLayoutData != 7810)
			{
				return true;
			}
			__instance.AddOutput((TerminalLineType)3, "Executing alarm-shutdown protocol......<color=orange>don't leave terminal!</color>", 3f, (TerminalSoundType)0, (TerminalSoundType)0);
			__instance.AddOutput((TerminalLineType)0, "Connecting to active alarm systems", 1f, (TerminalSoundType)0, (TerminalSoundType)0);
			__instance.AddOutput((TerminalLineType)0, "Confirming valid terminal ID", 2.4f, (TerminalSoundType)0, (TerminalSoundType)0);
			__instance.AddOutput((TerminalLineType)2, "Shutting down alarms...", 3f, (TerminalSoundType)0, (TerminalSoundType)0);
			ElevatorShaftLanding.StopAmbientAlarm();
			__instance.AddOutput((TerminalLineType)0, "Alarm(s) linked to this terminal successfully shut down.", 0.7f, (TerminalSoundType)0, (TerminalSoundType)0);
			__instance.AddOutput((TerminalLineType)0, "<color=red>://ERROR!</color> High tiered alarm <color=orange><i>CmDx1e4rL1</i></color> failed to deactivate.", 1.4f, (TerminalSoundType)0, (TerminalSoundType)0);
			__instance.OnEndOfQueue += Action.op_Implicit((Action)delegate
			{
				GuiManager.PlayerLayer.m_objectiveTimer.SetTimerActive(false, true);
			});
			return false;
		}
	}
	[HarmonyPatch]
	internal static class FogBeacon
	{
		[HarmonyPatch(typeof(ItemSpawnManager), "SetupItemPrefabs")]
		[HarmonyPostfix]
		private static void ChangeBeaconMaterial(ItemSpawnManager __instance)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			Material loadedAsset = AssetAPI.GetLoadedAsset<Material>("Assets/AmAssets/Ancillary/Items/DefoggerBig_red.mat");
			for (int i = 0; i < 3; i++)
			{
				Dictionary<uint, List<GameObject>> val = ((Il2CppArrayBase<Dictionary<uint, List<GameObject>>>)(object)ItemSpawnManager.m_loadedPrefabsPerItemMode)[i];
				GameObject val2 = Object.Instantiate<GameObject>(val[203u][1]);
				((Renderer)val2.GetComponentInChildren<MeshRenderer>()).sharedMaterial = loadedAsset;
				val2.transform.position = new Vector3(10000f, 10000f, 10000f);
				val[203u][1] = val2;
			}
		}

		[HarmonyPatch(typeof(LG_PickupItem), "SetupBigPickupItemWithItemId")]
		[HarmonyPostfix]
		private static void PickupItemSetup(LG_PickupItem __instance, uint itemId)
		{
			if (itemId == 203)
			{
				SetupAsFogBeacon(__instance);
			}
		}

		private static void SetupAsFogBeacon(LG_PickupItem pickupItem)
		{
			//IL_0022: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Expected O, but got Unknown
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Expected O, but got Unknown
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			float pickupTime = 1.9f;
			float placeTime = 1.5f;
			FogRepeller_Sphere val = new GameObject("FogInstance_Beacon_Fake").AddComponent<FogRepeller_Sphere>();
			val.InfiniteDuration = false;
			val.LifeDuration = float.MaxValue;
			val.GrowDuration = float.MaxValue;
			val.ShrinkDuration = float.MaxValue;
			val.Range = 1f;
			FogRepeller_Sphere beaconHeld = new GameObject("FogInstance_Beacon_SmallLayer").AddComponent<FogRepeller_Sphere>();
			beaconHeld.InfiniteDuration = true;
			beaconHeld.GrowDuration = 5f;
			beaconHeld.ShrinkDuration = 16f;
			beaconHeld.Range = 5f;
			beaconHeld.Offset = Vector3.zero;
			FogRepeller_Sphere beaconPlaced = new GameObject("FogInstance_Beacon_BigLayer").AddComponent<FogRepeller_Sphere>();
			beaconPlaced.InfiniteDuration = true;
			beaconPlaced.GrowDuration = 4f;
			beaconPlaced.ShrinkDuration = 12f;
			beaconPlaced.Range = 12f;
			beaconPlaced.Offset = Vector3.zero;
			PlaceNavMarkerOnGO componentInChildren = ((Component)pickupItem.m_root).GetComponentInChildren<PlaceNavMarkerOnGO>();
			componentInChildren.UpdatePlayerColor(new Color(1f, 0.5f, 0f));
			CarryItemPickup_Core componentInChildren2 = ((Component)pickupItem.m_root).GetComponentInChildren<CarryItemPickup_Core>();
			HeavyFogRepellerPickup val2 = ((Il2CppObjectBase)componentInChildren2).Cast<HeavyFogRepellerPickup>();
			iCarryItemWithGlobalState val3 = default(iCarryItemWithGlobalState);
			byte byteId = default(byte);
			if (CarryItemWithGlobalStateManager.TryCreateItemInstance((eCarryItemWithGlobalStateType)0, pickupItem.m_root, ref val3, ref byteId))
			{
				pItemData_Custom customData = ((Item)val2).GetCustomData();
				customData.byteId = byteId;
				pItemData_Custom val4 = customData;
				((Item)val2).SetCustomData(val4, true);
			}
			HeavyFogRepellerGlobalState val5 = ((Il2CppObjectBase)val3).Cast<HeavyFogRepellerGlobalState>();
			((Component)beaconHeld).transform.SetParent(((Component)val5).transform, false);
			((Component)beaconPlaced).transform.SetParent(((Component)val5).transform, false);
			val5.m_repellerSphere = val;
			beaconHeld.m_sphereAllocator = new FogSphereAllocator();
			beaconPlaced.m_sphereAllocator = new FogSphereAllocator();
			Interact_Pickup_PickupItem interact = ((Il2CppObjectBase)componentInChildren2.m_interact).Cast<Interact_Pickup_PickupItem>();
			((Interact_Timed)interact).InteractDuration = pickupTime;
			val5.CallbackOnStateChange += Action<pCarryItemWithGlobalState_State, pCarryItemWithGlobalState_State, bool>.op_Implicit((Action<pCarryItemWithGlobalState_State, pCarryItemWithGlobalState_State, bool>)delegate(pCarryItemWithGlobalState_State oldState, pCarryItemWithGlobalState_State newState, bool isRecall)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: 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_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Invalid comparison between Unknown and I4
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Invalid comparison between Unknown and I4
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				if (isRecall)
				{
					FogRepeller_Sphere obj = beaconHeld;
					if (obj != null)
					{
						obj.KillRepellerInstantly();
					}
					FogRepeller_Sphere obj2 = beaconPlaced;
					if (obj2 != null)
					{
						obj2.KillRepellerInstantly();
					}
				}
				else
				{
					eHeavyFogRepellerStatus val6 = (eHeavyFogRepellerStatus)newState.status;
					eHeavyFogRepellerStatus val7 = val6;
					if ((int)val7 != 1)
					{
						if ((int)val7 == 2)
						{
							FogRepeller_Sphere obj3 = beaconHeld;
							if (obj3 != null)
							{
								obj3.StopRepelling();
							}
							FogRepeller_Sphere obj4 = beaconPlaced;
							if (obj4 != null)
							{
								obj4.StartRepelling();
							}
							((Interact_Timed)interact).InteractDuration = pickupTime;
						}
					}
					else
					{
						FogRepeller_Sphere obj5 = beaconHeld;
						if (obj5 != null)
						{
							obj5.StartRepelling();
						}
						if (oldState.status != 0)
						{
							FogRepeller_Sphere obj6 = beaconPlaced;
							if (obj6 != null)
							{
								obj6.StopRepelling();
							}
						}
						((Interact_Timed)interact).InteractDuration = placeTime;
					}
				}
			});
		}
	}
}