using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using FishNet;
using FishNet.Managing;
using FishNet.Managing.Object;
using FishNet.Object;
using Flatline;
using HarmonyLib;
using MelonLoader;
using MelonLoader.Preferences;
using MelonLoader.Utils;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using ScheduleOne;
using ScheduleOne.Audio;
using ScheduleOne.AvatarFramework;
using ScheduleOne.Building.Doors;
using ScheduleOne.Combat;
using ScheduleOne.DevUtilities;
using ScheduleOne.Dialogue;
using ScheduleOne.Doors;
using ScheduleOne.EntityFramework;
using ScheduleOne.Equipping;
using ScheduleOne.FX;
using ScheduleOne.GameTime;
using ScheduleOne.Interaction;
using ScheduleOne.ItemFramework;
using ScheduleOne.Map;
using ScheduleOne.Money;
using ScheduleOne.NPCs;
using ScheduleOne.NPCs.CharacterClasses;
using ScheduleOne.ObjectScripts;
using ScheduleOne.Persistence;
using ScheduleOne.PlayerScripts;
using ScheduleOne.PlayerScripts.Health;
using ScheduleOne.Product;
using ScheduleOne.Property;
using ScheduleOne.Temperature;
using ScheduleOne.UI;
using ScheduleOne.UI.MainMenu;
using ScheduleOne.UI.Phone;
using ScheduleOne.UI.Phone.Messages;
using ScheduleOne.VoiceOver;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(global::Flatline.Flatline), "Flatline", "1.0.0", "XOWithSauce", "https://github.com/XOWithSauce/schedule-flatline")]
[assembly: MelonColor]
[assembly: MelonOptionalDependencies(new string[] { "FishNet.Runtime" })]
[assembly: MelonGame("TVGS", "Schedule I")]
[assembly: MelonPlatformDomain(/*Could not decode attribute arguments.*/)]
[assembly: VerifyLoaderVersion("0.7.0", true)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("XOWithSauce")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright XOWithSauce 2026 Source MIT")]
[assembly: AssemblyDescription("Schedule I Flatline Mod")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("Flatline")]
[assembly: AssemblyTitle("Flatline")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/XOWithSauce/schedule-flatline")]
[assembly: NeutralResourcesLanguage("en-US")]
[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 Flatline
{
	public static class BedRotSimulator
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass6_0
		{
			public NetworkManager instance;

			internal bool <InitBedRotModule>b__1()
			{
				return instance.Initialized;
			}
		}

		[CompilerGenerated]
		private sealed class <BedRotSimulatorRunner>d__12 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public InteractableObject intObj;

			public Bed bed;

			private Transform <playerTrRoot>5__2;

			private Vector3 <originalStandPoint>5__3;

			private Quaternion <originalRotation>5__4;

			private Vector3 <targetLocalPosition>5__5;

			private Quaternion <targetRotation>5__6;

			private float <animationDuration>5__7;

			private float <elapsed>5__8;

			private float <maxY>5__9;

			private Quaternion <currentRotation>5__10;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00bb: 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_00cc: 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_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0100: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Unknown result type (might be due to invalid IL or missing references)
				//IL_0209: Unknown result type (might be due to invalid IL or missing references)
				//IL_020f: Unknown result type (might be due to invalid IL or missing references)
				//IL_022d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0233: Unknown result type (might be due to invalid IL or missing references)
				//IL_023d: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0351: Unknown result type (might be due to invalid IL or missing references)
				//IL_0362: Unknown result type (might be due to invalid IL or missing references)
				//IL_0137: Unknown result type (might be due to invalid IL or missing references)
				//IL_013d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0143: Unknown result type (might be due to invalid IL or missing references)
				//IL_0154: Unknown result type (might be due to invalid IL or missing references)
				//IL_015a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0160: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					((Behaviour)intObj).enabled = false;
					((Behaviour)bed.intObj).enabled = false;
					Player.Local.CurrentBed = ((NetworkBehaviour)bed).NetworkObject;
					PlayerSingleton<PlayerCamera>.Instance.SetCanLook(false);
					PlayerSingleton<PlayerMovement>.Instance.CanMove = false;
					((Behaviour)PlayerSingleton<PlayerMovement>.Instance).enabled = false;
					((Collider)Player.Local.CapCol).enabled = false;
					<playerTrRoot>5__2 = ((Component)Player.Local).transform.root;
					<playerTrRoot>5__2.parent = ((Component)bed).transform;
					<originalStandPoint>5__3 = <playerTrRoot>5__2.localPosition;
					<originalRotation>5__4 = <playerTrRoot>5__2.localRotation;
					<targetLocalPosition>5__5 = new Vector3(0.009f, 0.23f, 0.012f);
					<targetRotation>5__6 = Quaternion.Euler(270f, 0f, 0f);
					<animationDuration>5__7 = 3f;
					<elapsed>5__8 = 0f;
					goto IL_0193;
				case 1:
					<>1__state = -1;
					goto IL_0193;
				case 2:
					<>1__state = -1;
					if (Quaternion.Angle(<playerTrRoot>5__2.localRotation, <targetRotation>5__6) > <maxY>5__9)
					{
						<playerTrRoot>5__2.localRotation = Quaternion.Slerp(<playerTrRoot>5__2.localRotation, <targetRotation>5__6, 0.05f);
					}
					if ((PlayerSingleton<Phone>.Instance.IsOpen || (!Input.GetKey((KeyCode)32) && !Input.GetKey((KeyCode)119) && !Input.GetKey((KeyCode)97) && !Input.GetKey((KeyCode)115) && !Input.GetKey((KeyCode)100))) && !FlatlinePlayer.isPassedOut && !FlatlinePlayer.isQueuedForDeath)
					{
						goto IL_028e;
					}
					goto IL_0298;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_028e:
					if (Flatline.registered)
					{
						<>2__current = Flatline.WaitFrame;
						<>1__state = 2;
						return true;
					}
					goto IL_0298;
					IL_0193:
					if (<elapsed>5__8 < <animationDuration>5__7 && Flatline.registered)
					{
						float num = <elapsed>5__8 / <animationDuration>5__7;
						<playerTrRoot>5__2.localPosition = Vector3.Lerp(<originalStandPoint>5__3, <targetLocalPosition>5__5, num);
						<playerTrRoot>5__2.localRotation = Quaternion.Slerp(<originalRotation>5__4, <targetRotation>5__6, num);
						<elapsed>5__8 += Time.deltaTime;
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<playerTrRoot>5__2.localPosition = <targetLocalPosition>5__5;
					<playerTrRoot>5__2.localRotation = <targetRotation>5__6;
					PlayerSingleton<PlayerCamera>.Instance.SetCanLook(true);
					<maxY>5__9 = 20f;
					goto IL_028e;
					IL_0298:
					PlayerSingleton<PlayerCamera>.Instance.SetCanLook(false);
					<elapsed>5__8 = 0f;
					<currentRotation>5__10 = <playerTrRoot>5__2.localRotation;
					break;
				}
				if (<elapsed>5__8 < <animationDuration>5__7 && Flatline.registered)
				{
					float num2 = <elapsed>5__8 / <animationDuration>5__7;
					<playerTrRoot>5__2.localPosition = Vector3.Lerp(<targetLocalPosition>5__5, <originalStandPoint>5__3, num2);
					<playerTrRoot>5__2.localRotation = Quaternion.Slerp(<currentRotation>5__10, <originalRotation>5__4, num2);
					<elapsed>5__8 += Time.deltaTime;
					<>2__current = null;
					<>1__state = 3;
					return true;
				}
				<playerTrRoot>5__2.localPosition = <originalStandPoint>5__3;
				<playerTrRoot>5__2.localRotation = <originalRotation>5__4;
				<playerTrRoot>5__2.parent = null;
				((Collider)Player.Local.CapCol).enabled = true;
				PlayerSingleton<PlayerCamera>.Instance.SetCanLook(true);
				((Behaviour)PlayerSingleton<PlayerMovement>.Instance).enabled = true;
				PlayerSingleton<PlayerMovement>.Instance.CanMove = true;
				((Behaviour)intObj).enabled = true;
				((Behaviour)bed.intObj).enabled = true;
				isBedrotting = false;
				Player.Local.CurrentBed = null;
				AfterBedrotEnd();
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <EvaluateBedState>d__11 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public InteractableObject intObj;

			public Bed bed;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (Player.Local.IsSkating)
					{
						intObj.SetInteractableState((EInteractableState)1);
						intObj.message = "Can't bedrot while skateboarding";
					}
					else if ((Object)(object)bed.AssignedEmployee != (Object)null)
					{
						intObj.SetInteractableState((EInteractableState)1);
						intObj.message = "Can't bedrot in an employee's bed";
					}
					else if (NetworkSingleton<TimeManager>.Instance.IsCurrentTimeWithinRange(359, 700))
					{
						intObj.SetInteractableState((EInteractableState)1);
						intObj.message = "Can't bedrot at late night";
					}
					else if (Player.PlayerList.Count > 1)
					{
						foreach (Player player in Player.PlayerList)
						{
							if ((Object)(object)player.CurrentBed == (Object)(object)((NetworkBehaviour)bed).NetworkObject)
							{
								intObj.SetInteractableState((EInteractableState)1);
								intObj.message = "Someone is already bedrotting here";
							}
						}
					}
					else
					{
						intObj.SetInteractableState((EInteractableState)0);
						intObj.message = "Rot in the bed";
					}
					<>2__current = Flatline.Wait1;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!Flatline.registered)
					{
						return false;
					}
					isEvaluatingBedState = false;
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <InitBedRotModule>d__6 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private <>c__DisplayClass6_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Expected O, but got Unknown
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass6_0();
					WaitUntil val2 = new WaitUntil((Func<bool>)(() => NetworkManager.Instances != null && NetworkManager.Instances.Count > 0));
					<>2__current = val2;
					<>1__state = 1;
					return true;
				}
				case 1:
				{
					<>1__state = -1;
					<>8__1.instance = NetworkManager.Instances.ToList()[0];
					WaitUntil val = new WaitUntil((Func<bool>)(() => <>8__1.instance.Initialized));
					<>2__current = val;
					<>1__state = 2;
					return true;
				}
				case 2:
					<>1__state = -1;
					PrepareBedRotInteractable();
					DebugModule.Log("Bed prefab changed succesfully", "InitBedRotModule");
					isInitialized = true;
					return false;
				}
			}

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

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

		public static bool isBedrotting = false;

		public static bool isInitialized = false;

		public static bool isEvaluatingBedState = false;

		public static readonly float energyRegenPerMinute = FlatlinePlayer.DefaultEnergyConsumption + 0.003f;

		public static readonly float healthRegenPerMinuteTarget = FlatlinePlayer.DefaultHealthRegeneration * 5f;

		public static readonly float healthRegenT = FlatlinePlayer.SystematicHomeostasisSpeed * 10f;

		[IteratorStateMachine(typeof(<InitBedRotModule>d__6))]
		public static IEnumerator InitBedRotModule()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <InitBedRotModule>d__6(0);
		}

		public static void ResetBedRotModule()
		{
			isBedrotting = false;
			isEvaluatingBedState = false;
		}

		public static void PrepareBedRotInteractable()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			PrefabObjects spawnablePrefabs = Object.FindObjectOfType<NetworkManager>(true).SpawnablePrefabs;
			for (int i = 0; i < spawnablePrefabs.GetObjectCount(); i++)
			{
				NetworkObject @object = spawnablePrefabs.GetObject(true, i);
				if (((@object != null) ? ((Object)((Component)@object).gameObject).name : null).Contains("SingleBed"))
				{
					((Component)@object).GetComponent<Bed>();
					GameObject val = new GameObject("BedRotIntObj");
					val.transform.parent = ((Component)@object).transform;
					((Object)val.gameObject).name = "BedRotIntObj";
					val.transform.position = new Vector3(0f, 0.264f, 0.8f);
					BoxCollider val2 = val.AddComponent<BoxCollider>();
					((Collider)val2).isTrigger = true;
					InteractableObject obj = val.AddComponent<InteractableObject>();
					obj.message = "Rot in the bed";
					obj.SetInteractableState((EInteractableState)0);
					val.SetActive(true);
					((Collider)val2).enabled = true;
					((Behaviour)obj).enabled = true;
				}
			}
		}

		public static void BedRotInteracted(InteractableObject intObj, Bed bed)
		{
			if (!isBedrotting)
			{
				isBedrotting = true;
				Flatline.coros.Add(MelonCoroutines.Start(BedRotSimulatorRunner(intObj, bed)));
			}
		}

		public static void BedRotInteractableHovered(InteractableObject intObj, Bed bed)
		{
			if (!isEvaluatingBedState)
			{
				isEvaluatingBedState = true;
				Flatline.coros.Add(MelonCoroutines.Start(EvaluateBedState(intObj, bed)));
			}
		}

		[IteratorStateMachine(typeof(<EvaluateBedState>d__11))]
		public static IEnumerator EvaluateBedState(InteractableObject intObj, Bed bed)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EvaluateBedState>d__11(0)
			{
				intObj = intObj,
				bed = bed
			};
		}

		[IteratorStateMachine(typeof(<BedRotSimulatorRunner>d__12))]
		public static IEnumerator BedRotSimulatorRunner(InteractableObject intObj, Bed bed)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <BedRotSimulatorRunner>d__12(0)
			{
				intObj = intObj,
				bed = bed
			};
		}

		public static void MinPassBedrotting()
		{
			if (!Flatline.registered || Flatline.isSaving || !isBedrotting || FlatlinePlayer.isQueuedForDeath || Flatline.haltExecution)
			{
				return;
			}
			if (Flatline.loadedPlayerData.State.Energy < 1f)
			{
				Flatline.loadedPlayerData.State.Energy = Mathf.Clamp01(Flatline.loadedPlayerData.State.Energy + energyRegenPerMinute);
			}
			if (Flatline.loadedPlayerData.State.healthData.CurrentHP < Flatline.loadedPlayerData.State.healthData.MaxHP)
			{
				if (FlatlinePlayer.HealthRegenPerMinute < healthRegenPerMinuteTarget)
				{
					FlatlinePlayer.HealthRegenPerMinute = Mathf.Lerp(FlatlinePlayer.HealthRegenPerMinute, healthRegenPerMinuteTarget, healthRegenT);
				}
				if (Random.Range(0f, 1f) > 0.9f)
				{
					Player.Local.Health.CurrentHealth = Mathf.Clamp(Player.Local.Health.CurrentHealth + 1f, 0f, Flatline.loadedPlayerData.State.healthData.MaxHP);
					if (Flatline.loadedPlayerData.State.Energy < 1f)
					{
						Mathf.Clamp01(Flatline.loadedPlayerData.State.Energy + energyRegenPerMinute * 8f);
					}
				}
			}
			if (Flatline.loadedPlayerData.State.Hunger < 1f && Flatline.loadedPlayerData.State.Hunger > 0.1f && FlatlinePlayer.FoodConsumptionPerMinute > FlatlinePlayer.DefaultFoodConsumption / 2f)
			{
				FlatlinePlayer.FoodConsumptionPerMinute = Mathf.Lerp(FlatlinePlayer.FoodConsumptionPerMinute, FlatlinePlayer.DefaultFoodConsumption / 2f, FlatlinePlayer.SystematicHomeostasisSpeed * 1.55f);
			}
			if (Flatline.loadedPlayerData.State.Thirst < 1f && Flatline.loadedPlayerData.State.Thirst > 0.1f && FlatlinePlayer.ThirstConsumptionPerMinute > FlatlinePlayer.DefaultThirstConsumption / 2f)
			{
				FlatlinePlayer.ThirstConsumptionPerMinute = Mathf.Lerp(FlatlinePlayer.ThirstConsumptionPerMinute, FlatlinePlayer.DefaultThirstConsumption / 2f, FlatlinePlayer.SystematicHomeostasisSpeed * 1.55f);
			}
		}

		public static void AfterBedrotEnd()
		{
			if (FlatlinePlayer.HealthRegenPerMinute > FlatlinePlayer.DefaultHealthRegeneration)
			{
				FlatlinePlayer.HealthRegenPerMinute = Mathf.Lerp(FlatlinePlayer.HealthRegenPerMinute, FlatlinePlayer.DefaultHealthRegeneration, 0.5f);
			}
			if (FlatlinePlayer.FoodConsumptionPerMinute < FlatlinePlayer.DefaultFoodConsumption)
			{
				FlatlinePlayer.FoodConsumptionPerMinute = Mathf.Lerp(FlatlinePlayer.FoodConsumptionPerMinute, FlatlinePlayer.DefaultFoodConsumption, 0.5f);
			}
			if (FlatlinePlayer.ThirstConsumptionPerMinute < FlatlinePlayer.DefaultThirstConsumption)
			{
				FlatlinePlayer.ThirstConsumptionPerMinute = Mathf.Lerp(FlatlinePlayer.ThirstConsumptionPerMinute, FlatlinePlayer.DefaultThirstConsumption, 0.5f);
			}
		}
	}
	[HarmonyPatch(typeof(Bed), "Awake")]
	public static class Bed_Awake_Patch
	{
		[HarmonyPrefix]
		public static bool Prefix(Bed __instance)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			Transform val = ((Component)__instance).transform.Find("BedRotIntObj");
			if ((Object)(object)val == (Object)null)
			{
				return true;
			}
			InteractableObject bedRotInt = ((Component)val).gameObject.GetComponent<InteractableObject>();
			bedRotInt.onInteractStart.AddListener(new UnityAction(OnBedRotInteraction));
			bedRotInt.onHovered.AddListener(new UnityAction(OnBedRotHovered));
			return true;
			void OnBedRotHovered()
			{
				if (Flatline.registered)
				{
					BedRotSimulator.BedRotInteractableHovered(bedRotInt, __instance);
				}
			}
			void OnBedRotInteraction()
			{
				if (Flatline.registered)
				{
					BedRotSimulator.BedRotInteracted(bedRotInt, __instance);
				}
			}
		}
	}
	public static class DepressionSimulator
	{
		[CompilerGenerated]
		private sealed class <DepressionBlandWorld>d__4 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Depression depression;

			private float <duration>5__2;

			private float <current>5__3;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_0022;
				case 1:
					<>1__state = -1;
					if (!Flatline.registered || !depression.data.Active || (FlatlinePlayer.isQueuedForDeath && Flatline.currentConfig.PermanentDeath))
					{
						return false;
					}
					if (!ShouldSkip() && !depression.isTemporaryCurePresent)
					{
						float num = Mathf.Lerp(0.95f, 0.75f, depression.data.Severity / 0.3f);
						if (!(Random.Range(0f, 1f) < num))
						{
							<duration>5__2 = Mathf.Lerp(Depression.minBlandEffectDuration, Depression.maxBlandEffectDuration, depression.data.Severity / 0.3f);
							<current>5__3 = 0f;
							Singleton<PostProcessingManager>.Instance.SaturationController.AddOverride(-56f, 25, "Depression");
							goto IL_010b;
						}
					}
					goto IL_0022;
				case 2:
					{
						<>1__state = -1;
						if (!Flatline.registered)
						{
							return false;
						}
						<current>5__3 += 1f;
						if (<current>5__3 >= <duration>5__2 || !depression.data.Active || depression.isTemporaryCurePresent)
						{
							Singleton<PostProcessingManager>.Instance.SaturationController.RemoveOverride("Depression");
							goto IL_0022;
						}
						goto IL_010b;
					}
					IL_0022:
					<>2__current = Flatline.Wait10;
					<>1__state = 1;
					return true;
					IL_010b:
					<>2__current = Flatline.Wait1;
					<>1__state = 2;
					return true;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <DepressionDoorDisabler>d__6 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Depression depression;

			private PropertyDoorController[] <doors>5__2;

			private float <duration>5__3;

			private float <current>5__4;

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

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

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

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

			private bool MoveNext()
			{
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0211: Unknown result type (might be due to invalid IL or missing references)
				//IL_0217: Invalid comparison between Unknown and I4
				//IL_022f: Unknown result type (might be due to invalid IL or missing references)
				//IL_015b: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_0022;
				case 1:
					<>1__state = -1;
					if (!Flatline.registered || !depression.data.Active || (FlatlinePlayer.isQueuedForDeath && Flatline.currentConfig.PermanentDeath))
					{
						return false;
					}
					if (!ShouldSkip() && (int)Player.Local.CrimeData.CurrentPursuitLevel == 0 && !depression.isTemporaryCurePresent)
					{
						float num = Mathf.Clamp01(((float)depression.data.Progression / 5f + depression.data.Severity / 0.3f) / 2f);
						float num2 = Mathf.Lerp(0.95f, 0.75f, num);
						if (!(Random.Range(0f, 1f) < num2) && (Object)(object)Player.Local.CurrentProperty != (Object)null && Player.Local.CurrentProperty.IsOwned)
						{
							if (PropertyTemperatureController.propertyDoors.TryGetValue(Player.Local.CurrentProperty.propertyCode, out <doors>5__2))
							{
								PropertyDoorController[] array = <doors>5__2;
								foreach (PropertyDoorController val2 in array)
								{
									if (!((DoorController)val2).IsOpen)
									{
										((DoorController)val2).PlayerAccess = (EDoorAccess)1;
										((DoorController)val2).noAccessErrorMessage = "You are too depressed right now";
									}
								}
								<duration>5__3 = Mathf.Lerp(Depression.minDisablerEffectDuration, Depression.maxDisablerEffectDuration, num);
								<current>5__4 = 0f;
								goto IL_019a;
							}
							goto IL_024d;
						}
					}
					goto IL_0022;
				case 2:
					{
						<>1__state = -1;
						if (!Flatline.registered)
						{
							return false;
						}
						<current>5__4 += 1f;
						if (!(<current>5__4 >= <duration>5__3) && depression.data.Active && !depression.isTemporaryCurePresent)
						{
							goto IL_019a;
						}
						PropertyDoorController[] array = <doors>5__2;
						foreach (PropertyDoorController val in array)
						{
							if ((int)((DoorController)val).PlayerAccess == 1 && ((DoorController)val).noAccessErrorMessage == "You are too depressed right now")
							{
								((DoorController)val).PlayerAccess = (EDoorAccess)0;
								((DoorController)val).noAccessErrorMessage = "";
							}
						}
						goto IL_024d;
					}
					IL_0022:
					<>2__current = Flatline.Wait10;
					<>1__state = 1;
					return true;
					IL_024d:
					<doors>5__2 = null;
					goto IL_0022;
					IL_019a:
					<>2__current = Flatline.Wait1;
					<>1__state = 2;
					return true;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <DepressionMessagerDisabler>d__5 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Depression depression;

			private float <duration>5__2;

			private float <current>5__3;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_0022;
				case 1:
					<>1__state = -1;
					if (!Flatline.registered || !depression.data.Active || (FlatlinePlayer.isQueuedForDeath && Flatline.currentConfig.PermanentDeath))
					{
						return false;
					}
					if (!ShouldSkip() && !depression.isTemporaryCurePresent)
					{
						float num = Mathf.Lerp(0.95f, 0.75f, depression.data.Severity / 0.3f);
						if (!(Random.Range(0f, 1f) < num))
						{
							<duration>5__2 = Mathf.Lerp(Depression.minDisablerEffectDuration, Depression.maxDisablerEffectDuration, depression.data.Severity / 0.3f);
							<current>5__3 = 0f;
							disabledOverlay.SetActive(true);
							goto IL_00fb;
						}
					}
					goto IL_0022;
				case 2:
					{
						<>1__state = -1;
						if (!Flatline.registered)
						{
							return false;
						}
						<current>5__3 += 1f;
						if (<current>5__3 >= <duration>5__2 || !depression.data.Active || depression.isTemporaryCurePresent)
						{
							disabledOverlay.SetActive(false);
							goto IL_0022;
						}
						goto IL_00fb;
					}
					IL_0022:
					<>2__current = Flatline.Wait10;
					<>1__state = 1;
					return true;
					IL_00fb:
					<>2__current = Flatline.Wait1;
					<>1__state = 2;
					return true;
				}
			}

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

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

		public static GameObject disabledOverlay;

		public static void InitiateDepressionSimulatorModule()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			disabledOverlay = new GameObject("DisableOverlay");
			disabledOverlay.transform.SetParent(((Component)PlayerSingleton<MessagesApp>.Instance).transform, false);
			RectTransform obj = disabledOverlay.AddComponent<RectTransform>();
			obj.sizeDelta = new Vector2(800f, 1200f);
			((Transform)obj).localScale = Vector3.one;
			((Transform)obj).localPosition = Vector3.zero;
			((Transform)obj).localRotation = Quaternion.identity;
			((Graphic)disabledOverlay.AddComponent<Image>()).color = new Color(0.1f, 0.1f, 0.1f, 0.93f);
			GameObject val = new GameObject("Text");
			val.transform.SetParent(disabledOverlay.transform);
			val.transform.localScale = Vector3.one;
			val.transform.localPosition = Vector3.zero;
			val.transform.localRotation = Quaternion.identity;
			val.AddComponent<RectTransform>().sizeDelta = new Vector2(600f, 1200f);
			TextMeshProUGUI obj2 = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj2).text = "You are too depressed right now";
			((TMP_Text)obj2).alignment = (TextAlignmentOptions)514;
			((TMP_Text)obj2).fontSize = 52f;
			disabledOverlay.SetActive(false);
			DebugModule.Log("Initiated depression simulator", "InitiateDepressionSimulatorModule");
		}

		public static void ResetDepressionSimulatorModule()
		{
			disabledOverlay = null;
		}

		public static bool ShouldSkip()
		{
			if (Player.PlayerList.Count > 1 && !Player.Local.Health.IsAlive)
			{
				return true;
			}
			if (NetworkSingleton<TimeManager>.Instance.CurrentTime < 659 && NetworkSingleton<TimeManager>.Instance.CurrentTime > 400)
			{
				return true;
			}
			if (Flatline.isSaving)
			{
				return true;
			}
			if (Flatline.haltExecution)
			{
				return true;
			}
			return false;
		}

		[IteratorStateMachine(typeof(<DepressionBlandWorld>d__4))]
		public static IEnumerator DepressionBlandWorld(Depression depression)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DepressionBlandWorld>d__4(0)
			{
				depression = depression
			};
		}

		[IteratorStateMachine(typeof(<DepressionMessagerDisabler>d__5))]
		public static IEnumerator DepressionMessagerDisabler(Depression depression)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DepressionMessagerDisabler>d__5(0)
			{
				depression = depression
			};
		}

		[IteratorStateMachine(typeof(<DepressionDoorDisabler>d__6))]
		public static IEnumerator DepressionDoorDisabler(Depression depression)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DepressionDoorDisabler>d__6(0)
			{
				depression = depression
			};
		}
	}
	public static class AudioLoader
	{
		public static AudioClip ToAudioClip(byte[] fileBytes, string name = "wav")
		{
			int num = 0;
			int num2 = 16000;
			ushort num3 = 1;
			int dataSize = fileBytes.Length;
			bool flag = true;
			byte[] array = new byte[4];
			Array.Copy(fileBytes, 0, array, 0, 4);
			if (!Encoding.ASCII.GetString(array).Equals("RIFF"))
			{
				flag = false;
			}
			if (flag)
			{
				int num4 = BitConverter.ToInt32(fileBytes, 16);
				BitConverter.ToUInt16(fileBytes, 20);
				num3 = BitConverter.ToUInt16(fileBytes, 22);
				num2 = BitConverter.ToInt32(fileBytes, 24);
				BitConverter.ToUInt16(fileBytes, 34);
				num = 20 + num4 + 4;
				dataSize = BitConverter.ToInt32(fileBytes, num);
			}
			float[] array2 = Convert16BitByteArrayToAudioClipData(fileBytes, num, dataSize);
			AudioClip obj = AudioClip.Create(name, array2.Length / num3, (int)num3, num2, false);
			obj.SetData(array2, 0);
			return obj;
		}

		private static float[] Convert16BitByteArrayToAudioClipData(byte[] source, int headerOffset, int dataSize)
		{
			int num = dataSize;
			if (headerOffset != 0)
			{
				num = BitConverter.ToInt32(source, headerOffset);
				headerOffset += 4;
			}
			int num2 = 2;
			int num3 = num / num2;
			float[] array = new float[num3];
			short num4 = short.MaxValue;
			int num5 = 0;
			for (int i = 0; i < num3; i++)
			{
				num5 = i * num2 + headerOffset;
				array[i] = (float)BitConverter.ToInt16(source, num5) / (float)num4;
			}
			return array;
		}
	}
	[Serializable]
	public class FlatlinePlayerData
	{
		public FlatlinePlayerState State = new FlatlinePlayerState();

		public List<DiseaseData> DiseaseData = new List<DiseaseData>();

		public FlatlinePlayerData()
		{
		}

		public FlatlinePlayerData(FlatlinePlayerData original)
		{
			State = new FlatlinePlayerState(original.State);
			DiseaseData = new List<DiseaseData>();
			foreach (DiseaseData diseaseDatum in original.DiseaseData)
			{
				DiseaseData.Add(new DiseaseData(diseaseDatum));
			}
		}
	}
	[Serializable]
	public class FlatlinePlayerState
	{
		public Dictionary<string, ConsumptionData> consumptionDatas = new Dictionary<string, ConsumptionData>();

		public HealthData healthData = new HealthData();

		public float Thirst = 1f;

		public float Hunger = 1f;

		public float Energy = 1f;

		public float Temperature = 1f;

		public FlatlinePlayerState()
		{
		}

		public FlatlinePlayerState(FlatlinePlayerState original)
		{
			Thirst = original.Thirst;
			Hunger = original.Hunger;
			Energy = original.Energy;
			Temperature = original.Temperature;
			foreach (KeyValuePair<string, ConsumptionData> consumptionData in original.consumptionDatas)
			{
				consumptionDatas.Add(consumptionData.Key, new ConsumptionData(consumptionData.Value));
			}
			healthData = new HealthData(original.healthData);
		}
	}
	[Serializable]
	public class ConsumptionData
	{
		public float overtimeLungDamage;

		public float overtimeLiverDamage;

		public float currentAmountInSystem;

		public ConsumptionData()
		{
		}

		public ConsumptionData(ConsumptionData original)
		{
			overtimeLungDamage = original.overtimeLungDamage;
			overtimeLiverDamage = original.overtimeLiverDamage;
			currentAmountInSystem = original.currentAmountInSystem;
		}
	}
	[Serializable]
	public class HealthData
	{
		public float MaxHP = 100f;

		public float CurrentHP = 100f;

		public float MoveSpeedScale = 1f;

		public float Predisposition;

		public float Gluttony;

		public int TimesSmoked;

		public bool IsLegBoneBroken;

		public HealthData()
		{
		}

		public HealthData(HealthData original)
		{
			MaxHP = original.MaxHP;
			CurrentHP = original.CurrentHP;
			MoveSpeedScale = original.MoveSpeedScale;
			Predisposition = original.Predisposition;
			Gluttony = original.Gluttony;
			TimesSmoked = original.TimesSmoked;
			IsLegBoneBroken = original.IsLegBoneBroken;
		}
	}
	[Serializable]
	public class DiseaseData
	{
		public string DiseaseID = "";

		public bool Active;

		public int MinsSinceDiseaseStart;

		public int Progression = 1;

		public float Severity;

		public float HealState;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public Dictionary<string, float> DiseaseStates;

		public DiseaseData()
		{
		}

		public DiseaseData(DiseaseData original)
		{
			DiseaseID = original.DiseaseID;
			Active = original.Active;
			MinsSinceDiseaseStart = original.MinsSinceDiseaseStart;
			Progression = original.Progression;
			Severity = original.Severity;
			HealState = original.HealState;
			if (original.DiseaseStates != null)
			{
				DiseaseStates = new Dictionary<string, float>(original.DiseaseStates);
			}
		}
	}
	public class FlatlineModConfig
	{
		public bool PermanentDeath = true;

		public bool FahrenheitTemp;
	}
	public static class ConfigLoader
	{
		private static readonly string BASE_USERDATA_NAME = "XO_WithSauce-Flatline";

		private static readonly string TS_PACKAGE_NAME = "XO_WithSauce-Flatline_";

		private static readonly string packagePathUserData = Path.Combine(MelonEnvironment.UserDataDirectory, TS_PACKAGE_NAME + "MONO", BASE_USERDATA_NAME);

		private static readonly string manualPathUserData = Path.Combine(MelonEnvironment.UserDataDirectory, BASE_USERDATA_NAME);

		private static readonly string pathPlayerData = Path.Combine(packagePathUserData, "PlayerData");

		private static readonly string pathModImageResources = Path.Combine(packagePathUserData, "ModResources", "Images");

		private static readonly string pathModAudioResources = Path.Combine(packagePathUserData, "ModResources", "Audio");

		private static readonly string pathManualPlayerData = Path.Combine(manualPathUserData, "PlayerData");

		private static readonly string pathManualModImageResources = Path.Combine(manualPathUserData, "ModResources", "Images");

		private static readonly string pathManualModAudioResources = Path.Combine(manualPathUserData, "ModResources", "Audio");

		public static readonly List<string> imageResources = new List<string> { "bleed", "bonebreak", "cancer", "depression", "energy", "fever", "meat", "temperature", "water" };

		public static readonly List<string> audioResources = new List<string> { "malecough", "malesneeze", "femalecough", "femalesneeze", "bonebreak", "flatline", "singleheartbeat" };

		public static object playerDataLock = new object();

		public static Dictionary<string, Sprite> loadedSprites = new Dictionary<string, Sprite>();

		public static Dictionary<string, AudioClip> loadedAudios = new Dictionary<string, AudioClip>();

		public static FlatlinePlayerData LoadPlayerData()
		{
			string organisationName = Singleton<LoadManager>.Instance.ActiveSaveInfo.OrganisationName;
			int saveSlotNumber = Singleton<LoadManager>.Instance.ActiveSaveInfo.SaveSlotNumber;
			string path = $"{saveSlotNumber}_{SanitizeAndFormatName(organisationName)}";
			string text = "";
			if (Directory.Exists(pathPlayerData))
			{
				text = pathPlayerData;
			}
			else
			{
				if (!Directory.Exists(pathManualPlayerData))
				{
					MelonLogger.Error("Failed to locate Flatline PlayerData from the UserData folder!");
					return null;
				}
				text = pathManualPlayerData;
			}
			FlatlinePlayerData flatlinePlayerData;
			if (File.Exists(Path.Combine(text, path)))
			{
				try
				{
					flatlinePlayerData = JsonConvert.DeserializeObject<FlatlinePlayerData>(File.ReadAllText(Path.Combine(text, path)));
				}
				catch (Exception ex)
				{
					flatlinePlayerData = new FlatlinePlayerData();
					MelonLogger.Warning("Failed to read flatline player data: " + ex);
				}
			}
			else
			{
				flatlinePlayerData = new FlatlinePlayerData();
				flatlinePlayerData.State.healthData.Predisposition = Random.Range(0.0005f, 0.02f);
				Save(flatlinePlayerData);
			}
			return flatlinePlayerData;
		}

		public static void Save(FlatlinePlayerData playerData)
		{
			lock (playerDataLock)
			{
				FlatlinePlayerData flatlinePlayerData = new FlatlinePlayerData(playerData);
				try
				{
					string organisationName = Singleton<LoadManager>.Instance.ActiveSaveInfo.OrganisationName;
					int saveSlotNumber = Singleton<LoadManager>.Instance.ActiveSaveInfo.SaveSlotNumber;
					string path = $"{saveSlotNumber}_{SanitizeAndFormatName(organisationName)}";
					string text = "";
					text = (Directory.Exists(pathPlayerData) ? pathPlayerData : ((!Directory.Exists(pathManualPlayerData)) ? pathPlayerData : pathManualPlayerData));
					string path2 = Path.Combine(text, path);
					string contents = JsonConvert.SerializeObject((object)flatlinePlayerData, (Formatting)1);
					Directory.CreateDirectory(Path.GetDirectoryName(path2));
					File.WriteAllText(path2, contents);
				}
				catch (Exception ex)
				{
					MelonLogger.Warning("Failed to save Flatline player data: " + ex);
				}
			}
		}

		public static void RemoveSaveAssociatedData(string orgName, int slotNum)
		{
			string path = $"{slotNum}_{SanitizeAndFormatName(orgName)}";
			string text = "";
			if (Directory.Exists(pathPlayerData))
			{
				text = pathPlayerData;
			}
			else
			{
				if (!Directory.Exists(pathManualPlayerData))
				{
					MelonLogger.Error("Failed to locate Flatline PlayerData from the UserData folder!");
					return;
				}
				text = pathManualPlayerData;
			}
			if (File.Exists(Path.Combine(text, path)))
			{
				try
				{
					File.Delete(Path.Combine(text, path));
				}
				catch (Exception ex)
				{
					MelonLogger.Warning("Failed to remove save associated flatline player data: " + ex);
				}
			}
		}

		public static void LoadModResources()
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			string text = "";
			string text2 = "";
			if (Directory.Exists(packagePathUserData))
			{
				text = pathModImageResources;
				text2 = pathModAudioResources;
			}
			else
			{
				if (!Directory.Exists(manualPathUserData))
				{
					MelonLogger.Error("Failed to locate Flatline mod resources from UserData!");
					return;
				}
				text = pathManualModImageResources;
				text2 = pathManualModAudioResources;
			}
			if (Directory.Exists(text))
			{
				foreach (string imageResource in imageResources)
				{
					string path = Path.Combine(text, imageResource + ".png");
					if (File.Exists(path))
					{
						byte[] array = File.ReadAllBytes(path);
						Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
						ImageConversion.LoadImage(val, array);
						((Object)val).name = imageResource;
						((Texture)val).anisoLevel = 1;
						val.Apply();
						Sprite value = Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f), 100f);
						loadedSprites.Add(imageResource, value);
					}
					else
					{
						MelonLogger.Error("Flatline mod expected to find file '" + imageResource + "' but it's missing!");
					}
				}
			}
			else
			{
				MelonLogger.Error("Flatline mod expected to find directory '" + text + "' but it's missing!");
			}
			if (Directory.Exists(text2))
			{
				foreach (string audioResource in audioResources)
				{
					string path2 = Path.Combine(text2, audioResource + ".wav");
					if (File.Exists(path2))
					{
						AudioClip value2 = AudioLoader.ToAudioClip(File.ReadAllBytes(path2));
						loadedAudios.Add(audioResource, value2);
					}
					else
					{
						MelonLogger.Error("Flatline mod expected to find file '" + audioResource + "' but it's missing!");
					}
				}
				return;
			}
			MelonLogger.Error("Flatline mod expected to find directory '" + text2 + "' but it's missing!");
		}

		public static string SanitizeAndFormatName(string orgName)
		{
			string text = orgName;
			if (text != null)
			{
				text = text.Replace(" ", "_").ToLower();
				text = text.Replace(",", "");
				text = text.Replace(".", "");
				text = text.Replace("<", "");
				text = text.Replace(">", "");
				text = text.Replace(":", "");
				text = text.Replace("\"", "");
				text = text.Replace("/", "");
				text = text.Replace("\\", "");
				text = text.Replace("|", "");
				text = text.Replace("?", "");
				text = text.Replace("*", "");
			}
			return text + ".json";
		}
	}
	public class Bleeding : Disease
	{
		[CompilerGenerated]
		private sealed class <RunBleedDamage>d__6 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Bleeding <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				Bleeding bleeding = <>4__this;
				float num2;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_0029;
				case 1:
					<>1__state = -1;
					num2 = 0.5f;
					goto IL_0081;
				case 2:
					{
						<>1__state = -1;
						num2 = 1f;
						goto IL_0081;
					}
					IL_0081:
					if (!Flatline.registered || !bleeding.data.Active || bleeding.data.Progression >= 5)
					{
						return false;
					}
					if (!Flatline.haltExecution && !Flatline.isSaving && !FlatlinePlayer.isPassedOut && !NetworkSingleton<TimeManager>.Instance.IsSleepInProgress)
					{
						if (FlatlinePlayer.isQueuedForDeath)
						{
							return false;
						}
						if (bleeding.maxHPReduced >= bleeding.MaximumMaxHPReduction)
						{
							return false;
						}
						if (!(bleeding.data.HealState > 0.9f) && !PlayerDiseaseDamage.isBleedingStemmed)
						{
							float num3 = (float)bleeding.minsRequiredForProgression * (1f + bleeding.data.Severity);
							float num4 = num3 * 5f / 1440f;
							float num5 = num3 * 1f / 1440f;
							float num6 = num4 - num5;
							float num7 = bleeding.MaximumMaxHPReduction / 1440f * num6 / num2;
							float num8 = Mathf.Lerp(Mathf.Approximately(bleeding.data.HealState, 0f) ? 0.015f : bleeding.data.HealState, 0.001f, (float)bleeding.data.Progression / 5f - 0.2f);
							num7 = Mathf.Clamp01(Mathf.Lerp(num7, 0f, num8)) * (float)bleeding.data.Progression;
							DebugModule.Log("Calc bleed reduction: " + num7, "RunBleedDamage");
							if (Random.Range(0f, 1f) > 0.33f)
							{
								Player.Local.Health.PlayBloodMist();
							}
							if (Flatline.loadedPlayerData.State.healthData.MaxHP - num7 < Flatline.loadedPlayerData.State.healthData.CurrentHP)
							{
								float num9 = Flatline.loadedPlayerData.State.healthData.CurrentHP - (Flatline.loadedPlayerData.State.healthData.MaxHP - num7);
								if (Player.Local.Health.CurrentHealth - num9 <= 0f)
								{
									FlatlineUIModule.causeOfDeath = "Bleeding";
								}
								Player.Local.Health.TakeDamage(num9, Random.Range(0, 10) == 0, false);
								FlatlinePlayer.AppendDamageSource($"Bleeding damage (-{num9}HP)");
							}
							else
							{
								DebugModule.Log("Bleed amount not smaller than current hp", "RunBleedDamage");
							}
							bleeding.maxHPReduced += num7;
							Flatline.loadedPlayerData.State.healthData.MaxHP = Mathf.Clamp(Flatline.loadedPlayerData.State.healthData.MaxHP - num7, 0f, 100f);
						}
					}
					goto IL_0029;
					IL_0029:
					num2 = 0f;
					if (bleeding.data.Progression >= 3)
					{
						<>2__current = Flatline.Wait05;
						<>1__state = 1;
						return true;
					}
					<>2__current = Flatline.Wait1;
					<>1__state = 2;
					return true;
				}
			}

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

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

		public static readonly float passiveDiseaseHealingMax = 0.003f;

		public static readonly float passiveDiseaseHealingMin = 0.0001f;

		public float MaximumMaxHPReduction = 100f;

		private float maxHPReduced;

		public Bleeding(DiseaseData data)
		{
			base.data = data;
			base.data.DiseaseID = "bleed";
			base.minsRequiredForProgression = 240;
			onDiseaseStarted = BleedingStarted;
			MaximumMaxHPReduction = Mathf.Lerp(40f, 150f, base.data.Severity / 0.3f);
			if (base.data.DiseaseStates == null)
			{
				base.data.DiseaseStates = new Dictionary<string, float>();
			}
			if (base.data.DiseaseStates.ContainsKey("maxHPReduced"))
			{
				maxHPReduced = base.data.DiseaseStates["maxHPReduced"];
			}
			else
			{
				base.data.DiseaseStates.Add("maxHPReduced", 0f);
			}
		}

		private void BleedingStarted()
		{
			PlayerDiseaseDamage.isBleedingStemmed = false;
			if (!PlayerDiseaseDamage.bleedPressureIntObj.activeSelf)
			{
				PlayerDiseaseDamage.bleedPressureIntObj.SetActive(true);
			}
			Flatline.coros.Add(MelonCoroutines.Start(RunBleedDamage()));
		}

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

		public override void DiseaseEffect()
		{
			float num = data.MinsSinceDiseaseStart;
			if (!PlayerDiseaseDamage.bleedPressureIntObj.activeSelf)
			{
				PlayerDiseaseDamage.bleedPressureIntObj.SetActive(true);
			}
			if (PlayerDiseaseDamage.isBleedingStemmed)
			{
				num *= 0.33f;
			}
			if (Mathf.Round(num * (1f + data.Severity)) / (float)base.minsRequiredForProgression >= (float)data.Progression)
			{
				data.Progression++;
			}
			if (data.Progression >= 5 && maxHPReduced >= MaximumMaxHPReduction && !PlayerDiseaseDamage.isBleedingStemmed)
			{
				DebugModule.Log("Player died of bleeding", "DiseaseEffect");
				FlatlineUIModule.causeOfDeath = "Bleeding";
				Flatline.coros.Add(MelonCoroutines.Start(FlatlinePlayer.PrePlayerDied()));
				data.Active = false;
				return;
			}
			if (data.Progression >= 4 && Flatline.loadedPlayerData.State.Thirst > 0.15f)
			{
				Flatline.loadedPlayerData.State.Thirst -= 0.0015f;
			}
			data.HealState += Random.Range(passiveDiseaseHealingMin, passiveDiseaseHealingMax);
			if (maxHPReduced >= MaximumMaxHPReduction)
			{
				data.HealState += Random.Range(passiveDiseaseHealingMin * 3f, passiveDiseaseHealingMax * 3f);
			}
			float num2 = Mathf.Lerp(12f, 24f, Mathf.Clamp01(data.HealState));
			float num3 = Mathf.Lerp(1f, 3f, Mathf.Clamp01((float)data.Progression / 5f));
			if (PlayerDiseaseDamage.isBleedingStemmed)
			{
				data.HealState += passiveDiseaseHealingMax * num2;
			}
			else
			{
				data.HealState = Mathf.Clamp01(data.HealState - passiveDiseaseHealingMax * num3);
			}
			DebugModule.Log("Bleeding Max HP reduction total so far: " + maxHPReduced, "DiseaseEffect");
		}

		public override void DiseaseHealed()
		{
			if (PlayerDiseaseDamage.bleedPressureIntObj.activeSelf)
			{
				PlayerDiseaseDamage.bleedPressureIntObj.SetActive(false);
			}
			PlayerDiseaseDamage.isBleedingStemmed = false;
			DebugModule.Log("Healed bleeding succesfully", "DiseaseHealed");
		}

		public override void UpdateDiseaseData()
		{
			if (data.DiseaseStates == null)
			{
				data.DiseaseStates = new Dictionary<string, float>();
			}
			if (data.DiseaseStates.ContainsKey("maxHPReduced"))
			{
				data.DiseaseStates["maxHPReduced"] = maxHPReduced;
			}
			else
			{
				data.DiseaseStates.Add("maxHPReduced", maxHPReduced);
			}
		}
	}
	public class BoneBreak : Disease
	{
		public static readonly float passiveDiseaseHealingMax = 0.001f;

		public static readonly float passiveDiseaseHealingMin = 0.0001f;

		public static readonly float healingReductionWhileSprinting = 0.008f;

		public static readonly float baseMoveSpeedReduction = 0.03f;

		public static readonly float minMoveSpeedScaleValue = 0.65f;

		private bool hasDisabledJump;

		public BoneBreak(DiseaseData data)
		{
			base.data = data;
			base.data.DiseaseID = "bonebreak";
			base.minsRequiredForProgression = 4320;
		}

		public override void DiseaseEffect()
		{
			if (Mathf.Round((float)data.MinsSinceDiseaseStart * (1f + data.Severity)) / (float)base.minsRequiredForProgression >= (float)data.Progression)
			{
				data.Progression++;
			}
			if (data.Progression >= 5)
			{
				DebugModule.Log("Player died of a broken bone", "DiseaseEffect");
				FlatlineUIModule.causeOfDeath = "Broken bone";
				Flatline.coros.Add(MelonCoroutines.Start(FlatlinePlayer.PrePlayerDied()));
				data.Active = false;
				return;
			}
			data.HealState += Random.Range(passiveDiseaseHealingMin, passiveDiseaseHealingMax);
			if (PlayerSingleton<PlayerMovement>.Instance.IsSprinting)
			{
				data.HealState = Mathf.Clamp01(data.HealState - healingReductionWhileSprinting * (float)data.Progression);
			}
			if (BedRotSimulator.isBedrotting)
			{
				data.HealState += Random.Range(passiveDiseaseHealingMin, passiveDiseaseHealingMax);
			}
			if (data.Progression >= 1)
			{
				float num = Mathf.Lerp(minMoveSpeedScaleValue, 1f, data.HealState);
				if (Flatline.loadedPlayerData.State.healthData.MoveSpeedScale > num)
				{
					float num2 = Mathf.Lerp(baseMoveSpeedReduction * (float)data.Progression * (1f + data.Severity), 0f, data.HealState);
					float moveSpeedScale = Mathf.Clamp(Flatline.loadedPlayerData.State.healthData.MoveSpeedScale - num2, minMoveSpeedScaleValue, 1f);
					Flatline.loadedPlayerData.State.healthData.MoveSpeedScale = moveSpeedScale;
				}
			}
			if (data.Progression < 3 || !(data.HealState < 0.5f) || !Flatline.loadedPlayerData.State.healthData.IsLegBoneBroken)
			{
				return;
			}
			if (PlayerSingleton<PlayerMovement>.Instance.CanJump && !hasDisabledJump)
			{
				if (Random.Range(0f, 1f) > 0.95f)
				{
					PlayerSingleton<PlayerMovement>.Instance.CanJump = false;
					hasDisabledJump = true;
				}
			}
			else if (!PlayerSingleton<PlayerMovement>.Instance.CanJump && hasDisabledJump)
			{
				PlayerSingleton<PlayerMovement>.Instance.CanJump = true;
				hasDisabledJump = false;
			}
		}

		public override void DiseaseHealed()
		{
			Flatline.loadedPlayerData.State.healthData.IsLegBoneBroken = false;
			DebugModule.Log("Healed bone break succesfully", "DiseaseHealed");
		}

		public override void UpdateDiseaseData()
		{
		}
	}
	public class Cancer : Disease
	{
		public static readonly float MaximumMaxHPReduction = 100f;

		public Cancer(DiseaseData data)
		{
			base.data = data;
			base.data.DiseaseID = "cancer";
			base.minsRequiredForProgression = 10080;
		}

		public override void DiseaseEffect()
		{
			float num = Mathf.Round((float)data.MinsSinceDiseaseStart * (1f + data.Severity));
			float num2 = (float)base.minsRequiredForProgression * (1f + data.Severity);
			if (num / (float)base.minsRequiredForProgression >= (float)data.Progression)
			{
				data.Progression++;
			}
			if (data.Progression >= 5)
			{
				DebugModule.Log("Player died of cancer", "DiseaseEffect");
				FlatlineUIModule.causeOfDeath = "Cancer";
				Flatline.coros.Add(MelonCoroutines.Start(FlatlinePlayer.PrePlayerDied()));
				data.Active = false;
				return;
			}
			if (data.Progression >= 3)
			{
				float num3 = num2 * 5f / 1440f;
				float num4 = num2 * 3f / 1440f;
				float num5 = num3 - num4;
				float num6 = MaximumMaxHPReduction / 1440f * num5 / 10f;
				DebugModule.Log("Cancer Max HP reduction: " + num6, "DiseaseEffect");
				if (Flatline.loadedPlayerData.State.healthData.MaxHP - num6 < Flatline.loadedPlayerData.State.healthData.CurrentHP)
				{
					float num7 = Flatline.loadedPlayerData.State.healthData.CurrentHP - (Flatline.loadedPlayerData.State.healthData.MaxHP - num6);
					if (Player.Local.Health.CurrentHealth - num7 <= 0f)
					{
						FlatlineUIModule.causeOfDeath = "Cancer";
					}
					Player.Local.Health.TakeDamage(num7, true, false);
					FlatlinePlayer.AppendDamageSource($"Cancer damage (-{num7}HP)");
				}
				Flatline.loadedPlayerData.State.healthData.MaxHP = Mathf.Clamp(Flatline.loadedPlayerData.State.healthData.MaxHP - num6, 0f, 100f);
			}
			if (!FlatlinePlayer.flatlinePlayerAudio.isPlaying)
			{
				AudioClip val = null;
				val = ((Player.Local.Avatar.CurrentSettings.Gender > 0.5f) ? ((!(Random.Range(0f, 1f) > 0.5f)) ? ConfigLoader.loadedAudios["femalesneeze"] : ConfigLoader.loadedAudios["femalecough"]) : ((!(Random.Range(0f, 1f) > 0.5f)) ? ConfigLoader.loadedAudios["malesneeze"] : ConfigLoader.loadedAudios["malecough"]));
				if (data.Progression == 2 && Random.Range(0f, 1f) > 0.99f)
				{
					FlatlinePlayer.flatlinePlayerAudio.PlayOneShot(val);
				}
				else if (data.Progression >= 3 && Random.Range(0f, 1f) > 0.95f)
				{
					FlatlinePlayer.flatlinePlayerAudio.PlayOneShot(val);
				}
			}
		}

		public override void DiseaseHealed()
		{
			DebugModule.Log("Healed cancer succesfully", "DiseaseHealed");
		}

		public override void UpdateDiseaseData()
		{
		}
	}
	public class Depression : Disease
	{
		public static readonly float passiveDiseaseHealingMax = 0.0025f;

		public static readonly float passiveDiseaseHealingMin = 0.0001f;

		public static readonly float baseEnergyConsumptionIncrease = 0.002f;

		public static readonly float baseFoodConsumptionIncrease = 0.0008f;

		public static readonly int maxTemporaryCureMins = 120;

		public static readonly float maxBlandEffectDuration = 180f;

		public static readonly float minBlandEffectDuration = 80f;

		public static readonly float maxDisablerEffectDuration = 120f;

		public static readonly float minDisablerEffectDuration = 50f;

		private static int minsSpentBedrotting = 0;

		public bool isTemporaryCurePresent;

		private int minsSinceTemporaryCureStarted;

		public static readonly List<string> temporaryDepressionCures = new List<string> { "weed", "shroom", "cocaine", "meth" };

		public Depression(DiseaseData data)
		{
			base.data = data;
			base.data.DiseaseID = "depression";
			base.minsRequiredForProgression = 4320;
			onDiseaseStarted = RunDepressionCoros;
		}

		private void RunDepressionCoros()
		{
			Flatline.coros.Add(MelonCoroutines.Start(DepressionSimulator.DepressionBlandWorld(this)));
			Flatline.coros.Add(MelonCoroutines.Start(DepressionSimulator.DepressionDoorDisabler(this)));
			Flatline.coros.Add(MelonCoroutines.Start(DepressionSimulator.DepressionMessagerDisabler(this)));
		}

		public override void DiseaseEffect()
		{
			if (Mathf.Round((float)data.MinsSinceDiseaseStart * (1f + data.Severity)) / (float)base.minsRequiredForProgression >= (float)data.Progression)
			{
				data.Progression++;
			}
			if (data.Progression >= 5)
			{
				DebugModule.Log("Player died of depression", "DiseaseEffect");
				FlatlineUIModule.causeOfDeath = "Depression";
				Flatline.coros.Add(MelonCoroutines.Start(FlatlinePlayer.PrePlayerDied()));
				data.Active = false;
				return;
			}
			if (BedRotSimulator.isBedrotting)
			{
				minsSpentBedrotting += 10;
				float num = Mathf.Lerp(0f, 1f, Mathf.Clamp01((float)minsSpentBedrotting / 1440f));
				if (num > data.HealState)
				{
					data.HealState = num;
				}
				else
				{
					data.HealState += num / 10f;
				}
			}
			data.HealState += Random.Range(passiveDiseaseHealingMin, passiveDiseaseHealingMax);
			if (isTemporaryCurePresent)
			{
				minsSinceTemporaryCureStarted += 10;
				if (minsSinceTemporaryCureStarted >= maxTemporaryCureMins)
				{
					isTemporaryCurePresent = false;
				}
			}
			if (Flatline.loadedPlayerData.State.healthData.TimesSmoked > 0 && Flatline.loadedPlayerData.State.consumptionDatas.Count > 0)
			{
				Dictionary<string, ConsumptionData> dictionary = new Dictionary<string, ConsumptionData>(Flatline.loadedPlayerData.State.consumptionDatas);
				float num2 = 0f;
				int num3 = 0;
				foreach (KeyValuePair<string, ConsumptionData> item in dictionary)
				{
					if (temporaryDepressionCures.Contains(item.Key))
					{
						num2 += item.Value.currentAmountInSystem;
						if (num2 > 0.15f && !isTemporaryCurePresent)
						{
							isTemporaryCurePresent = true;
							minsSinceTemporaryCureStarted = 0;
						}
						num3++;
					}
				}
				if (num3 > 0)
				{
					num2 = Mathf.Clamp01(num2 / (float)num3);
					float num4 = passiveDiseaseHealingMax * (1f + num2);
					float num5 = Random.Range(passiveDiseaseHealingMin * (1f + num2), num4);
					num5 = Mathf.Lerp(num5, num4, num2);
					data.HealState += Mathf.Clamp(num5, 0f, 0.01f);
				}
			}
			if (!BedRotSimulator.isBedrotting)
			{
				float num6 = Mathf.Lerp(3f, 5f, (float)data.Progression / 5f - 0.2f);
				float num7 = Mathf.Clamp(baseEnergyConsumptionIncrease * (float)data.Progression * (1f + data.Severity), 0f, 0.01f);
				float num8 = Mathf.Clamp(baseFoodConsumptionIncrease * (float)data.Progression * (1f + data.Severity), 0f, 0.0052f);
				FlatlinePlayer.EnergyConsumptionPerMinute = Mathf.Lerp(FlatlinePlayer.EnergyConsumptionPerMinute, FlatlinePlayer.EnergyConsumptionPerMinute + num7, MaximumSystematicPropertyChangePerTick * num6);
				FlatlinePlayer.FoodConsumptionPerMinute = Mathf.Lerp(FlatlinePlayer.FoodConsumptionPerMinute, FlatlinePlayer.FoodConsumptionPerMinute + num8, MaximumSystematicPropertyChangePerTick * num6);
			}
		}

		public override void DiseaseHealed()
		{
			if (FlatlinePlayer.FoodConsumptionPerMinute > FlatlinePlayer.DefaultFoodConsumption)
			{
				FlatlinePlayer.FoodConsumptionPerMinute = Mathf.Lerp(FlatlinePlayer.FoodConsumptionPerMinute, FlatlinePlayer.DefaultFoodConsumption, 0.5f);
			}
			if (FlatlinePlayer.EnergyConsumptionPerMinute > FlatlinePlayer.DefaultEnergyConsumption)
			{
				FlatlinePlayer.EnergyConsumptionPerMinute = Mathf.Lerp(FlatlinePlayer.EnergyConsumptionPerMinute, FlatlinePlayer.DefaultEnergyConsumption, 0.5f);
			}
			DebugModule.Log("Healed depression succesfully", "DiseaseHealed");
		}

		public override void UpdateDiseaseData()
		{
		}
	}
	public class Fever : Disease
	{
		[CompilerGenerated]
		private sealed class <BlurShort>d__11 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Fever <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				Fever fever = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!Flatline.registered || FlatlinePlayer.isPassedOut || FlatlinePlayer.isQueuedForDeath)
					{
						return false;
					}
					DebugModule.Log("Start blur", "BlurShort");
					Mathf.Lerp(2f, 5f, (float)fever.data.Progression / 5f);
					PlayerSingleton<PlayerCamera>.Instance.FoVChangeSmoother.AddOverride(-8f, 5, "fever");
					PlayerSingleton<PlayerCamera>.Instance.SmoothLookSmoother.AddOverride(0.8f, 5, "fever");
					if (fever.data.Progression > 3)
					{
						Player.Local.Disoriented = true;
					}
					Player.Local.Seizure = true;
					Singleton<PostProcessingManager>.Instance.SetBlur(1f);
					<>2__current = Flatline.Wait5;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!Flatline.registered)
					{
						return false;
					}
					Player.Local.Seizure = false;
					if (fever.data.Progression > 3 && Player.Local.Disoriented)
					{
						Player.Local.Disoriented = false;
					}
					Singleton<PostProcessingManager>.Instance.SetBlur(0f);
					PlayerSingleton<PlayerCamera>.Instance.FoVChangeSmoother.RemoveOverride("fever");
					PlayerSingleton<PlayerCamera>.Instance.SmoothLookSmoother.RemoveOverride("fever");
					DebugModule.Log("End blur", "BlurShort");
					return false;
				}
			}

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

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

		public static readonly float baseEnergyConsumptionIncrease = 7E-05f;

		public static readonly float baseTemperatureConsumptionIncrease = 0.00025f;

		public static readonly float baseThirstConsumptionIncrease = 0.00012f;

		public static readonly float passiveDiseaseHealingMax = 0.0055f;

		public static readonly float passiveDiseaseHealingMin = 0.0003f;

		public static readonly float MaximumMaxHPReduction = 33f;

		private int minsSinceLastFeverShiver;

		private int minsUntilNextFeverShiver = 120;

		public Fever(DiseaseData data)
		{
			base.data = data;
			base.data.DiseaseID = "fever";
			base.minsRequiredForProgression = 1080;
			onDiseaseStarted = FeverStarted;
		}

		private void FeverStarted()
		{
			Player.Local.Avatar.Effects.SetSicklySkinColor(true);
			Player.Local.Avatar.EmotionManager.AddEmotionOverride("Concerned", "Sickly", 0f, 5);
		}

		public override void DiseaseEffect()
		{
			minsSinceLastFeverShiver += 10;
			DebugModule.Log("Mins until next fever jitter " + (minsUntilNextFeverShiver - minsSinceLastFeverShiver), "DiseaseEffect");
			float num = Mathf.Round((float)data.MinsSinceDiseaseStart * (1f + data.Severity));
			float num2 = (float)base.minsRequiredForProgression * (1f + data.Severity);
			if (num / (float)base.minsRequiredForProgression >= (float)data.Progression)
			{
				data.Progression++;
			}
			if (data.Progression >= 5)
			{
				DebugModule.Log("Player died of fever", "DiseaseEffect");
				FlatlineUIModule.causeOfDeath = "Fever";
				Flatline.coros.Add(MelonCoroutines.Start(FlatlinePlayer.PrePlayerDied()));
				data.Active = false;
				return;
			}
			data.HealState += Random.Range(passiveDiseaseHealingMin, passiveDiseaseHealingMax);
			if (BedRotSimulator.isBedrotting)
			{
				data.HealState += Random.Range(passiveDiseaseHealingMin * 5f, passiveDiseaseHealingMax * 5f);
			}
			if (PlayerSingleton<PlayerMovement>.Instance.IsSprinting)
			{
				data.HealState = Mathf.Clamp01(data.HealState - Random.Range(passiveDiseaseHealingMin, passiveDiseaseHealingMax * 2f));
			}
			if (!FlatlinePlayer.flatlinePlayerAudio.isPlaying)
			{
				AudioClip val = null;
				val = ((Player.Local.Avatar.CurrentSettings.Gender > 0.5f) ? ((!(Random.Range(0f, 1f) > 0.5f)) ? ConfigLoader.loadedAudios["femalesneeze"] : ConfigLoader.loadedAudios["femalecough"]) : ((!(Random.Range(0f, 1f) > 0.5f)) ? ConfigLoader.loadedAudios["malesneeze"] : ConfigLoader.loadedAudios["malecough"]));
				if (data.Progression == 1 && Random.Range(0f, 1f) > 0.96f)
				{
					FlatlinePlayer.flatlinePlayerAudio.PlayOneShot(val);
				}
				else if (data.Progression == 2 && Random.Range(0f, 1f) > 0.94f)
				{
					FlatlinePlayer.flatlinePlayerAudio.PlayOneShot(val);
				}
				else if (data.Progression == 3 && Random.Range(0f, 1f) > 0.92f)
				{
					FlatlinePlayer.flatlinePlayerAudio.PlayOneShot(val);
				}
				else if (data.Progression >= 4 && Random.Range(0f, 1f) > 0.87f)
				{
					FlatlinePlayer.flatlinePlayerAudio.PlayOneShot(val);
				}
			}
			if (data.Progression >= 1)
			{
				float num3 = Mathf.Clamp(FlatlinePlayer.EnergyConsumptionPerMinute + Mathf.Clamp(baseEnergyConsumptionIncrease * (float)data.Progression * (1f + data.Severity), 0f, 0.0009f), 0f, FlatlinePlayer.DefaultEnergyConsumption * 3f);
				FlatlinePlayer.EnergyConsumptionPerMinute = Mathf.Lerp(FlatlinePlayer.EnergyConsumptionPerMinute, num3, MaximumSystematicPropertyChangePerTick * 2f);
				float num4 = Mathf.Clamp(FlatlinePlayer.TemperatureConsumption + Mathf.Clamp(baseTemperatureConsumptionIncrease * (float)data.Progression * (1f + data.Severity), 0f, 0.0015f), 0f, FlatlinePlayer.TemperatureConsumptionPerMinutePerDegreeDiff * 3f);
				FlatlinePlayer.TemperatureConsumption = Mathf.Lerp(FlatlinePlayer.TemperatureConsumption, num4, MaximumSystematicPropertyChangePerTick * 3f);
				float num5 = Mathf.Clamp(FlatlinePlayer.ThirstConsumptionPerMinute + Mathf.Clamp(baseThirstConsumptionIncrease * (float)data.Progression * (1f + data.Severity), 0f, 0.0015f), 0f, FlatlinePlayer.DefaultThirstConsumption * 3f);
				FlatlinePlayer.ThirstConsumptionPerMinute = Mathf.Lerp(FlatlinePlayer.ThirstConsumptionPerMinute, num5, MaximumSystematicPropertyChangePerTick * 3f);
			}
			if (data.Progression >= 2 && data.HealState < 0.8f && Flatline.loadedPlayerData.State.healthData.MaxHP > 100f - MaximumMaxHPReduction)
			{
				float num6 = num2 * 5f / 1440f;
				float num7 = num2 * 2f / 1440f;
				float num8 = num6 - num7;
				float num9 = MaximumMaxHPReduction / 1440f * num8 / 10f;
				num9 = Mathf.Clamp01(Mathf.Lerp(num9, 0f, data.HealState));
				DebugModule.Log("Fever Max HP reduction: " + num9, "DiseaseEffect");
				if (Flatline.loadedPlayerData.State.healthData.MaxHP - num9 < Flatline.loadedPlayerData.State.healthData.CurrentHP)
				{
					float num10 = Flatline.loadedPlayerData.State.healthData.CurrentHP - (Flatline.loadedPlayerData.State.healthData.MaxHP - num9);
					if (Player.Local.Health.CurrentHealth - num10 <= 0f)
					{
						FlatlineUIModule.causeOfDeath = "Fever";
					}
					Player.Local.Health.TakeDamage(num10, false, false);
					FlatlinePlayer.AppendDamageSource($"Fever damage (-{num10}HP)");
				}
				Flatline.loadedPlayerData.State.healthData.MaxHP = Mathf.Clamp(Flatline.loadedPlayerData.State.healthData.MaxHP - num9, 10f, 100f);
			}
			if (minsSinceLastFeverShiver >= minsUntilNextFeverShiver)
			{
				Flatline.coros.Add(MelonCoroutines.Start(BlurShort()));
				minsSinceLastFeverShiver = 0;
				switch (data.Progression)
				{
				case 1:
					minsUntilNextFeverShiver = Random.Range(100, 200);
					break;
				case 2:
					minsUntilNextFeverShiver = Random.Range(80, 180);
					break;
				case 3:
					minsUntilNextFeverShiver = Random.Range(70, 120);
					break;
				case 4:
					minsUntilNextFeverShiver = Random.Range(50, 100);
					break;
				default:
					minsUntilNextFeverShiver = Random.Range(80, 360);
					break;
				}
			}
		}

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

		public override void DiseaseHealed()
		{
			if (FlatlinePlayer.EnergyConsumptionPerMinute > FlatlinePlayer.DefaultEnergyConsumption)
			{
				FlatlinePlayer.EnergyConsumptionPerMinute = Mathf.Lerp(FlatlinePlayer.EnergyConsumptionPerMinute, FlatlinePlayer.DefaultFoodConsumption, 0.5f);
			}
			if (FlatlinePlayer.ThirstConsumptionPerMinute > FlatlinePlayer.DefaultThirstConsumption)
			{
				FlatlinePlayer.ThirstConsumptionPerMinute = Mathf.Lerp(FlatlinePlayer.ThirstConsumptionPerMinute, FlatlinePlayer.DefaultThirstConsumption, 0.5f);
			}
			if (FlatlinePlayer.TemperatureConsumption > FlatlinePlayer.TemperatureConsumptionPerMinutePerDegreeDiff)
			{
				FlatlinePlayer.TemperatureConsumption = Mathf.Lerp(FlatlinePlayer.TemperatureConsumption, FlatlinePlayer.TemperatureConsumptionPerMinutePerDegreeDiff, 0.5f);
			}
			Player.Local.Avatar.Effects.SetSicklySkinColor(false);
			Player.Local.Avatar.EmotionManager.RemoveEmotionOverride("Sickly");
			DebugModule.Log("Healed fever succesfully", "DiseaseHealed");
		}

		public override void UpdateDiseaseData()
		{
		}
	}
	public abstract class Disease
	{
		[CompilerGenerated]
		private sealed class <DiseaseEvaluator>d__12 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Disease <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				Disease disease = <>4__this;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					if (!FlatlinePlayer.isQueuedForDeath || Flatline.currentConfig.PermanentDeath || Player.PlayerList.Count <= 1)
					{
						if (!Flatline.registered || FlatlinePlayer.isQueuedForDeath)
						{
							return false;
						}
						if (!Flatline.isSaving && !FlatlinePlayer.isPassedOut && !NetworkSingleton<TimeManager>.Instance.IsSleepInProgress && !Flatline.haltExecution && (Player.PlayerList.Count <= 1 || Player.Local.Health.IsAlive) && (NetworkSingleton<TimeManager>.Instance.CurrentTime >= 659 || NetworkSingleton<TimeManager>.Instance.CurrentTime <= 400))
						{
							if (disease.data.DiseaseID != "cancer" && Flatline.loadedPlayerData.State.Hunger > 0.9f)
							{
								disease.data.HealState += disease.ParasympatheticHealing;
							}
							if (disease.data.HealState >= 1f)
							{
								goto IL_01bd;
							}
							if (HospitalHealing.hospitalChoiceInitialized)
							{
								disease.UpdateChoiceState((NPC)(object)HospitalHealing.lisaNPC, HospitalHealing.lisaCureChoices);
								disease.UpdateChoiceState((NPC)(object)HospitalHealing.ireneNPC, HospitalHealing.ireneCureChoices);
							}
							disease.data.MinsSinceDiseaseStart += 10;
							disease.DiseaseEffect();
						}
					}
				}
				else
				{
					<>1__state = -1;
					FlatlineUIModule.diseaseIcons[disease.data.DiseaseID].SetActive(true);
					if (disease.onDiseaseStarted != null)
					{
						disease.onDiseaseStarted();
					}
				}
				if (disease.data.Active)
				{
					<>2__current = Flatline.Wait10;
					<>1__state = 1;
					return true;
				}
				goto IL_01bd;
				IL_01bd:
				disease.data.Active = false;
				FlatlineUIModule.diseaseIcons[disease.data.DiseaseID].SetActive(false);
				disease.DiseaseHealed();
				if (HospitalHealing.hospitalChoiceInitialized)
				{
					disease.UpdateChoiceState((NPC)(object)HospitalHealing.lisaNPC, HospitalHealing.lisaCureChoices);
					disease.UpdateChoiceState((NPC)(object)HospitalHealing.ireneNPC, HospitalHealing.ireneCureChoices);
				}
				disease.diseaseCoroutine = null;
				return false;
			}

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

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

		public readonly float ParasympatheticHealing = 0.0002f;

		public readonly float MaximumSystematicPropertyChangePerTick = 1f / 144f;

		public DiseaseData data;

		public object diseaseCoroutine;

		public Action onDiseaseStarted;

		public int minsRequiredForProgression { get; set; }

		public abstract void DiseaseEffect();

		public abstract void DiseaseHealed();

		public abstract void UpdateDiseaseData();

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

		private void UpdateChoiceState(NPC npc, Dictionary<string, DialogueChoice> choices)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)npc != (Object)null && choices.TryGetValue(data.DiseaseID, out var value))
			{
				value.Enabled = Vector3.Distance(npc.CenterPoint, HospitalHealing.hospitalDoorPoint) <= 7f && data.Active && data.HealState < 1f;
			}
		}
	}
	public static class PlayerConsumeDamage
	{
		public enum EConsumeType
		{
			None,
			Weed,
			Meth,
			Cocaine,
			Shroom,
			Paracetamol,
			Addy,
			Chili
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass31_0
		{
			public ProductItemInstance current;

			internal bool <CurrentProductMonitor>g__CanContinue|0()
			{
				if (Flatline.registered && !FlatlinePlayer.isQueuedForDeath && Player.Local.ConsumedProduct != null && Player.Local.ConsumedProduct == current)
				{
					return Flatline.haltExecution;
				}
				return true;
			}

			internal bool <CurrentProductMonitor>b__1()
			{
				return <CurrentProductMonitor>g__CanContinue|0();
			}
		}

		[CompilerGenerated]
		private sealed class <CurrentProductMonitor>d__31 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private <>c__DisplayClass31_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass31_0();
					if (ProductEffectRunning)
					{
						return false;
					}
					ProductEffectRunning = true;
					<>2__current = Flatline.Wait025;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>8__1.current = Player.Local.ConsumedProduct;
					if (<>8__1.current != null)
					{
						WaitUntil val = new WaitUntil((Func<bool>)(() => <>8__1.<CurrentProductMonitor>g__CanContinue|0()));
						<>2__current = val;
						<>1__state = 2;
						return true;
					}
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				DebugModule.Log("Current product has ended, disable", "CurrentProductMonitor");
				ProductEffectRunning = false;
				IsWeedEffectRunning = false;
				IsShroomEffectRunning = false;
				IsMethEffectRunning = false;
				IsCocaineEffectRunning = false;
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <HeartPumpOverride>d__34 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public string consumedID;

			private ConsumptionData <data>5__2;

			private float <maxTotalElapsed>5__3;

			private float <totalElapsed>5__4;

			private int <maxBeatsPerMinute>5__5;

			private int <minBeatsPerMinute>5__6;

			private float <elapsedSinceLast>5__7;

			private float <secondsForBeat>5__8;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					<totalElapsed>5__4 += 0.1f;
					<elapsedSinceLast>5__7 += 0.1f;
					if (<elapsedSinceLast>5__7 >= <secondsForBeat>5__8)
					{
						if ((Object)(object)heartBeatSource != (Object)null && !heartBeatSource.isPlaying)
						{
							heartBeatSource.PlayOneShot(ConfigLoader.loadedAudios["singleheartbeat"]);
						}
						if (Mathf.RoundToInt(<totalElapsed>5__4) % 5 == 0)
						{
							int num2 = Mathf.RoundToInt(Mathf.Lerp((float)<minBeatsPerMinute>5__6, (float)<maxBeatsPerMinute>5__5, Mathf.Clamp01(<data>5__2.currentAmountInSystem)));
							float num3 = (float)num2 / 60f;
							<secondsForBeat>5__8 = 1f / num3;
						}
					}
				}
				else
				{
					<>1__state = -1;
					if (heartPumpOverrideActive)
					{
						return false;
					}
					heartPumpOverrideActive = true;
					DebugModule.Log("Starting heart pump override", "HeartPumpOverride");
					if (!Flatline.loadedPlayerData.State.consumptionDatas.TryGetValue(consumedID, out <data>5__2))
					{
						DebugModule.Log("No match for id in consumption data", "HeartPumpOverride");
						heartPumpOverrideActive = false;
						return false;
					}
					if (!<HeartPumpOverride>g__CanContinue|34_0(<data>5__2))
					{
						heartPumpOverrideActive = false;
						return false;
					}
					<maxTotalElapsed>5__3 = 120f;
					<totalElapsed>5__4 = 0f;
					<maxBeatsPerMinute>5__5 = 200;
					<minBeatsPerMinute>5__6 = 70;
					int num2 = Mathf.RoundToInt(Mathf.Lerp((float)<minBeatsPerMinute>5__6, (float)<maxBeatsPerMinute>5__5, Mathf.Clamp01(<data>5__2.currentAmountInSystem)));
					DebugModule.Log("Setting bpm to " + num2, "HeartPumpOverride");
					<elapsedSinceLast>5__7 = 0f;
					float num3 = (float)num2 / 60f;
					<secondsForBeat>5__8 = 1f / num3;
				}
				if (!Flatline.registered)
				{
					return false;
				}
				if (<HeartPumpOverride>g__CanContinue|34_0(<data>5__2) && !(<totalElapsed>5__4 >= <maxTotalElapsed>5__3))
				{
					<>2__current = Flatline.Wait01;
					<>1__state = 1;
					return true;
				}
				DebugModule.Log("Finished heart pump override", "HeartPumpOverride");
				heartPumpOverrideActive = false;
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <ShroomEffectChanger>d__32 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private float <amplitudeMax>5__2;

			private float <amplitudeMin>5__3;

			private float <blendMax>5__4;

			private float <blendMin>5__5;

			private float <noiseScaleMax>5__6;

			private float <noiseScaleMin>5__7;

			private float <targetAmp>5__8;

			private float <targetBld>5__9;

			private float <targetNoi>5__10;

			private MaterialProperties <activeProperties>5__11;

			private MaterialProperties <source>5__12;

			private MaterialProperties <targetMaterialProperties>5__13;

			private float <easeInTime>5__14;

			private float <currentEase>5__15;

			private float <sleepTime>5__16;

			private float <sleepCurrent>5__17;

			private bool <shouldBreak>5__18;

			private MaterialProperties <temp>5__19;

			private bool <useBlend>5__20;

			private bool <useNoise>5__21;

			private bool <useAmplitude>5__22;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<activeProperties>5__11 = null;
				<source>5__12 = null;
				<targetMaterialProperties>5__13 = null;
				<temp>5__19 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				ConsumptionData value2;
				float num2;
				float num3;
				float num4;
				float num5;
				List<int> list;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					if (IsShroomEffectRunning)
					{
						return false;
					}
					IsShroomEffectRunning = true;
					<amplitudeMax>5__2 = 0.5f;
					<amplitudeMin>5__3 = 0.19f;
					<blendMax>5__4 = 0.4f;
					<blendMin>5__5 = 0.016f;
					<noiseScaleMax>5__6 = 50f;
					<noiseScaleMin>5__7 = 15f;
					float num = 0f;
					if (Flatline.loadedPlayerData.State.consumptionDatas.TryGetValue("shroom", out var value))
					{
						num = Mathf.Clamp01(value.currentAmountInSystem);
					}
					<targetAmp>5__8 = Mathf.Lerp(<amplitudeMin>5__3, <amplitudeMax>5__2, num) * Random.Range(0.95f, 1.05f);
					<targetBld>5__9 = Mathf.Lerp(<blendMin>5__5, <blendMax>5__4, num) * Random.Range(0.95f, 1.05f);
					<targetNoi>5__10 = Mathf.Lerp(<noiseScaleMin>5__7, <noiseScaleMax>5__6, num) * Random.Range(0.95f, 1.05f);
					<activeProperties>5__11 = Singleton<PostProcessingManager>.Instance.GetActivePsychedelicEffectProperties();
					<source>5__12 = <activeProperties>5__11.Clone();
					PsychedelicFullScreenData psychedelicEffectDataPreset = Singleton<PostProcessingManager>.Instance.GetPsychedelicEffectDataPreset("Active");
					<targetMaterialProperties>5__13 = psychedelicEffectDataPreset.ConvertToMaterialProperties();
					<targetMaterialProperties>5__13.Blend = <targetBld>5__9;
					<targetMaterialProperties>5__13.NoiseScale = <targetNoi>5__10;
					<targetMaterialProperties>5__13.Amplitude = <targetAmp>5__8;
					Singleton<EnvironmentFX>.Instance.SetEnvironmentScrollingActive(true);
					Singleton<PostProcessingManager>.Instance.SetPsychedelicEffectActive(true);
					<easeInTime>5__14 = 2f;
					<currentEase>5__15 = 0f;
					goto IL_0243;
				}
				case 1:
					<>1__state = -1;
					goto IL_0243;
				case 2:
					<>1__state = -1;
					goto IL_02d7;
				case 3:
					{
						<>1__state = -1;
						goto IL_06d2;
					}
					IL_0281:
					if (<shouldBreak>5__18)
					{
						break;
					}
					goto IL_02d7;
					IL_02d7:
					if (<sleepCurrent>5__17 < <sleepTime>5__16)
					{
						<sleepCurrent>5__17 += Time.deltaTime;
						if (!Flatline.registered)
						{
							return false;
						}
						if (ProductEffectRunning && IsShroomEffectRunning)
						{
							<>2__current = null;
							<>1__state = 2;
							return true;
						}
						<shouldBreak>5__18 = true;
					}
					<sleepCurrent>5__17 = 0f;
					if (<shouldBreak>5__18)
					{
						break;
					}
					if (Flatline.isSaving || !Flatline.loadedPlayerData.State.consumptionDatas.TryGetValue("shroom", out value2))
					{
						goto IL_0281;
					}
					num2 = Mathf.Clamp01(value2.currentAmountInSystem);
					if (num2 > 0.75f && Random.Range(0f, 1f) > 0.98f)
					{
						Player.Local.Avatar.Effects.TriggerSick(false);
						Flatline.loadedPlayerData.State.Hunger = Mathf.Clamp01(Flatline.loadedPlayerData.State.Hunger - 0.05f);
						Flatline.loadedPlayerData.State.Thirst = Mathf.Clamp01(Flatline.loadedPlayerData.State.Thirst - 0.02f);
					}
					<targetAmp>5__8 = Mathf.Lerp(<amplitudeMin>5__3, <amplitudeMax>5__2, num2);
					<targetBld>5__9 = Mathf.Lerp(<blendMin>5__5, <blendMax>5__4, num2);
					<targetNoi>5__10 = Mathf.Lerp(<noiseScaleMin>5__7, <noiseScaleMax>5__6, num2);
					<temp>5__19 = Singleton<PostProcessingManager>.Instance.GetActivePsychedelicEffectProperties().Clone();
					<targetAmp>5__8 = Mathf.Clamp(<targetAmp>5__8, <temp>5__19.Amplitude - <amplitudeMax>5__2 / 10f, <temp>5__19.Amplitude + <amplitudeMax>5__2 / 10f);
					<targetBld>5__9 = Mathf.Clamp(<targetBld>5__9, <temp>5__19.Blend - <blendMax>5__4 / 10f, <temp>5__19.Blend + <blendMax>5__4 / 10f);
					<targetNoi>5__10 = Mathf.Clamp(<targetNoi>5__10, <temp>5__19.NoiseScale - <noiseScaleMax>5__6 / 10f, <temp>5__19.NoiseScale + <noiseScaleMax>5__6 / 10f);
					num3 = Random.Range(0f, 1f);
					num4 = Random.Range(0f, 1f);
					num5 = Random.Range(0f, 1f);
					<useBlend>5__20 = false;
					<useNoise>5__21 = false;
					<useAmplitude>5__22 = false;
					list = new List<int> { 0, 1, 2 };
					ListExtensions.Shuffle<int>((IList<int>)list, -1);
					for (int i = 0; i < 2; i++)
					{
						if (list[i] == 0 && (double)num3 > 0.33)
						{
							<useBlend>5__20 = true;
						}
						if (list[i] == 1 && (double)num4 > 0.33)
						{
							<useNoise>5__21 = true;
						}
						if (list[i] == 2 && (double)num5 > 0.33)
						{
							<useAmplitude>5__22 = true;
						}
					}
					if (<useBlend>5__20 | <useNoise>5__21 | <useAmplitude>5__22)
					{
						<currentEase>5__15 = 0f;
						goto IL_06d2;
					}
					goto IL_0736;
					IL_06d2:
					if (<currentEase>5__15 < <easeInTime>5__14)
					{
						if (!Flatline.registered)
						{
							return false;
						}
						if (ProductEffectRunning && IsShroomEffectRunning)
						{
							<currentEase>5__15 += Time.deltaTime;
							float num6 = <currentEase>5__15 / <easeInTime>5__14;
							float num7 = Mathf.SmoothStep(0f, 1f, num6);
							if (<useBlend>5__20)
							{
								<activeProperties>5__11.Blend = Mathf.Lerp(<temp>5__19.Blend, <targetBld>5__9, num7);
							}
							if (<useNoise>5__21)
							{
								<activeProperties>5__11.NoiseScale = Mathf.Lerp(<temp>5__19.NoiseScale, <targetNoi>5__10, num7);
							}
							if (<useAmplitude>5__22)
							{
								<activeProperties>5__11.Amplitude = Mathf.Lerp(<temp>5__19.Amplitude, <targetAmp>5__8, num7);
							}
							<>2__current = null;
							<>1__state = 3;
							return true;
						}
						<shouldBreak>5__18 = true;
					}
					if (<shouldBreak>5__18)
					{
						break;
					}
					<targetMaterialProperties>5__13 = <activeProperties>5__11.Clone();
					Singleton<PostProcessingManager>.Instance.SetPsychedelicEffectProperties(<targetMaterialProperties>5__13);
					<sleepTime>5__16 = Random.Range(5f, 10f);
					<easeInTime>5__14 = Random.Range(2f, 6f);
					goto IL_0736;
					IL_0736:
					<temp>5__19 = null;
					goto IL_0281;
					IL_0243:
					if (<currentEase>5__15 < <easeInTime>5__14)
					{
						if (!Flatline.registered)
						{
							return false;
						}
						<currentEase>5__15 += Time.deltaTime;
						float num8 = <currentEase>5__15 / <easeInTime>5__14;
						<activeProperties>5__11.Blend = Mathf.Lerp(<source>5__12.Blend, <targetMaterialProperties>5__13.Blend, num8);
						Singleton<EnvironmentFX>.Instance.SetEnvironmentScrollingSpeedByPercentage(Mathf.Lerp(0f, 1f, num8));
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					Singleton<PostProcessingManager>.Instance.SetPsychedelicEffectProperties(<targetMaterialProperties>5__13);
					<sleepTime>5__16 = 5f;
					<sleepCurrent>5__17 = 0f;
					<shouldBreak>5__18 = false;
					goto IL_0281;
				}
				DebugModule.Log("Shroom effect changer ended", "ShroomEffectChanger");
				IsShroomEffectRunning = false;
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <StimulantEffectChanger>d__33 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private float <sleepTime>5__2;

			private float <sleepCurrent>5__3;

			private bool <shouldBreak>5__4;

			private float <rotAmount>5__5;

			private int <i>5__6;

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

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

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

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

			private bool MoveNext()
			{
				//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0348: Unknown result type (might be due to invalid IL or missing references)
				//IL_034f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0362: Unknown result type (might be due to invalid IL or missing references)
				//IL_0369: Unknown result type (might be due to invalid IL or missing references)
				ConsumptionData value;
				ConsumptionData value2;
				float num5;
				float num6;
				float num7;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (IsCocaineEffectRunning || IsMethEffectRunning)
					{
						return false;
					}
					IsCocaineEffectRunning = true;
					IsMethEffectRunning = true;
					<>2__current = Flatline.Wait2;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!Flatline.registered)
					{
						return false;
					}
					<sleepTime>5__2 = 2f;
					<sleepCurrent>5__3 = 0f;
					<shouldBreak>5__4 = false;
					goto IL_0083;
				case 2:
					<>1__state = -1;
					goto IL_00e0;
				case 3:
					{
						<>1__state = -1;
						if (!Flatline.registered)
						{
							return false;
						}
						if (!ProductEffectRunning || !IsMethEffectRunning || !IsCocaineEffectRunning)
						{
							<shouldBreak>5__4 = true;
							goto IL_043a;
						}
						if (Random.Range(0f, 1f) > 0.55f)
						{
							float num = 0.5f;
							float num2 = 0f;
							Quaternion rotation = ((Component)Player.Local).transform.root.rotation;
							while (num2 < num)
							{
								if (!Flatline.registered)
								{
									return false;
								}
								if (!ProductEffectRunning || !IsMethEffectRunning || !IsCocaineEffectRunning)
								{
									<shouldBreak>5__4 = true;
									break;
								}
								num2 += Time.deltaTime;
								float num3 = num2 / num;
								((Component)Player.Local).transform.root.rotation = Quaternion.Lerp(rotation, Quaternion.Euler(0f, rotation.y + <rotAmount>5__5, 0f), num3);
							}
							if (<shouldBreak>5__4)
							{
								goto IL_043a;
							}
						}
						if (<i>5__6 % 2 == 0)
						{
							PlayerInventory instance = PlayerSingleton<PlayerInventory>.Instance;
							if (!GameInput.IsTyping && !Singleton<PauseMenu>.Instance.IsPaused && instance.HotbarEnabled)
							{
								int num4 = Random.Range(0, 8);
								if (num4 != instance.EquippedSlotIndex)
								{
									if (instance.EquippedSlotIndex != -1)
									{
										instance.IndexAllSlots(instance.EquippedSlotIndex).Unequip();
									}
									instance.PreviousEquippedSlotIndex = instance.EquippedSlotIndex;
									instance.EquippedSlotIndex = num4;
									instance.Equip(instance.IndexAllSlots(num4));
									PlayerSingleton<ViewmodelSway>.Instance.RefreshViewmodel();
								}
							}
						}
						<i>5__6++;
						goto IL_0428;
					}
					IL_043a:
					if (<shouldBreak>5__4)
					{
						break;
					}
					goto IL_0083;
					IL_0428:
					if (<i>5__6 < Random.Range(4, 8))
					{
						<>2__current = Flatline.Wait05;
						<>1__state = 3;
						return true;
					}
					goto IL_043a;
					IL_0083:
					if (<shouldBreak>5__4)
					{
						break;
					}
					goto IL_00e0;
					IL_00e0:
					if (<sleepCurrent>5__3 < <sleepTime>5__2)
					{
						<sleepCurrent>5__3 += Time.deltaTime;
						if (!Flatline.registered)
						{
							return false;
						}
						if (ProductEffectRunning && IsMethEffectRunning && IsCocaineEffectRunning)
						{
							<>2__current = null;
							<>1__state = 2;
							return true;
						}
						<shouldBreak>5__4 = true;
					}
					<sleepCurrent>5__3 = 0f;
					if (<shouldBreak>5__4)
					{
						break;
					}
					num5 = 0f;
					if (Flatline.loadedPlayerData.State.consumptionDatas.TryGetValue("meth", out value) && value.currentAmountInSystem > 0.001f)
					{
						num5 = value.currentAmountInSystem;
					}
					if (Flatline.loadedPlayerData.State.consumptionDatas.TryGetValue("cocaine", out value2) && value2.currentAmountInSystem > 0.001f && value2.currentAmountInSystem > num5)
					{
						num5 = value2.currentAmountInSystem;
					}
					num5 = Mathf.Clamp01(num5);
					if (num5 > 0.75f && Random.Range(0f, 1f) > 0.98f)
					{
						Player.Local.Avatar.Effects.TriggerSick(false);
						Flatline.loadedPlayerData.State.Hunger = Mathf.Clamp01(Flatline.loadedPlayerData.State.Hunger - 0.05f);
						Flatline.loadedPlayerData.State.Thirst = Mathf.Clamp01(Flatline.loadedPlayerData.State.Thirst - 0.02f);
					}
					num6 = Mathf.Lerp(0.9f, 0.75f, num5);
					if (Random.Range(0f, 1f) < num6)
					{
						goto IL_0083;
					}
					num7 = Mathf.Lerp(1.15f, 2f, num5);
					<rotAmount>5__5 = Random.Range(2f, 6f) * num7;
					<rotAmount>5__5 = ((Random.Range(0, 2) == 0) ? (0f - <rotAmount>5__5) : <rotAmount>5__5);
					<i>5__6 = 0;
					goto IL_0428;
				}
				IsCocaineEffectRunning = false;
				IsMethEffectRunning = false;
				DebugModule.Log("Stimulant effect changer ended", "StimulantEffectChanger");
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <SystemicDecay>d__29 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (Flatline.isSaving)
					{
						WaitUntil val = new WaitUntil((Func<bool>)(() => !Flatline.isSa