using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
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.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using BoneLib;
using BoneLib.BoneMenu;
using BoneLib.BoneMenu.UI;
using BoneLib.Notifications;
using HarmonyLib;
using Il2CppCysharp.Threading.Tasks;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSLZ.Bonelab;
using Il2CppSLZ.Marrow;
using Il2CppSLZ.Marrow.AI;
using Il2CppSLZ.Marrow.Combat;
using Il2CppSLZ.Marrow.Data;
using Il2CppSLZ.Marrow.Interaction;
using Il2CppSLZ.Marrow.Pool;
using Il2CppSLZ.Marrow.PuppetMasta;
using Il2CppSLZ.Marrow.SceneStreaming;
using Il2CppSLZ.Marrow.Warehouse;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppTMPro;
using LabFusion.Data;
using LabFusion.Data.Serializables;
using LabFusion.Entities;
using LabFusion.Marrow.Messages;
using LabFusion.Network;
using LabFusion.Player;
using LabFusion.RPC;
using MelonLoader;
using Microsoft.CodeAnalysis;
using PersistentScene;
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(Core), "PersistentScene", "1.0.0", "CAitStudio", null)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: MelonOptionalDependencies(new string[] { "LabFusion" })]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("PersistentScene")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("PersistentScene")]
[assembly: AssemblyTitle("PersistentScene")]
[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.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace PersistentScene
{
	public class Core : MelonMod
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass69_0
		{
			public Constrainer constrainer;

			public int got;

			public Action<Constrainer> <>9__0;

			public Action<int> <>9__1;

			internal void <RestoreConstraintsWithRetryTimeSliced>b__0(Constrainer constrainerInstance)
			{
				constrainer = constrainerInstance;
			}

			internal void <RestoreConstraintsWithRetryTimeSliced>b__1(int count)
			{
				got = count;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass95_0
		{
			public Constrainer constrainer;

			public int joints;

			internal void <LoadCurrentLevelSave>b__0(Constrainer constrainerInstance)
			{
				constrainer = constrainerInstance;
			}

			internal void <LoadCurrentLevelSave>b__1(int got)
			{
				joints = got;
			}
		}

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

			private object <>2__current;

			public SceneSaveFile save;

			public Core <>4__this;

			public List<Poolee> made;

			private Stopwatch <stopwatch>5__2;

			private int <i>5__3;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				Core core = <>4__this;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					<stopwatch>5__2.Restart();
					goto IL_00f1;
				}
				<>1__state = -1;
				<stopwatch>5__2 = Stopwatch.StartNew();
				<i>5__3 = 0;
				goto IL_0103;
				IL_0103:
				if (<i>5__3 < save.Objects.Count && <i>5__3 < made.Count)
				{
					if (!save.Objects[<i>5__3].HasAIBrain)
					{
						HealthRecord health = save.Objects[<i>5__3].Health;
						if (health == null || !health.IsDead.GetValueOrDefault())
						{
							goto IL_00b5;
						}
					}
					core.ApplySavedTransforms(made[<i>5__3], save.Objects[<i>5__3], restoreWorldPose: true, keepRigidbodiesFrozen: true);
					goto IL_00b5;
				}
				return false;
				IL_00f1:
				<i>5__3++;
				goto IL_0103;
				IL_00b5:
				if (<stopwatch>5__2.Elapsed.TotalMilliseconds >= restoreBudget)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				goto IL_00f1;
			}

			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 <DespawnExistingPooleesTimeSliced>d__85 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Core <>4__this;

			private Stopwatch <stopwatch>5__2;

			private Poolee[] <>7__wrap2;

			private int <>7__wrap3;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				Core core = <>4__this;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					<stopwatch>5__2.Restart();
					goto IL_00e2;
				}
				<>1__state = -1;
				<stopwatch>5__2 = Stopwatch.StartNew();
				<>7__wrap2 = core.PooleesNow();
				<>7__wrap3 = 0;
				goto IL_00f0;
				IL_00e2:
				<>7__wrap3++;
				goto IL_00f0;
				IL_00f0:
				if (<>7__wrap3 < <>7__wrap2.Length)
				{
					Poolee val = <>7__wrap2[<>7__wrap3];
					if (core.CanClearPoolee(val))
					{
						SpawnableCrate spawnableCrate = val.SpawnableCrate;
						object value;
						if (spawnableCrate == null)
						{
							value = null;
						}
						else
						{
							Barcode barcode = ((Scannable)spawnableCrate).Barcode;
							value = ((barcode != null) ? barcode.ID : null);
						}
						if (!string.IsNullOrWhiteSpace((string?)value))
						{
							try
							{
								val.Despawn();
								core.Dirty();
							}
							catch
							{
								Object.Destroy((Object)(object)((Component)val).gameObject);
								core.Dirty();
							}
							if (<stopwatch>5__2.Elapsed.TotalMilliseconds >= restoreBudget)
							{
								<>2__current = null;
								<>1__state = 1;
								return true;
							}
						}
					}
					goto IL_00e2;
				}
				<>7__wrap2 = 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();
			}
		}

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

			private object <>2__current;

			public Core <>4__this;

			private Stopwatch <stopwatch>5__2;

			private Poolee[] <>7__wrap2;

			private int <>7__wrap3;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				Core core = <>4__this;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					<stopwatch>5__2.Restart();
					goto IL_0100;
				}
				<>1__state = -1;
				<stopwatch>5__2 = Stopwatch.StartNew();
				<>7__wrap2 = core.PooleesNow();
				<>7__wrap3 = 0;
				goto IL_010e;
				IL_0100:
				<>7__wrap3++;
				goto IL_010e;
				IL_010e:
				if (<>7__wrap3 < <>7__wrap2.Length)
				{
					Poolee val = <>7__wrap2[<>7__wrap3];
					if (!((Object)(object)val == (Object)null))
					{
						SpawnableCrate spawnableCrate = val.SpawnableCrate;
						if (!(((spawnableCrate != null) ? ((Scannable)spawnableCrate).Barcode : null) == (Barcode)null))
						{
							string iD = ((Scannable)val.SpawnableCrate).Barcode.ID;
							if (IsSpentCasing(val, iD) || IsLooseEmptyMagazine(val))
							{
								try
								{
									val.Despawn();
									core.Dirty();
								}
								catch
								{
									Object.Destroy((Object)(object)((Component)val).gameObject);
									core.Dirty();
								}
								if (<stopwatch>5__2.Elapsed.TotalMilliseconds >= restoreBudget)
								{
									<>2__current = null;
									<>1__state = 1;
									return true;
								}
							}
						}
					}
					goto IL_0100;
				}
				<>7__wrap2 = 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();
			}
		}

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

			private object <>2__current;

			public Core <>4__this;

			private int <i>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Expected O, but got Unknown
				int num = <>1__state;
				Core CS$<>8__locals0 = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<i>5__2 = 0;
					break;
				case 1:
				{
					<>1__state = -1;
					Button val = CS$<>8__locals0.FindYesButton();
					if (!((Object)(object)val == (Object)null))
					{
						CS$<>8__locals0.RetitlePopup(((Component)val).gameObject);
						val.onClick = new ButtonClickedEvent();
						((UnityEvent)val.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
						{
							if (!CS$<>8__locals0.SaveCurrentLevel("SaveAndQuit"))
							{
								((MelonBase)CS$<>8__locals0).LoggerInstance.Warning("falied to save,pls try again");
							}
							else
							{
								CS$<>8__locals0._quitSaved = true;
								Application.Quit();
							}
						}));
						return false;
					}
					<i>5__2++;
					break;
				}
				}
				if (<i>5__2 < 60)
				{
					<>2__current = null;
					<>1__state = 1;
					return 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();
			}
		}

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

			private object <>2__current;

			public Core <>4__this;

			public Action<Constrainer> onResolved;

			private Constrainer <made>5__2;

			private Task<Poolee> <spawnTask>5__3;

			private float <timeoutAt>5__4;

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

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

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

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

			private bool MoveNext()
			{
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				Core core = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((Object)(object)core._dummyConstrainer != (Object)null && !((Il2CppObjectBase)core._dummyConstrainer).WasCollected)
					{
						onResolved?.Invoke(core._dummyConstrainer);
						return false;
					}
					<made>5__2 = null;
					<spawnTask>5__3 = null;
					try
					{
						string barcode = Barcodes.Get(SceneSaveBarcode.CONSTRAINER);
						<spawnTask>5__3 = SpawnBits.SpawnAsync(barcode, new Vector3(1000f, 1000f, 1000f), Quaternion.identity, Vector3.one);
					}
					catch (Exception ex)
					{
						((MelonBase)core).LoggerInstance.Warning("Could not spawn dummy constrainer: " + ex.Message);
					}
					<timeoutAt>5__4 = Time.realtimeSinceStartup + 12f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<spawnTask>5__3 != null && !<spawnTask>5__3.IsCompleted && Time.realtimeSinceStartup < <timeoutAt>5__4)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				if (<spawnTask>5__3 != null && <spawnTask>5__3.IsCompletedSuccessfully)
				{
					Poolee result = <spawnTask>5__3.Result;
					if ((Object)(object)result != (Object)null)
					{
						SuppressDummyVisualEffects(((Component)result).gameObject);
						<made>5__2 = ((Component)result).GetComponent<Constrainer>() ?? ((Component)result).GetComponentInChildren<Constrainer>(true);
					}
				}
				core._dummyConstrainer = <made>5__2 ?? Object.FindObjectOfType<Constrainer>();
				if ((Object)(object)core._dummyConstrainer != (Object)null)
				{
					SuppressDummyVisualEffects(((Component)core._dummyConstrainer).gameObject);
				}
				onResolved?.Invoke(core._dummyConstrainer);
				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 <HoldKinematicLoadWindow>d__133 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public float seconds;

			public Dictionary<Rigidbody, bool> frozen;

			private float <endTime>5__2;

			private float <nextReassertTime>5__3;

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

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

			[DebuggerHidden]
			public <HoldKinematicLoadWindow>d__133(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 (seconds <= 0f)
					{
						return false;
					}
					<endTime>5__2 = Time.realtimeSinceStartup + seconds;
					<nextReassertTime>5__3 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (Time.realtimeSinceStartup < <endTime>5__2)
				{
					if (Time.realtimeSinceStartup >= <nextReassertTime>5__3)
					{
						ReassertFrozenRigidbodies(frozen);
						<nextReassertTime>5__3 = Time.realtimeSinceStartup + 0.25f;
					}
					try
					{
						Physics.SyncTransforms();
					}
					catch
					{
					}
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				ReassertFrozenRigidbodies(frozen);
				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 <KeepPlayerThere>d__255 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public PlayerPoseRecord pose;

			public Core <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Expected O, but got Unknown
				int num = <>1__state;
				Core core = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (pose == null)
					{
						return false;
					}
					break;
				case 1:
				{
					<>1__state = -1;
					RigManager val = TryGetRigManager();
					if ((Object)(object)val != (Object)null && (Object)(object)val.remapHeptaRig != (Object)null)
					{
						HoldPlayerThere(val, pose, 0.18f);
					}
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				case 2:
					<>1__state = -1;
					break;
				}
				if (core._holdPlayer && core._loadingNow)
				{
					RigManager val = TryGetRigManager();
					if ((Object)(object)val != (Object)null && (Object)(object)val.remapHeptaRig != (Object)null)
					{
						HoldPlayerThere(val, pose, 0.18f);
					}
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 1;
					return 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();
			}
		}

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

			private object <>2__current;

			public Core <>4__this;

			public string path;

			public bool automatic;

			private <>c__DisplayClass95_0 <>8__1;

			private SceneSaveFile <save>5__2;

			private bool <interceptedAutoLoad>5__3;

			private bool <movePlayer>5__4;

			private Dictionary<Rigidbody, bool> <frozen>5__5;

			private List<Poolee> <made>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 22u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>8__1 = null;
				<save>5__2 = null;
				<frozen>5__5 = null;
				<made>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0464: Unknown result type (might be due to invalid IL or missing references)
				//IL_046e: Expected O, but got Unknown
				//IL_04b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_04c3: Expected O, but got Unknown
				//IL_0223: Unknown result type (might be due to invalid IL or missing references)
				//IL_022d: Expected O, but got Unknown
				try
				{
					int num = <>1__state;
					Core core = <>4__this;
					bool[] array;
					List<int> spawnOrder;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (!core._config.ModEnabled)
						{
							core._blockDefaultCrateSpawners = false;
							core._skipSceneSpawnerRouteForLoad = false;
							return false;
						}
						if (!FusionCompat.CanTouchScene)
						{
							core._blockDefaultCrateSpawners = false;
							core._skipSceneSpawnerRouteForLoad = false;
							((MelonBase)core).LoggerInstance.Msg("Fusion client detected, skipping load.");
							return false;
						}
						if (core._loadingNow)
						{
							return false;
						}
						try
						{
							<save>5__2 = LoadSaveFile(path);
						}
						catch (Exception value)
						{
							((MelonBase)core).LoggerInstance.Error($"Load failed: {value}");
							return false;
						}
						if (<save>5__2 == null || <save>5__2.LevelBarcode != core._levelBarcode)
						{
							core._blockDefaultCrateSpawners = false;
							((MelonBase)core).LoggerInstance.Warning("Save file does not match current level, skipping: " + path);
							return false;
						}
						EnsureSaveIds(<save>5__2);
						core.CleanSave(<save>5__2);
						if (core.IsBlacklisted(core._levelBarcode) || core.IsBlacklisted(<save>5__2.LevelBarcode))
						{
							core._blockDefaultCrateSpawners = false;
							((MelonBase)core).LoggerInstance.Msg("Skipping load for blacklisted level: " + core._levelBarcode);
							return false;
						}
						core._loadingNow = true;
						<>1__state = -3;
						<>8__1 = new <>c__DisplayClass95_0();
						<interceptedAutoLoad>5__3 = automatic && core._blockDefaultCrateSpawners;
						core._skipSceneSpawnerRouteForLoad = <interceptedAutoLoad>5__3;
						NotifySaveLoadStarted();
						<>2__current = (object)new WaitForSecondsRealtime(GetLoadDelay(automatic));
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						<>2__current = RestorePlayerAmmoWhenReady(<save>5__2.PlayerAmmo);
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -3;
						<>2__current = core.RestorePlayerInventoryWhenReady(<save>5__2.PlayerInventory);
						<>1__state = 3;
						return true;
					case 3:
						<>1__state = -3;
						<movePlayer>5__4 = core._config.SavePlayerLocation && <save>5__2.PlayerPose != null;
						if (<movePlayer>5__4)
						{
							core._holdPlayer = true;
							MelonCoroutines.Start(core.KeepPlayerThere(<save>5__2.PlayerPose));
							<>2__current = core.MovePlayerWhenReady(<save>5__2.PlayerPose);
							<>1__state = 4;
							return true;
						}
						goto IL_0314;
					case 4:
						<>1__state = -3;
						goto IL_0314;
					case 5:
						<>1__state = -3;
						<>2__current = core.DespawnExistingPooleesTimeSliced();
						<>1__state = 6;
						return true;
					case 6:
						<>1__state = -3;
						goto IL_037e;
					case 7:
						<>1__state = -3;
						<>2__current = (object)new WaitForSecondsRealtime(0.05f);
						<>1__state = 8;
						return true;
					case 8:
						<>1__state = -3;
						<>2__current = core.ApplyNpcWorldPosePass(<save>5__2, <made>5__6);
						<>1__state = 9;
						return true;
					case 9:
						<>1__state = -3;
						<>2__current = (object)new WaitForSecondsRealtime(0.1f);
						<>1__state = 10;
						return true;
					case 10:
						<>1__state = -3;
						<>2__current = core.ApplyNpcWorldPosePass(<save>5__2, <made>5__6);
						<>1__state = 11;
						return true;
					case 11:
						<>1__state = -3;
						<>2__current = RestoreSavedRigidbodyStatesTimeSliced(<save>5__2, <made>5__6, <frozen>5__5, keepKinematic: true);
						<>1__state = 12;
						return true;
					case 12:
						<>1__state = -3;
						core.RegrabLoadedRigidbodies(<save>5__2, <made>5__6, <frozen>5__5);
						((MelonBase)core).LoggerInstance.Msg($"Holding loaded rigidbodies kinematic for {2f:0.#} seconds.");
						<>2__current = HoldKinematicLoadWindow(2f, <frozen>5__5);
						<>1__state = 13;
						return true;
					case 13:
						<>1__state = -3;
						<>2__current = core.ApplyNpcWorldPosePass(<save>5__2, <made>5__6);
						<>1__state = 14;
						return true;
					case 14:
						<>1__state = -3;
						core.RegrabLoadedRigidbodies(<save>5__2, <made>5__6, <frozen>5__5);
						<>2__current = RestoreSavedRigidbodyStatesTimeSliced(<save>5__2, <made>5__6, <frozen>5__5, keepKinematic: true);
						<>1__state = 15;
						return true;
					case 15:
						<>1__state = -3;
						<>8__1.constrainer = null;
						<>2__current = core.GetOrSpawnConstrainer(delegate(Constrainer constrainerInstance)
						{
							<>8__1.constrainer = constrainerInstance;
						});
						<>1__state = 16;
						return true;
					case 16:
						<>1__state = -3;
						<>8__1.joints = 0;
						<>2__current = core.RestoreConstraintsWithRetryTimeSliced(<save>5__2, <made>5__6, <>8__1.constrainer, delegate(int got)
						{
							<>8__1.joints = got;
						});
						<>1__state = 17;
						return true;
					case 17:
						<>1__state = -3;
						<>2__current = core.RestoreNpcHealthTimeSliced(<save>5__2, <made>5__6);
						<>1__state = 18;
						return true;
					case 18:
						<>1__state = -3;
						<>2__current = core.RestoreSceneLogicStates(<save>5__2);
						<>1__state = 19;
						return true;
					case 19:
						<>1__state = -3;
						<>2__current = RestoreSavedRigidbodyStatesTimeSliced(<save>5__2, <made>5__6, <frozen>5__5, keepKinematic: false);
						<>1__state = 20;
						return true;
					case 20:
						<>1__state = -3;
						<>2__current = core.StabilizeDeadNpcPosesTimeSliced(<save>5__2, <made>5__6);
						<>1__state = 21;
						return true;
					case 21:
						<>1__state = -3;
						UnfreezeRemainingRigidbodies(<frozen>5__5);
						if (<movePlayer>5__4)
						{
							core._holdPlayer = false;
							<>2__current = null;
							<>1__state = 22;
							return true;
						}
						break;
					case 22:
						<>1__state = -3;
						<>2__current = core.PutPlayerBackAfterLoad(<save>5__2.PlayerPose);
						<>1__state = 23;
						return true;
					case 23:
						{
							<>1__state = -3;
							break;
						}
						IL_037e:
						core._blockDefaultCrateSpawners = false;
						<frozen>5__5 = new Dictionary<Rigidbody, bool>(UnityObjectComparer<Rigidbody>.Instance);
						<made>5__6 = Enumerable.Repeat<Poolee>(null, <save>5__2.Objects.Count).ToList();
						array = new bool[<save>5__2.Objects.Count];
						spawnOrder = GetSpawnOrder(<save>5__2);
						foreach (int item in Enumerable.Range(0, <save>5__2.Objects.Count).Except(spawnOrder))
						{
							array[item] = true;
						}
						<>2__current = core.SpawnSavedObjectsOneAtATime(<save>5__2, <made>5__6, array, <frozen>5__5, spawnOrder);
						<>1__state = 7;
						return true;
						IL_0314:
						if (!<interceptedAutoLoad>5__3)
						{
							core.MarkExistingDeletedPoolees(<save>5__2);
							<>2__current = core.DespawnIgnoredPooleesTimeSliced();
							<>1__state = 5;
							return true;
						}
						((MelonBase)core).LoggerInstance.Msg("Skipped scene spawnable scan/clear because default CrateSpawners were blocked for this auto-load.");
						goto IL_037e;
					}
					<save>5__2.SupportedVersion = "1.0.0";
					WriteSaveOver(path, <save>5__2);
					NotifySaveLoadFinished(<made>5__6.Count, <>8__1.joints);
					((MelonBase)core).LoggerInstance.Msg($"Loaded {<made>5__6.Count} saved spawnables and got {<>8__1.joints}/{<save>5__2.Constraints.Count} constraints for {core._levelBarcode}.");
					<>8__1 = null;
					<frozen>5__5 = null;
					<made>5__6 = null;
					<>m__Finally1();
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				Core core = <>4__this;
				core._blockDefaultCrateSpawners = false;
				core._skipSceneSpawnerRouteForLoad = false;
				core._holdPlayer = false;
				core._loadingNow = false;
			}

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

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

			private object <>2__current;

			public PlayerPoseRecord pose;

			public bool rotatePlayer;

			private int <i>5__2;

			private RigManager <rigManager>5__3;

			private int <repeat>5__4;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (pose == null)
					{
						return false;
					}
					<i>5__2 = 0;
					goto IL_0102;
				case 1:
					<>1__state = -1;
					<repeat>5__4++;
					goto IL_00c9;
				case 2:
					{
						<>1__state = -1;
						<rigManager>5__3 = null;
						<i>5__2++;
						goto IL_0102;
					}
					IL_00c9:
					if (<repeat>5__4 < 8)
					{
						HoldPlayerThere(<rigManager>5__3, pose, 0.18f);
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					return false;
					IL_0102:
					if (<i>5__2 < 180)
					{
						<rigManager>5__3 = TryGetRigManager();
						if ((Object)(object)<rigManager>5__3 != (Object)null && (Object)(object)<rigManager>5__3.remapHeptaRig != (Object)null)
						{
							TeleportPlayerToPose(<rigManager>5__3, pose, 0.18f, rotatePlayer);
							<repeat>5__4 = 0;
							goto IL_00c9;
						}
						<>2__current = null;
						<>1__state = 2;
						return 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();
			}
		}

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

			private object <>2__current;

			public PlayerPoseRecord pose;

			private int <i>5__2;

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

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

			[DebuggerHidden]
			public <PutPlayerBackAfterLoad>d__256(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 (pose == null)
					{
						return false;
					}
					<i>5__2 = 0;
					break;
				case 1:
					<>1__state = -1;
					<i>5__2++;
					break;
				}
				if (<i>5__2 < 10)
				{
					RigManager val = TryGetRigManager();
					if ((Object)(object)val != (Object)null && (Object)(object)val.remapHeptaRig != (Object)null)
					{
						HoldPlayerThere(val, pose, 0.04f);
					}
					<>2__current = null;
					<>1__state = 1;
					return 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();
			}
		}

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

			private object <>2__current;

			public Core <>4__this;

			private int <i>5__2;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				Core core = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<i>5__2 = 0;
					break;
				case 1:
					<>1__state = -1;
					<i>5__2++;
					break;
				}
				if (<i>5__2 < 30)
				{
					core.MakeSaveQuitButton();
					if ((Object)(object)core._saveQuitObj != (Object)null && !((Il2CppObjectBase)core._saveQuitObj).WasCollected)
					{
						return false;
					}
					<>2__current = null;
					<>1__state = 1;
					return 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();
			}
		}

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

			private object <>2__current;

			public Constrainer constrainer;

			public Action<int> onDone;

			public HashSet<int> doneJoints;

			public SceneSaveFile save;

			public Core <>4__this;

			public List<Poolee> made;

			private int <got>5__2;

			private Stopwatch <stopwatch>5__3;

			private int <i>5__4;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				Core core = <>4__this;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					<stopwatch>5__3.Restart();
					goto IL_015a;
				}
				<>1__state = -1;
				if ((Object)(object)constrainer == (Object)null)
				{
					onDone?.Invoke(doneJoints?.Count ?? 0);
					return false;
				}
				<got>5__2 = doneJoints?.Count ?? 0;
				<stopwatch>5__3 = Stopwatch.StartNew();
				<i>5__4 = 0;
				goto IL_016a;
				IL_015a:
				<i>5__4++;
				goto IL_016a;
				IL_016a:
				if (<i>5__4 < save.Constraints.Count)
				{
					if (doneJoints == null || !doneJoints.Contains(<i>5__4))
					{
						ConstraintRecord record = save.Constraints[<i>5__4];
						try
						{
							if (core.RestoreConstraint(record, save, made, constrainer))
							{
								<got>5__2++;
								doneJoints?.Add(<i>5__4);
							}
						}
						catch (Exception ex)
						{
							((MelonBase)core).LoggerInstance.Warning("Failed to restore constraint: " + ex.Message);
						}
						if (<stopwatch>5__3.Elapsed.TotalMilliseconds >= restoreBudget)
						{
							<>2__current = null;
							<>1__state = 1;
							return true;
						}
					}
					goto IL_015a;
				}
				onDone?.Invoke(<got>5__2);
				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 <RestoreConstraintsWithRetryTimeSliced>d__69 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Constrainer constrainer;

			private <>c__DisplayClass69_0 <>8__1;

			public Core <>4__this;

			public SceneSaveFile save;

			public List<Poolee> made;

			public Action<int> onDone;

			private HashSet<int> <doneJoints>5__2;

			private int <pass>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Expected O, but got Unknown
				int num = <>1__state;
				Core core = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass69_0();
					<>8__1.constrainer = constrainer;
					<doneJoints>5__2 = new HashSet<int>();
					<>8__1.got = 0;
					<pass>5__3 = 0;
					goto IL_017d;
				case 1:
					<>1__state = -1;
					goto IL_0095;
				case 2:
					<>1__state = -1;
					goto IL_0104;
				case 3:
					{
						<>1__state = -1;
						<pass>5__3++;
						goto IL_017d;
					}
					IL_017d:
					if (<pass>5__3 >= 3 || <>8__1.got >= save.Constraints.Count)
					{
						break;
					}
					if (<pass>5__3 > 0)
					{
						<>2__current = (object)new WaitForSecondsRealtime(0.35f);
						<>1__state = 1;
						return true;
					}
					goto IL_0095;
					IL_0095:
					if ((Object)(object)<>8__1.constrainer == (Object)null || ((Il2CppObjectBase)<>8__1.constrainer).WasCollected)
					{
						<>2__current = core.GetOrSpawnConstrainer(delegate(Constrainer constrainerInstance)
						{
							<>8__1.constrainer = constrainerInstance;
						});
						<>1__state = 2;
						return true;
					}
					goto IL_0104;
					IL_0104:
					<>2__current = core.RestoreConstraintsTimeSliced(save, made, <>8__1.constrainer, <doneJoints>5__2, delegate(int count)
					{
						<>8__1.got = count;
					});
					<>1__state = 3;
					return true;
				}
				if (<>8__1.got < save.Constraints.Count)
				{
					((MelonBase)core).LoggerInstance.Warning($"Restored {<>8__1.got}/{save.Constraints.Count} constraints after delayed retry.");
				}
				onDone?.Invoke(<>8__1.got);
				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 <RestoreNpcHealthTimeSliced>d__112 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SceneSaveFile save;

			public List<Poolee> made;

			public Core <>4__this;

			private Stopwatch <stopwatch>5__2;

			private int <i>5__3;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				Core core = <>4__this;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					<stopwatch>5__2.Restart();
					goto IL_00cf;
				}
				<>1__state = -1;
				<stopwatch>5__2 = Stopwatch.StartNew();
				<i>5__3 = 0;
				goto IL_00e1;
				IL_00cf:
				<i>5__3++;
				goto IL_00e1;
				IL_00e1:
				if (<i>5__3 < save.Objects.Count && <i>5__3 < made.Count)
				{
					SavedObject savedObject = save.Objects[<i>5__3];
					if (savedObject?.Health != null && !((Object)(object)made[<i>5__3] == (Object)null))
					{
						core.RestoreHealth(made[<i>5__3], savedObject.Health);
						if (<stopwatch>5__2.Elapsed.TotalMilliseconds >= restoreBudget)
						{
							<>2__current = null;
							<>1__state = 1;
							return true;
						}
					}
					goto IL_00cf;
				}
				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 <RestorePlayerAmmoWhenReady>d__118 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public PlayerAmmoRecord ammo;

			private AmmoInventory <inv>5__2;

			private int <i>5__3;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (ammo == null)
					{
						return false;
					}
					<inv>5__2 = null;
					<i>5__3 = 0;
					break;
				case 1:
					<>1__state = -1;
					<i>5__3++;
					break;
				}
				if (<i>5__3 < 180)
				{
					<inv>5__2 = AmmoInventory.Instance;
					if (!((Object)(object)<inv>5__2 != (Object)null))
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
				}
				if ((Object)(object)<inv>5__2 == (Object)null)
				{
					return false;
				}
				try
				{
					<inv>5__2.ClearAmmo();
					<inv>5__2.AddCartridge(<inv>5__2.lightAmmoGroup, Math.Max(0, ammo.LightAmmo));
					<inv>5__2.AddCartridge(<inv>5__2.mediumAmmoGroup, Math.Max(0, ammo.MediumAmmo));
					<inv>5__2.AddCartridge(<inv>5__2.heavyAmmoGroup, Math.Max(0, ammo.HeavyAmmo));
				}
				catch
				{
				}
				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 <RestorePlayerInventoryWhenReady>d__119 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public PlayerInventoryRecord inv;

			public Core <>4__this;

			private RigManager <rig>5__2;

			private int <restored>5__3;

			private int <i>5__4;

			private List<PlayerInventoryItemRecord>.Enumerator <>7__wrap4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<rig>5__2 = null;
				<>7__wrap4 = default(List<PlayerInventoryItemRecord>.Enumerator);
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					Core core = <>4__this;
					RigManager obj3;
					object obj4;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (inv?.Items == null || inv.Items.Count == 0)
						{
							return false;
						}
						<rig>5__2 = null;
						<i>5__4 = 0;
						goto IL_00c2;
					case 1:
						<>1__state = -1;
						<i>5__4++;
						goto IL_00c2;
					case 2:
						{
							<>1__state = -3;
							<restored>5__3++;
							break;
						}
						IL_00c2:
						if (<i>5__4 < 180)
						{
							<rig>5__2 = TryGetRigManager();
							RigManager obj = <rig>5__2;
							object obj2;
							if (obj == null)
							{
								obj2 = null;
							}
							else
							{
								Inventory inventory = obj.inventory;
								obj2 = ((inventory != null) ? inventory.bodySlots : null);
							}
							if (obj2 == null)
							{
								<>2__current = null;
								<>1__state = 1;
								return true;
							}
						}
						obj3 = <rig>5__2;
						if (obj3 == null)
						{
							obj4 = null;
						}
						else
						{
							Inventory inventory2 = obj3.inventory;
							obj4 = ((inventory2 != null) ? inventory2.bodySlots : null);
						}
						if (obj4 == null)
						{
							return false;
						}
						<restored>5__3 = 0;
						<>7__wrap4 = inv.Items.GetEnumerator();
						<>1__state = -3;
						break;
					}
					while (<>7__wrap4.MoveNext())
					{
						PlayerInventoryItemRecord current = <>7__wrap4.Current;
						if (current != null && !string.IsNullOrWhiteSpace(current.SlotName) && !string.IsNullOrWhiteSpace(current.Barcode))
						{
							SlotContainer obj5 = FindBodySlot(<rig>5__2, current.SlotName);
							InventorySlotReceiver val = ((obj5 != null) ? obj5.inventorySlotReceiver : null);
							if (!((Object)(object)val == (Object)null))
							{
								<>2__current = core.SpawnInventoryItem(val, current);
								<>1__state = 2;
								return true;
							}
						}
					}
					<>m__Finally1();
					<>7__wrap4 = default(List<PlayerInventoryItemRecord>.Enumerator);
					if (<restored>5__3 > 0)
					{
						((MelonBase)core).LoggerInstance.Msg($"Restored {<restored>5__3} inventory slot items.");
					}
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>7__wrap4).Dispose();
			}

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

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

			private object <>2__current;

			public List<Poolee> made;

			public SceneSaveFile save;

			public bool keepKinematic;

			public Dictionary<Rigidbody, bool> frozen;

			private Stopwatch <stopwatch>5__2;

			private int <i>5__3;

			private Poolee <poolee>5__4;

			private bool <keepDeadNpcFrozen>5__5;

			private bool <rootOnly>5__6;

			private List<TransformRecord>.Enumerator <>7__wrap6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<stopwatch>5__2 = null;
				<poolee>5__4 = null;
				<>7__wrap6 = default(List<TransformRecord>.Enumerator);
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_017d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0182: Unknown result type (might be due to invalid IL or missing references)
				//IL_0193: Unknown result type (might be due to invalid IL or missing references)
				//IL_0198: Unknown result type (might be due to invalid IL or missing references)
				//IL_01af: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_0215: Unknown result type (might be due to invalid IL or missing references)
				//IL_021e: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -3;
						<stopwatch>5__2.Restart();
						goto IL_0268;
					}
					<>1__state = -1;
					<stopwatch>5__2 = Stopwatch.StartNew();
					<i>5__3 = 0;
					goto IL_02a3;
					IL_02a3:
					if (<i>5__3 < save.Objects.Count && <i>5__3 < made.Count)
					{
						<poolee>5__4 = made[<i>5__3];
						SavedObject savedObject = save.Objects[<i>5__3];
						if (!((Object)(object)<poolee>5__4 == (Object)null) && savedObject != null)
						{
							<keepDeadNpcFrozen>5__5 = IsDeadNpcObject(savedObject);
							<rootOnly>5__6 = OnlyRootPoseForThis(savedObject);
							<>7__wrap6 = savedObject.Transforms.GetEnumerator();
							<>1__state = -3;
							goto IL_0268;
						}
						goto IL_0291;
					}
					return false;
					IL_0291:
					<i>5__3++;
					goto IL_02a3;
					IL_0268:
					while (<>7__wrap6.MoveNext())
					{
						TransformRecord current = <>7__wrap6.Current;
						if ((<rootOnly>5__6 && !RootRecord(current)) || current.Rigidbody == null)
						{
							continue;
						}
						Transform val = ResolveBySiblingPath(((Component)<poolee>5__4).transform, current.SiblingPath);
						if ((Object)(object)val == (Object)null)
						{
							val = ResolveRelativePath(((Component)<poolee>5__4).transform, current.Path);
						}
						if ((Object)(object)val == (Object)null)
						{
							continue;
						}
						Rigidbody component = ((Component)val).GetComponent<Rigidbody>();
						if ((Object)(object)component == (Object)null)
						{
							continue;
						}
						component.isKinematic = (keepKinematic | <keepDeadNpcFrozen>5__5) || current.Rigidbody.IsKinematic;
						component.useGravity = current.Rigidbody.UseGravity;
						Vector3 val2 = current.Rigidbody.Velocity.ToUnity();
						Vector3 val3 = current.Rigidbody.AngularVelocity.ToUnity();
						component.velocity = ((keepKinematic | <keepDeadNpcFrozen>5__5) ? Vector3.zero : val2);
						component.angularVelocity = ((keepKinematic | <keepDeadNpcFrozen>5__5) ? Vector3.zero : val3);
						if (keepKinematic)
						{
							ClearRigidbodyMotion(component);
						}
						else
						{
							frozen.Remove(component);
							if (!<keepDeadNpcFrozen>5__5 && !current.Rigidbody.IsKinematic)
							{
								component.WakeUp();
								component.velocity = val2;
								component.angularVelocity = val3;
							}
						}
						if (<stopwatch>5__2.Elapsed.TotalMilliseconds >= restoreBudget)
						{
							<>2__current = null;
							<>1__state = 1;
							return true;
						}
					}
					<>m__Finally1();
					<>7__wrap6 = default(List<TransformRecord>.Enumerator);
					<poolee>5__4 = null;
					goto IL_0291;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>7__wrap6).Dispose();
			}

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

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

			private object <>2__current;

			public SceneSaveFile save;

			public Core <>4__this;

			private Dictionary<string, Transform> <pathCache>5__2;

			private Stopwatch <clock>5__3;

			private int <ok>5__4;

			private List<SceneLogicRecord>.Enumerator <>7__wrap4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<pathCache>5__2 = null;
				<clock>5__3 = null;
				<>7__wrap4 = default(List<SceneLogicRecord>.Enumerator);
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					Core core = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (save?.SceneLogic == null || save.SceneLogic.Count == 0)
						{
							return false;
						}
						<pathCache>5__2 = new Dictionary<string, Transform>(StringComparer.Ordinal);
						<clock>5__3 = Stopwatch.StartNew();
						<ok>5__4 = 0;
						<>7__wrap4 = save.SceneLogic.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						<clock>5__3.Restart();
						break;
					}
					while (<>7__wrap4.MoveNext())
					{
						SceneLogicRecord current = <>7__wrap4.Current;
						if (core.RestoreSceneLogicRecord(current, <pathCache>5__2))
						{
							<ok>5__4++;
						}
						if (<clock>5__3.Elapsed.TotalMilliseconds >= restoreBudget)
						{
							<>2__current = null;
							<>1__state = 1;
							return true;
						}
					}
					<>m__Finally1();
					<>7__wrap4 = default(List<SceneLogicRecord>.Enumerator);
					if (<ok>5__4 > 0)
					{
						((MelonBase)core).LoggerInstance.Msg($"Restored {<ok>5__4}/{save.SceneLogic.Count} scene logic states.");
					}
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>7__wrap4).Dispose();
			}

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

		[CompilerGenerated]
		private sealed class <SimpleMembers>d__303 : IEnumerable<MemberInfo>, IEnumerable, IEnumerator<MemberInfo>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private MemberInfo <>2__current;

			private int <>l__initialThreadId;

			private Type type;

			public Type <>3__type;

			private BindingFlags <flags>5__2;

			private FieldInfo[] <>7__wrap2;

			private int <>7__wrap3;

			private PropertyInfo[] <>7__wrap4;

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

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

			[DebuggerHidden]
			public <SimpleMembers>d__303(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<flags>5__2 = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
					<>7__wrap2 = type.GetFields(<flags>5__2);
					<>7__wrap3 = 0;
					goto IL_008a;
				case 1:
					<>1__state = -1;
					goto IL_007c;
				case 2:
					{
						<>1__state = -1;
						goto IL_010c;
					}
					IL_008a:
					if (<>7__wrap3 < <>7__wrap2.Length)
					{
						FieldInfo fieldInfo = <>7__wrap2[<>7__wrap3];
						if (SimpleType(fieldInfo.FieldType))
						{
							<>2__current = fieldInfo;
							<>1__state = 1;
							return true;
						}
						goto IL_007c;
					}
					<>7__wrap2 = null;
					<>7__wrap4 = type.GetProperties(<flags>5__2);
					<>7__wrap3 = 0;
					goto IL_011a;
					IL_007c:
					<>7__wrap3++;
					goto IL_008a;
					IL_011a:
					if (<>7__wrap3 < <>7__wrap4.Length)
					{
						PropertyInfo propertyInfo = <>7__wrap4[<>7__wrap3];
						if (propertyInfo.GetIndexParameters().Length == 0 && propertyInfo.CanRead && propertyInfo.CanWrite && SimpleType(propertyInfo.PropertyType))
						{
							<>2__current = propertyInfo;
							<>1__state = 2;
							return true;
						}
						goto IL_010c;
					}
					<>7__wrap4 = null;
					return false;
					IL_010c:
					<>7__wrap3++;
					goto IL_011a;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<MemberInfo> IEnumerable<MemberInfo>.GetEnumerator()
			{
				<SimpleMembers>d__303 <SimpleMembers>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<SimpleMembers>d__ = this;
				}
				else
				{
					<SimpleMembers>d__ = new <SimpleMembers>d__303(0);
				}
				<SimpleMembers>d__.type = <>3__type;
				return <SimpleMembers>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<MemberInfo>)this).GetEnumerator();
			}
		}

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

			private object <>2__current;

			public InventorySlotReceiver receiver;

			public PlayerInventoryItemRecord item;

			public Core <>4__this;

			private float <timeout>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Expected O, but got Unknown
				int num = <>1__state;
				Core core = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((Object)(object)receiver == (Object)null || item == null)
					{
						return false;
					}
					try
					{
						if ((Object)(object)receiver._slottedWeapon != (Object)null)
						{
							receiver.DespawnContents();
						}
					}
					catch
					{
					}
					try
					{
						receiver.SpawnInSlotAsync(new Barcode(item.Barcode));
					}
					catch (Exception ex)
					{
						((MelonBase)core).LoggerInstance.Warning("Could not spawn inventory item " + item.Barcode + ": " + ex.Message);
					}
					<timeout>5__2 = Time.realtimeSinceStartup + 2f;
					goto IL_00dc;
				case 1:
					<>1__state = -1;
					goto IL_00dc;
				case 2:
					{
						<>1__state = -1;
						_ = (Object)(object)FindPooleeInReceiver(receiver) == (Object)null;
						return false;
					}
					IL_00dc:
					if ((Object)(object)receiver._slottedWeapon == (Object)null && Time.realtimeSinceStartup < <timeout>5__2)
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<>2__current = null;
					<>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 <SpawnOneSavedObject>d__107 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public int i;

			public SceneSaveFile save;

			public bool[] done;

			public Dictionary<int, Task<Poolee>> running;

			public bool retry;

			public Core <>4__this;

			public List<int> slow;

			public List<Poolee> made;

			public Dictionary<Rigidbody, bool> frozen;

			private Task<Poolee> <task>5__2;

			private float <timeoutAt>5__3;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				Core core = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (i < 0 || i >= save.Objects.Count || done[i])
					{
						return false;
					}
					<task>5__2 = null;
					running.TryGetValue(i, out <task>5__2);
					if (<task>5__2 == null || <task>5__2.IsFaulted || (retry && <task>5__2.IsCompleted && (Object)(object)<task>5__2.Result == (Object)null))
					{
						<task>5__2 = core.SpawnSavedObject(save.Objects[i]);
						running[i] = <task>5__2;
					}
					<timeoutAt>5__3 = Time.realtimeSinceStartup + 1f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (!<task>5__2.IsCompleted && Time.realtimeSinceStartup < <timeoutAt>5__3)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				if (!<task>5__2.IsCompleted)
				{
					if (!retry)
					{
						slow?.Add(i);
					}
					else
					{
						((MelonBase)core).LoggerInstance.Warning("Still waiting on slow spawnable after retry: " + save.Objects[i].Barcode);
					}
					return false;
				}
				if (<task>5__2.IsFaulted)
				{
					((MelonBase)core).LoggerInstance.Warning("Failed to spawn " + save.Objects[i].Barcode + ": " + <task>5__2.Exception?.GetBaseException().Message);
					done[i] = true;
					return false;
				}
				Poolee result = <task>5__2.Result;
				if ((Object)(object)result == (Object)null)
				{
					if (!retry)
					{
						slow?.Add(i);
					}
					else
					{
						((MelonBase)core).LoggerInstance.Warning("Spawn returned null for " + save.Objects[i].Barcode);
						done[i] = true;
					}
					return false;
				}
				made[i] = result;
				core.RememberLoadedSaveId(result, save.Objects[i]);
				TouchLoadedPoolee(result, save.Objects[i], frozen);
				core.RestoreObjectState(result, save.Objects[i], keepRigidbodiesFrozen: true);
				done[i] = 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();
			}
		}

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

			private object <>2__current;

			public List<int> order;

			public SceneSaveFile save;

			public bool[] done;

			public Core <>4__this;

			public List<Poolee> made;

			public Dictionary<Rigidbody, bool> frozen;

			private Dictionary<int, Task<Poolee>> <running>5__2;

			private Dictionary<int, float> <started>5__3;

			private List<int> <active>5__4;

			private List<int> <slow>5__5;

			private Queue<int> <todo>5__6;

			private Queue<int> <retry>5__7;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<running>5__2 = null;
				<started>5__3 = null;
				<active>5__4 = null;
				<slow>5__5 = null;
				<todo>5__6 = null;
				<retry>5__7 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				Core core = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<running>5__2 = new Dictionary<int, Task<Poolee>>();
					<started>5__3 = new Dictionary<int, float>();
					<active>5__4 = new List<int>();
					<slow>5__5 = new List<int>();
					<todo>5__6 = new Queue<int>(order);
					goto IL_0149;
				case 1:
					<>1__state = -1;
					goto IL_0149;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_0149:
					while (<todo>5__6.Count > 0 || <active>5__4.Count > 0)
					{
						while (<todo>5__6.Count > 0 && <active>5__4.Count < 6)
						{
							int num2 = <todo>5__6.Dequeue();
							if (num2 >= 0 && num2 < save.Objects.Count && !done[num2])
							{
								Task<Poolee> value = core.SpawnSavedObject(save.Objects[num2]);
								<running>5__2[num2] = value;
								<started>5__3[num2] = Time.realtimeSinceStartup;
								<active>5__4.Add(num2);
							}
						}
						if (!core.PumpSpawnQueue(save, made, done, frozen, <running>5__2, <started>5__3, <active>5__4, <slow>5__5, retry: false))
						{
							<>2__current = null;
							<>1__state = 1;
							return true;
						}
					}
					if (<slow>5__5.Count <= 0)
					{
						return false;
					}
					((MelonBase)core).LoggerInstance.Msg($"Retrying {<slow>5__5.Count} slow spawnables after the first pass.");
					<retry>5__7 = new Queue<int>(<slow>5__5);
					<slow>5__5.Clear();
					break;
				}
				while (<retry>5__7.Count > 0 || <active>5__4.Count > 0)
				{
					while (<retry>5__7.Count > 0 && <active>5__4.Count < 6)
					{
						int num3 = <retry>5__7.Dequeue();
						if (num3 >= 0 && num3 < save.Objects.Count && !done[num3])
						{
							if (!<running>5__2.TryGetValue(num3, out var value2) || value2.IsFaulted || (value2.IsCompleted && (Object)(object)value2.Result == (Object)null))
							{
								value2 = core.SpawnSavedObject(save.Objects[num3]);
								<running>5__2[num3] = value2;
							}
							<started>5__3[num3] = Time.realtimeSinceStartup;
							<active>5__4.Add(num3);
						}
					}
					if (!core.PumpSpawnQueue(save, made, done, frozen, <running>5__2, <started>5__3, <active>5__4, null, retry: true))
					{
						<>2__current = null;
						<>1__state = 2;
						return 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();
			}
		}

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

			private object <>2__current;

			public SceneSaveFile save;

			public List<Poolee> made;

			public Core <>4__this;

			private Stopwatch <releaseStopwatch>5__2;

			private int <pass>5__3;

			private Stopwatch <stopwatch>5__4;

			private int <i>5__5;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				Core core = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<pass>5__3 = 0;
					goto IL_0184;
				case 1:
					<>1__state = -1;
					<stopwatch>5__4.Restart();
					goto IL_010d;
				case 2:
					<>1__state = -1;
					<stopwatch>5__4 = null;
					<pass>5__3++;
					goto IL_0184;
				case 3:
					{
						<>1__state = -1;
						<releaseStopwatch>5__2.Restart();
						goto IL_0249;
					}
					IL_0184:
					if (<pass>5__3 < 10)
					{
						<stopwatch>5__4 = Stopwatch.StartNew();
						<i>5__5 = 0;
						goto IL_011d;
					}
					<releaseStopwatch>5__2 = Stopwatch.StartNew();
					<pass>5__3 = 0;
					goto IL_0259;
					IL_010d:
					<i>5__5++;
					goto IL_011d;
					IL_0259:
					if (<pass>5__3 >= save.Objects.Count || <pass>5__3 >= made.Count)
					{
						break;
					}
					if (IsDeadNpcObject(save.Objects[<pass>5__3]) && !((Object)(object)made[<pass>5__3] == (Object)null))
					{
						ReleaseDeadNpcRigidbodies(made[<pass>5__3], save.Objects[<pass>5__3]);
						if (<releaseStopwatch>5__2.Elapsed.TotalMilliseconds >= restoreBudget)
						{
							<>2__current = null;
							<>1__state = 3;
							return true;
						}
					}
					goto IL_0249;
					IL_0249:
					<pass>5__3++;
					goto IL_0259;
					IL_011d:
					if (<i>5__5 < save.Objects.Count && <i>5__5 < made.Count)
					{
						if (IsDeadNpcObject(save.Objects[<i>5__5]) && !((Object)(object)made[<i>5__5] == (Object)null))
						{
							core.ApplySavedTransforms(made[<i>5__5], save.Objects[<i>5__5], restoreWorldPose: true, keepRigidbodiesFrozen: true);
							ClearPooleeRigidbodyMotion(made[<i>5__5]);
							if (<stopwatch>5__4.Elapsed.TotalMilliseconds >= restoreBudget)
							{
								<>2__current = null;
								<>1__state = 1;
								return true;
							}
						}
						goto IL_010d;
					}
					try
					{
						Physics.SyncTransforms();
					}
					catch
					{
					}
					<>2__current = null;
					<>1__state = 2;
					return 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 const string ModVersion = "1.0.0";

		private const string ConfigFileName = "config.json";

		private const string DefaultPlayerRigBarcode = "SLZ.BONELAB.Core.DefaultPlayerRig";

		private const string BlankRigBarcode = "SLZ.BONELAB.Core.Spawnable.RigManagerBlank";

		private const float SystemObjectDistance = 500f;

		private const float LoadInitialDelaySeconds = 0.05f;

		private const float AutoLoadInitialDelaySeconds = 1.25f;

		private const double RestoreBudgetMs = 4.5;

		private const float SpawnItemTimeoutSeconds = 1f;

		private const int PcSpawnBatchSize = 6;

		private const float ZoneMissingPreserveDistance = 12f;

		private const float CrateSpawnerMatchDistance = 4f;

		private const float CrateSpawnerDeleteMatchDistance = 25f;

		private const float LoadKinematicHoldSeconds = 2f;

		private const float PlayerLoadLift = 0.18f;

		private const float PlayerLoadSettleLift = 0.04f;

		private const string MainMenuBarcode = "c2534c5a-80e1-4a29-93ca-f3254d656e75";

		private const string VoidG114Barcode = "fa534c5a868247138f50c62e424c4144.Level.VoidG114";

		private static readonly (string Name, string Barcode)[] defaultBlacklist = new(string, string)[24]
		{
			("00-MainMenu", "c2534c5a-80e1-4a29-93ca-f3254d656e75"),
			("01-Descent", "c2534c5a-4197-4879-8cd3-4a695363656e"),
			("03-LongRun", "c2534c5a-56a6-40ab-a8ce-23074c657665"),
			("04-MineDive", "c2534c5a-54df-470b-baaf-741f4c657665"),
			("05-BigAnomaly", "c2534c5a-7601-4443-bdfe-7f235363656e"),
			("06-StreetPuncher", "SLZ.BONELAB.Content.Level.LevelStreetPunch"),
			("07-SprintBridge", "SLZ.BONELAB.Content.Level.SprintBridge04"),
			("08-MagmaGate", "SLZ.BONELAB.Content.Level.SceneMagmaGate"),
			("09-Moonbase", "SLZ.BONELAB.Content.Level.MoonBase"),
			("10-MonogonMotorway", "SLZ.BONELAB.Content.Level.LevelKartRace"),
			("11-PillarClimb", "c2534c5a-c056-4883-ac79-e051426f6964"),
			("12-BigAnomaly2", "SLZ.BONELAB.Content.Level.LevelBigAnomalyB"),
			("13-Ascent", "c2534c5a-db71-49cf-b694-24584c657665"),
			("14-Home", "SLZ.BONELAB.Content.Level.LevelOutro"),
			("NeonTrial", "c2534c5a-4f3b-480e-ad2f-69175363656e"),
			("DropPit", "c2534c5a-de61-4df9-8f6c-416954726547"),
			("TunnelTipper", "c2534c5a-c180-40e0-b2b7-325c5363656e"),
			("FantasyArena", "fa534c5a868247138f50c62e424c4144.Level.LevelArenaMin"),
			("ContainerYard", "c2534c5a-162f-4661-a04d-975d5363656e"),
			("DungeonWarrior", "c2534c5a-5c2f-4eef-a851-66214c657665"),
			("Rooftops", "c2534c5a-c6ac-48b4-9c5f-b5cd5363656e"),
			("NeonParkour", "fa534c5a83ee4ec6bd641fec424c4142.Level.SceneparkourDistrictLogic"),
			("LoadDefault", "fa534c5a83ee4ec6bd641fec424c4142.Level.DefaultLoad"),
			("LoadMod", "SLZ.BONELAB.CORE.Level.LevelModLevelLoad")
		};

		private static readonly HashSet<string> dontSaveThese = new HashSet<string>(StringComparer.Ordinal) { "Lakatrazz.FusionContent.Spawnable.AchievementBoard", "Lakatrazz.FusionContent.Spawnable.BitMart", "Lakatrazz.FusionContent.Spawnable.InfoBoard" };

		private static readonly JsonSerializerOptions jsonOpts = new JsonSerializerOptions
		{
			WriteIndented = true,
			IncludeFields = false
		};

		private string _homeDir;

		private string _saveFolder;

		private string _cfg;

		private SceneSaveConfig _config = new SceneSaveConfig();

		private Page _page;

		private Page _setting;

		private Page _savePage;

		private Page _banPage;

		private Page _manual;

		private string _levelBarcode;

		private string _levelTitle;

		private Constrainer _dummyConstrainer;

		private bool _inLevel;

		private bool _savingNow;

		private bool _loadingNow;

		private bool _savedThisTrip;

		private bool _quitSaved;

		private bool _jumpTried;

		private bool _blockDefaultCrateSpawners;

		private bool _skipSceneSpawnerRouteForLoad;

		private Action _quitHook;

		private Poolee[] _poolCache;

		private float _poolCacheAt = -999f;

		private CrateSpawner[] _spawnerCache;

		private float _spawnerCacheAt = -999f;

		private readonly Dictionary<IntPtr, string> _savedIds = new Dictionary<IntPtr, string>();

		private readonly Dictionary<string, Poolee> _loadedIds = new Dictionary<string, Poolee>(StringComparer.Ordinal);

		private readonly HashSet<string> _deletedIds = new HashSet<string>(StringComparer.Ordinal);

		private readonly HashSet<IntPtr> _deadPtrs = new HashSet<IntPtr>();

		private static Transform _constraintDummyTransform;

		private bool _holdPlayer;

		private GameObject _saveQuitObj;

		private Button _saveQuitBtn;

		private static readonly string[] switchyBoolNames = new string[26]
		{
			"isOn", "_isOn", "m_isOn", "IsOn", "on", "_on", "m_On", "isToggled", "_isToggled", "toggled",
			"_toggled", "isActivated", "_isActivated", "activated", "_activated", "isActive", "_isActive", "m_IsActive", "powered", "_powered",
			"isPowered", "_isPowered", "lightOn", "_lightOn", "flashlightOn", "_flashlightOn"
		};

		private static readonly string[] switchyFloatNames = new string[3] { "intensity", "_intensity", "m_Intensity" };

		private const string holodeckRecordType = "PersistentScene.GameControl_Holodeck";

		private static readonly string[] logicHints = new string[15]
		{
			"ButtonController", "Il2CppSLZ.Marrow.Circuits", "Il2CppSLZ.Marrow.VoidLogic", "VoidLogic", "RPCBool", "RPCFloat", "RPCInt", "RPCString", "RPCVector3", "RPCVariable",
			"MaterialDecorator", "MaterialSwitch", "MaterialSwitcher", "MaterialSelector", "MaterialSelect"
		};

		private static readonly string[] logicBoolNames = new string[27]
		{
			"_charged", "charged", "Charged", "_toggleCharged", "toggleCharged", "ToggleCharged", "_isOn", "isOn", "IsOn", "_isActive",
			"isActive", "IsActive", "_active", "active", "Active", "_enabled", "enabled", "Enabled", "_value", "value",
			"Value", "_boolValue", "boolValue", "BoolValue", "_state", "state", "State"
		};

		private static readonly string[] logicFloatNames = new string[16]
		{
			"_value", "value", "Value", "_floatValue", "floatValue", "FloatValue", "_lastSensorValue", "lastSensorValue", "_sensorValue", "sensorValue",
			"_charge", "charge", "_input", "inputValue", "_output", "outputValue"
		};

		private static readonly string[] logicIntNames = new string[17]
		{
			"_value", "value", "Value", "_intValue", "intValue", "IntValue", "_state", "state", "State", "_index",
			"index", "_currentIndex", "currentIndex", "_selection", "selection", "_setting", "setting"
		};

		private static readonly string[] logicStringNames = new string[8] { "_value", "value", "Value", "_stringValue", "stringValue", "StringValue", "_text", "text" };

		private static readonly string[] logicVectorNames = new string[6] { "_value", "value", "Value", "_vector3Value", "vector3Value", "Vector3Value" };

		private static double restoreBudget => 4.5;

		internal static Core Current { get; private set; }

		public override void OnInitializeMelon()
		{
			Current = this;
			_homeDir = SaveRoot();
			_saveFolder = Path.Combine(_homeDir, "PersistentScene_SaveFiles");
			_cfg = Path.Combine(_saveFolder, "config.json");
			Directory.CreateDirectory(_saveFolder);
			LoadConfig();
			SpawnBits.Init(((MelonBase)this).HarmonyInstance);
			CrateSpawnerAwakeBlocker.Init(((MelonBase)this).HarmonyInstance);
			PooleeHooks.Init(((MelonBase)this).HarmonyInstance);
			JointBits.Init(((MelonBase)this).HarmonyInstance);
			NpcBits.Init(((MelonBase)this).HarmonyInstance);
			HolodeckBits.Init(((MelonBase)this).HarmonyInstance);
			LevelHooks.Init(((MelonBase)this).HarmonyInstance);
			BuildBoneMenu();
			Hooking.OnLevelLoading += OnLevelLoading;
			Hooking.OnLevelLoaded += OnLevelLoaded;
			Hooking.OnLevelUnloaded += OnLevelUnloaded;
			Hooking.OnUIRigCreated += OnUIRigCreated;
			_quitHook = OnUnityQuitting;
			Application.quitting += Action.op_Implicit(_quitHook);
			((MelonBase)this).LoggerInstance.Msg("Initialized. Saves: " + _saveFolder);
		}

		private static string SaveRoot()
		{
			string folderPath = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
			return Path.Combine(folderPath, "AppData", "LocalLow", "Stress Level Zero", "BONELAB", "Saves");
		}

		public override void OnSceneWasInitialized(int buildIndex, string sceneName)
		{
			if (_config.ModEnabled && !_jumpTried && !string.IsNullOrWhiteSpace(sceneName) && sceneName.Contains("BOOTSTRAP", StringComparison.OrdinalIgnoreCase))
			{
				_jumpTried = true;
				if (HasLastLevelToOpen())
				{
					AssetWarehouse.OnReady(Action.op_Implicit((Action)StartupJump));
				}
			}
		}

		public override void OnDeinitializeMelon()
		{
			if (!_quitSaved && _config.ModEnabled)
			{
				SaveOnTheWayOut("melon shutdown");
			}
			if (_quitHook != null)
			{
				Application.quitting -= Action.op_Implicit(_quitHook);
				_quitHook = null;
			}
			Hooking.OnUIRigCreated -= OnUIRigCreated;
			if (Current == this)
			{
				Current = null;
			}
		}

		public override void OnApplicationQuit()
		{
			SaveOnTheWayOut("application quit");
		}

		private void OnUnityQuitting()
		{
			SaveOnTheWayOut("unity quitting");
		}

		private void OnLevelLoading(LevelInfo nextLevel)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			if (!_config.ModEnabled)
			{
				_blockDefaultCrateSpawners = false;
				_skipSceneSpawnerRouteForLoad = false;
			}
			else if (!_savedThisTrip && _inLevel && !string.IsNullOrWhiteSpace(_levelBarcode))
			{
				SaveCurrentLevel("level loading");
				_savedThisTrip = true;
			}
			_blockDefaultCrateSpawners = _config.ModEnabled && ShouldBlockDefaultSpawns(nextLevel);
			_skipSceneSpawnerRouteForLoad = false;
			if (_blockDefaultCrateSpawners)
			{
				((MelonBase)this).LoggerInstance.Msg("Blocking default CrateSpawner Awake for saved level: " + nextLevel.barcode);
			}
			ClearRuntimeJunk();
			_savedIds.Clear();
			_loadedIds.Clear();
			_deletedIds.Clear();
			_deadPtrs.Clear();
			_inLevel = false;
			KillSaveQuitButton();
		}

		private void OnLevelLoaded(LevelInfo info)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			ClearRuntimeJunk();
			_savedIds.Clear();
			_loadedIds.Clear();
			_deletedIds.Clear();
			_deadPtrs.Clear();
			_levelBarcode = info.barcode;
			_levelTitle = info.title;
			_inLevel = true;
			_savedThisTrip = false;
			_quitSaved = false;
			DropFindCache();
			RefreshBoneMenu();
			MelonCoroutines.Start(RefreshSaveQuitSoon());
			if (!_config.ModEnabled)
			{
				_blockDefaultCrateSpawners = false;
				((MelonBase)this).LoggerInstance.Msg("Mod disabled, skipping load.");
				return;
			}
			if (FusionCompat.ClientInRoom)
			{
				_blockDefaultCrateSpawners = false;
				((MelonBase)this).LoggerInstance.Msg("Fusion client detected, host will handle PersistentScene load.");
				return;
			}
			if (IsBlacklisted(_levelBarcode))
			{
				_blockDefaultCrateSpawners = false;
				ForgetLast();
				((MelonBase)this).LoggerInstance.Msg("Level is blacklisted, skipping load: " + _levelBarcode);
				return;
			}
			RememberLevel(info);
			string savePath = GetSavePath(_levelBarcode);
			if (string.IsNullOrWhiteSpace(savePath) || !Directory.Exists(savePath))
			{
				_blockDefaultCrateSpawners = false;
				((MelonBase)this).LoggerInstance.Msg("No save for level: " + _levelBarcode);
			}
			else
			{
				MelonCoroutines.Start(LoadCurrentLevelSave(savePath, automatic: true));
			}
		}

		private void OnLevelUnloaded()
		{
			if (!_savedThisTrip && _inLevel && !string.IsNullOrWhiteSpace(_levelBarcode))
			{
				((MelonBase)this).LoggerInstance.Warning("Skipping late level-unloaded save; the scene is already tearing down.");
			}
			ClearRuntimeJunk();
			DropFindCache();
			_blockDefaultCrateSpawners = false;
			_skipSceneSpawnerRouteForLoad = false;
			_savedIds.Clear();
			_loadedIds.Clear();
			_deletedIds.Clear();
			_deadPtrs.Clear();
			_inLevel = false;
			_levelTitle = null;
			_savedThisTrip = false;
			KillSaveQuitButton();
		}

		internal void SaveBeforeSceneStreamerLoad(string reason)
		{
			if (_config.ModEnabled && !_savedThisTrip && _inLevel && !string.IsNullOrWhiteSpace(_levelBarcode) && SaveCurrentLevel(reason))
			{
				_savedThisTrip = true;
			}
		}

		private static void ClearRuntimeJunk()
		{
			SpawnBits.Clear();
			NpcBits.Clear();
			JointBits.Clear();
			HolodeckBits.Clear();
		}

		private bool ShouldBlockDefaultSpawns(LevelInfo nextLevel)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (!_config.ModEnabled)
			{
				return false;
			}
			if (FusionCompat.ClientInRoom)
			{
				return false;
			}
			string barcode = nextLevel.barcode;
			if (string.IsNullOrWhiteSpace(barcode))
			{
				return false;
			}
			if (IsBlacklisted(barcode))
			{
				return false;
			}
			string savePath = GetSavePath(barcode, nextLevel.title);
			if (string.IsNullOrWhiteSpace(savePath) || !Directory.Exists(savePath))
			{
				return false;
			}
			SceneSaveFile sceneSaveFile = ReadSaveMaybe(savePath);
			if (sceneSaveFile != null)
			{
				return string.Equals(sceneSaveFile.LevelBarcode, barcode, StringComparison.Ordinal);
			}
			return false;
		}

		internal bool ShouldBlockCrateSpawnerAwake(CrateSpawner spawner)
		{
			if (!_blockDefaultCrateSpawners || (Object)(object)spawner == (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)spawner).GetComponentInParent<Poolee>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)spawner).GetComponentInParent<RigManager>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)spawner).GetComponentInParent<UIRig>() != (Object)null)
			{
				return false;
			}
			return true;
		}

		[IteratorStateMachine(typeof(<RestoreConstraintsWithRetryTimeSliced>d__69))]
		private IEnumerator RestoreConstraintsWithRetryTimeSliced(SceneSaveFile save, List<Poolee> made, Constrainer constrainer, Action<int> onDone)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RestoreConstraintsWithRetryTimeSliced>d__69(0)
			{
				<>4__this = this,
				save = save,
				made = made,
				constrainer = constrainer,
				onDone = onDone
			};
		}

		[IteratorStateMachine(typeof(<RestoreConstraintsTimeSliced>d__70))]
		private IEnumerator RestoreConstraintsTimeSliced(SceneSaveFile save, List<Poolee> made, Constrainer constrainer, HashSet<int> doneJoints, Action<int> onDone)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RestoreConstraintsTimeSliced>d__70(0)
			{
				<>4__this = this,
				save = save,
				made = made,
				constrainer = constrainer,
				doneJoints = doneJoints,
				onDone = onDone
			};
		}

		private bool RestoreConstraint(ConstraintRecord record, SceneSaveFile save, List<Poolee> made, Constrainer constrainer)
		{
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: 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_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0337: 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_0353: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0373: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Unknown result type (might be due to invalid IL or missing references)
			//IL_037a: Unknown result type (might be due to invalid IL or missing references)
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0388: Unknown result type (might be due to invalid IL or missing references)
			Transform val = ResolveConstraintTransform(record.FirstObjectIndex, record.FirstPath, record.FirstSiblingPath, save, made);
			Transform val2 = ResolveConstraintTransform(record.SecondObjectIndex, record.SecondPath, record.SecondSiblingPath, save, made);
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
			{
				((MelonBase)this).LoggerInstance.Warning($"Constraint endpoint missing: {record.FirstObjectIndex}:{record.FirstSiblingPath ?? record.FirstPath} -> {record.SecondObjectIndex}:{record.SecondSiblingPath ?? record.SecondPath}");
				return false;
			}
			Vector3 val3 = record.FirstPoint.ToUnity();
			Vector3 val4 = record.SecondPoint.ToUnity();
			Vector3 val5 = record.FirstNormal.ToUnity();
			Vector3 val6 = record.SecondNormal.ToUnity();
			if (val5 == Vector3.zero)
			{
				val5 = Vector3.up;
			}
			if (val6 == Vector3.zero)
			{
				val6 = Vector3.up;
			}
			bool flag = record.HasFirstTargetPose;
			bool flag2 = record.HasSecondTargetPose;
			Vector3 val7 = record.FirstTargetPosition.ToUnity();
			Quaternion val8 = Quaternion.Euler(record.FirstTargetRotation.ToUnity());
			Vector3 val9 = record.SecondTargetPosition.ToUnity();
			Quaternion val10 = Quaternion.Euler(record.SecondTargetRotation.ToUnity());
			bool flag3 = record.FirstObjectIndex >= 0;
			bool flag4 = record.SecondObjectIndex >= 0;
			if (record.FirstObjectIndex < 0)
			{
				val.position = val3;
				val.rotation = Quaternion.identity;
			}
			if (record.SecondObjectIndex < 0)
			{
				val2.position = val4;
				val2.rotation = Quaternion.identity;
			}
			MarrowBody val11 = FindBodyForConstraint(val);
			MarrowBody val12 = FindBodyForConstraint(val2);
			if ((Object)(object)val11 == (Object)null && (Object)(object)val12 == (Object)null)
			{
				((MelonBase)this).LoggerInstance.Warning("Constraint bodies missing: " + ((Object)val).name + " -> " + ((Object)val2).name);
				return false;
			}
			if ((Object)(object)val11 == (Object)null)
			{
				Transform obj = val2;
				val2 = val;
				val = obj;
				MarrowBody obj2 = val12;
				val12 = val11;
				val11 = obj2;
				Vector3 val13 = val4;
				val4 = val3;
				val3 = val13;
				Vector3 val14 = val6;
				val6 = val5;
				val5 = val14;
				bool num = flag2;
				flag2 = flag;
				flag = num;
				Vector3 val15 = val9;
				val9 = val7;
				val7 = val15;
				Quaternion val16 = val10;
				val10 = val8;
				val8 = val16;
				bool num2 = flag4;
				flag4 = flag3;
				flag3 = num2;
			}
			if (!Enum.TryParse<ConstraintMode>(record.Mode, out ConstraintMode result))
			{
				result = (ConstraintMode)1;
			}
			Vector3 position = val.position;
			Quaternion rotation = val.rotation;
			Vector3 position2 = val2.position;
			Quaternion rotation2 = val2.rotation;
			bool flag5 = flag3 && flag;
			bool flag6 = flag4 && flag2;
			try
			{
				if (flag)
				{
					val.SetPositionAndRotation(val7, val8);
				}
				if (flag2)
				{
					val2.SetPositionAndRotation(val9, val10);
				}
				constrainer.mode = result;
				constrainer._gO1 = ((Component)val).gameObject;
				constrainer._gO2 = ((Component)val2).gameObject;
				constrainer._mb1 = val11;
				constrainer._mb2 = val12;
				constrainer._point1 = val3;
				constrainer._point2 = val4;
				constrainer._normal1 = val5;
				constrainer._normal2 = val6;
				constrainer.PrimaryButtonUp();
				FusionCompat.SendConstraint(((Component)val).gameObject, ((Component)val2).gameObject, result, val3, val4, val5, val6, flag ? val7 : val.position, flag ? val8 : val.rotation, flag2 ? val9 : val2.position, flag2 ? val10 : val2.rotation);
			}
			finally
			{
				if (flag5 && (Object)(object)val != (Object)null)
				{
					val.SetPositionAndRotation(position, rotation);
				}
				if (flag6 && (Object)(object)val2 != (Object)null)
				{
					val2.SetPositionAndRotation(position2, rotation2);
				}
			}
			return true;
		}

		private static MarrowBody FindBodyForConstraint(Transform transform)
		{
			if ((Object)(object)transform == (Object)null)
			{
				return null;
			}
			MarrowBody val = MarrowBody.Cache.Get(((Component)transform).gameObject);
			if (val == null)
			{
				val = ((Component)transform).GetComponent<MarrowBody>();
			}
			if (val == null)
			{
				val = ((Component)transform).GetComponentInParent<MarrowBody>();
			}
			if (val == null)
			{
				val = ((Component)transform).GetComponentInChildren<MarrowBody>(true);
			}
			if ((Object)(object)val == (Object)null)
			{
				Rigidbody val2 = ((Component)transform).GetComponent<Rigidbody>() ?? ((Component)transform).GetComponentInParent<Rigidbody>() ?? ((Component)transform).GetComponentInChildren<Rigidbody>(true);
				if ((Object)(object)val2 != (Object)null)
				{
					val = MarrowBody.Cache.Get(((Component)val2).gameObject) ?? ((Component)val2).GetComponent<MarrowBody>() ?? ((Component)val2).GetComponentInParent<MarrowBody>();
				}
			}
			return val;
		}

		private Transform ResolveConstraintTransform(int objectIndex, string relativePath, string siblingPath, SceneSaveFile save, List<Poolee> made)
		{
			if (objectIndex < 0 || objectIndex >= made.Count)
			{
				object obj;
				if (string.IsNullOrWhiteSpace(relativePath))
				{
					obj = null;
				}
				else
				{
					GameObject obj2 = GameObject.Find(relativePath);
					obj = ((obj2 != null) ? obj2.transform : null);
				}
				if (obj == null)
				{
					obj = GetConstraintDummyTransform();
				}
				return (Transform)obj;
			}
			if ((Object)(object)made[objectIndex] == (Object)null && save?.Objects != null && objectIndex < save.Objects.Count)
			{
				Poolee val = FindLoadedPooleeForSavedObject(save.Objects[objectIndex]);
				if ((Object)(object)val != (Object)null)
				{
					made[objectIndex] = val;
				}
			}
			if ((Object)(object)made[objectIndex] == (Object)null)
			{
				return GetConstraintDummyTransform();
			}
			Transform transform = ((Component)made[objectIndex]).transform;
			Transform val2 = ResolveBySiblingPath(transform, siblingPath);
			if ((Object)(object)val2 != (Object)null)
			{
				return val2;
			}
			return ResolveRelativePath(transform, relativePath);
		}

		private static Transform GetConstraintDummyTransform()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			if ((Object)(object)_constraintDummyTransform == (Object)null)
			{
				GameObject val = new GameObject("SceneSave Constraint Dummy");
				Object.DontDestroyOnLoad((Object)val);
				_constraintDummyTransform = val.transform;
			}
			return _constraintDummyTransform;
		}

		private static Transform ResolveRelativePath(Transform root, string relativePath)
		{
			if ((Object)(object)root == (Object)null)
			{
				return null;
			}
			if (string.IsNullOrEmpty(relativePath))
			{
				return root;
			}
			Transform val = root;
			string[] array = relativePath.Split('/');
			foreach (string text in array)
			{
				if (!string.IsNullOrEmpty(text))
				{
					Transform val2 = val.Find(text);
					if ((Object)(object)val2 == (Object)null)
					{
						return null;
					}
					val = val2;
				}
			}
			return val;
		}

		private static Transform ResolveBySiblingPath(Transform root, string siblingPath)
		{
			if ((Object)(object)root == (Object)null || string.IsNullOrWhiteSpace(siblingPath))
			{
				return null;
			}
			Transform val = root;
			string[] array = siblingPath.Split('/');
			for (int i = 0; i < array.Length; i++)
			{
				if (!int.TryParse(array[i], out var result) || result < 0 || result >= val.childCount)
				{
					return null;
				}
				val = val.GetChild(result);
			}
			return val;
		}

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

		private static void SuppressDummyVisualEffects(GameObject root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			foreach (ParticleSystem componentsInChild in root.GetComponentsInChildren<ParticleSystem>(true))
			{
				componentsInChild.emission.enabled = false;
				componentsInChild.Stop(true, (ParticleSystemStopBehavior)0);
			}
		}

		private HealthRecord CaptureHealth(Poolee poolee)
		{
			AIBrain componentInChildren = ((Component)poolee).GetComponentInChildren<AIBrain>(true);
			object obj;
			if (componentInChildren == null)
			{
				obj = null;
			}
			else
			{
				BehaviourBaseNav behaviour = componentInChildren.behaviour;
				obj = ((behaviour != null) ? behaviour.health : null);
			}
			SubBehaviourHealth val = (SubBehaviourHealth)obj;
			if ((Object)(object)componentInChildren == (Object)null && val == null)
			{
				return null;
			}
			NpcRuntimeState state = NpcBits.GetState(componentInChildren, val);
			if (val == null)
			{
				HealthRecord healthRecord = new HealthRecord();
				healthRecord.IsDead = state.IsDead || TryReadBoolMember(componentInChildren, "_isDead", "isDead").GetValueOrDefault();
				healthRecord.AppliedDamage = ((state.DamageTaken > 0f) ? new float?(state.DamageTaken) : null);
				return healthRecord;
			}
			float? num = TryReadFloatMember(val, "curr_Health", "currentHealth", "_health", "health");
			float? maxHealth = TryReadFloatMember(val, "max_Health", "maxHealth");
			bool? isDead = TryReadBoolMember(componentInChildren, "_isDead", "isDead") ?? TryReadBoolMember(val, "_isDead", "isDead");
			if (state.IsDead || num <= 0f)
			{
				isDead = true;
			}
			return new HealthRecord
			{
				CurrentHealth = num,
				MaxHealth = maxHealth,
				IsDead = isDead,
				AppliedDamage = ((state.DamageTaken > 0f) ? new float?(state.DamageTaken) : null)
			};
		}

		private DestructibleRecord CaptureDestructible(Poolee poolee)
		{
			ObjectDestructible componentInChildren = ((Component)poolee).GetComponentInChildren<ObjectDestructible>(true);
			if ((Object)(object)componentInChildren == (Object)null)
			{
				return null;
			}
			return new DestructibleRecord
			{
				Health = componentInChildren._health,
				MaxHealth = componentInChildren.maxHealth,
				IsDead = componentInChildren._isDead
			};
		}

		private void RestoreHealth(Poolee poolee, HealthRecord record)
		{
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Expected O, but got Unknown
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Expected O, but got Unknown
			if (record == null)
			{
				return;
			}
			AIBrain componentInChildren = ((Component)poolee).GetComponentInChildren<AIBrain>(true);
			object obj;
			if (componentInChildren == null)
			{
				obj = null;
			}
			else
			{
				BehaviourBaseNav behaviour = componentInChildren.behaviour;
				obj = ((behaviour != null) ? behaviour.health : null);
			}
			SubBehaviourHealth val = (SubBehaviourHealth)obj;
			if (val == null)
			{
				return;
			}
			if (record.MaxHealth.HasValue)
			{
				TryWriteFloatMember(val, record.MaxHealth.Value, "max_Health", "maxHealth");
			}
			if (record.IsDead.GetValueOrDefault())
			{
				KillNpc(componentInChildren, val);
			}
			else if (record.CurrentHealth.HasValue)
			{
				if (!TryWriteFloatMember(val, record.CurrentHealth.Value, "curr_Health", "currentHealth", "_health", "health"))
				{
					float valueOrDefault = record.MaxHealth.GetValueOrDefault(100f);
					float num = Mathf.Max(0f, valueOrDefault - record.CurrentHealth.Value);
					if (num > 0f)
					{
						val.TakeDamage(1, new Attack
						{
							damage = num
						});
					}
				}
			}
			else if (record.AppliedDamage.HasValue && record.AppliedDamage.Value > 0f)
			{
				val.TakeDamage(1, new Attack
				{
					damage = record.AppliedDamage.Value
				});
			}
		}

		private static void KillNpc(AIBrain brain, SubBehaviourHealth health)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			try
			{
				health.TakeDamage(1, new Attack
				{
					damage = 999999f
				});
			}
			catch
			{
			}
			try
			{
				if (brain != null)
				{
					brain.OnDeath();
				}
			}
			catch
			{
			}
		}

		private void RestoreDestructible(Poolee poolee, DestructibleRecord record)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (record == null)
			{
				return;
			}
			ObjectDestructible componentInChildren = ((Component)poolee).GetComponentInChildren<ObjectDestructible>(true);
			if (!((Object)(object)componentInChildren == (Object)null))
			{
				componentInChildren.maxHealth = record.MaxHealth;
				componentInChildren._health = record.Health;
				if (record.IsDead && !componentInChildren._isDead)
				{
					componentInChildren.TakeDamage(Vector3.up, componentInChildren._health + 1f, false, (AttackType)64);
				}
				else
				{
					componentInChildren._isDead = record.IsDead;
				}
			}
		}

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

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

		private static void WalkHierarchy(Transform root, List<Transform> transforms)
		{
			transforms.Add(root);
			for (int i = 0; i < root.childCount; i++)
			{
				Transform child = root.GetChild(i);
				if (!ShouldIgnoreTransform(child))
				{
					WalkHierarchy(child, transforms);
				}
			}
		}

		private static bool ShouldIgnoreTransform(Transform transform)
		{
			string name = ((Object)transform).name;
			if (!name.StartsWith("jPt", StringComparison.Ordinal))
			{
				return name.StartsWith("SavingBounds", StringComparison.Ordinal);
			}
			return true;
		}

		private static string GetRelativePath(Transform root, Transform transform)
		{
			if ((Object)(object)root == (Object)(object)transform)
			{
				return string.Empty;
			}
			List<string> list = new List<string>();
			Transform val = transform;
			while ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)root)
			{
				list.Add(((Object)val).name);
				val = val.parent;
			}
			list.Reverse();
			return string.Join("/", list);
		}

		private static string GetSiblingPath(Transform root, Transform transform)
		{
			if ((Object)(object)root == (Object)null || (Object)(object)transform == (Object)null)
			{
				return null;
			}
			List<int> list = new List<int>();
			Transform val = transform;
			while ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)root)
			{
				list.Add(val.GetSiblingIndex());
				val = val.parent;
			}
			if ((Object)(object)val != (Object)(object)root)
			{
				return null;
			}
			list.Reverse();
			return string.Join("/", list);
		}

		private static Transform NormalizeConstraintTransform(Transform transform)
		{
			if ((Object)(object)transform != (Object)null && ((Object)transform).name.StartsWith("jPt", StringComparison.Ordinal) && (Object)(object)transform.parent != (Object)null)
			{
				return transform.parent;
			}
			return transform;
		}

		private static Poolee GetPooleeUpwards(Transform transform)
		{
			if ((Object)(object)transform != (Object)null)
			{
				Poolee val = Poolee.Cache.Get(((Component)transform.root).gameObject);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			while ((Object)(object)transform != (Object)null)
			{
				Poolee val2 = Poolee.Cache.Get(((Component)transform).gameObject);
				if ((Object)(object)val2 != (Object)null)
				{
					return val2;
				}
				transform = transform.parent;
			}
			return null;
		}

		private static bool IsProbablyMenuOrSystemObject(Transform transform)
		{
			while ((Object)(object)transform != (Object)null)
			{
				string name = ((Object)transform).name;
				if (name.Contains("BoneMenu", StringComparison.OrdinalIgnoreCase) || name.Contains("UIRig", StringComparison.OrdinalIgnoreCase) || name.Contains("PopUpMenu", StringComparison.OrdinalIgnoreCase) || name.Contains("PreferencesPanel", StringComparison.OrdinalIgnoreCase) || name.Contains("QuickMenu", StringComparison.OrdinalIgnoreCase) || name.Contains("SceneSave Dummy", StringComparison.OrdinalIgnoreCase) || name.Contains("SSBL Dummy", StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
				transform = transform.parent;
			}
			return false;
		}

		[IteratorStateMachine(typeof(<LoadCurrentLevelSave>d__95))]
		private IEnumerator LoadCurrentLevelSave(string path, bool automatic = false)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadCurrentLevelSave>d__95(0)
			{
				<>4__this = this,
				path = path,
				automatic = automatic
			};
		}

		private static float GetLoadDelay(bool automatic)
		{
			if (!automatic)
			{
				return 0.05f;
			}
			return 1.25f;
		}

		private static SceneSaveFile LoadSaveFile(string path)
		{
			return ReadSaveMaybe(path);
		}

		private static List<int> GetSpawnOrder(SceneSaveFile save)
		{
			return (from i in Enumerable.Range(0, save.Objects.Count)
				where CanLoadSavedObject(save.Objects[i])
				select i).OrderBy(delegate(int i)
			{
				if (!save.Objects[i].HasAIBrain)
				{
					HealthRecord health = save.Objects[i].Health;
					if (health == null || !health.IsDead.GetValueOrDefault())
					{
						return 1;
					}
				}
				return 0;
			}).ThenBy((int i) => save.Objects[i].Transforms?.Count ?? 0).ThenBy((int i) => i)
				.ToList();
		}

		private static float? TryReadFloatMember(object target, params string[] names)
		{
			foreach (string name in names)
			{
				object obj = TryReadMember(target, name);
				if (obj is float)
				{
					return (float)obj;
				}
				if (obj is int num)
				{
					return num;
				}
			}
			return null;
		}

		private static bool? TryReadBoolMember(object target, params string[] names)
		{
			foreach (string name in names)
			{
				object obj = TryReadMember(target, name);
				if (obj is bool)
				{
					return (bool)obj;
				}
			}
			return null;
		}

		private static int? TryReadIntMember(object target, params string[] names)
		{
			foreach (string name in names)
			{
				object obj = TryReadMember(target, name);
				if (obj is int)
				{
					return (int)obj;
				}
				if (obj is byte)
				{
					return (byte)obj;
				}
				if (obj is short)
				{
					return (short)obj;
				}
				if (obj is long num)
				{
					return (int)((num > int.MaxValue) ? int.MaxValue : ((num < int.MinValue) ? int.MinValue : num));
				}
			}
			return null;
		}

		private static object TryReadMember(object target, string name)
		{
			if (target == null)
			{
				return null;
			}
			Type type = target.GetType();
			FieldInfo field = type.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null)
			{
				return field.GetValue(target);
			}
			PropertyInfo property = type.GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (property != null && property.CanRead)
			{
				return property.GetValue(target);
			}
			return null;
		}

		private static bool TryWriteFloatMember(object target, float value, params string[] names)
		{
			foreach (string name in names)
			{
				if (TryWriteMember(target, name, value))
				{
					return true;
				}
			}
			return false;
		}

		private static bool TryWriteMember(object target, string name, object value)
		{
			if (target == null)
			{
				return false;
			}
			Type type = target.GetType();
			FieldInfo field = type.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null)
			{
				field.SetValue(target, value);
				return true;
			}
			PropertyInfo property = type.GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (property != null && property.CanWrite)
			{
				property.SetValue(target, value);
				return true;
			}
			return false;
		}

		[IteratorStateMachine(typeof(<SpawnSavedObjectsOneAtATime>d__105))]
		private IEnumerator SpawnSavedObjectsOneAtATime(SceneSaveFile save, List<Poolee> made, bool[] done, Dictionary<Rigidbody, bool> frozen, List<int> order)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SpawnSavedObjectsOneAtATime>d__105(0)
			{
				<>4__this = this,
				save = save,
				made = made,
				done = done,
				frozen = frozen,
				order = order
			};
		}

		private bool PumpSpawnQueue(SceneSaveFile save, List<Poolee> made, bool[] done, Dictionary<Rigidbody, bool> frozen, Dictionary<int, Task<Poolee>> running, Dictionary<int, float> started, List<int> active, List<int> slow, bool retry)
		{
			bool result = false;
			for (int num = active.Count - 1; num >= 0; num--)
			{
				int num2 = active[num];
				if (!running.TryGetValue(num2, out var value))
				{
					active.RemoveAt(num);
					result = true;
				}
				else if (!value.IsCompleted)
				{
					if (started.TryGetValue(num2, out var value2) && Time.realtimeSinceStartup - value2 >= 1f)
					{
						active.RemoveAt(num);
						if (!retry)
						{
							slow?.Add(num2);
						}
						else
						{
							((MelonBase)this).LoggerInstance.Warning("Still waiting on slow spawnable after retry: " + save.Objects[num2].Barcode);
						}
						result = true;
					}
				}
				else
				{
					active.RemoveAt(num);
					started.Remove(num2);
					if (value.IsFaulted)
					{
						((MelonBase)this).LoggerInstance.Warning("Failed to spawn " + save.Objects[num2].Barcode + ": " + value.Exception?.GetBaseException().Message);
						done[num2] = true;
						result = true;
					}
					else
					{
						Poolee result2 = value.Result;
						if ((Object)(object)result2 == (Object)null)
						{
							if (!retry)
							{
								slow?.Add(num2);
							}
							else
							{
								((MelonBase)this).LoggerInstance.Warning("Spawn returned null for " + save.Objects[num2].Barcode);
								done[num2] = true;
							}
							result = true;
						}
						else
						{
							made[num2] = result2;
							RememberLoadedSaveId(result2, save.Objects[num2]);
							TouchLoadedPoolee(result2, save.Objects[num2], frozen);
							RestoreObjectState(result2, save.Objects[num2], keepRigidbodiesFrozen: true);
							done[num2] = true;
							result = true;
						}
					}
				}
			}
			return result;
		}

		[IteratorStateMachine(typeof(<SpawnOneSavedObject>d__107))]
		private IEnumerator SpawnOneSavedObject(SceneSaveFile save, List<Poolee> made, bool[] done, Dictionary<Rigidbody, bool> frozen, Dictionary<int, Task<Poolee>> running, List<int> slow, int i, bool retry)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SpawnOneSavedObject>d__107(0)
			{
				<>4__this = this,
				save = save,
				made = made,
				done = done,
				frozen = frozen,
				running = running,
				slow = slow,
				i = i,
				retry = retry
			};
		}

		private void MarkExistingDeletedPoolees(SceneSaveFile save)
		{
			if (save?.DeletedSaveIds == null || save.DeletedSaveIds.Count == 0)
			{
				return;
			}
			HashSet<string> hashSet = save.DeletedSaveIds.Where((string id) => !string.IsNullOrWhiteSpace(id)).ToHashSet<string>(StringComparer.Ordinal);
			if (hashSet.Count == 0)
			{
				return;
			}
			CrateSpawner[] spawners = SpawnersNow();
			int num = 0;
			Poolee[] array = PooleesNow();
			foreach (Poolee val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Il2CppObjectBase)val).WasCollected && IsDeletedPoolee(val, save.LevelBarcode, spawners, hashSet))
				{
					_deadPtrs.Add(((Il2CppObjectBase)val).Pointer);
					num++;
				}
			}
			if (num > 0)
			{
				((MelonBase)this).LoggerInstance.Msg($"Marked {num} existing scene poolees as deleted before loading the save.");
			}
		}

		private static void TouchLoadedPoolee(Poolee poolee, SavedObject thing, Dictionary<Rigidbody, bool> frozen)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)poolee == (Object)null) && thing != null)
			{
				((Component)poolee).transform.position = thing.Position.ToUnity();
				((Component)poolee).transform.rotation = Quaternion.Euler(thing.Rotation.ToUnity());
				((Component)poolee).transform.localScale = thing.Scale.ToUnity();
				FreezePooleeRigidbodies(poolee, frozen);
				ClearPooleeRigidbodyMotion(poolee);
			}
		}

		private void RememberLoadedSaveId(Poolee poolee, SavedObject thing)
		{
			if (!((Object)(object)poolee == (Object)null) && thing != null && !string.IsNullOrWhiteSpace(thing.SaveId))
			{
				_savedIds[((Il2CppObjectBase)poolee).Pointer] = thing.SaveId;
				_loadedIds[thing.SaveId] = poolee;
			}
		}

		[IteratorStateMachine(typeof(<ApplyNpcWorldPosePass>d__111))]
		private IEnumerator ApplyNpcWorldPosePass(SceneSaveFile save, List<Poolee> made)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ApplyNpcWorldPosePass>d__111(0)
			{
				<>4__this = this,
				save = save,
				made = made
			};
		}

		[IteratorStateMachine(typeof(<RestoreNpcHealthTimeSliced>d__112))]
		private IEnumerator RestoreNpcHealthTimeSliced(SceneSaveFile save, List<Poolee> made)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RestoreNpcHealthTimeSliced>d__112(0)
			{
				<>4__this = this,
				save = save,
				made = made
			};
		}

		private async Task<Poolee> SpawnSavedObject(SavedObject thing)
		{
			_ = 2;
			try
			{
				Poolee val = await SpawnSavedObjectFromSceneCrateSpawner(thing);
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).transform.localScale = thing.Scale.ToUnity();
					return val;
				}
				Vector3 val2 = thing.Position.ToUnity();
				Quaternion val3 = Quaternion.Euler(thing.Rotation.ToUnity());
				Vector3 scale = thing.Scale.ToUnity();
				val = ((!FusionCompat.InRoom || !FusionCompat.Hosting) ? (await SpawnBits.SpawnAsync(thing.Barcode, val2, val3, scale)) : (await FusionCompat.SpawnSceneThing(thing.Barcode, val2, val3, scale)));
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).transform.localScale = thing.Scale.ToUnity();
				}
				return val;
			}
			catch (Exception ex)
			{
				((MelonBase)this).LoggerInstance.Warning("Failed to spawn " + thing.Barcode + ": " + ex.Message);
				return null;
			}
		}

		private Task<Poolee> SpawnSavedObjectFromSceneCrateSpawner(SavedObject thing)
		{
			TaskCompletionSource<Poolee> tcs = new TaskCompletionSource<Poolee>();
			if (_skipSceneSpawnerRouteForLoad)
			{
				tcs.TrySetResult(null);
				return tcs.Task;
			}
			if (thing == null || (!IsSceneSpawnerSavedObject(thing) && !LooksLikeSceneSpawnerSaveId(thing.SaveId)))
			{
				tcs.TrySetResult(null);
				return tcs.Task;
			}
			CrateSpawner spawner = FindSceneCrateSpawner(thing);
			if ((Object)(object)spawner == (Object)null)
			{
				tcs.TrySetResult(null);
				return tcs.Task;
			}
			try
			{
				UniTask<Poolee> val = spawner.SpawnSpawnableAsync(false);
				Awaiter<Poolee> awaiter = val.GetAwaiter();
				awaiter.OnCompleted(Action.op_Implicit((Action)delegate
				{
					//IL_0041: Unknown result type (might be due to invalid IL or missing references)
					try
					{
						Poolee result = awaiter.GetResult();
						if ((Object)(object)result != (Object)null)
						{
							tcs.TrySetResult(result);
						}
						else
						{
							tcs.TrySetResult(FindRecentlySpawnedScenePoolee(thing, ((Component)spawner).transform.position));
						}
					}
					catch (Exception ex2)
					{
						((MelonBase)this).LoggerInstance.Warning("Scene CrateSpawner spawn failed for " + thing.Name + ": " + ex2.Message);
						tcs.TrySetResult(null);
					}
				}));
			}
			catch (Exception ex)
			{
				((MelonBase)this).LoggerInstance.Warning("Scene CrateSpawner spawn failed for " + thing.Name + ": " + ex.Message);
				tcs.TrySetResult(null);
			}
			return tcs.Task;
		}

		private CrateSpawner FindSceneCrateSpawner(SavedObject thing)
		{
			if (thing == null || string.IsNullOrWhiteSpace(thing.Barcode))
			{
				return null;
			}
			string text = ((!string.IsNullOrWhiteSpace(thing.SceneSpawnerId)) ? thing.SceneSpawnerId : thing.SaveId);
			if (string.IsNullOrWhiteSpace(text))
			{
				return null;
			}
			CrateSpawner[] array = SpawnersNow();
			foreach (CrateSpawner val in array)
			{
				if (TryGetCrateSpawnerBarcode(val, out var barcode) && string.Equals(barcode, thing.Barcode, StringComparison.Ordinal))
				{
					string sceneCrateSpawnerSaveId = GetSceneCrateSpawnerSaveId(_levelBarcode, val, barcode);
					if (string.Equals(sceneCrateSpawnerSaveId, text, StringComparison.Ordinal) || string.Equals(sceneCrateSpawnerSaveId, thing.SaveId, StringComparison.Ordinal))
					{
						return val;
					}
				}
			}
			return null;
		}

		private Poolee FindRecentlySpawnedScenePoolee(SavedObject thing, Vector3 spawnerPosition)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			if (thing == null || string.IsNullOrWhiteSpace(thing.Barcode))
			{
				return null;
			}
			Poolee result = null;
			float num = float.PositiveInfinity;
			Poolee[] array = PooleesNow();
			foreach (Poolee val in array)
			{
				if ((Object)(object)val == (Object)null || ((Il2CppObjectBase)val).WasCollected)
				{
					continue;
				}
				SpawnableCrate spawnableCrate = val.SpawnableCrate;
				if (!(((spawnableCrate != null) ? ((Scannable)spawnableCrate).Barcode : null) == (Barcode)null) && string.Equals(((Scannable)val.SpawnableCrate).Barcode.ID, thing.Barcode, StringComparison.Ordinal))
				{
					float num2 = Vector3.Distance(((Component)val).transform.position, spawnerPosition);
					if (num2 < num)
					{
						result = val;
						num = num2;
					}
				}
			}
			if (!(num <= 4f))
			{
				return null;
			}
			return result;
		}

		private void RestoreObjectState(Poolee poolee, SavedObject thing, bool keepRigidbodiesFrozen = false)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)poolee == (Object)null) && !((Il2CppObjectBase)poolee).WasCollected)
			{
				ApplySavedTransforms(poolee, thing, restoreWorldPose: false, keepRigidbodiesFrozen);
				if (thing.HasAIBrain)
				{
					((Component)poolee).transform.position = thing.Position.ToUnity();
					((Component)poolee).transform.rotation = Quaternion.Euler(thing.Rotation.ToUnity());
				}
				RestoreHealth(poolee, thing.Health);
				RestoreDestructible(poolee, thing.Destructible);
			}
		}

		[IteratorStateMachine(typeof(<RestorePlayerAmmoWhenReady>d__118))]
		private static IEnumerator RestorePlayerAmmoWhenReady(PlayerAmmoRecord ammo)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RestorePlayerAmmoWhenReady>d__118(0)
			{
				ammo = ammo
			};
		}

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

		[IteratorStateMachine(typeof(<SpawnInventoryItem>d__120))]
		private IEnumerator SpawnInventoryItem(InventorySlotReceiver receiver, PlayerInventoryItemRecord item)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SpawnInventoryItem>d__120(0)
			{
				<>4__this = this,
				receiver = receiver,
				item = item
			};
		}

		private static SlotContainer FindBodySlot(RigManager rig, string slotName)
		{
			object obj;
			if (rig == null)
			{
				obj = null;
			}
			else
			{
				Inventory inventory = rig.inventory;
				obj = ((inventory != null) ? inventory.bodySlots : null);
			}
			if (obj == null)
			{
				return null;
			}
			foreach (SlotContainer item in (Il2CppArrayBase<SlotContainer>)(object)rig.inventory.bodySlots)
			{
				if ((Object)(object)item != (Object)null && ((Object)((Component)item).gameObject).name == slotName)
				{
					return item;
				}
			}
			return null;
		}

		private static Poolee FindPooleeInReceiver(InventorySlotReceiver receiver)
		{
			try
			{
				if ((Object)(object)receiver == (Object)null || (Object)(object)receiver._slottedWeapon == (Object)null)
				{
					return null;
				}
				InteractableHost interactableHost = receiver._slottedWeapon.interactableHost;
				object obj = TryReadMember(TryReadMember(interactableHost, "marrowEntity"), "_poolee");
				Poolee val = (Poolee)((obj is Poolee) ? obj : null);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
				GameObject val2 = (((Object)(object)interactableHost == (Object)null) ? null : ((Component)interactableHost).gameObject);
				return ((Object)(object)val2 == (Object)null) ? null : val2.GetComponentInParent<Poolee>();
			}
			catch
			{
				return null;
			}
		}

		private void ApplySavedTransforms(Poolee poolee, SavedObject thing, bool restoreWorldPose, bool keepRigidbodiesFrozen = false)
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)poolee == (Object)null || thing == null)
			{
				return;
			}
			bool flag = OnlyRootPoseForThis(thing);
			Dictionary<string, Transform> dictionary = null;
			foreach (TransformRecord transform in thing.Transforms)
			{
				if (flag && !RootRecord(transform))
				{
					continue;
				}
				Transform value = ResolveBySiblingPath(((Component)poolee).transform, transform.SiblingPath);
				if ((Object)(object)value == (Object)null)
				{
					if (dictionary == null)
					{
						dictionary = BuildRuntimeTransformMap(((Component)poolee).transform);
					}
					if (!dictionary.TryGetValue(transform.Path, out value))
					{
						continue;
					}
				}
				value.localPosition = transform.LocalPosition.ToUnity();
				value.localRotation = Quaternion.Euler(transform.LocalRotation.ToUnity());
				value.localScale = transform.LocalScale.ToUnity();
				bool flag2 = restoreWorldPose && transform.HasWorldPose && !string.IsNullOrEmpty(transform.SiblingPath);
				if (flag2)
				{
					value.position = transform.WorldPosition.ToUnity();
					value.rotation = Quaternion.Euler(transform.WorldRotation.ToUnity());
				}
				PutSmallObjectStateBack(value, transform);
				if (transform.Rigidbody == null)
				{
					continue;
				}
				Rigidbody component = ((Component)value).GetComponent<Rigidbody>();
				if (!((Object)(object)component == (Object)null))
				{
					if (flag2)
					{
						component.position = transform.WorldPosition.ToUnity();
						component.rotation = Quaternion.Euler(transform.WorldRotation.ToUnity());
					}
					component.isKinematic = keepRigidbodiesFrozen || transform.Rigidbody.IsKinematic;
					component.useGravity = transform.Rigidbody.UseGravity;
					component.velocity = transform.Rigidbody.Velocity.ToUnity();
					component.angularVelocity = transform.Rigidbody.AngularVelocity.ToUnity();
				}
			}
		}

		private static void PutSmallObjectStateBack(Transform transform, TransformRecord record)
		{
			if ((Object)(object)transform == (Object)null || record == null)
			{
				return;
			}
			if (record.ComponentToggles != null && record.ComponentToggles.Count > 0)
			{
				foreach (ComponentToggleRecord componentToggle in record.ComponentToggles)
				{
					if (DontGrabTinyState(componentToggle.TypeName))
					{
						continue;
					}
					Component val = FindSavedComponent(transform, componentToggle.TypeName, componentToggle.TypeSlot);
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					try
					{
						Behaviour val2 = (Behaviour)(object)((val is Behaviour) ? val : null);
						if (val2 != null)
						{
							val2.enabled = componentToggle.Enabled;
							continue;
						}
						Renderer val3 = (Renderer)(object)((val is Renderer) ? val : null);
						if (val3 != null)
						{
							val3.enabled = componentToggle.Enabled;
							continue;
						}
						Collider val4 = (Collider)(object)((val is Collider) ? val : null);
						if (val4 != null)
						{
							val4.enabled = componentToggle.Enabled;
						}
					}
					catch
					{
					}
				}
			}
			if (record.ComponentBools != null && record.ComponentBools.Count > 0)
			{
				foreach (ComponentBoolRecord componentBool in record.ComponentBools)
				{
					if (string.IsNullOrWhiteSpace(componentBool.Name) || DontGrabTinyState(componentBool.TypeName))
					{
						continue;
					}
					Component val5 = FindSavedComponent(transform, componentBool.TypeName, componentBool.TypeSlot);
					if (!((Object)(object)val5 == (Object)null))
					{
						try
						{
							TryWriteMember(val5, componentBool.Name, componentBool.Value);
						}
						catch
						{
						}
					}
				}
			}
			if (record.ComponentFloats != null && record.ComponentFloats.Count > 0)
			{
				foreach (ComponentFloatRecord componentFloat in record.ComponentFloats)
				{
					if (string.IsNullOrWhiteSpace(componentFloat.Name) || DontGrabTinyState(componentFloat.TypeName))
					{
						continue;
					}
					Component val6 = FindSavedComponent(transform, componentFloat.TypeName, componentFloat.TypeSlot);
					if (!((Object)(object)val6 == (Object)null))
					{
						try
						{
							TryWriteMember(val6, componentFloat.Name, componentFloat.Value);
						}
						catch
						{
						}
					}
				}
			}
			try
			{
				if (((Component)transform).gameObject.activeSelf != record.ActiveSelf)
				{
					((Component)transform).gameObject.SetActive(record.ActiveSelf);
				}
			}
			catch
			{
			}
		}

		private static Component FindSavedComponent(Transform transform, string typeName, int slot)
		{
			if ((Object)(object)transform == (Object)null || string.IsNullOrWhiteSpace(typeName))
			{
				return null;
			}
			Component[] array;
			try
			{
				array = Il2CppArrayBase<Component>.op_Implicit(((Component)transform).GetComponents<Component>());
			}
			catch
			{
				return null;
			}
			int num = 0;
			Component[] array2 = array;
			foreach (Component val in array2)
			{
				if (!((Object)(object)val == (Object)null) && string.Equals(GetCompName(val), typeName, StringComparison.Ordinal))
				{
					if (num == slot)
					{
						return val;
					}
					num++;
				}
			}
			return null;
		}

		private static bool DontGrabTinyState(Component comp, string typeName)
		{
			if ((Object)(object)comp == (Object)null)
			{
				return true;
			}
			if (comp is Transform)
			{
				return true;
			}
			return DontGrabTinyState(typeName);
		}

		private static bool DontGrabTinyState(string typeName)
		{
			if (string.IsNullOrWhiteSpace(typeName))
			{
				return true;
			}
			if (typeName == "UnityEngine.Transform")
			{
				return true;
			}
			if (typeName == "UnityEngine.RectTransform")
			{
				return true;
			}
			return false;
		}

		private static Dictionary<string, Transform> BuildRuntimeTransformMap(Transform root)
		{
			Dictionary<string, Transform> dictionary = new Dictionary<string, Transform>(StringComparer.Ordinal);
			List<Transform> list = new List<Transform>();
			WalkHierarchy(root, list);
			foreach (Transform item in list)
			{
				dictionary[GetRelativePath(root, item)] = item;
			}
			return dictionary;
		}

		private static void FreezePooleeRigidbodies(Poolee poolee, Dictionary<Rigidbody, bool> frozen)
		{
			if ((Object)(object)poolee == (Object)null)
			{
				return;
			}
			foreach (Rigidbody componentsInChild in ((Component)poolee).GetComponentsInChildren<Rigidbody>(true))
			{
				if (!((Object)(object)componentsInChild == (Object)null) && !frozen.ContainsKey(componentsInChild))
				{
					frozen[componentsInChild] = componentsInChild.isKinematic;
					componentsInChild.isKinematic = true;
				}
			}
		}

		private void RegrabLoadedRigidbodies(SceneSaveFile save, List<Poolee> made, Dictionary<Rigidbody, bool> frozen)
		{
			if (save == null || frozen == null)
			{
				return;
			}
			if (made != null)
			{
				for (int i = 0; i < made.Count; i++)
				{
					if ((Object)(object)made[i] == (Object)null && save.Objects != null && i < save.Objects.Count)
					{
						made[i] = FindLoadedPooleeForSavedObject(save.Objects[i]);
					}
					FreezePooleeRigidbodies(made[i], frozen);
				}
			}
			HashSet<string> hashSet = (from obj in save.Objects?.Where((SavedObject obj) => obj != null && !string.IsNullOrWhiteSpace(obj.SaveId))
				select obj.SaveId).ToHashSet<string>(StringComparer.Ordinal) ?? new HashSet<string>(StringComparer.Ordinal);
			if (hashSet.Count == 0)
			{
				return;
			}
			Poolee[] array = PooleesNow();
			foreach (Poolee val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Il2CppObjectBase)val).WasCollected && _savedIds.TryGetValue(((Il2CppObjectBase)val).Pointer, out var value) && hashSet.Contains(value))
				{
					FreezePooleeRigidbodies(val, frozen);
				}
			}
		}

		private Poolee FindLoadedPooleeForSavedObject(SavedObject obj)
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: 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)
			if (obj == null)
			{
				return null;
			}
			Poolee[] array;
			if (!string.IsNullOrWhiteSpace(obj.SaveId))
			{
				if (_loadedIds.TryGetValue(obj.SaveId, out var value))
				{
					if ((Object)(object)value != (Object)null && !((Il2CppObjectBase)value).WasCollected)
					{
						return value;
					}
					_loadedIds.Remove(obj.SaveId);
				}
				array = PooleesNow();
				foreach (Poolee val in array)
				{
					if (!((Object)(object)val == (Object)null) && !((Il2CppObjectBase)val).WasCollected && _savedIds.TryGetValue(((Il2CppObjectBase)val).Pointer, out var value2) && string.Equals(value2, obj.SaveId, StringComparison.Ordinal))
					{
						_loadedIds[obj.SaveId] = val;
						return val;
					}
				}
			}
			if (string.IsNullOrWhiteSpace(obj.Barcode))
			{
				return null;
			}
			Vector3 val2 = obj.Position.ToUnity();
			Poolee val3 = null;
			float num = 3f;
			array = PooleesNow();
			foreach (Poolee val4 in array)
			{
				if ((Object)(object)val4 == (Object)null || ((Il2CppObjectBase)val4).WasCollected)
				{
					continue;
				}
				SpawnableCrate spawnableCrate = val4.SpawnableCrate;
				if (!(((spawnableCrate != null) ? ((Scannable)spawnableCrate).Barcode : null) == (Barcode)null) && string.Equals(((Scannable)val4.SpawnableCrate).Barcode.ID, obj.Barcode, StringComparison.Ordinal))
				{
					float num2 = Vector3.Distance(((Component)val4).transform.position, val2);
					if (!(num2 > num))
					{
						val3 = val4;
						num = num2;
					}
				}
			}
			if ((Object)(object)val3 != (Object)null && !string.IsNullOrWhiteSpace(obj.SaveId))
			{
				_savedIds[((Il2CppObjectBase)val3).Pointer] = obj.SaveId;
				_loadedIds[obj.SaveId] = val3;
			}
			return val3;
		}

		[IteratorStateMachine(typeof(<RestoreSavedRigidbodyStatesTimeSliced>d__132))]
		private static IEnumerator RestoreSavedRigidbodyStatesTimeSliced(SceneSaveFile save, List<Poolee> made, Dictionary<Rigidbody, bool> frozen, bool keepKinematic)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RestoreSavedRigidbodyStatesTimeSliced>d__132(0)
			{
				save = save,
				made = made,
				frozen = frozen,
				keepKinematic = keepKinematic
			};
		}

		[IteratorStateMachine(typeof(<HoldKinematicLoadWindow>d__133))]
		private static IEnumerator HoldKinematicLoadWindow(float seconds, Dictionary<Rigidbody, bool> frozen)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <HoldKinematicLoadWindow>d__133(0)
			{
				seconds = seconds,
				frozen = frozen
			};
		}

		private static void ReassertFrozenRigidbodies(Dictionary<Rigidbody, bool> frozen)
		{
			if (frozen == null)
			{
				return;
			}
			foreach (Rigidbody item in frozen.Keys.ToList())
			{
				if ((Object)(object)item == (Object)null)
				{
					frozen.Remove(item);
					continue;
				}
				item.isKinematic = true;
				ClearRigidbodyMotion(item);
			}
		}

		[IteratorStateMachine(typeof(<StabilizeDeadNpcPosesTimeSliced>d__135))]
		private IEnumerator StabilizeDeadNpcPosesTimeSliced(SceneSaveFile save, List<Poolee> made)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <StabilizeDeadNpcPosesTimeSliced>d__135(0)
			{
				<>4__this = this,
				save = save,
				made = made
			};
		}

		private static bool IsDeadNpcObject(SavedObject obj)
		{
			if (obj != null && obj.HasAIBrain)
			{
				return obj.Health?.IsDead.GetValueOrDefault() ?? false;
			}
			return false;
		}

		private static void ClearPooleeRigidbodyMotion(Poolee poolee)
		{
			if ((Object)(object)poolee == (Object)null)
			{
				return;
			}
			foreach (Rigidbody componentsInChild in ((Component)poolee).GetComponentsInChildren<Rigidbody>(true))
			{
				ClearRigidbodyMotion(componentsInChild);
			}
		}

		private static void ClearRigidbodyMotion(Rigidbody rb)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)rb == (Object)null))
			{
				rb.velocity = Vector3.zero;
				rb.angularVelocity = Vector3.zero;
				rb.Sleep();
			}
		}

		private static void ReleaseDeadNpcRigidbodies(Poolee poolee, SavedObject obj)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			foreach (TransformRecord transform in obj.Transforms)
			{
				if (transform.Rigidbody == null)
				{
					continue;
				}
				Transform val = ResolveBySiblingPath(((Component)poolee).transform, transform.SiblingPath);
				if ((Object)(object)val == (Object)null)
				{
					val = ResolveRelativePath(((Component)poolee).transform, transform.Path);
				}
				if (!((Object)(object)val == (Object)null))
				{
					Rigidbody component = ((Component)val).GetComponent<Rigidbody>();
					if (!((Object)(object)component == (Object)null))
					{
						component.position = transform.WorldPosition.ToUnity();
						component.rotation = Quaternion.Euler(transform.WorldRotation.ToUnity());
						component.isKinematic = transform.Rigidbody.IsKinematic;
						component.useGravity = transform.Rigidbody.UseGravity;
						ClearRigidbodyMotion(component);
					}
				}
			}
		}

		private static void UnfreezeRemainingRigidbodies(Dictionary<Rigidbody, bool> frozen)
		{
			KeyValuePair<Rigidbody, bool>[] array = frozen.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				KeyValuePair<Rigidbody, bool> keyValuePair = array[i];
				if ((Object)(object)keyValuePair.Key != (Object)null)
				{
					keyValuePair.Key.isKinematic = keyValuePair.Value;
				}
			}
			frozen.Clear();
		}

		private static void NotifySaveLoadStarted()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			Notifier.Send(new Notification
			{
				Title = NotificationText.op_Implicit("Loading Save"),
				Message = NotificationText.op_Implicit("Asynchronously loading saved spawnables. Please wait."),
				Type = (NotificationType)0,
				ShowTitleOnPopup = true,
				PopupLength = 3f
			});
		}

		private static void NotifySaveLoadFinished(int spawnables, int constraints)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			Notifier.Send(new Notification
			{
				Title = NotificationText.op_Implicit("Save Loaded Successfully:"),
				Message = NotificationText.op_Implicit($"Loaded {spawnables} spawnables, {constraints} constraints."),
				Type = (NotificationType)3,
				ShowTitleOnPopup = true,
				PopupLength = 5f
			});
		}

		private static void ShowModVersion()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			Notifier.Send(new Notification
			{
				Title = NotificationText.op_Implicit("PersistentScene"),
				Message = NotificationText.op_Implicit("Mod Version: 1.0.0"),
				Type = (NotificationType)0,
				ShowTitleOnPopup = true,
				PopupLength = 5f
			});
		}

		private void OnUIRigCreated()
		{
			MakeSaveQuitButton();
		}

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

		private void MakeSaveQuitButton()
		{
			if (!ShowSaveQuit())
			{
				KillSaveQuitButton();
			}
			else
			{
				if ((Object)(object)_saveQuitObj != (Object)null && !((Il2CppObjectBase)_saveQuitObj).WasCollected)
				{
					return;
				}
				Button val = FindRealQuitButton();
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				Transform parent = ((Component)val).transform.parent;
				if (!((Object)(object)parent == (Object)null))
				{
					Transform val2 = parent.Find("button_SaveAndQuit");
					if ((Object)(object)val2 != (Object)null)
					{
						((Object)val2).name = "button_SaveAndQuit_old";
						Object.Destroy((Object)(object)((Component)val2).gameObject);
					}
					GameObject val3 = Object.Instantiate<GameObject>(((Component)val).gameObject, parent, false);
					((Object)val3).name = "button_SaveAndQuit";
					val3.transform.SetSiblingIndex(((Component)val).transform.GetSiblingIndex());
					_saveQuitObj = val3;
					_saveQuitBtn = val3.GetComponent<Button>();
					HookSaveQuitButton();
					PutButtonText(val3, "Save & Quit");
				}
			}
		}

		private void HookSaveQuitButton()
		{
			if (!((Object)(object)_saveQuitBtn == (Object)null))
			{
				((UnityEvent)_saveQuitBtn.onClick).AddListener(UnityAction.op_Implicit((Action)OnSaveQuitButtonPressed));
			}
		}

		private void OnSaveQuitButtonPressed()
		{
			if (ShowSaveQuit())
			{
				MelonCoroutines.Start(FixSaveQuitPopup());
			}
		}

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

		private Button FindYesButton()
		{
			UIRig uIRig = Player.UIRig;
			object obj;
			if (uIRig == null)
			{
				obj = null;
			}
			else
			{
				PopUpMenuView popUpMenu = uIRig.popUpMenu;
				obj = ((popUpMenu != null) ? popUpMenu.preferencesPanelView : null);
			}
			PreferencesPanelView val = (PreferencesPanelView)obj;
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Button result = null;
			foreach (Button componentsInChild in ((Component)val).GetComponentsInChildren<Button>(true))
			{
				if ((Object)(object)componentsInChild == (Object)null || !((Component)componentsInChild).gameObject.activeInHierarchy || ((Object)(object)_saveQuitBtn != (Object)null && (Object)(object)componentsInChild == (Object)(object)_saveQuitBtn) || (Object)(object)componentsInChild == (Object)(object)FindRealQuitButton() || InOptionsGrid(((Component)componentsInChild).transform))
				{
					continue;
				}
				string text = ButtonText(((Component)componentsInChild).gameObject);
				string name = ((Object)componentsInChild).name ?? string.Empty;
				if (!LooksNoish(name, text) && LooksYesish(name, text))
				{
					result = componentsInChild;
					if (text.Contains("yes", StringComparison.OrdinalIgnoreCase) || text.Contains("confirm", StringComparison.OrdinalIgnoreCase) || text.Contains("main menu", StringComparison.OrdinalIgnoreCase))
					{
						return componentsInChild;
					}
				}
			}
			return result;
		}

		private static bool InOptionsGrid(Transform t)
		{
			while ((Object)(object)t != (Object)null)
			{
				string a = ((Object)t).name ?? string.Empty;
				if (string.Equals(a, "grid_Options", StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
				if (string.Equals(a, "page_OPTIONS", StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
				t = t.parent;
			}
			return false;
		}

		private static bool LooksYesish(string name, string text)
		{
			string text2 = name + " " + text;
			if (!text2.Contains("confirm", StringComparison.OrdinalIgnoreCase) && !text2.Contains("accept", StringComparison.OrdinalIgnoreCase) && !text2.Contains("yes", StringComparison.OrdinalIgnoreCase) && !text2.Contains("ok", StringComparison.OrdinalIgnoreCase))
			{
				return text2.Contains("main menu", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		private static bool LooksNoish(string name, string text)
		{
			string text2 = name + " " + text;
			if (!text2.Contains("cancel", StringComparison.OrdinalIgnoreCase) && !text2.Contains("deny", StringComparison.OrdinalIgnoreCase) && !text2.Contains("no", StringComparison.OrdinalIgnoreCase) && !text2.Contains("back", StringComparison.OrdinalIgnoreCase))
			{
				return text2.Contains("close", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		private void RetitlePopup(GameObject confirmButton)
		{
			Transform val = ((confirmButton != null) ? confirmButton.transform : null);
			for (int i = 0; i < 4; i++)
			{
				if (!((Object)(object)((val != null) ? val.parent : null) != (Object)null))
				{
					break;
				}
				val = val.parent;
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			foreach (TMP_Text componentsInChild in ((Component)val).GetComponentsInChildren<TMP_Text>(true))
			{
				if (!((Object)(object)componentsInChild == (Object)null) && !IsButtonChild(componentsInChild.transform))
				{
					string text = componentsInChild.text ?? string.Empty;
					if (text.Contains("main menu", StringComparison.OrdinalIgnoreCase) || text.Contains("return", StringComparison.OrdinalIgnoreCase) || text.Contains("quit", StringComparison.OrdinalIgnoreCase))
					{
						componentsInChild.text = "Save and Quit?";
					}
				}
			}
		}

		private static bool IsButtonChild(Transform t)
		{
			while ((Object)(object)t != (Object)null)
			{
				if ((Object)(object)((Component)t).GetComponent<Button>() != (Object)null)
				{
					return true;
				}
				t = t.parent;
			}
			return false;
		}

		private Button FindRealQuitButton()
		{
			try
			{
				UIRig uIRig = Player.UIRig;
				object obj;
				if (uIRig == null)
				{
					obj = null;
				}
				else
				{
					PopUpMenuView popUpMenu = uIRig.popUpMenu;
					obj = ((popUpMenu != null) ? popUpMenu.preferencesPanelView : null);
				}
				PreferencesPanelView val = (PreferencesPanelView)obj;
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
				Transform val2 = ((Component)val).transform.Find("page_OPTIONS/grid_Options");
				if ((Object)(object)val2 == (Object)null && val.pages != null)
				{
					GameObject obj2 = ((Il2CppArrayBase<GameObject>)(object)val.pages)[val.defaultPage];
					val2 = ((obj2 != null) ? obj2.transform.Find("grid_Options") : null);
				}
				Transform val3 = ((val2 != null) ? val2.Find("button_Quit") : null);
				if ((Object)(object)val3 != (Object)null)
				{
					return ((Component)val3).GetComponent<Button>();
				}
				Button[] array = Il2CppArrayBase<Button>.op_Implicit(((Component)(val2 ?? ((Component)val).transform)).GetComponentsInChildren<Button>(true));
				foreach (Button val4 in array)
				{
					if (!((Object)(object)val4 == (Object)null))
					{
						GameObject gameObject = ((Component)val4).gameObject;
						if (!((Object)(object)gameObject == (Object)null) && !string.Equals(((Object)gameObject).name, "button_SaveAndQuit", StringComparison.OrdinalIgnoreCase) && (((Object)gameObject).name.Contains("button_Quit", StringComparison.OrdinalIgnoreCase) || ((Object)gameObject).name.Contains("Quit", StringComparison.OrdinalIgnoreCase) || ButtonSays(gameObject, "Main Menu")))
						{
							return val4;
						}
					}
				}
			}
			catch (Exception ex)
			{
				((MelonBase)this).LoggerInstance.Warning("Could not find native quit button: " + ex.Message);
			}
			return null;
		}

		private bool ButtonSays(GameObject button, string text)
		{
			if ((Object)(object)button == (Object)null)
			{
				return false;
			}
			foreach (TMP_Text componentsInChild in button.GetComponentsInChildren<TMP_Text>(true))
			{
				if ((Object)(object)componentsInChild != (Object)null && string.Equals(componentsInChild.text, text, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		private void KillSaveQuitButton()
		{
			if (!((Object)(object)_saveQuitObj == (Object)null) && !((Il2CppObjectBase)_saveQuitObj).WasCollected)
			{
				Object.Destroy((Object)(object)_saveQuitObj);
				_saveQuitObj = null;
				_saveQuitBtn = null;
			}
		}

		private bool ShowSaveQuit()
		{
			if (!_inLevel || string.IsNullOrWhiteSpace(_levelBarcode))
			{
				return false;
			}
			if (string.Equals(_levelBarcode, "c2534c5a-80e1-4a29-93ca-f3254d656e75", StringComparison.Ordinal))
			{
				return false;
			}
			if (string.Equals(_levelBarcode, "fa534c5a868247138f50c62e424c4144.Level.VoidG114", StringComparison.Ordinal))
			{
				return false;
			}
			return true;
		}

		private static string ButtonText(GameObject button)
		{
			if ((Object)(object)button == (Object)null)
			{
				return string.Empty;
			}
			return string.Join(" ", from label in (IEnumerable<TMP_Text>)button.GetComponentsInChildren<TMP_Text>(true)
				where (Object)(object)label != (Object)null && !string.IsNullOrWhiteSpace(label.text)
				select label.text);
		}

		private static void PutButtonText(GameObject button, string text)
		{
			if ((Object)(object)button == (Object)null)
			{
				return;
			}
			foreach (TMP_Text componentsInChild in button.GetComponentsInChildren<TMP_Text>(true))
			{
				if ((Object)(object)componentsInChild != (Object)null)
				{
					componentsInChild.text = text;
				}
			}
		}

		private void BuildBoneMenu()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: 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_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			_page = Page.Root.CreatePage("PersistentScene", Color.cyan, 0, true);
			_setting = _page.CreatePage("Settings", Color.white, 0, true);
			_setting.CreateBool("Enable Mod", Color.white, _config.ModEnabled, (Action<bool>)delegate(bool value)
			{
				_config.ModEnabled = value;
				if (!value)
				{
					_blockDefaultCrateSpawners = false;
					_skipSceneSpawnerRouteForLoad = false;
				}
				SaveConfig();
			});
			_setting.CreateBool("Save Player Location", Color.white, _config.SavePlayerLocation, (Action<bool>)delegate(bool value)
			{
				_config.SavePlayerLocation = value;
				SaveConfig();
			});
			_page.CreateFunction("Delete current level save", Color.yellow, (Action)DeleteCurrentLevelSave);
			_page.CreateFunction("Mod Version", Color.white, (Action)ShowModVersion);
			_page.CreateFunction("Join Discord:)", Color.cyan, (Action)OpenDiscord);
			_page.CreateFunction("Refresh menu", Color.white, (Action)RefreshBoneMenu);
			_manual = _page.CreatePage("ManualSave", Color.white, 0, true);
			_manual.CreateFunction("Save Current Level", Color.white, (Action)delegate
			{
				SaveCurrentLevel("BoneMenu");
			});
			_manual.CreateFunction("Load Current Level", Color.white, (Action)delegate
			{
				if (!string.IsNullOrWhiteSpace(_levelBarcode) && !IsBlacklisted(_levelBarcode))
				{
					string text = (string.IsNullOrWhiteSpace(_levelBarcode) ? null : GetSavePath(_levelBarcode));
					if (text != null)
					{
						MelonCoroutines.Start(LoadCurrentLevelSave(text));
					}
				}
			});
			_banPage = _page.CreatePage("Blacklist", Color.yellow, 0, true);
			_savePage = _page.CreatePage("Save files", Color.white, 0, true);
			RefreshBoneMenu();
		}

		private static void OpenDiscord()
		{
			Application.OpenURL("https://discord.gg/Qf3r2zKwx");
		}

		private void RefreshBoneMenu()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: 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_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			if (_savePage == null || _banPage == null)
			{
				return;
			}
			_savePage.RemoveAll();
			_savePage.CreateFunction("Clear All", Color.yellow, (Action)AskClearSaves);
			foreach (string file in GetSaveFiles().OrderBy<string, string>(SaveMenuName, StringComparer.OrdinalIgnoreCase))
			{
				Page obj = _savePage.CreatePage(SaveMenuName(file), Color.white, 0, true);
				obj.CreateFunction("Delete", Color.yellow, (Action)delegate
				{
					Directory.Delete(file, recursive: true);
					RefreshBoneMenu();
					Menu.OpenPage(_savePage);
				});
				obj.CreateFunction("View save info", Color.white, (Action)delegate
				{
					ShowSaveInfo(file);
				});
				obj.CreateFunction("Repair filename", Color.white, (Action)delegate
				{
					RepairSaveName(file);
				});
			}
			_banPage.RemoveAll();
			_banPage.CreateFunction("Clear All", Color.yellow, (Action)AskClearBlacklist);
			bool flag = IsBlacklisted(_levelBarcode);
			string text = (flag ? "Remove current from blacklist" : "Add current to blacklist");
			_banPage.CreateFunction(text, flag ? Color.green : Color.white, (Action)ToggleCurrentLevelBlacklist);
			foreach (string barcode in _config.BlacklistedLevelBarcodes.OrderBy<string, string>(LevelNameForMenu, StringComparer.Ordinal))
			{
				Page obj2 = _banPage.CreatePage(LevelNameForMenu(barcode), Color.yellow, 0, true);
				obj2.CreateFunction("Remove", Color.green, (Action)delegate
				{
					_config.BlacklistedLevelBarcodes.Remove(barcode);
					SaveConfig();
					RefreshBoneMenu();
					Menu.OpenPage(_banPage);
				});
				obj2.CreateFunction("Show barcode", Color.gray, (Action)delegate
				{
					Menu.DisplayDialog("Blacklisted level", barcode, (Texture2D)null, (Action)null, (Action)null);
				});
			}
		}

		private void AskClearSaves()
		{
			Menu.DisplayDialog("Clear all save files?", "This will delete all SceneSave save file. Are you sure?", Dialog.WarningIcon, (Action)ClearSavesNow, (Action)null);
		}

		private void ClearSavesNow()
		{
			int num = 0;
			foreach (string item in GetSaveFiles().ToList())
			{
				try
				{
					Directory.Delete(item, recursive: true);
					num++;
				}
				catch (Exception ex)
				{
					((MelonBase)this).LoggerInstance.Warning("Could not delete save file " + Path.GetFileName(item) + ": " + ex.Message);
				}
			}
			((MelonBase)this).LoggerInstance.Msg($"Deleted {num} SceneSave save files.");
			RefreshBoneMenu();
			Menu.OpenPage(_savePage);
		}

		private void AskClearBlacklist()
		{
			Menu.DisplayDialog("Clear blacklist?", "This will remove all level from the SceneSave blacklist. Are you sure?", Dialog.WarningIcon, (Action)ClearBlacklistNow, (Action)null);
		}

		private void ClearBlacklistNow()
		{
			_config.BlacklistedLevelBarcodes.Clear();
			SaveConfig();
			((MelonBase)this).LoggerInstance.Msg("Cleared SceneSave level blacklist.");
			RefreshBoneMenu();
			Menu.OpenPage(_banPage);
		}

		private void RepairSaveName(string file)
		{
			SceneSaveFile sceneSaveFile = ReadSaveMaybe(file);
			if (sceneSaveFile == null || string.IsNullOrWhiteSpace(sceneSaveFile.LevelBarcode))
			{
				Menu.DisplayDialog("PersistentScene", "Could not repair this save. The file has no readable level barcode.", (Texture2D)null, (Action)null, (Action)null);
				return;
			}
			string savePath = GetSavePath(sceneSaveFile.LevelBarcode, sceneSaveFile.LevelName);
			string fullPath = Path.GetFullPath(file);
			string fullPath2 = Path.GetFullPath(savePath);
			if (string.Equals(fullPath, fullPath2, StringComparison.OrdinalIgnoreCase))
			{
				Menu.DisplayDialog("PersistentScene", "Filename is already OK.\n\nLevel: " + (sceneSaveFile.LevelName ?? ShortName(sceneSaveFile.LevelBarcode)), (Texture2D)null, (Action)null, (Action)null);
				return;
			}
			if (Directory.Exists(savePath))
			{
				Menu.DisplayDialog("PersistentScene", "Could not repair save folder because the target already exists:\n" + Path.GetFileName(savePath), (Texture2D)null, (Action)null, (Action)null);
				return;
			}
			try
			{
				Directory.Move(file, savePath);
				((MelonBase)this).LoggerInstance.Msg("Repaired save folder: " + Path.GetFileName(file) + " -> " + Path.GetFileName(savePath));
				RefreshBoneMenu();
				Menu.OpenPage(_savePage);
			}
			catch (Exception ex)
			{
				Menu.DisplayDialog("PersistentScene", "Could not repair filename:\n" + ex.Message, (Texture2D)null, (Action)null, (Action)null);
			}
		}

		private void DeleteCurrentLevelSave()
		{
			if (!string.IsNullOrWhiteSpace(_levelBarcode))
			{
				string savePath = GetSavePath(_levelBarcode);
				if (Directory.Exists(savePath))
				{
					Directory.Delete(savePath, recursive: true);
				}
				RefreshBoneMenu();
			}
		}

		private void ToggleCurrentLevelBlacklist()
		{
			if (!string.IsNullOrWhiteSpace(_levelBarcode))
			{
				if (!_config.BlacklistedLevelBarcodes.Add(_levelBarcode))
				{
					_config.BlacklistedLevelBarcodes.Remove(_levelBarcode);
				}
				if (IsBlacklisted(_levelBarcode))
				{
					ClearLastLevelBits();
				}
				else
				{
					StashLastLevel(_levelBarcode, _levelTitle);
				}
				SaveConfig();
				RefreshBoneMenu();
			}
		}

		private bool HasLastLevelToOpen()
		{
			if (string.IsNullOrWhiteSpace(_config.LastLevelBarcode))
			{
				return false;
			}
			return !IsBlacklisted(_config.LastLevelBarcode);
		}

		private void StartupJump()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			string lastLevelBarcode = _config.LastLevelBarcode;
			if (string.IsNullOrWhiteSpace(lastLevelBarcode) || IsBlacklisted(lastLevelBarcode))
			{
				return;
			}
			try
			{
				SceneBootstrapper_Bonelab val = Object.FindObjectOfType<SceneBootstrapper_Bonelab>();
				if ((Object)(object)val == (Object)null)
				{
					((MelonBase)this).LoggerInstance.Warning("Could not find SceneBootstrapper_Bonelab for startup level redirect.");
					return;
				}
				val.VoidG114CrateRef = new LevelCrateReference(lastLevelBarcode);
				val.MenuHollowCrateRef = new LevelCrateReference(lastLevelBarcode);
				string value = (string.IsNullOrWhiteSpace(_config.LastLevelName) ? LevelNameForMenu(lastLevelBarcode) : _config.LastLevelName);
				((MelonBase)this).LoggerInstance.Msg($"Startup will open last SceneSave level: {value} ({lastLevelBarcode}).");
			}
			catch (Exception ex)
			{
				((MelonBase)this).LoggerInstance.Warning("Startup level redirect failed: " + ex.Message);
			}
		}

		private void RememberLevel(LevelInfo info)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			RememberLevel(info.barcode, info.title);
		}

		private void RememberLevel(string barcode, string title)
		{
			if (StashLastLevel(barcode, title))
			{
				SaveConfig();
			}
		}

		private bool StashLastLevel(string barcode, string title)
		{
			if (string.IsNullOrWhiteSpace(barcode))
			{
				return ClearLastLevelBits();
			}
			if (IsBlacklisted(barcode))
			{
				return ClearLastLevelBits();
			}
			if (string.Equals(_config.LastLevelBarcode, barcode, StringComparison.Ordinal) && string.Equals(_config.LastLevelName, title, StringComparison.Ordinal))
			{
				return false;
			}
			_config.LastLevelBarcode = barcode;
			_config.LastLevelName = title;
			return true;
		}

		private void ForgetLast()
		{
			if (ClearLastLevelBits())
			{
				SaveConfig();
			}
		}

		private bool ClearLastLevelBits()
		{
			if (string.IsNullOrWhiteSpace(_config.LastLevelBarcode) && string.IsNullOrWhiteSpace(_config.LastLevelName))
			{
				return false;
			}
			_config.LastLevelBarcode = null;
			_config.LastLevelName = null;
			return true;
		}

		private bool IsBlacklisted(string barcode)
		{
			if (!string.IsNullOrWhiteSpace(barcode))
			{
				return _config.BlacklistedLevelBarcodes.Contains(barcode);
			}
			return false;
		}

		private string LevelNameForMenu(string barcode)
		{
			if (string.IsNullOrWhiteSpace(barcode))
			{
				return "Unknown";
			}
			if (barcode == _levelBarcode && !string.IsNullOrWhiteSpace(_levelTitle))
			{
				return _levelTitle;
			}
			(string, string)[] array = defaultBlacklist;
			for (int i = 0; i < array.Length; i++)
			{
				(string, string) tuple = array[i];
				var (result, _) = tuple;
				if (string.Equals(tuple.Item2, barcode, StringComparison.Ordinal))
				{
					return result;
				}
			}
			return ShortName(barcode);
		}

		private void ShowSaveInfo(string file)
		{
			try
			{
				SceneSaveFile sceneSaveFile = ReadSaveMaybe(file);
				if (sceneSaveFile == null)
				{
					Menu.DisplayDialog("PersistentScene", "Could not read save metadata.", (Texture2D)null, (Action)null, (Action)null);
					return;
				}
				DateTime value = ((sceneSaveFile.SavedAtUtc.Kind == DateTimeKind.Utc) ? sceneSaveFile.SavedAtUtc.ToLocalTime() : DateTime.SpecifyKind(sceneSaveFile.SavedAtUtc, DateTimeKind.Utc).ToLocalTime());
				string text = $"File: {Path.GetFileName(file)}\nInitial version: {sceneSaveFile.InitialSaveVersion ?? "Unknown"}\nSupported version: {sceneSaveFile.SupportedVersion ?? "Unknown"}\nLevel name: {sceneSaveFile.LevelName ?? ShortName(sceneSaveFile.LevelBarcode)}\nLevel barcode:\n{sceneSaveFile.LevelBarcode}\n\nSaved time: {value:yyyy-MM-dd HH:mm:ss}\nUTC: {sceneSaveFile.SavedAtUtc:yyyy-MM-dd HH:mm:ss}Z\nObjects: {sceneSaveFile.Objects.Count}\nConstraints: {sceneSaveFile.Constraints.Count}\nPlayer position saved: {((sceneSaveFile.PlayerPose != null) ? "Yes" : "No")}";
				Menu.DisplayDialog("SceneSave Info", text, (Texture2D)null, (Action)null, (Action)null);
			}
			catch (Exception ex)
			{
				Menu.DisplayDialog("PersistentScene", "Could not read save metadata:\n" + ex.Message, (Texture2D)null, (Action)null, (Action)null);
			}
		}

		private void LoadConfig()
		{
			try
			{
				if (File.Exists(_cfg))
				{
					_config = JsonSerializer.Deserialize<SceneSaveConfig>(File.ReadAllText(_cfg, Encoding.UTF8), jsonOpts) ?? new SceneSaveConfig();
				}
			}
			catch (Exception ex)
			{
				((MelonBase)this).LoggerInstance.Warning("Config load failed, using empty config: " + ex.Message);
				_config = new SceneSaveConfig();
			}
			SceneSaveConfig config = _config;
			if (config.BlacklistedLevelBarcodes == null)
			{
				HashSet<string> hashSet2 = (config.BlacklistedLevelBarcodes = new HashSet<string>(StringComparer.Ordinal));
			}
			bool flag = false;
			if (SeedBlacklistOnce())
			{
				flag = true;
			}
			if (SeedPlayerPosOnce())
			{
				flag = true;
			}
			if (!string.IsNullOrWhiteSpace(_config.LastLevelBarcode) && IsBlacklisted(_config.LastLevelBarcode) && ClearLastLevelBits())
			{
				flag = true;
			}
			if (flag)
			{
				SaveConfig();
			}
		}

		private void SaveConfig()
		{
			File.WriteAllText(_cfg, JsonSerializer.Serialize(_config, jsonOpts), Encoding.UTF8);
		}

		private bool SeedBlacklistOnce()
		{
			if (_config.DefaultBlacklistSeeded)
			{
				return false;
			}
			(string, string)[] array = defaultBlacklist;
			for (int i = 0; i < array.Length; i++)
			{
				string item = array[i].Item2;
				_config.BlacklistedLevelBarcodes.Add(item);
			}
			_config.DefaultBlacklistSeeded = true;
			return true;
		}

		private bool SeedPlayerPosOnce()
		{
			if (_config.SavePlayerLocationDefaultSeeded)
			{
				return false;
			}
			_config.SavePlayerLocation = true;
			_config.SavePlayerLocationDefaultSeeded = true;
			return true;
		}

		private string SaveMenuName(string file)
		{
			try
			{
				SceneSaveFile sceneSaveFile = ReadSaveMaybe(file);
				if (sceneSaveFile != null)
				{
					if (!string.IsNullOrWhiteSpace(sceneSaveFile.LevelName))
					{
						return sceneSaveFile.LevelName;
					}
					if (!string.IsNullOrWhiteSpace(sceneSaveFile.LevelBarcode))
					{
						return LevelNameForMenu(sceneSaveFile.LevelBarcode);
					}
				}
			}
			catch
			{
			}
			return Path.GetFileNameWithoutExtension(file);
		}

		private string GetSavePath(string levelBarcode, string levelName = null)
		{
			string input = ((!string.IsNullOrWhiteSpace(levelName)) ? levelName : LevelNameForMenu(levelBarcode));
			return Path.Combine(_saveFolder, ShortName(input) + "_" + StableId(levelBarcode));
		}

		private IEnumerable<string> GetSaveFiles()
		{
			if (!Directory.Exists(_saveFolder))
			{
				return Enumerable.Empty<string>();
			}
			return Directory.EnumerateDirectories(_saveFolder);
		}

		private static string StableId(string input)
		{
			return Convert.ToHexString(SHA1.HashData(Encoding.UTF8.GetBytes(input ?? string.Empty))).Substring(0, 12).ToLowerInvariant();
		}

		private static string ShortName(string input)
		{
			if (string.IsNullOrWhiteSpace(input))
			{
				return "unknown";
			}
			string? obj = input.Split('.').LastOrDefault() ?? input;
			StringBuilder stringBuilder = new StringBuilder();
			string text = obj;
			foreach (char c in text)
			{
				if (char.IsLetterOrDigit(c) || c == '-' || c == '_')
				{
					stringBuilder.Append(c);
				}
			}
			string text2 = ((stringBuilder.Length == 0) ? "level" : stringBuilder.ToString());
			if (text2.Length <= 32)
			{
				return text2;
			}
			return text2.Substring(0, 32);
		}

		private HashSet<string> GetDeletedIds(SceneSaveFile oldSave)
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			if (oldSave?.DeletedSaveIds != null)
			{
				foreach (string deletedSaveId in oldSave.DeletedSaveIds)
				{
					if (!string.IsNullOrWhiteSpace(deletedSaveId))
					{
						hashSet.Add(deletedSaveId);
					}
				}
			}
			foreach (string deletedId in _deletedIds)
			{
				if (!string.IsNullOrWhiteSpace(deletedId))
				{
					hashSet.Add(deletedId);
				}
			}
			return hashSet;
		}

		private void ApplyDeletedIds(SceneSaveFile file, SceneSaveFile oldSave)
		{
			if (file == null)
			{
				return;
			}
			HashSet<string> deletedIds = GetDeletedIds(oldSave);
			if (deletedIds.Count > 0)
			{
				Dictionary<int, int> dictionary = new Dictionary<int, int>();
				List<SavedObject> list = new List<SavedObject>();
				int num = 0;
				for (int i = 0; i < file.Objects.Count; i++)
				{
					SavedObject savedObject = file.Objects[i];
					if (!string.IsNullOrWhiteSpace(savedObject?.SaveId) && deletedIds.Contains(savedObject.SaveId))
					{
						num++;
						continue;
					}
					dictionary[i] = list.Count;
					list.Add(savedObject);
				}
				if (num > 0)
				{
					file.Objects = list;
					List<ConstraintRecord> list2 = new List<ConstraintRecord>();
					foreach (ConstraintRecord constraint in file.Constraints)
					{
						ConstraintRecord constraintRecord = RemapPreviousConstraint(constraint, dictionary);
						if (constraintRecord != null)
						{
							list2.Add(constraintRecord);
						}
					}
					file.Constraints = list2;
					((MelonBase)this).LoggerInstance.Msg($"Removed {num} deleted saved objects before writing the save.");
				}
			}
			file.DeletedSaveIds = deletedIds.OrderBy<string, string>((string id) => id, StringComparer.Ordinal).ToList();
		}

		private void CleanSave(SceneSaveFile file)
		{
			if (file?.Objects == null || file.Objects.Count == 0)
			{
				return;
			}
			EnsureSaveIds(file);
			int num = 0;
			foreach (SavedObject @object in file.Objects)
			{
				if (@object != null && !IsSceneSpawnerSavedObject(@object) && LooksLikeSceneSpawnerSaveId(@object.SaveId) && !((Object)(object)FindSceneCrateSpawner(@object) == (Object)null))
				{
					@object.SceneSpawnerId = @object.SaveId;
					@object.FromSceneCrateSpawner = true;
					num++;
				}
			}
			HashSet<int> hashSet = new HashSet<int>();
			Dictionary<int, int> dictionary = new Dictionary<int, int>();
			int num2 = 0;
			foreach (IGrouping<string, (SavedObject, int)> item3 in from @group in (from pair in file.Objects.Select((SavedObject obj, int index) => (obj, index))
					where pair.Object != null && !string.IsNullOrWhiteSpace(pair.Object.SaveId)
					select pair).GroupBy<(SavedObject, int), string>(((SavedObject Object, int Index) pair) => pair.Object.SaveId, StringComparer.Ordinal)
				where @group.Count() > 1
				select @group)
			{
				List<(SavedObject, int)> list = item3.ToList();
				if (list.Any<(SavedObject, int)>(((SavedObject Object, int Index) entry) => IsSceneSpawnerSavedObject(entry.Object) || LooksLikeSceneSpawnerSaveId(entry.Object.SaveId)))
				{
					Vector3? spawnerPosition = GetSceneSpawnerPositionForDuplicateGroup(list);
					(SavedObject, int) tuple = (from entry in list
						orderby (!spawnerPosition.HasValue) ? float.PositiveInfinity : Vector3.Distance(entry.Object.Position.ToUnity(), spawnerPosition.Value), GetSavedObjectKeepScore(entry.Object) descending, entry.Index
						select entry).First();
					foreach (var item4 in list)
					{
						int item = item4.Item2;
						if (item != tuple.Item2)
						{
							hashSet.Add(item);
							dictionary[item] = tuple.Item2;
						}
					}
					tuple.Item1.SceneSpawnerId = tuple.Item1.SaveId;
					tuple.Item1.FromSceneCrateSpawner = true;
					continue;
				}
				foreach (var item5 in list.Skip(1))
				{
					SavedObject item2 = item5.Item1;
					item2.SaveId = Guid.NewGuid().ToString("N");
					item2.SceneSpawnerId = null;
					item2.FromSceneCrateSpawner = false;
					num2++;
				}
			}
			int value = AddSameTransformDuplicateRemovals(file, hashSet, dictionary);
			if (hashSet.Count <= 0)
			{
				if (num2 > 0 || num > 0)
				{
					((MelonBase)this).LoggerInstance.Msg($"Promoted {num} scene-spawner save ids and reassigned {num2} duplicate runtime save ids.");
				}
				return;
			}
			Dictionary<int, int> dictionary2 = new Dictionary<int, int>();
			List<SavedObject> list2 = new List<SavedObject>();
			for (int i = 0; i < file.Objects.Count; i++)
			{
				if (!hashSet.Contains(i))
				{
					dictionary2[i] = list2.Count;
					list2.Add(file.Objects[i]);
				}
			}
			foreach (KeyValuePair<int, int> item6 in dictionary)
			{
				if (dictionary2.TryGetValue(item6.Value, out var value2))
				{
					dictionary2[item6.Key] = value2;
				}
			}
			file.Objects = list2;
			List<ConstraintRecord> list3 = new List<ConstraintRecord>();
			foreach (ConstraintRecord constraint in file.Constraints)
			{
				ConstraintRecord constraintRecord = RemapPreviousConstraint(constraint, dictionary2);
				if (constraintRecord != null)
				{
					list3.Add(constraintRecord);
				}
			}
			file.Constraints = list3;
			((MelonBase)this).LoggerInstance.Msg($"Promoted {num} scene-spawner save ids, removed {hashSet.Count} duplicate saved objects ({value} same transform), and reassigned {num2} runtime duplicate ids.");
		}

		private static int AddSameTransformDuplicateRemovals(SceneSaveFile file, HashSet<int> drop, Dictionary<int, int> redirects)
		{
			if (file?.Objects == null || file.Objects.Count < 2)
			{
				return 0;
			}
			int num = 0;
			foreach (IGrouping<string, (SavedObject, int)> item2 in from @group in (from pair in file.Objects.Select((SavedObject obj, int index) => (obj, index))
					where pair.Object != null && !drop.Contains(pair.Index) && CanLoadSavedObject(pair.Object)
					select pair).GroupBy<(SavedObject, int), string>(((SavedObject Object, int Index) pair) => GetSameTransformKey(pair.Object), StringComparer.Ordinal)
				where @group.Count() > 1
				select @group)
			{
				(SavedObject, int) tuple = (from entry in item2
					orderby GetSavedObjectKeepScore(entry.Object) descending, IsSceneSpawnerSavedObject(entry.Object) descending, entry.Index
					select entry).First();
				foreach (var item3 in item2)
				{
					int item = item3.Item2;
					if (item != tuple.Item2)
					{
						if (drop.Add(item))
						{
							num++;
						}
						redirects[item] = tuple.Item2;
					}
				}
			}
			return num;
		}

		private static string GetSameTransformKey(SavedObject obj)
		{
			return string.Join("|", obj.Barcode ?? string.Empty, RoundForKey(obj.Position.X), RoundForKey(obj.Position.Y), RoundForKey(obj.Position.Z), RoundForKey(obj.Rotation.X), RoundForKey(obj.Rotation.Y), RoundForKey(obj.Rotation.Z), RoundForKey(obj.Scale.X), RoundForKey(obj.Scale.Y), RoundForKey(obj.Scale.Z));
		}

		private Vector3? GetSceneSpawnerPositionForDuplicateGroup(List<(SavedObject Object, int Index)> entries)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			foreach (var entry in entries)
			{
				SavedObject item = entry.Object;
				CrateSpawner val = FindSceneCrateSpawner(item);
				if ((Object)(object)val != (Object)null)
				{
					return ((Component)val).transform.position;
				}
			}
			return null;
		}

		private static bool IsSceneSpawnerSavedObject(SavedObject obj)
		{
			if (obj != null)
			{
				if (!obj.FromSceneCrateSpawner)
				{
					return !string.IsNullOrWhiteSpace(obj.SceneSpawnerId);
				}
				return true;
			}
			return false;
		}

		private static bool LooksLikeSceneSpawnerSaveId(string saveId)
		{
			if (!string.IsNullOrWhiteSpace(saveId) && saveId.Length == 12)
			{
				return saveId.All(Uri.IsHexDigit);
			}
			return false;
		}

		private static int GetSavedObjectKeepScore(SavedObject obj)
		{
			if (obj == null)
			{
				return int.MinValue;
			}
			int num = 0;
			num += obj.Transforms?.Count ?? 0;
			if (!obj.FromSceneCrateSpawner)
			{
				num += 1000;
			}
			if (!string.IsNullOrWhiteSpace(obj.SceneSpawnerId))
			{
				num += 50;
			}
			if (obj.Health != null)
			{
				num += 20;
			}
			if (obj.Destructible != null)
			{
				num += 20;
			}
			if (obj.HasAIBrain)
			{
				num += 20;
			}
			return num;
		}

		private static Dictionary<string, SavedObject> BuildPreviousObjectLookup(SceneSaveFile oldSave, string levelBarcode)
		{
			Dictionary<string, SavedObject> dictionary = new Dictionary<string, SavedObject>(StringComparer.Ordinal);
			if (oldSave == null || oldSave.LevelBarcode != levelBarcode || oldSave.Objects == null)
			{
				return dictionary;
			}
			EnsureSaveIds(oldSave);
			foreach (SavedObject @object in oldSave.Objects)
			{
				if (@object != null && !string.IsNullOrWhiteSpace(@object.SaveId) && !dontSaveThese.Contains(@object.Barcode))
				{
					dictionary.TryAdd(@object.SaveId, @object);
				}
			}
			return dictionary;
		}

		private static bool ShouldCaptureMissingZoneCrateSpawner(CrateSpawner spawner, string barcode, Vector3 playerPos)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)spawner == (Object)null || (Object)(object)((Component)spawner).transform == (Object)null)
			{
				return false;
			}
			Scene scene = ((Component)spawner).gameObject.scene;
			if (((Scene)(ref scene)).name == "DontDestroyOnLoad")
			{
				return false;
			}
			if (string.IsNullOrWhiteSpace(barcode))
			{
				return false;
			}
			if (dontSaveThese.Contains(barcode))
			{
				return false;
			}
			if (IsSystemBarcodeOrName(barcode, ((Object)spawner).name))
			{
				return false;
			}
			if (IsSpentCasing(barcode, ((Object)spawner).name))
			{
				return false;
			}
			if (IsProbablyMenuOrSystemObject(((Component)spawner).transform))
			{
				return false;
			}
			if (IsProbablyMenuOrSystemObject(((Component)spawner).transform.root))
			{
				return false;
			}
			float num = Vector3.Distance(playerPos, ((Component)spawner).transform.position);
			if (((Component)spawner).gameObject.activeInHierarchy)
			{
				return num >= 12f;
			}
			return true;
		}

		private static SavedObject CaptureCrateSpawnerFallback(string levelBarcode, CrateSpawner spawner, string barcode, string saveId)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			SavedObject obj = new SavedObject
			{
				SaveId = saveId,
				SceneSpawnerId = saveId,
				FromSceneCrateSpawner = true,
				Barcode = barcode,
				Name = ((Object)spawner).name,
				Position = Vec3.From(((Component)spawner).transform.position)
			};
			Quaternion rotation = ((Component)spawner).transform.rotation;
			obj.Rotation = Vec3.From(((Quaternion)(ref rotation)).eulerAngles);
			obj.Scale = Vec3.From(Vector3.one);
			return obj;
		}

		private static bool TryGetCrateSpawnerBarcode(CrateSpawner spawner, out string barcode)
		{
			barcode = null;
			if ((Object)(object)spawner == (Object)null || spawner._spawnable == null || spawner._spawnable.crateRef == null || ((ScannableReference)spawner._spawnable.crateRef).Barcode == (Barcode)null)
			{
				return false;
			}
			barcode = ((ScannableReference)spawner._spawnable.crateRef).Barcode.ID;
			return !string.IsNullOrWhiteSpace(barcode);
		}

		private static string GetSceneCrateSpawnerSaveId(string levelBarcode, CrateSpawner spawner, string barcode)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			string sceneTransformPath = GetSceneTransformPath((spawner != null) ? ((Component)spawner).transform : null);
			string text;
			if (!((Object)(object)spawner == (Object)null) && !((Object)(object)((Component)spawner).gameObject == (Object)null))
			{
				Scene scene = ((Component)spawner).gameObject.scene;
				text = ((Scene)(ref scene)).name;
			}
			else
			{
				text = string.Empty;
			}
			string text2 = text;
			return StableId(string.Join("|", levelBarcode ?? string.Empty, "CrateSpawner", text2, sceneTransformPath, barcode ?? string.Empty));
		}

		private static string GetSceneTransformPath(Transform transform)
		{
			if ((Object)(object)transform == (Object)null)
			{
				return string.Empty;
			}
			List<string> list = new List<string>();
			Transform val = transform;
			while ((Object)(object)val != (Object)null)
			{
				list.Add($"{val.GetSiblingIndex()}:{((Object)val).name}");
				val = val.parent;
			}
			list.Reverse();
			return string.Join("/", list);
		}

		private void KeepOtherZoneStuff(SceneSaveFile save, SceneSaveFile oldSave)
		{
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			if (save == null || oldSave == null || oldSave.LevelBarcode != save.LevelBarcode || save.PlayerPose == null)
			{
				return;
			}
			EnsureSaveIds(save);
			EnsureSaveIds(oldSave);
			HashSet<string> hashSet = (from obj in save.Objects
				where !string.IsNullOrWhiteSpace(obj.SaveId)
				select obj.SaveId).ToHashSet<string>(StringComparer.Ordinal);
			HashSet<string> hashSet2 = save.DeletedSaveIds?.Where((string id) => !string.IsNullOrWhiteSpace(id)).ToHashSet<string>(StringComparer.Ordinal) ?? new HashSet<string>(StringComparer.Ordinal);
			Dictionary<int, int> dictionary = new Dictionary<int, int>();
			for (int i = 0; i < save.Objects.Count; i++)
			{
				string saveId = save.Objects[i].SaveId;
				if (!string.IsNullOrWhiteSpace(saveId))
				{
					int num = oldSave.Objects.FindIndex((SavedObject obj) => obj.SaveId == saveId);
					if (num >= 0)
					{
						dictionary[num] = i;
					}
				}
			}
			Dictionary<string, Poolee> knownRuntimePoolees = GetKnownRuntimePoolees();
			Vector3 playerPos = save.PlayerPose.Position.ToUnity();
			int num2 = 0;
			List<int> list = new List<int>();
			for (int j = 0; j < oldSave.Objects.Count; j++)
			{
				SavedObject savedObject = oldSave.Objects[j];
				if (savedObject != null && !string.IsNullOrWhiteSpace(savedObject.SaveId) && !hashSet.Contains(savedObject.SaveId) && !hashSet2.Contains(savedObject.SaveId) && CanLoadSavedObject(savedObject) && !dontSaveThese.Contains(savedObject.Barcode) && ShouldPreserveMissingZoneObject(savedObject, playerPos, knownRuntimePoolees))
				{
					dictionary[j] = save.Objects.Count;
					save.Objects.Add(savedObject);
					list.Add(save.Objects.Count - 1);
					hashSet.Add(savedObject.SaveId);
					num2++;
				}
			}
			if (num2 <= 0)
			{
				return;
			}
			HashSet<string> hashSet3 = save.Constraints.Select(GetConstraintKey).ToHashSet<string>(StringComparer.Ordinal);
			int num3 = 0;
			foreach (ConstraintRecord constraint in oldSave.Constraints)
			{
				ConstraintRecord constraintRecord = RemapPreviousConstraint(constraint, dictionary);
				if (constraintRecord != null)
				{
					string constraintKey = GetConstraintKey(constraintRecord);
					if (hashSet3.Add(constraintKey))
					{
						save.Constraints.Add(constraintRecord);
						num3++;
					}
				}
			}
			((MelonBase)this).LoggerInstance.Msg($"Preserved {num2} far saved objects and {num3} constraints that may be hidden by level zones.");
		}

		private void KeepOldConstraints(SceneSaveFile save, SceneSaveFile oldSave)
		{
			if (save == null || oldSave == null || oldSave.LevelBarcode != save.LevelBarcode || oldSave.Constraints == null || oldSave.Constraints.Count == 0 || (save.Constraints != null && save.Constraints.Count > 0))
			{
				return;
			}
			List<ConstraintRecord> list = RemapOldConstraints(save, oldSave);
			if (list.Count != 0)
			{
				if (save.Constraints == null)
				{
					List<ConstraintRecord> list3 = (save.Constraints = new List<ConstraintRecord>());
				}
				save.Constraints.AddRange(list);
				((MelonBase)this).LoggerInstance.Msg($"Kept {list.Count} previous constraints because this capture returned none.");
			}
		}

		private static List<ConstraintRecord> RemapOldConstraints(SceneSaveFile save, SceneSaveFile oldSave)
		{
			List<ConstraintRecord> list = new List<ConstraintRecord>();
			if (save?.Objects == null || oldSave?.Objects == null || oldSave.Constraints == null)
			{
				return list;
			}
			EnsureSaveIds(save);
			EnsureSaveIds(oldSave);
			Dictionary<string, int> dictionary = (from pair in save.Objects.Select((SavedObject obj, int index) => (obj, index))
				where pair.obj != null && !string.IsNullOrWhiteSpace(pair.obj.SaveId)
				select pair).ToDictionary<(SavedObject, int), string, int>(((SavedObject obj, int index) pair) => pair.obj.SaveId, ((SavedObject obj, int index) pair) => pair.index, StringComparer.Ordinal);
			Dictionary<int, int> dictionary2 = new Dictionary<int, int>();
			for (int i = 0; i < oldSave.Objects.Count; i++)
			{
				string text = oldSave.Objects[i]?.SaveId;
				if (!string.IsNullOrWhiteSpace(text) && dictionary.TryGetValue(text, out var value))
				{
					dictionary2[i] = value;
				}
			}
			HashSet<string> hashSet = save.Constraints?.Select(GetConstraintKey).ToHashSet<string>(StringComparer.Ordinal) ?? new HashSet<string>(StringComparer.Ordinal);
			foreach (ConstraintRecord constraint in oldSave.Constraints)
			{
				ConstraintRecord constraintRecord = RemapPreviousConstraint(constraint, dictionary2);
				if (constraintRecord != null && (constraintRecord.FirstObjectIndex >= 0 || constraintRecord.SecondObjectIndex >= 0) && hashSet.Add(GetConstraintKey(constraintRecord)))
				{
					list.Add(constraintRecord);
				}
			}
			return list;
		}

		private static void DropBadConstraints(SceneSaveFile save)
		{
			if (save?.Constraints == null || save.Constraints.Count == 0)
			{
				return;
			}
			int count = save.Constraints.Count;
			save.Constraints = save.Constraints.Where((ConstraintRecord constraint) => ConstraintCanLoad(save, constraint)).ToList();
			int num = count - save.Constraints.Count;
			if (num > 0)
			{
				Core current = Current;
				if (current != null)
				{
					((MelonBase)current).LoggerInstance.Msg($"Dropped {num} constraints with missing saved endpoints.");
				}
			}
		}

		private static bool ConstraintCanLoad(SceneSaveFile save, ConstraintRecord constraint)
		{
			if (constraint == null)
			{
				return false;
			}
			if (constraint.FirstObjectIndex < 0 && constraint.SecondObjectIndex < 0)
			{
				return false;
			}
			if (!ConstraintEndpointCanLoad(save, constraint.FirstObjectIndex))
			{
				return ConstraintEndpointCanLoad(save, constraint.SecondObjectIndex);
			}
			return true;
		}

		private static bool ConstraintEndpointCanLoad(SceneSaveFile save, int objectIndex)
		{
			if (objectIndex < 0)
			{
				return true;
			}
			if (save?.Objects == null || objectIndex >= save.Objects.Count)
			{
				return false;
			}
			return CanLoadSavedObject(save.Objects[objectIndex]);
		}

		private static bool LooksLikeLiveConstraint(ConstraintTracker tracker)
		{
			if ((Object)(object)tracker == (Object)null || ((Il2CppObjectBase)tracker).WasCollected)
			{
				return false;
			}
			if (!tracker.isHost)
			{
				tracker = tracker.otherTracker;
			}
			if ((Object)(object)tracker == (Object)null || ((Il2CppObjectBase)tracker).WasCollected)
			{
				return false;
			}
			if ((Object)(object)tracker.attachPoint == (Object)null)
			{
				return false;
			}
			if ((Object)(object)tracker.otherTracker == (Object)null || ((Il2CppObjectBase)tracker.otherTracker).WasCollected)
			{
				return false;
			}
			return (Object)(object)tracker.otherTracker.attachPoint != (Object)null;
		}

		private Dictionary<string, Poolee> GetKnownRuntimePoolees()
		{
			Dictionary<string, Poolee> dictionary = new Dictionary<string, Poolee>(StringComparer.Ordinal);
			Poolee[] array = PooleesNow();
			foreach (Poolee val in array)
			{
				if (!((Object)(object)val == (Object)null) && _savedIds.TryGetValue(((Il2CppObjectBase)val).Pointer, out var value) && !string.IsNullOrWhiteSpace(value))
				{
					dictionary[value] = val;
				}
			}
			return dictionary;
		}

		private static bool ShouldPreserveMissingZoneObject(SavedObject obj, Vector3 playerPos, Dictionary<string, Poolee> runtimePool)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			if (obj == null || string.IsNullOrWhiteSpace(obj.SaveId))
			{
				return false;
			}
			if (runtimePool != null && runtimePool.TryGetValue(obj.SaveId, out var value) && ((Object)(object)value == (Object)null || ((Il2CppObjectBase)value).WasCollected || ((Component)value).gameObject.activeInHierarchy))
			{
				return false;
			}
			Vector3 val = obj.Position.ToUnity();
			return Vector3.Distance(playerPos, val) >= 12f;
		}

		private static ConstraintRecord RemapPreviousConstraint(ConstraintRecord constraint, Dictionary<int, int> oldToNow)
		{
			if (constraint == null)
			{
				return null;
			}
			int num = RemapConstraintIndex(constraint.FirstObjectIndex, oldToNow);
			int num2 = RemapConstraintIndex(constraint.SecondObjectIndex, oldToNow);
			if (num == int.MinValue || num2 == int.MinValue)
			{
				return null;
			}
			return new ConstraintRecord
			{
				Mode = constraint.Mode,
				FirstObjectIndex = num,
				FirstPath = constraint.FirstPath,
				FirstSiblingPath = constraint.FirstSiblingPath,
				SecondObjectIndex = num2,
				SecondPath = constraint.SecondPath,
				SecondSiblingPath = constraint.SecondSiblingPath,
				FirstPoint = constraint.FirstPoint,
				SecondPoint = constraint.SecondPoint,
				FirstNormal = constraint.FirstNormal,
				SecondNormal = constraint.SecondNormal,
				HasFirstTargetPose = constraint.HasFirstTargetPose,
				FirstTargetPosition = constraint.FirstTargetPosition,
				FirstTargetRotation = constraint.FirstTargetRotation,
				HasSecondTargetPose = constraint.HasSecondTargetPose,
				SecondTargetPosition = constraint.SecondTargetPosition,
				SecondTargetRotation = constraint.SecondTargetRotation
			};
		}

		private static int RemapConstraintIndex(int oldIndex, Dictionary<int, int> oldToNow)
		{
			if (oldIndex < 0)
			{
				return oldIndex;
			}
			if (!oldToNow.TryGetValue(oldIndex, out var value))
			{
				return int.MinValue;
			}
			return value;
		}

		private static string GetConstraintKey(ConstraintRecord constraint)
		{
			if (constraint == null)
			{
				return string.Empty;
			}
			return string.Join("|", constraint.Mode, constraint.FirstObjectIndex, constraint.FirstSiblingPath ?? constraint.FirstPath ?? string.Empty, constraint.SecondObjectIndex, constraint.SecondSiblingPath ?? constraint.SecondPath ?? string.Empty, RoundForKey(constraint.FirstPoint.X), RoundForKey(constraint.FirstPoint.Y), RoundForKey(constraint.FirstPoint.Z), RoundForKey(constraint.SecondPoint.X), RoundForKey(constraint.SecondPoint.Y), RoundForKey(constraint.SecondPoint.Z));
		}

		private static string RoundForKey(float value)
		{
			return MathF.Round(value, 3).ToString("0.###", CultureInfo.InvariantCulture);
		}

		private static void EnsureSaveIds(SceneSaveFile save)
		{
			if (save?.Objects == null)
			{
				return;
			}
			for (int i = 0; i < save.Objects.Count; i++)
			{
				SavedObject savedObject = save.Objects[i];
				if (savedObject != null && string.IsNullOrWhiteSpace(savedObject.SaveId))
				{
					savedObject.SaveId = StableId(string.Join("|", save.LevelBarcode ?? string.Empty, i, savedObject.Barcode ?? string.Empty, savedObject.Name ?? string.Empty, RoundForKey(savedObject.Position.X), RoundForKey(savedObject.Position.Y), RoundForKey(savedObject.Position.Z)));
				}
			}
		}

		private string GetCurrentLevelName(string levelBarcode)
		{
			if (!string.IsNullOrWhiteSpace(_levelTitle) && levelBarcode == _levelBarcode)
			{
				return _levelTitle;
			}
			return ShortName(levelBarcode);
		}

		private ConstraintRecord CaptureConstraint(ConstraintTracker tracker, List<Poolee> poolees, Dictionary<IntPtr, int> pooleeLookup, HashSet<IntPtr> savedConstraintTrackers)
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: 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_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)tracker == (Object)null)
			{
				return null;
			}
			if (!tracker.isHost)
			{
				tracker = tracker.otherTracker;
			}
			if ((Object)(object)tracker == (Object)null || ((Il2CppObjectBase)tracker).WasCollected || (Object)(object)tracker.attachPoint == (Object)null || (Object)(object)tracker.otherTracker == (Object)null || (Object)(object)tracker.otherTracker.attachPoint == (Object)null)
			{
				return null;
			}
			if (!savedConstraintTrackers.Add(((Il2CppObjectBase)tracker).Pointer))
			{
				return null;
			}
			Transform val = NormalizeConstraintTransform(tracker.attachPoint);
			Transform val2 = NormalizeConstraintTransform(tracker.otherTracker.attachPoint);
			Vector3 vector = tracker.attachPoint.position;
			Vector3 vector2 = tracker.otherTracker.attachPoint.position;
			Poolee pooleeUpwards = GetPooleeUpwards(tracker.attachPoint);
			Poolee pooleeUpwards2 = GetPooleeUpwards(tracker.otherTracker.attachPoint);
			if ((Object)(object)pooleeUpwards == (Object)null && (Object)(object)pooleeUpwards2 == (Object)null)
			{
				return null;
			}
			int value = -1;
			int value2 = -1;
			bool flag = (Object)(object)pooleeUpwards != (Object)null && pooleeLookup.TryGetValue(((Il2CppObjectBase)pooleeUpwards).Pointer, out value);
			bool flag2 = (Object)(object)pooleeUpwards2 != (Object)null && pooleeLookup.TryGetValue(((Il2CppObjectBase)pooleeUpwards2).Pointer, out value2);
			if (!flag && !flag2)
			{
				return null;
			}
			ConstraintMode modeWhenSpawned = JointBits.GetModeWhenSpawned(tracker, (ConstraintMode)1);
			Vector3 vector3 = Vector3.up;
			Vector3 vector4 = Vector3.up;
			if (JointBits.TryGetStateWhenSpawned(tracker, out var state))
			{
				vector = state.PointStart;
				vector2 = state.PointEnd;
				vector3 = state.NormalStart;
				vector4 = state.NormalEnd;
			}
			ConstraintRecord obj = new ConstraintRecord
			{
				Mode = ((object)(ConstraintMode)(ref modeWhenSpawned)).ToString(),
				FirstObjectIndex = (flag ? value : (-1)),
				FirstPath = (flag ? GetRelativePath(((Component)poolees[value]).transform, val) : null),
				FirstSiblingPath = (flag ? GetSiblingPath(((Component)poolees[value]).transform, val) : null),
				SecondObjectIndex = (flag2 ? value2 : (-1)),
				SecondPath = (flag2 ? GetRelativePath(((Component)poolees[value2]).transform, val2) : null),
				SecondSiblingPath = (flag2 ? GetSiblingPath(((Component)poolees[value2]).transform, val2) : null),
				FirstPoint = Vec3.From(vector),
				SecondPoint = Vec3.From(vector2),
				FirstNormal = Vec3.From(vector3),
				SecondNormal = Vec3.From(vector4),
				HasFirstTargetPose = true,
				FirstTargetPosition = Vec3.From(val.position)
			};
			Quaternion rotation = val.rotation;
			obj.FirstTargetRotation = Vec3.From(((Quaternion)(ref rotation)).eulerAngles);
			obj.HasSecondTargetPose = true;
			obj.SecondTargetPosition = Vec3.From(val2.position);
			rotation = val2.rotation;
			obj.SecondTargetRotation = Vec3.From(((Quaternion)(ref rotation)).eulerAngles);
			return obj;
		}

		private bool SaveCurrentLevel(string reason)
		{
			if (!_config.ModEnabled)
			{
				return true;
			}
			if (!FusionCompat.CanTouchScene)
			{
				((MelonBase)this).LoggerInstance.Msg("Fusion client detected, skipping save.");
				return true;
			}
			if (_savingNow)
			{
				return false;
			}
			if (_loadingNow)
			{
				return false;
			}
			if (!_inLevel)
			{
				return false;
			}
			if (string.IsNullOrWhiteSpace(_levelBarcode))
			{
				return false;
			}
			if (IsBlacklisted(_levelBarcode))
			{
				((MelonBase)this).LoggerInstance.Msg("Skipping save for blacklisted level: " + _levelBarcode);
				return true;
			}
			try
			{
				_savingNow = true;
				RememberLevel(_levelBarcode, _levelTitle);
				string savePath = GetSavePath(_levelBarcode);
				SceneSaveFile oldSave = ReadSaveMaybe(savePath);
				SceneSaveFile sceneSaveFile = PackScene(_levelBarcode, oldSave);
				KeepOtherZoneStuff(sceneSaveFile, oldSave);
				KeepOldConstraints(sceneSaveFile, oldSave);
				DropBadConstraints(sceneSaveFile);
				CleanSave(sceneSaveFile);
				DropBadConstraints(sceneSaveFile);
				WriteSaveOver(savePath, sceneSaveFile);
				((MelonBase)this).LoggerInstance.Msg($"Saved {sceneSaveFile.Objects.Count} spawnables, {sceneSaveFile.Constraints.Count} constraints ({reason}).");
				RefreshBoneMenu();
				return true;
			}
			catch (Exception value)
			{
				((MelonBase)this).LoggerInstance.Error($"Save failed: {value}");
				return false;
			}
			finally
			{
				_savingNow = false;
			}
		}

		private void SaveOnTheWayOut(string reason)
		{
			if (!_quitSaved)
			{
				if (SaveCurrentLevel(reason))
				{
					_quitSaved = true;
				}
				if (!_inLevel || string.IsNullOrWhiteSpace(_levelBarcode) || IsBlacklisted(_levelBarcode))
				{
					_quitSaved = true;
				}
			}
		}

		private void Dirty()
		{
			DropFindCache();
		}

		internal void SceneGotTouched()
		{
			Dirty();
		}

		private void DropFindCache()
		{
			_poolCache = null;
			_poolCacheAt = -999f;
			_spawnerCache = null;
			_spawnerCacheAt = -999f;
		}

		private Poolee[] PooleesNow()
		{
			if (_poolCache != null && Time.realtimeSinceStartup - _poolCacheAt < 0.5f)
			{
				return _poolCache;
			}
			_poolCache = Il2CppArrayBase<Poolee>.op_Implicit(Object.FindObjectsOfType<Poolee>(true));
			_poolCacheAt = Time.realtimeSinceStartup;
			return _poolCache;
		}

		private CrateSpawner[] SpawnersNow()
		{
			if (_spawnerCache != null && Time.realtimeSinceStartup - _spawnerCacheAt < 0.5f)
			{
				return _spawnerCache;
			}
			_spawnerCache = Il2CppArrayBase<CrateSpawner>.op_Implicit(Object.FindObjectsOfType<CrateSpawner>(true));
			_spawnerCacheAt = Time.realtimeSinceStartup;
			return _spawnerCache;
		}

		private static SceneSaveFile ReadSaveMaybe(string path)
		{
			if (string.IsNullOrWhiteSpace(path) || !Directory.Exists(path))
			{
				return null;
			}
			try
			{
				SceneSaveFile sceneSaveFile = ReadSplitSave(path);
				EnsureSaveIds(sceneSaveFile);
				return sceneSaveFile;
			}
			catch
			{
				return null;
			}
		}

		private static void WriteSaveOver(string path, SceneSaveFile save)
		{
			WriteSplitSave(path, save);
		}

		private static SceneSaveFile ReadSplitSave(string folder)
		{
			string path = Path.Combine(folder, "manifest.json");
			if (!File.Exists(path))
			{
				return null;
			}
			SceneSaveManifest sceneSaveManifest = JsonSerializer.Deserialize<SceneSaveManifest>(File.ReadAllText(path, Encoding.UTF8), jsonOpts);
			if (sceneSaveManifest == null)
			{
				return null;
			}
			SceneSaveFile obj = new SceneSaveFile
			{
				InitialSaveVersion = sceneSaveManifest.InitialSaveVersion,
				SupportedVersion = sceneSaveManifest.SupportedVersion,
				LevelBarcode = sceneSaveManifest.LevelBarcode,
				LevelName = sceneSaveManifest.LevelName,
				SavedAtUtc = sceneSaveManifest.SavedAtUtc,
				PlayerPose = sceneSaveManifest.PlayerPose,
				PlayerAmmo = sceneSaveManifest.PlayerAmmo,
				PlayerInventory = sceneSaveManifest.PlayerInventory,
				Objects = (ReadSplitPart<List<SavedObject>>(folder, "spawnables.json") ?? new List<SavedObject>()),
				Constraints = (ReadSplitPart<List<ConstraintRecord>>(folder, "constraints.json") ?? new List<ConstraintRecord>()),
				SceneLogic = (ReadSplitPart<List<SceneLogicRecord>>(folder, "scene_logic.json") ?? new List<SceneLogicRecord>()),
				DeletedSaveIds = (ReadSplitPart<List<string>>(folder, "deleted.json") ?? new List<string>())
			};
			FixVersions(obj);
			return obj;
		}

		private static T ReadSplitPart<T>(string folder, string file)
		{
			string path = Path.Combine(folder, file);
			if (!File.Exists(path))
			{
				return default(T);
			}
			return JsonSerializer.Deserialize<T>(File.ReadAllText(path, Encoding.UTF8), jsonOpts);
		}

		private static void WriteSplitSave(string folder, SceneSaveFile save)
		{
			FixVersions(save);
			string text = folder + ".tmp";
			if (Directory.Exists(text))
			{
				Directory.Delete(text, recursive: true);
			}
			if (Directory.Exists(folder))
			{
				Directory.Delete(folder, recursive: true);
			}
			Directory.CreateDirectory(text);
			SceneSaveManifest data = new SceneSaveManifest
			{
				InitialSaveVersion = save.InitialSaveVersion,
				SupportedVersion = save.SupportedVersion,
				LevelBarcode = save.LevelBarcode,
				LevelName = save.LevelName,
				SavedAtUtc = save.SavedAtUtc,
				PlayerPose = save.PlayerPose,
				PlayerAmmo = save.PlayerAmmo,
				PlayerInventory = save.PlayerInventory
			};
			WriteSplitPart(text, "manifest.json", data);
			WriteSplitPart(text, "spawnables.json", save.Objects ?? new List<SavedObject>());
			WriteSplitPart(text, "constraints.json", save.Constraints ?? new List<ConstraintRecord>());
			WriteSplitPart(text, "scene_logic.json", save.SceneLogic ?? new List<SceneLogicRecord>());
			WriteSplitPart(text, "deleted.json", save.DeletedSaveIds ?? new List<string>());
			Directory.Move(text, folder);
		}

		private static void WriteSplitPart(string folder, string file, object data)
		{
			File.WriteAllText(Path.Combine(folder, file), JsonSerializer.Serialize(data, jsonOpts), Encoding.UTF8);
		}

		private static void FixVersions(SceneSaveFile save)
		{
			if (save != null)
			{
				if (string.IsNullOrWhiteSpace(save.InitialSaveVersion))
				{
					save.InitialSaveVersion = "1.0.0";
				}
				if (string.IsNullOrWhiteSpace(save.SupportedVersion))
				{
					save.SupportedVersion = save.InitialSaveVersion;
				}
			}
		}

		private SceneSaveFile PackScene(string levelBarcode, SceneSaveFile oldSave = null)
		{
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			DropFindCache();
			Poolee[] source = PooleesNow();
			CrateSpawner[] spawners = SpawnersNow();
			PlayerPoseRecord playerPoseRecord = CapturePlayerPose();
			PlayerAmmoRecord playerAmmo = CapturePlayerAmmo();
			PlayerInventoryRecord playerInventoryRecord = CapturePlayerInventory();
			if (playerInventoryRecord?.Items != null && playerInventoryRecord.Items.Count > 0)
			{
				((MelonBase)this).LoggerInstance.Msg($"Saved {playerInventoryRecord.Items.Count} inventory slot items.");
			}
			else if (oldSave?.PlayerInventory?.Items != null && oldSave.PlayerInventory.Items.Count > 0)
			{
				((MelonBase)this).LoggerInstance.Msg($"Keeping {oldSave.PlayerInventory.Items.Count} previous inventory slot items.");
			}
			Vector3 playerPos = playerPoseRecord?.Position.ToUnity() ?? Vector3.zero;
			HashSet<string> deleted = GetDeletedIds(oldSave);
			List<Poolee> list = source.Where((Poolee p) => CanSavePoolee(p, playerPos, levelBarcode, spawners, deleted)).OrderBy<Poolee, string>((Poolee p) => ((Scannable)p.SpawnableCrate).Barcode.ID, StringComparer.Ordinal).ThenBy((Poolee p) => ((Component)p).transform.position.x)
				.ThenBy((Poolee p) => ((Component)p).transform.position.y)
				.ThenBy((Poolee p) => ((Component)p).transform.position.z)
				.ToList();
			HashSet<IntPtr> knownBefore = (from p in list
				where _savedIds.ContainsKey(((Il2CppObjectBase)p).Pointer)
				select ((Il2CppObjectBase)p).Pointer).ToHashSet();
			Dictionary<IntPtr, int> pooleeLookup = list.Select((Poolee p, int i) => (p, i)).ToDictionary<(Poolee, int), IntPtr, int>(((Poolee p, int i) x) => ((Il2CppObjectBase)x.p).Pointer, ((Poolee p, int i) x) => x.i);
			SceneSaveFile sceneSaveFile = new SceneSaveFile
			{
				InitialSaveVersion = (oldSave?.InitialSaveVersion ?? "1.0.0"),
				SupportedVersion = "1.0.0",
				LevelBarcode = levelBarcode,
				LevelName = GetCurrentLevelName(levelBarcode),
				SavedAtUtc = DateTime.UtcNow,
				PlayerPose = ((levelBarcode == "fa534c5a868247138f50c62e424c4144.Level.VoidG114") ? null : playerPoseRecord),
				PlayerAmmo = playerAmmo,
				PlayerInventory = (playerInventoryRecord ?? oldSave?.PlayerInventory)
			};
			foreach (Poolee item in list)
			{
				sceneSaveFile.Objects.Add(CapturePoolee(item));
			}
			StampSceneSpawnerIds(sceneSaveFile, list, spawners, knownBefore);
			GrabMissingZoneSpawners(sceneSaveFile, spawners, oldSave);
			HashSet<IntPtr> savedConstraintTrackers = new HashSet<IntPtr>();
			ConstraintTracker[] array = Il2CppArrayBase<ConstraintTracker>.op_Implicit(Object.FindObjectsOfType<ConstraintTracker>(true));
			foreach (ConstraintTracker tracker in array)
			{
				ConstraintRecord constraintRecord = CaptureConstraint(tracker, list, pooleeLookup, savedConstraintTrackers);
				if (constraintRecord != null)
				{
					sceneSaveFile.Constraints.Add(constraintRecord);
				}
			}
			ApplyDeletedIds(sceneSaveFile, oldSave);
			CaptureSceneLogicStates(sceneSaveFile);
			CleanSave(sceneSaveFile);
			return sceneSaveFile;
		}

		internal void RememberSpawnerPoolee(CrateSpawner spawner, GameObject made)
		{
			if (!_inLevel || string.IsNullOrWhiteSpace(_levelBarcode) || (Object)(object)spawner == (Object)null || (Object)(object)made == (Object)null || !TryGetCrateSpawnerBarcode(spawner, out var barcode) || dontSaveThese.Contains(barcode) || IsSystemBarcodeOrName(barcode, ((Object)spawner).name) || IsSpentCasing(barcode, ((Object)spawner).name))
			{
				return;
			}
			Poolee val = Poolee.Cache.Get(made);
			if (val == null)
			{
				val = made.GetComponent<Poolee>();
			}
			if (!((Object)(object)val == (Object)null))
			{
				SpawnableCrate spawnableCrate = val.SpawnableCrate;
				if (!(((spawnableCrate != null) ? ((Scannable)spawnableCrate).Barcode : null) == (Barcode)null) && string.Equals(((Scannable)val.SpawnableCrate).Barcode.ID, barcode, StringComparison.Ordinal))
				{
					string sceneCrateSpawnerSaveId = GetSceneCrateSpawnerSaveId(_levelBarcode, spawner, barcode);
					_savedIds[((Il2CppObjectBase)val).Pointer] = sceneCrateSpawnerSaveId;
					_loadedIds[sceneCrateSpawnerSaveId] = val;
					_deadPtrs.Remove(((Il2CppObjectBase)val).Pointer);
					_deletedIds.Remove(sceneCrateSpawnerSaveId);
					Dirty();
				}
			}
		}

		internal void PooleeWokeUp(Poolee poolee)
		{
			if (!((Object)(object)poolee == (Object)null))
			{
				_deadPtrs.Remove(((Il2CppObjectBase)poolee).Pointer);
				if (_savedIds.TryGetValue(((Il2CppObjectBase)poolee).Pointer, out var value) && _deletedIds.Contains(value))
				{
					_savedIds.Remove(((Il2CppObjectBase)poolee).Pointer);
					_loadedIds.Remove(value);
					Dirty();
				}
			}
		}

		internal void PooleeWentAway(Poolee poolee)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			if (_loadingNow || !_inLevel || string.IsNullOrWhiteSpace(_levelBarcode) || IsBlacklisted(_levelBarcode) || (Object)(object)poolee == (Object)null)
			{
				return;
			}
			SpawnableCrate spawnableCrate = poolee.SpawnableCrate;
			if (((spawnableCrate != null) ? ((Scannable)spawnableCrate).Barcode : null) == (Barcode)null || IsMenuOrPlayerRigPoolee(poolee))
			{
				return;
			}
			PlayerPoseRecord playerPoseRecord = CapturePlayerPose();
			if (playerPoseRecord != null && Vector3.Distance(playerPoseRecord.Position.ToUnity(), ((Component)poolee).transform.position) >= 12f)
			{
				return;
			}
			_deadPtrs.Add(((Il2CppObjectBase)poolee).Pointer);
			string text = null;
			if (_savedIds.TryGetValue(((Il2CppObjectBase)poolee).Pointer, out var value) && !string.IsNullOrWhiteSpace(value))
			{
				text = value;
			}
			else
			{
				string iD = ((Scannable)poolee.SpawnableCrate).Barcode.ID;
				CrateSpawner val = FindMatchingSceneCrateSpawner(_levelBarcode, SpawnersNow(), iD, ((Component)poolee).transform.position, null, 25f);
				if ((Object)(object)val != (Object)null)
				{
					text = GetSceneCrateSpawnerSaveId(_levelBarcode, val, iD);
				}
			}
			if (!string.IsNullOrWhiteSpace(text))
			{
				_deletedIds.Add(text);
				_loadedIds.Remove(text);
				Dirty();
			}
		}

		private void StampSceneSpawnerIds(SceneSaveFile file, List<Poolee> pool, CrateSpawner[] spawners, HashSet<IntPtr> knownBefore)
		{
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			if (file == null || pool == null || spawners == null)
			{
				return;
			}
			HashSet<string> hashSet = (from obj in file.Objects
				where !string.IsNullOrWhiteSpace(obj.SaveId) && obj.FromSceneCrateSpawner
				select obj.SaveId).ToHashSet<string>(StringComparer.Ordinal);
			for (int i = 0; i < pool.Count && i < file.Objects.Count; i++)
			{
				Poolee val = pool[i];
				SavedObject savedObject = file.Objects[i];
				if (!((Object)(object)val == (Object)null) && savedObject != null && (knownBefore == null || !knownBefore.Contains(((Il2CppObjectBase)val).Pointer)))
				{
					CrateSpawner val2 = FindMatchingSceneCrateSpawner(file.LevelBarcode, spawners, savedObject.Barcode, ((Component)val).transform.position, hashSet);
					if (!((Object)(object)val2 == (Object)null))
					{
						string text2 = (savedObject.SceneSpawnerId = (savedObject.SaveId = GetSceneCrateSpawnerSaveId(file.LevelBarcode, val2, savedObject.Barcode)));
						savedObject.FromSceneCrateSpawner = true;
						_savedIds[((Il2CppObjectBase)val).Pointer] = text2;
						hashSet.Add(text2);
					}
				}
			}
		}

		private static CrateSpawner FindMatchingSceneCrateSpawner(string levelBarcode, CrateSpawner[] spawners, string barcode, Vector3 objPos, HashSet<string> claimed, float maxDist = 4f)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			if (spawners == null || string.IsNullOrWhiteSpace(barcode))
			{
				return null;
			}
			CrateSpawner result = null;
			float num = maxDist;
			foreach (CrateSpawner val in spawners)
			{
				if (!TryGetCrateSpawnerBarcode(val, out var barcode2) || !string.Equals(barcode2, barcode, StringComparison.Ordinal))
				{
					continue;
				}
				string sceneCrateSpawnerSaveId = GetSceneCrateSpawnerSaveId(levelBarcode, val, barcode);
				if (claimed == null || !claimed.Contains(sceneCrateSpawnerSaveId))
				{
					float num2 = Vector3.Distance(objPos, ((Component)val).transform.position);
					if (!(num2 > num))
					{
						result = val;
						num = num2;
					}
				}
			}
			return result;
		}

		private void GrabMissingZoneSpawners(SceneSaveFile file, CrateSpawner[] spawners, SceneSaveFile oldSave)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			if (file == null || spawners == null || spawners.Length == 0)
			{
				return;
			}
			Vector3 playerPos = file.PlayerPose?.Position.ToUnity() ?? Vector3.zero;
			Dictionary<string, SavedObject> dictionary = BuildPreviousObjectLookup(oldSave, file.LevelBarcode);
			Dictionary<string, Poolee> runtimePool = ((dictionary.Count > 0) ? GetKnownRuntimePoolees() : new Dictionary<string, Poolee>(StringComparer.Ordinal));
			HashSet<string> deletedIds = GetDeletedIds(oldSave);
			HashSet<string> hashSet = (from obj in file.Objects
				where !string.IsNullOrWhiteSpace(obj.SaveId)
				select obj.SaveId).ToHashSet<string>(StringComparer.Ordinal);
			int num = 0;
			int num2 = 0;
			foreach (CrateSpawner spawner in spawners)
			{
				if (!TryGetCrateSpawnerBarcode(spawner, out var barcode) || !ShouldCaptureMissingZoneCrateSpawner(spawner, barcode, playerPos))
				{
					continue;
				}
				string sceneCrateSpawnerSaveId = GetSceneCrateSpawnerSaveId(file.LevelBarcode, spawner, barcode);
				if (hashSet.Contains(sceneCrateSpawnerSaveId) || deletedIds.Contains(sceneCrateSpawnerSaveId))
				{
					continue;
				}
				if (dictionary.TryGetValue(sceneCrateSpawnerSaveId, out var value))
				{
					if (CanLoadSavedObject(value) && ShouldPreserveMissingZoneObject(value, playerPos, runtimePool))
					{
						num2++;
					}
					continue;
				}
				SavedObject savedObject = CaptureCrateSpawnerFallback(file.LevelBarcode, spawner, barcode, sceneCrateSpawnerSaveId);
				if (CanLoadSavedObject(savedObject))
				{
					file.Objects.Add(savedObject);
					hashSet.Add(sceneCrateSpawnerSaveId);
					num++;
				}
			}
			if (num > 0 || num2 > 0)
			{
				((MelonBase)this).LoggerInstance.Msg($"Captured {num} unloaded zone spawners; {num2} previous zone objects will be preserved from the old save.");
			}
		}

		private PlayerPoseRecord CapturePlayerPose()
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			RigManager val = TryGetRigManager();
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			PhysicsRig physicsRig = val.physicsRig;
			Transform val2 = (((Object)(object)((physicsRig != null) ? ((Rig)physicsRig).centerOfPressure : null) != (Object)null) ? ((Rig)val.physicsRig).centerOfPressure : (((Object)(object)val.remapHeptaRig != (Object)null) ? ((Component)val.remapHeptaRig).transform : ((Component)val).transform));
			Vector3 forward = val2.forward;
			if (((Vector3)(ref forward)).sqrMagnitude < 0.001f)
			{
				forward = ((Component)val).transform.forward;
			}
			PlayerPoseRecord obj = new PlayerPoseRecord
			{
				Position = Vec3.From(val2.position),
				Forward = Vec3.From(forward),
				HasRotation = true
			};
			Quaternion val3 = Quaternion.LookRotation(forward, Vector3.up);
			obj.Rotation = Vec3.From(((Quaternion)(ref val3)).eulerAngles);
			return obj;
		}

		private static PlayerAmmoRecord CapturePlayerAmmo()
		{
			AmmoInventory instance = AmmoInventory.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return null;
			}
			try
			{
				return new PlayerAmmoRecord
				{
					LightAmmo = instance.GetCartridgeCount("light"),
					MediumAmmo = instance.GetCartridgeCount("medium"),
					HeavyAmmo = instance.GetCartridgeCount("heavy")
				};
			}
			catch
			{
				return null;
			}
		}

		private static PlayerInventoryRecord CapturePlayerInventory()
		{
			RigManager val = TryGetRigManager();
			object obj;
			if (val == null)
			{
				obj = null;
			}
			else
			{
				Inventory inventory = val.inventory;
				obj = ((inventory != null) ? inventory.bodySlots : null);
			}
			if (obj == null)
			{
				return null;
			}
			PlayerInventoryRecord playerInventoryRecord = new PlayerInventoryRecord();
			foreach (SlotContainer item in (Il2CppArrayBase<SlotContainer>)(object)val.inventory.bodySlots)
			{
				try
				{
					if (!((Object)(object)item == (Object)null) && !((Object)(object)item.inventorySlotReceiver == (Object)null))
					{
						Poolee pooleeInSlot = GetPooleeInSlot(item);
						string slotBarcode = GetSlotBarcode(item, pooleeInSlot);
						if (!string.IsNullOrWhiteSpace(slotBarcode) && !dontSaveThese.Contains(slotBarcode))
						{
							playerInventoryRecord.Items.Add(new PlayerInventoryItemRecord
							{
								SlotName = ((Object)((Component)item).gameObject).name,
								Barcode = slotBarcode
							});
						}
					}
				}
				catch
				{
				}
			}
			return playerInventoryRecord;
		}

		private static string GetSlotBarcode(SlotContainer slot, Poolee poolee)
		{
			object obj;
			if (poolee == null)
			{
				obj = null;
			}
			else
			{
				SpawnableCrate spawnableCrate = poolee.SpawnableCrate;
				obj = ((spawnableCrate != null) ? ((Scannable)spawnableCrate).Barcode : null);
			}
			if ((Barcode)obj != (Barcode)null)
			{
				return ((Scannable)poolee.SpawnableCrate).Barcode.ID;
			}
			try
			{
				InventorySlotReceiver obj2 = ((slot != null) ? slot.inventorySlotReceiver : null);
				object obj3;
				if (obj2 == null)
				{
					obj3 = null;
				}
				else
				{
					WeaponSlot slottedWeapon = obj2._slottedWeapon;
					obj3 = ((slottedWeapon != null) ? slottedWeapon.interactableHost : null);
				}
				InteractableHost val = (InteractableHost)obj3;
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
				string text = null;
				if ((Object)(object)val.manager != (Object)null)
				{
					text = GetAssetPooleeBarcode(((Component)val.manager).transform);
				}
				if (text == null)
				{
					text = GetAssetPooleeBarcode(((Component)val).transform);
				}
				if (text == null)
				{
					text = GetAssetPooleeBarcodeUp(((Component)val).transform);
				}
				if (text == null)
				{
					text = GetAssetPooleeBarcodeDown(((Component)val).transform);
				}
				return text;
			}
			catch
			{
				return null;
			}
		}

		private static string GetAssetPooleeBarcode(Transform transform)
		{
			if ((Object)(object)transform == (Object)null)
			{
				return null;
			}
			foreach (Component component in ((Component)transform).GetComponents<Component>())
			{
				string compName = GetCompName(component);
				if (compName != null && compName.Contains("AssetPoolee", StringComparison.OrdinalIgnoreCase))
				{
					string text = ReadSpawnableCrateBarcode(component);
					if (!string.IsNullOrWhiteSpace(text))
					{
						return text;
					}
				}
			}
			return null;
		}

		private static string GetAssetPooleeBarcodeUp(Transform transform)
		{
			while ((Object)(object)transform != (Object)null)
			{
				string assetPooleeBarcode = GetAssetPooleeBarcode(transform);
				if (!string.IsNullOrWhiteSpace(assetPooleeBarcode))
				{
					return assetPooleeBarcode;
				}
				transform = transform.parent;
			}
			return null;
		}

		private static string GetAssetPooleeBarcodeDown(Transform transform)
		{
			if ((Object)(object)transform == (Object)null)
			{
				return null;
			}
			string assetPooleeBarcode = GetAssetPooleeBarcode(transform);
			if (!string.IsNullOrWhiteSpace(assetPooleeBarcode))
			{
				return assetPooleeBarcode;
			}
			for (int i = 0; i < transform.childCount; i++)
			{
				assetPooleeBarcode = GetAssetPooleeBarcodeDown(transform.GetChild(i));
				if (!string.IsNullOrWhiteSpace(assetPooleeBarcode))
				{
					return assetPooleeBarcode;
				}
			}
			return null;
		}

		private static string ReadSpawnableCrateBarcode(object assetPoolee)
		{
			object target = TryReadMember(assetPoolee, "spawnableCrate") ?? TryReadMember(assetPoolee, "SpawnableCrate");
			object target2 = TryReadMember(target, "Barcode") ?? TryReadMember(target, "_barcode");
			return (TryReadMember(target2, "ID") ?? TryReadMember(target2, "Id") ?? TryReadMember(target2, "id")) as string;
		}

		private static Poolee GetPooleeInSlot(SlotContainer slot)
		{
			try
			{
				InventorySlotReceiver val = ((slot != null) ? slot.inventorySlotReceiver : null);
				if ((Object)(object)val == (Object)null || (Object)(object)val._slottedWeapon == (Object)null)
				{
					return null;
				}
				InteractableHost interactableHost = val._slottedWeapon.interactableHost;
				object obj = TryReadMember(TryReadMember(interactableHost, "marrowEntity"), "_poolee");
				Poolee val2 = (Poolee)((obj is Poolee) ? obj : null);
				if ((Object)(object)val2 != (Object)null)
				{
					return val2;
				}
				GameObject val3 = (((Object)(object)interactableHost == (Object)null) ? null : ((Component)interactableHost).gameObject);
				val2 = (((Object)(object)val3 == (Object)null) ? null : val3.GetComponentInParent<Poolee>());
				if ((Object)(object)val2 != (Object)null)
				{
					return val2;
				}
				val2 = (((Object)(object)val3 == (Object)null) ? null : val3.GetComponentInChildren<Poolee>(true));
				if ((Object)(object)val2 != (Object)null)
				{
					return val2;
				}
				if ((Object)(object)((interactableHost != null) ? interactableHost.manager : null) != (Object)null)
				{
					val2 = ((Component)((Component)interactableHost.manager).transform).GetComponentInParent<Poolee>();
					if ((Object)(object)val2 != (Object)null)
					{
						return val2;
					}
					val2 = ((Component)((Component)interactableHost.manager).transform).GetComponentInChildren<Poolee>(true);
				}
				return val2;
			}
			catch
			{
				return null;
			}
		}

		[IteratorStateMachine(typeof(<MovePlayerWhenReady>d__254))]
		private IEnumerator MovePlayerWhenReady(PlayerPoseRecord pose, bool rotatePlayer = true)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <MovePlayerWhenReady>d__254(0)
			{
				pose = pose,
				rotatePlayer = rotatePlayer
			};
		}

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

		[IteratorStateMachine(typeof(<PutPlayerBackAfterLoad>d__256))]
		private IEnumerator PutPlayerBackAfterLoad(PlayerPoseRecord pose)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PutPlayerBackAfterLoad>d__256(0)
			{
				pose = pose
			};
		}

		private static RigManager TryGetRigManager()
		{
			if ((Object)(object)Player.RigManager != (Object)null)
			{
				return Player.RigManager;
			}
			return Object.FindObjectOfType<RigManager>();
		}

		private static void TeleportPlayerToPose(RigManager rigManager, PlayerPoseRecord pose, float lift = 0f, bool rotatePlayer = true)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rigManager == (Object)null || pose == null)
			{
				return;
			}
			Vector3 val = pose.Position.ToUnity();
			val.y += lift;
			if (rotatePlayer)
			{
				Vector3 val2 = pose.Forward.ToUnity();
				val2.y = 0f;
				if (((Vector3)(ref val2)).sqrMagnitude > 0.001f)
				{
					((Vector3)(ref val2)).Normalize();
					rigManager.Teleport(val, val2, true);
				}
				else
				{
					rigManager.Teleport(val, true);
				}
			}
			else
			{
				rigManager.Teleport(val, true);
			}
			PhysicsRig physicsRig = rigManager.physicsRig;
			if (physicsRig != null)
			{
				physicsRig.ResetHands((Handedness)3);
			}
		}

		private static void HoldPlayerThere(RigManager rigManager, PlayerPoseRecord pose, float lift = 0f)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)rigManager == (Object)null) && pose != null)
			{
				Vector3 val = pose.Position.ToUnity();
				val.y += lift;
				rigManager.Teleport(val, true);
				KillPlayerSpeed(rigManager);
			}
		}

		private static void KillPlayerSpeed(RigManager rigManager)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			object obj;
			if (rigManager == null)
			{
				obj = null;
			}
			else
			{
				PhysicsRig physicsRig = rigManager.physicsRig;
				obj = ((physicsRig != null) ? physicsRig.selfRbs : null);
			}
			if (obj == null)
			{
				return;
			}
			Enumerator<Rigidbody> enumerator = rigManager.physicsRig.selfRbs.GetEnumerator();
			while (enumerator.MoveNext())
			{
				Rigidbody current = enumerator.Current;
				if (!((Object)(object)current == (Object)null))
				{
					current.velocity = Vector3.zero;
					current.angularVelocity = Vector3.zero;
				}
			}
		}

		private bool CanSavePoolee(Poolee poolee, Vector3 playerPos, string levelBarcode, CrateSpawner[] spawners, HashSet<string> DeletedSaveIds)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: 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)
			if ((Object)(object)poolee == (Object)null)
			{
				return false;
			}
			if ((Object)(object)poolee.SpawnableCrate == (Object)null)
			{
				return false;
			}
			if (((Scannable)poolee.SpawnableCrate).Barcode == (Barcode)null)
			{
				return false;
			}
			Scene scene = ((Component)poolee).gameObject.scene;
			if (((Scene)(ref scene)).name == "DontDestroyOnLoad")
			{
				return false;
			}
			if (((Il2CppObjectBase)poolee).WasCollected)
			{
				return false;
			}
			if (IsDeletedPoolee(poolee, levelBarcode, spawners, DeletedSaveIds))
			{
				return false;
			}
			if (!((Component)poolee).gameObject.activeInHierarchy && Vector3.Distance(playerPos, ((Component)poolee).transform.position) < 12f)
			{
				return false;
			}
			string iD = ((Scannable)poolee.SpawnableCrate).Barcode.ID;
			if (string.IsNullOrWhiteSpace(iD))
			{
				return false;
			}
			if (dontSaveThese.Contains(iD))
			{
				return false;
			}
			if (IsMenuOrPlayerRigPoolee(poolee))
			{
				return false;
			}
			if (IsSystemBarcodeOrName(iD, ((Object)poolee).name))
			{
				return false;
			}
			if (IsSpentCasing(poolee, iD))
			{
				return false;
			}
			if (IsLooseEmptyMagazine(poolee))
			{
				return false;
			}
			if ((Object)(object)((Component)poolee).GetComponentInParent<RigManager>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)poolee).GetComponentInParent<UIRig>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)poolee).GetComponentInParent<Canvas>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)poolee).GetComponentInParent<GUIMenu>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)poolee).GetComponentInParent<GUIPoolee>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)poolee).GetComponentInChildren<Constrainer>(true) != (Object)null)
			{
				float num = 250000f;
				Vector3 position = ((Component)poolee).transform.position;
				if (((Vector3)(ref position)).sqrMagnitude > num)
				{
					return false;
				}
			}
			if (IsProbablyMenuOrSystemObject(((Component)poolee).transform))
			{
				return false;
			}
			if (IsProbablyMenuOrSystemObject(((Component)poolee).transform.root))
			{
				return false;
			}
			return true;
		}

		private bool IsDeletedPoolee(Poolee poolee, string levelBarcode, CrateSpawner[] spawners, HashSet<string> DeletedSaveIds)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)poolee == (Object)null)
			{
				return false;
			}
			if (_deadPtrs.Contains(((Il2CppObjectBase)poolee).Pointer))
			{
				return true;
			}
			if (DeletedSaveIds == null || DeletedSaveIds.Count == 0)
			{
				return false;
			}
			if (_savedIds.TryGetValue(((Il2CppObjectBase)poolee).Pointer, out var value) && DeletedSaveIds.Contains(value))
			{
				return true;
			}
			SpawnableCrate spawnableCrate = poolee.SpawnableCrate;
			if (((spawnableCrate != null) ? ((Scannable)spawnableCrate).Barcode : null) == (Barcode)null)
			{
				return false;
			}
			string iD = ((Scannable)poolee.SpawnableCrate).Barcode.ID;
			CrateSpawner val = FindMatchingSceneCrateSpawner(levelBarcode, spawners, iD, ((Component)poolee).transform.position, null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			string sceneCrateSpawnerSaveId = GetSceneCrateSpawnerSaveId(levelBarcode, val, iD);
			return DeletedSaveIds.Contains(sceneCrateSpawnerSaveId);
		}

		private bool CanClearPoolee(Poolee poolee)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)poolee == (Object)null || (Object)(object)poolee.SpawnableCrate == (Object)null || ((Scannable)poolee.SpawnableCrate).Barcode == (Barcode)null)
			{
				return false;
			}
			if (!((Il2CppObjectBase)poolee).WasCollected)
			{
				Scene scene = ((Component)poolee).gameObject.scene;
				if (!(((Scene)(ref scene)).name == "DontDestroyOnLoad"))
				{
					string iD = ((Scannable)poolee.SpawnableCrate).Barcode.ID;
					if (string.IsNullOrWhiteSpace(iD))
					{
						return false;
					}
					if (dontSaveThese.Contains(iD))
					{
						return false;
					}
					if (IsMenuOrPlayerRigPoolee(poolee))
					{
						return false;
					}
					if (IsSystemBarcodeOrName(iD, ((Object)poolee).name))
					{
						return false;
					}
					if ((Object)(object)((Component)poolee).GetComponentInParent<RigManager>() != (Object)null)
					{
						return false;
					}
					if ((Object)(object)((Component)poolee).GetComponentInParent<UIRig>() != (Object)null)
					{
						return false;
					}
					if ((Object)(object)((Component)poolee).GetComponentInParent<Canvas>() != (Object)null)
					{
						return false;
					}
					if ((Object)(object)((Component)poolee).GetComponentInParent<GUIMenu>() != (Object)null)
					{
						return false;
					}
					if ((Object)(object)((Component)poolee).GetComponentInParent<GUIPoolee>() != (Object)null)
					{
						return false;
					}
					if ((Object)(object)((Component)poolee).GetComponentInChildren<Constrainer>(true) != (Object)null)
					{
						Vector3 position = ((Component)poolee).transform.position;
						if (((Vector3)(ref position)).sqrMagnitude > 250000f)
						{
							return false;
						}
					}
					if (IsProbablyMenuOrSystemObject(((Component)poolee).transform))
					{
						return false;
					}
					if (IsProbablyMenuOrSystemObject(((Component)poolee).transform.root))
					{
						return false;
					}
					return true;
				}
			}
			return false;
		}

		private static bool IsMenuOrPlayerRigPoolee(Poolee poolee)
		{
			if ((Object)(object)poolee == (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)poolee).GetComponentInChildren<RigManager>(true) != (Object)null)
			{
				return true;
			}
			if ((Object)(object)((Component)poolee).GetComponentInChildren<UIRig>(true) != (Object)null)
			{
				return true;
			}
			if ((Object)(object)((Component)poolee).GetComponentInChildren<GUIMenu>(true) != (Object)null)
			{
				return true;
			}
			if ((Object)(object)((Component)poolee).GetComponentInChildren<GUIPoolee>(true) != (Object)null)
			{
				return true;
			}
			Transform val = ((Component)poolee).transform;
			while ((Object)(object)val != (Object)null)
			{
				if (IsProbablyMenuOrSystemObject(val))
				{
					return true;
				}
				val = val.parent;
			}
			return false;
		}

		private static bool CanLoadSavedObject(SavedObject obj)
		{
			if (obj == null)
			{
				return false;
			}
			if (IsSystemBarcodeOrName(obj.Barcode, obj.Name))
			{
				return false;
			}
			if (IsSpentCasing(obj.Barcode, obj.Name))
			{
				return false;
			}
			return true;
		}

		private static bool IsSystemBarcodeOrName(string barcode, string name)
		{
			if (barcode == "SLZ.BONELAB.Core.DefaultPlayerRig" || barcode == "SLZ.BONELAB.Core.Spawnable.RigManagerBlank")
			{
				return true;
			}
			string text = barcode + " " + name;
			if (!text.Contains("RigManager", StringComparison.OrdinalIgnoreCase) && !text.Contains("UIRig", StringComparison.OrdinalIgnoreCase) && !text.Contains("BoneMenu", StringComparison.OrdinalIgnoreCase) && !text.Contains("GUIMenu", StringComparison.OrdinalIgnoreCase) && !text.Contains("GUIPoolee", StringComparison.OrdinalIgnoreCase) && !text.Contains("MenuIndicator", StringComparison.OrdinalIgnoreCase) && !text.Contains("PopUpMenu", StringComparison.OrdinalIgnoreCase) && !text.Contains("QuickMenu", StringComparison.OrdinalIgnoreCase))
			{
				return text.Contains("PreferencesPanel", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		private static bool IsSpentCasing(Poolee poolee, string barcode)
		{
			if ((Object)(object)((Component)poolee).GetComponentInChildren<Gun>(true) != (Object)null || (Object)(object)((Component)poolee).GetComponentInChildren<Magazine>(true) != (Object)null)
			{
				return false;
			}
			if (HasComponentTypeName(((Component)poolee).gameObject, "Casing", "CartridgeCase", "Spent", "ShellCasing"))
			{
				return true;
			}
			return IsSpentCasing(barcode, (poolee != null) ? ((Object)poolee).name : null);
		}

		private static bool IsSpentCasing(string barcode, string name)
		{
			string text = barcode + " " + name;
			if (text.Contains("mag", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			if (!text.Contains("casing", StringComparison.OrdinalIgnoreCase) && !text.Contains("cartridgecase", StringComparison.OrdinalIgnoreCase) && !text.Contains("brass", StringComparison.OrdinalIgnoreCase) && (!text.Contains("spent", StringComparison.OrdinalIgnoreCase) || !text.Contains("shell", StringComparison.OrdinalIgnoreCase)) && (!text.Contains("spent", StringComparison.OrdinalIgnoreCase) || !text.Contains("cartridge", StringComparison.OrdinalIgnoreCase)) && !text.Contains("spentcase", StringComparison.OrdinalIgnoreCase) && !text.Contains("cartridge", StringComparison.OrdinalIgnoreCase))
			{
				return text.Contains("shellcase", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		private static bool HasComponentTypeName(GameObject root, params string[] names)
		{
			if ((Object)(object)root == (Object)null)
			{
				return false;
			}
			foreach (Component componentsInChild in root.GetComponentsInChildren<Component>(true))
			{
				if ((Object)(object)componentsInChild == (Object)null)
				{
					continue;
				}
				string text = ((Object)componentsInChild).GetIl2CppType().FullName ?? ((object)componentsInChild).GetType().FullName ?? ((object)componentsInChild).GetType().Name;
				foreach (string value in names)
				{
					if (text.Contains(value, StringComparison.OrdinalIgnoreCase))
					{
						return true;
					}
				}
			}
			return false;
		}

		private static bool IsLooseEmptyMagazine(Poolee poolee)
		{
			Magazine componentInChildren = ((Component)poolee).GetComponentInChildren<Magazine>(true);
			if ((Object)(object)componentInChildren == (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)poolee).GetComponentInChildren<Gun>(true) != (Object)null)
			{
				return false;
			}
			if (IsMagazineInserted(componentInChildren))
			{
				return false;
			}
			return TryGetMagazineAmmoCount(componentInChildren) == 0;
		}

		private static bool IsMagazineInserted(Magazine magazine)
		{
			try
			{
				if ((Object)(object)magazine == (Object)null || (Object)(object)magazine.magazinePlug == (Object)null)
				{
					return false;
				}
				if (((AlignPlug)magazine.magazinePlug)._isLocked)
				{
					return true;
				}
				foreach (AmmoSocket item in Object.FindObjectsOfType<AmmoSocket>(true))
				{
					if ((Object)(object)item != (Object)null && (Object)(object)item._magazinePlug == (Object)(object)magazine.magazinePlug)
					{
						return true;
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private static int? TryGetMagazineAmmoCount(Magazine magazine)
		{
			if ((Object)(object)magazine == (Object)null)
			{
				return null;
			}
			try
			{
				if (magazine.magazineState != null)
				{
					if (magazine.magazineState.AmmoCount >= 0)
					{
						return magazine.magazineState.AmmoCount;
					}
					int? num = TryReadIntMember(magazine.magazineState, "AmmoCount");
					if (num.HasValue)
					{
						return num.Value;
					}
					if (magazine.magazineState._cartridges != null)
					{
						return magazine.magazineState._cartridges.Count;
					}
					int? num2 = TryReadIntMember(TryReadMember(magazine.magazineState, "_cartridges"), "Count");
					if (num2.HasValue)
					{
						return num2.Value;
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private SavedObject CapturePoolee(Poolee poolee)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)poolee).transform;
			AIBrain componentInChildren = ((Component)poolee).GetComponentInChildren<AIBrain>(true);
			Transform val = GetNpcPoseTransform(poolee, componentInChildren) ?? transform;
			SavedObject obj = new SavedObject
			{
				SaveId = GetOrCreateSaveId(poolee),
				Barcode = ((Scannable)poolee.SpawnableCrate).Barcode.ID,
				Name = ((Object)poolee).name,
				Position = Vec3.From(val.position)
			};
			Quaternion rotation = val.rotation;
			obj.Rotation = Vec3.From(((Quaternion)(ref rotation)).eulerAngles);
			obj.Scale = Vec3.From(transform.localScale);
			obj.HasAIBrain = (Object)(object)componentInChildren != (Object)null;
			obj.Health = CaptureHealth(poolee);
			obj.Destructible = CaptureDestructible(poolee);
			SavedObject savedObject = obj;
			List<Transform> list = new List<Transform>();
			if (OnlyRootPoseForThis(savedObject))
			{
				list.Add(transform);
			}
			else
			{
				WalkHierarchy(transform, list);
			}
			foreach (Transform item in list)
			{
				savedObject.Transforms.Add(CaptureTransform(transform, item));
			}
			return savedObject;
		}

		private static bool OnlyRootPoseForThis(SavedObject obj)
		{
			if (obj == null)
			{
				return false;
			}
			return string.Equals(obj.Barcode, "SLZ.BONELAB.Content.Spawnable.OfficeDesk", StringComparison.Ordinal);
		}

		private static bool RootRecord(TransformRecord record)
		{
			if (record == null)
			{
				return false;
			}
			if (string.IsNullOrEmpty(record.Path))
			{
				return string.IsNullOrEmpty(record.SiblingPath);
			}
			return false;
		}

		private string GetOrCreateSaveId(Poolee poolee)
		{
			if ((Object)(object)poolee != (Object)null && _savedIds.TryGetValue(((Il2CppObjectBase)poolee).Pointer, out var value) && !string.IsNullOrWhiteSpace(value))
			{
				return value;
			}
			string text = Guid.NewGuid().ToString("N");
			if ((Object)(object)poolee != (Object)null)
			{
				_savedIds[((Il2CppObjectBase)poolee).Pointer] = text;
			}
			return text;
		}

		private static Transform GetNpcPoseTransform(Poolee poolee, AIBrain brain)
		{
			if ((Object)(object)poolee == (Object)null || (Object)(object)brain == (Object)null || (Object)(object)brain.puppetMaster == (Object)null)
			{
				return null;
			}
			try
			{
				Il2CppReferenceArray<BehaviourBase> behaviours = brain.puppetMaster.behaviours;
				object obj;
				if (behaviours == null)
				{
					obj = null;
				}
				else
				{
					BehaviourBase? obj2 = ((IEnumerable<BehaviourBase>)behaviours).FirstOrDefault();
					obj = ((obj2 != null) ? ((Il2CppObjectBase)obj2).TryCast<BehaviourBaseNav>() : null);
				}
				BehaviourBaseNav val = (BehaviourBaseNav)obj;
				if ((Object)(object)val != (Object)null && (Object)(object)val._navAgent != (Object)null)
				{
					return ((Component)val._navAgent).transform;
				}
			}
			catch
			{
			}
			return null;
		}

		private TransformRecord CaptureTransform(Transform root, Transform transform)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			TransformRecord obj = new TransformRecord
			{
				Path = GetRelativePath(root, transform),
				SiblingPath = GetSiblingPath(root, transform),
				LocalPosition = Vec3.From(transform.localPosition)
			};
			Quaternion val = transform.localRotation;
			obj.LocalRotation = Vec3.From(((Quaternion)(ref val)).eulerAngles);
			obj.LocalScale = Vec3.From(transform.localScale);
			obj.HasWorldPose = true;
			obj.WorldPosition = Vec3.From(transform.position);
			val = transform.rotation;
			obj.WorldRotation = Vec3.From(((Quaternion)(ref val)).eulerAngles);
			obj.ActiveSelf = ((Component)transform).gameObject.activeSelf;
			TransformRecord transformRecord = obj;
			GrabSmallObjectState(transform, transformRecord);
			Rigidbody component = ((Component)transform).GetComponent<Rigidbody>();
			if ((Object)(object)component != (Object)null)
			{
				transformRecord.Rigidbody = new RigidbodyRecord
				{
					IsKinematic = component.isKinematic,
					UseGravity = component.useGravity,
					Velocity = Vec3.From(component.velocity),
					AngularVelocity = Vec3.From(component.angularVelocity)
				};
			}
			return transformRecord;
		}

		private static void GrabSmallObjectState(Transform transform, TransformRecord record)
		{
			if ((Object)(object)transform == (Object)null || record == null)
			{
				return;
			}
			Component[] array;
			try
			{
				array = Il2CppArrayBase<Component>.op_Implicit(((Component)transform).GetComponents<Component>());
			}
			catch
			{
				return;
			}
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.Ordinal);
			Component[] array2 = array;
			foreach (Component val in array2)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				string compName = GetCompName(val);
				if (string.IsNullOrWhiteSpace(compName) || DontGrabTinyState(val, compName))
				{
					continue;
				}
				dictionary.TryGetValue(compName, out var value);
				dictionary[compName] = value + 1;
				try
				{
					Behaviour val2 = (Behaviour)(object)((val is Behaviour) ? val : null);
					if (val2 != null)
					{
						record.ComponentToggles.Add(new ComponentToggleRecord
						{
							TypeName = compName,
							TypeSlot = value,
							Enabled = val2.enabled
						});
					}
					else
					{
						Renderer val3 = (Renderer)(object)((val is Renderer) ? val : null);
						if (val3 != null)
						{
							record.ComponentToggles.Add(new ComponentToggleRecord
							{
								TypeName = compName,
								TypeSlot = value,
								Enabled = val3.enabled
							});
						}
						else
						{
							Collider val4 = (Collider)(object)((val is Collider) ? val : null);
							if (val4 != null)
							{
								record.ComponentToggles.Add(new ComponentToggleRecord
								{
									TypeName = compName,
									TypeSlot = value,
									Enabled = val4.enabled
								});
							}
						}
					}
				}
				catch
				{
				}
				string[] array3 = switchyBoolNames;
				foreach (string name in array3)
				{
					object obj3;
					try
					{
						obj3 = TryReadMember(val, name);
					}
					catch
					{
						continue;
					}
					if (obj3 is bool value2)
					{
						record.ComponentBools.Add(new ComponentBoolRecord
						{
							TypeName = compName,
							TypeSlot = value,
							Name = name,
							Value = value2
						});
					}
				}
				array3 = switchyFloatNames;
				foreach (string name2 in array3)
				{
					object obj5;
					try
					{
						obj5 = TryReadMember(val, name2);
					}
					catch
					{
						continue;
					}
					float value3;
					if (obj5 is float num)
					{
						value3 = num;
					}
					else
					{
						if (!(obj5 is int num2))
						{
							continue;
						}
						value3 = num2;
					}
					record.ComponentFloats.Add(new ComponentFloatRecord
					{
						TypeName = compName,
						TypeSlot = value,
						Name = name2,
						Value = value3
					});
				}
			}
		}

		private static string GetCompName(Component comp)
		{
			if ((Object)(object)comp == (Object)null)
			{
				return null;
			}
			try
			{
				Type il2CppType = ((Object)comp).GetIl2CppType();
				return ((il2CppType != null) ? il2CppType.FullName : null) ?? ((object)comp).GetType().FullName ?? ((object)comp).GetType().Name;
			}
			catch
			{
				return ((object)comp).GetType().FullName ?? ((object)comp).GetType().Name;
			}
		}

		private void CaptureSceneLogicStates(SceneSaveFile file)
		{
			if (file == null)
			{
				return;
			}
			if (file.SceneLogic == null)
			{
				List<SceneLogicRecord> list2 = (file.SceneLogic = new List<SceneLogicRecord>());
			}
			file.SceneLogic.Clear();
			Component[] array;
			try
			{
				array = Il2CppArrayBase<Component>.op_Implicit(Object.FindObjectsOfType<Component>(true));
			}
			catch
			{
				return;
			}
			Dictionary<IntPtr, Dictionary<string, int>> slotCache = new Dictionary<IntPtr, Dictionary<string, int>>();
			Component[] array2 = array;
			foreach (Component comp in array2)
			{
				SceneLogicRecord sceneLogicRecord = null;
				try
				{
					sceneLogicRecord = CaptureLogicComponent(comp, slotCache);
				}
				catch
				{
				}
				if (sceneLogicRecord != null)
				{
					file.SceneLogic.Add(sceneLogicRecord);
				}
			}
			CaptureHolodeck(file);
			if (file.SceneLogic.Count > 0)
			{
				((MelonBase)this).LoggerInstance.Msg($"Saved {file.SceneLogic.Count} scene logic states.");
			}
		}

		private SceneLogicRecord CaptureLogicComponent(Component comp, Dictionary<IntPtr, Dictionary<string, int>> slotCache)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)comp == (Object)null || (Object)(object)comp.transform == (Object)null)
			{
				return null;
			}
			Scene scene = comp.gameObject.scene;
			if (((Scene)(ref scene)).name == "DontDestroyOnLoad")
			{
				return null;
			}
			if ((Object)(object)comp.GetComponentInParent<Poolee>() != (Object)null)
			{
				return null;
			}
			if (IsProbablyMenuOrSystemObject(comp.transform))
			{
				return null;
			}
			string compName = GetCompName(comp);
			if (!LooksLikeSceneLogic(compName))
			{
				return null;
			}
			SceneLogicRecord sceneLogicRecord = new SceneLogicRecord();
			scene = comp.gameObject.scene;
			sceneLogicRecord.SceneName = ((Scene)(ref scene)).name;
			sceneLogicRecord.TransformPath = GetSceneTransformPath(comp.transform);
			sceneLogicRecord.TypeName = compName;
			sceneLogicRecord.TypeSlot = GetLogicTypeSlot(comp, slotCache);
			sceneLogicRecord.Latest = TryCaptureLatest(comp);
			SceneLogicRecord sceneLogicRecord2 = sceneLogicRecord;
			Behaviour val = (Behaviour)(object)((comp is Behaviour) ? comp : null);
			if (val != null)
			{
				sceneLogicRecord2.BehaviourEnabled = val.enabled;
			}
			GrabLogicMembers(comp, sceneLogicRecord2);
			GrabSimpleMembers(comp, sceneLogicRecord2);
			if (sceneLogicRecord2.BehaviourEnabled.HasValue || sceneLogicRecord2.Latest != null || sceneLogicRecord2.Bools.Count > 0 || sceneLogicRecord2.Floats.Count > 0 || sceneLogicRecord2.Ints.Count > 0 || sceneLogicRecord2.Strings.Count > 0 || sceneLogicRecord2.Vectors.Count > 0)
			{
				return sceneLogicRecord2;
			}
			return null;
		}

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

		private bool RestoreSceneLogicRecord(SceneLogicRecord rec, Dictionary<string, Transform> pathCache)
		{
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			if (rec == null || string.IsNullOrWhiteSpace(rec.TypeName))
			{
				return false;
			}
			if (rec.TypeName == "PersistentScene.GameControl_Holodeck")
			{
				return RestoreHolodeck(rec);
			}
			Component val = FindLogicComponent(ResolveSceneTransformPath(rec.SceneName, rec.TransformPath, pathCache), rec.TypeName, rec.TypeSlot);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			try
			{
				if (rec.BehaviourEnabled.HasValue)
				{
					Behaviour val2 = (Behaviour)(object)((val is Behaviour) ? val : null);
					if (val2 != null)
					{
						val2.enabled = rec.BehaviourEnabled.Value;
					}
				}
				if (rec.Bools != null)
				{
					foreach (ComponentBoolRecord @bool in rec.Bools)
					{
						WriteLoose(val, @bool.Name, @bool.Value);
					}
				}
				if (rec.Floats != null)
				{
					foreach (ComponentFloatRecord @float in rec.Floats)
					{
						WriteLoose(val, @float.Name, @float.Value);
					}
				}
				if (rec.Ints != null)
				{
					foreach (ComponentIntRecord @int in rec.Ints)
					{
						WriteLoose(val, @int.Name, @int.Value);
					}
				}
				if (rec.Strings != null)
				{
					foreach (ComponentStringRecord @string in rec.Strings)
					{
						WriteLoose(val, @string.Name, @string.Value);
					}
				}
				if (rec.Vectors != null)
				{
					foreach (ComponentVectorRecord vector in rec.Vectors)
					{
						WriteLoose(val, vector.Name, vector.Value.ToUnity());
					}
				}
				RestoreLatest(val, rec.Latest);
				FixButtonJoint(val);
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static void GrabLogicMembers(Component comp, SceneLogicRecord rec)
		{
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			string[] array = logicBoolNames;
			foreach (string name in array)
			{
				if (ReadLoose(comp, name) is bool value)
				{
					rec.Bools.Add(new ComponentBoolRecord
					{
						Name = name,
						Value = value
					});
				}
			}
			array = logicFloatNames;
			foreach (string name2 in array)
			{
				object obj = ReadLoose(comp, name2);
				if (obj is float value2)
				{
					rec.Floats.Add(new ComponentFloatRecord
					{
						Name = name2,
						Value = value2
					});
				}
				else if (obj is double num)
				{
					rec.Floats.Add(new ComponentFloatRecord
					{
						Name = name2,
						Value = (float)num
					});
				}
			}
			array = logicIntNames;
			foreach (string name3 in array)
			{
				if (TryInt(ReadLoose(comp, name3), out var result))
				{
					rec.Ints.Add(new ComponentIntRecord
					{
						Name = name3,
						Value = result
					});
				}
			}
			array = logicStringNames;
			foreach (string name4 in array)
			{
				if (ReadLoose(comp, name4) is string value3)
				{
					rec.Strings.Add(new ComponentStringRecord
					{
						Name = name4,
						Value = value3
					});
				}
			}
			array = logicVectorNames;
			foreach (string name5 in array)
			{
				if (ReadLoose(comp, name5) is Vector3 vector)
				{
					rec.Vectors.Add(new ComponentVectorRecord
					{
						Name = name5,
						Value = Vec3.From(vector)
					});
				}
			}
		}

		private static void GrabSimpleMembers(Component comp, SceneLogicRecord rec)
		{
			//IL_033c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0341: 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)
			HashSet<string> hashSet = (from x in rec.Bools
				select x.Name into x
				where !string.IsNullOrWhiteSpace(x)
				select x).ToHashSet<string>(StringComparer.Ordinal);
			HashSet<string> hashSet2 = (from x in rec.Floats
				select x.Name into x
				where !string.IsNullOrWhiteSpace(x)
				select x).ToHashSet<string>(StringComparer.Ordinal);
			HashSet<string> hashSet3 = (from x in rec.Ints
				select x.Name into x
				where !string.IsNullOrWhiteSpace(x)
				select x).ToHashSet<string>(StringComparer.Ordinal);
			HashSet<string> hashSet4 = (from x in rec.Strings
				select x.Name into x
				where !string.IsNullOrWhiteSpace(x)
				select x).ToHashSet<string>(StringComparer.Ordinal);
			HashSet<string> hashSet5 = (from x in rec.Vectors
				select x.Name into x
				where !string.IsNullOrWhiteSpace(x)
				select x).ToHashSet<string>(StringComparer.Ordinal);
			foreach (MemberInfo item in SimpleMembers(((object)comp).GetType()))
			{
				string name = item.Name;
				if (!BadLogicMemberName(name))
				{
					object obj = ReadLoose(comp, item);
					int result;
					if (obj is bool value && hashSet.Add(name))
					{
						rec.Bools.Add(new ComponentBoolRecord
						{
							Name = name,
							Value = value
						});
					}
					else if (obj is float value2 && hashSet2.Add(name))
					{
						rec.Floats.Add(new ComponentFloatRecord
						{
							Name = name,
							Value = value2
						});
					}
					else if (obj is double num && hashSet2.Add(name))
					{
						rec.Floats.Add(new ComponentFloatRecord
						{
							Name = name,
							Value = (float)num
						});
					}
					else if (TryInt(obj, out result) && hashSet3.Add(name))
					{
						rec.Ints.Add(new ComponentIntRecord
						{
							Name = name,
							Value = result
						});
					}
					else if (obj is string value3 && hashSet4.Add(name))
					{
						rec.Strings.Add(new ComponentStringRecord
						{
							Name = name,
							Value = value3
						});
					}
					else if (obj is Vector3 vector && hashSet5.Add(name))
					{
						rec.Vectors.Add(new ComponentVectorRecord
						{
							Name = name,
							Value = Vec3.From(vector)
						});
					}
				}
			}
		}

		private void CaptureHolodeck(SceneSaveFile file)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			GameControl_Holodeck val = Object.FindObjectOfType<GameControl_Holodeck>(true);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			SceneLogicRecord sceneLogicRecord = new SceneLogicRecord();
			Scene scene = ((Component)val).gameObject.scene;
			sceneLogicRecord.SceneName = ((Scene)(ref scene)).name;
			sceneLogicRecord.TransformPath = GetSceneTransformPath(((Component)val).transform);
			sceneLogicRecord.TypeName = "PersistentScene.GameControl_Holodeck";
			SceneLogicRecord sceneLogicRecord2 = sceneLogicRecord;
			if (HolodeckBits.TryMat(val, out var value))
			{
				sceneLogicRecord2.Ints.Add(new ComponentIntRecord
				{
					Name = "material",
					Value = value
				});
			}
			else
			{
				int? num = GuessHolodeckMaterial(val);
				if (num.HasValue)
				{
					int valueOrDefault = num.GetValueOrDefault();
					sceneLogicRecord2.Ints.Add(new ComponentIntRecord
					{
						Name = "material",
						Value = valueOrDefault
					});
				}
			}
			bool value2;
			if ((Object)(object)val.doorHide != (Object)null)
			{
				sceneLogicRecord2.Bools.Add(new ComponentBoolRecord
				{
					Name = "doorHide",
					Value = val.doorHide.activeSelf
				});
			}
			else if (HolodeckBits.TryDoor(val, out value2))
			{
				sceneLogicRecord2.Bools.Add(new ComponentBoolRecord
				{
					Name = "doorHide",
					Value = value2
				});
			}
			if (sceneLogicRecord2.Ints.Count > 0 || sceneLogicRecord2.Bools.Count > 0)
			{
				file.SceneLogic.Add(sceneLogicRecord2);
			}
		}

		private bool RestoreHolodeck(SceneLogicRecord rec)
		{
			GameControl_Holodeck val = Object.FindObjectOfType<GameControl_Holodeck>(true);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			try
			{
				ComponentIntRecord componentIntRecord = rec.Ints?.FirstOrDefault((ComponentIntRecord x) => x.Name == "material");
				if (componentIntRecord != null)
				{
					val.SELECTMATERIAL(componentIntRecord.Value);
				}
				ComponentBoolRecord componentBoolRecord = rec.Bools?.FirstOrDefault((ComponentBoolRecord x) => x.Name == "doorHide");
				if (componentBoolRecord != null && (Object)(object)val.doorHide != (Object)null && val.doorHide.activeSelf != componentBoolRecord.Value)
				{
					val.doorHide.SetActive(!componentBoolRecord.Value);
					val.TOGGLEDOOR();
				}
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static bool LooksLikeSceneLogic(string typeName)
		{
			if (string.IsNullOrWhiteSpace(typeName))
			{
				return false;
			}
			string[] array = logicHints;
			foreach (string value in array)
			{
				if (typeName.Contains(value, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		private static int GetLogicTypeSlot(Component comp, Dictionary<IntPtr, Dictionary<string, int>> slotCache)
		{
			Transform transform = comp.transform;
			string compName = GetCompName(comp);
			if (!slotCache.TryGetValue(((Il2CppObjectBase)transform).Pointer, out var value))
			{
				value = new Dictionary<string, int>(StringComparer.Ordinal);
				slotCache[((Il2CppObjectBase)transform).Pointer] = value;
			}
			value.TryGetValue(compName, out var value2);
			value[compName] = value2 + 1;
			return value2;
		}

		private static Component FindLogicComponent(Transform tr, string typeName, int slot)
		{
			if ((Object)(object)tr == (Object)null || string.IsNullOrWhiteSpace(typeName))
			{
				return null;
			}
			int num = 0;
			foreach (Component component in ((Component)tr).GetComponents<Component>())
			{
				if (!((Object)(object)component == (Object)null) && string.Equals(GetCompName(component), typeName, StringComparison.Ordinal))
				{
					if (num == slot)
					{
						return component;
					}
					num++;
				}
			}
			return null;
		}

		private static Transform ResolveSceneTransformPath(string sceneName, string path, Dictionary<string, Transform> cache = null)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(path))
			{
				return null;
			}
			string key = (sceneName ?? string.Empty) + "\n" + path;
			if (cache != null && cache.TryGetValue(key, out var value))
			{
				return value;
			}
			Scene val = (Scene)((!string.IsNullOrWhiteSpace(sceneName)) ? SceneManager.GetSceneByName(sceneName) : default(Scene));
			if (!((Scene)(ref val)).IsValid())
			{
				val = SceneManager.GetActiveScene();
			}
			GameObject[] array = Il2CppArrayBase<GameObject>.op_Implicit((Il2CppArrayBase<GameObject>)(object)((Scene)(ref val)).GetRootGameObjects());
			Transform val2 = null;
			string[] array2 = path.Split('/');
			foreach (string text in array2)
			{
				if (string.IsNullOrWhiteSpace(text))
				{
					continue;
				}
				int num = text.IndexOf(':');
				string s = ((num >= 0) ? text.Substring(0, num) : text);
				object obj;
				if (num < 0)
				{
					obj = null;
				}
				else
				{
					string text2 = text;
					int num2 = num + 1;
					obj = text2.Substring(num2, text2.Length - num2);
				}
				string name = (string)obj;
				if (!int.TryParse(s, out var result))
				{
					return null;
				}
				if ((Object)(object)val2 == (Object)null)
				{
					if (result >= 0 && result < array.Length)
					{
						val2 = array[result].transform;
					}
					else if (!string.IsNullOrWhiteSpace(name))
					{
						val2 = array.Select((GameObject x) => x.transform).FirstOrDefault((Func<Transform, bool>)((Transform x) => ((Object)x).name == name));
					}
				}
				else if (result >= 0 && result < val2.childCount)
				{
					val2 = val2.GetChild(result);
				}
				else if (!string.IsNullOrWhiteSpace(name))
				{
					val2 = FindChildByName(val2, name);
				}
				if ((Object)(object)val2 == (Object)null)
				{
					return null;
				}
			}
			if (cache != null && (Object)(object)val2 != (Object)null)
			{
				cache[key] = val2;
			}
			return val2;
		}

		private static Transform FindChildByName(Transform root, string name)
		{
			for (int i = 0; i < root.childCount; i++)
			{
				Transform child = root.GetChild(i);
				if (((Object)child).name == name)
				{
					return child;
				}
			}
			return null;
		}

		[IteratorStateMachine(typeof(<SimpleMembers>d__303))]
		private static IEnumerable<MemberInfo> SimpleMembers(Type type)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SimpleMembers>d__303(-2)
			{
				<>3__type = type
			};
		}

		private static bool SimpleType(Type type)
		{
			if (!(type == typeof(bool)) && !(type == typeof(float)) && !(type == typeof(double)) && !(type == typeof(int)) && !(type == typeof(short)) && !(type == typeof(byte)) && !(type == typeof(long)) && !(type == typeof(string)))
			{
				return type == typeof(Vector3);
			}
			return true;
		}

		private static bool BadLogicMemberName(string name)
		{
			if (string.IsNullOrWhiteSpace(name))
			{
				return true;
			}
			switch (name)
			{
			case "CachedPtr":
			case "transform":
			case "gameObject":
			case "name":
			case "tag":
			case "Pointer":
			case "WasCollected":
				return true;
			default:
				return false;
			}
		}

		private static object ReadLoose(object target, string name)
		{
			if (target == null || string.IsNullOrWhiteSpace(name))
			{
				return null;
			}
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
			Type type = target.GetType();
			try
			{
				FieldInfo field = type.GetField(name, bindingAttr);
				if (field != null)
				{
					return field.GetValue(target);
				}
				PropertyInfo property = type.GetProperty(name, bindingAttr);
				if (property != null && property.CanRead && property.GetIndexParameters().Length == 0)
				{
					return property.GetValue(target);
				}
			}
			catch
			{
			}
			return null;
		}

		private static object ReadLoose(object target, MemberInfo member)
		{
			try
			{
				if (member is FieldInfo fieldInfo)
				{
					return fieldInfo.GetValue(target);
				}
				if (member is PropertyInfo propertyInfo && propertyInfo.GetIndexParameters().Length == 0)
				{
					return propertyInfo.GetValue(target);
				}
			}
			catch
			{
			}
			return null;
		}

		private static bool WriteLoose(object target, string name, object value)
		{
			if (target == null || string.IsNullOrWhiteSpace(name))
			{
				return false;
			}
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
			Type type = target.GetType();
			try
			{
				FieldInfo field = type.GetField(name, bindingAttr);
				if (field != null)
				{
					field.SetValue(target, CoerceValue(value, field.FieldType));
					return true;
				}
				PropertyInfo property = type.GetProperty(name, bindingAttr);
				if (property != null && property.CanWrite && property.GetIndexParameters().Length == 0)
				{
					property.SetValue(target, CoerceValue(value, property.PropertyType));
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		private static object CoerceValue(object value, Type type)
		{
			try
			{
				if (type == typeof(float) && value is int num)
				{
					return (float)num;
				}
				if (type == typeof(double) && value is float num2)
				{
					return (double)num2;
				}
				if (type == typeof(int) && value is float num3)
				{
					return (int)num3;
				}
				if (type == typeof(short) && value is int num4)
				{
					return (short)num4;
				}
				if (type == typeof(byte) && value is int num5)
				{
					return (byte)num5;
				}
				if (type == typeof(long) && value is int)
				{
					int num6 = (int)value;
					return (long)num6;
				}
			}
			catch
			{
			}
			return value;
		}

		private static bool TryInt(object value, out int result)
		{
			result = 0;
			if (value is int num)
			{
				result = num;
				return true;
			}
			if (value is byte b)
			{
				result = b;
				return true;
			}
			if (value is short num2)
			{
				result = num2;
				return true;
			}
			if (value is long num3)
			{
				result = (int)((num3 > int.MaxValue) ? int.MaxValue : ((num3 < int.MinValue) ? int.MinValue : num3));
				return true;
			}
			return false;
		}

		private static LogicLatestRecord TryCaptureLatest(Component comp)
		{
			try
			{
				MethodInfo method = ((object)comp).GetType().GetMethod("GetLatestValue", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				return (method == null) ? null : MakeLatest(method.Invoke(comp, Array.Empty<object>()));
			}
			catch
			{
				return null;
			}
		}

		private static LogicLatestRecord MakeLatest(object value)
		{
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			if (value is bool boolValue)
			{
				return new LogicLatestRecord
				{
					Kind = "bool",
					BoolValue = boolValue
				};
			}
			if (TryInt(value, out var result))
			{
				return new LogicLatestRecord
				{
					Kind = "int",
					IntValue = result
				};
			}
			if (value is float floatValue)
			{
				return new LogicLatestRecord
				{
					Kind = "float",
					FloatValue = floatValue
				};
			}
			if (value is double num)
			{
				return new LogicLatestRecord
				{
					Kind = "float",
					FloatValue = (float)num
				};
			}
			if (value is string stringValue)
			{
				return new LogicLatestRecord
				{
					Kind = "string",
					StringValue = stringValue
				};
			}
			if (value is Vector3 vector)
			{
				return new LogicLatestRecord
				{
					Kind = "vector3",
					VectorValue = Vec3.From(vector)
				};
			}
			return null;
		}

		private static void RestoreLatest(Component comp, LogicLatestRecord latest)
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)comp == (Object)null || latest == null || string.IsNullOrWhiteSpace(latest.Kind))
			{
				return;
			}
			object obj = latest.Kind switch
			{
				"bool" => latest.BoolValue, 
				"int" => latest.IntValue, 
				"float" => latest.FloatValue, 
				"string" => latest.StringValue, 
				"vector3" => latest.VectorValue.ToUnity(), 
				_ => null, 
			};
			if (obj == null)
			{
				return;
			}
			try
			{
				((object)comp).GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => m.Name == "ReceiveValue" && m.GetParameters().Length == 1)?.Invoke(comp, new object[1] { obj });
			}
			catch
			{
			}
		}

		private static int? GuessHolodeckMaterial(GameControl_Holodeck deck)
		{
			string[] array = new string[7] { "selectionIndex", "SelectionIndex", "selectedIndex", "SelectedIndex", "matIndex", "materialIndex", "i" };
			foreach (string name in array)
			{
				if (TryInt(ReadLoose(deck, name), out var result))
				{
					return result;
				}
			}
			return null;
		}

		private static void FixButtonJoint(Component comp)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			string compName = GetCompName(comp);
			if (compName != null && compName.Contains("ButtonController", StringComparison.OrdinalIgnoreCase))
			{
				object obj = ReadLoose(comp, "_charged");
				bool flag = default(bool);
				int num;
				if (obj is bool)
				{
					flag = (bool)obj;
					num = 1;
				}
				else
				{
					num = 0;
				}
				bool flag2 = (byte)((uint)num & (flag ? 1u : 0u)) != 0;
				object obj2 = ReadLoose(ReadLoose(comp, "_servo"), "joint");
				ConfigurableJoint val = (ConfigurableJoint)((obj2 is ConfigurableJoint) ? obj2 : null);
				if (!((Object)(object)val == (Object)null))
				{
					SoftJointLimit linearLimit = val.linearLimit;
					float limit = ((SoftJointLimit)(ref linearLimit)).limit;
					val.targetPosition = Vector3.right * (flag2 ? (0f - limit) : limit);
				}
			}
		}
	}
	public static class ModInfo
	{
		public const string ModVersion = "1.0.0";
	}
	internal static class FusionCompat
	{
		private static bool? _hasFusion;

		public static bool Installed
		{
			get
			{
				if (_hasFusion.HasValue)
				{
					return _hasFusion.Value;
				}
				_hasFusion = AppDomain.CurrentDomain.GetAssemblies().Any((Assembly a) => string.Equals(a.GetName().Name, "LabFusion", StringComparison.OrdinalIgnoreCase));
				return _hasFusion.Value;
			}
		}

		public static bool InRoom
		{
			get
			{
				if (!Installed)
				{
					return false;
				}
				try
				{
					return NetworkInfo.HasServer;
				}
				catch
				{
					return false;
				}
			}
		}

		public static bool Hosting
		{
			get
			{
				if (!Installed)
				{
					return false;
				}
				try
				{
					return NetworkInfo.IsHost;
				}
				catch
				{
					return false;
				}
			}
		}

		public static bool ClientInRoom
		{
			get
			{
				if (InRoom)
				{
					return !Hosting;
				}
				return false;
			}
		}

		public static bool CanTouchScene
		{
			get
			{
				if (InRoom)
				{
					return Hosting;
				}
				return true;
			}
		}

		public static Task<Poolee> SpawnSceneThing(string barcode, Vector3 pos, Quaternion rot, Vector3 scale)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			TaskCompletionSource<Poolee> tcs = new TaskCompletionSource<Poolee>();
			try
			{
				Spawnable spawnable = Barcodes.Make(barcode);
				SpawnRequestInfo val = default(SpawnRequestInfo);
				val.Spawnable = spawnable;
				val.Position = pos;
				val.Rotation = rot;
				val.SpawnEffect = false;
				val.SpawnSource = (EntitySource)1;
				val.SpawnCallback = delegate(SpawnCallbackInfo info)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0015: Unknown result type (might be due to invalid IL or missing references)
					//IL_0031: Unknown result type (might be due to invalid IL or missing references)
					try
					{
						Poolee val2 = null;
						if ((Object)(object)info.Spawned != (Object)null)
						{
							val2 = Poolee.Cache.Get(info.Spawned);
						}
						if ((Object)(object)val2 != (Object)null)
						{
							((Component)val2).transform.localScale = scale;
						}
						tcs.TrySetResult(val2);
					}
					catch (Exception exception2)
					{
						tcs.TrySetException(exception2);
					}
				};
				NetworkAssetSpawner.Spawn(val);
			}
			catch (Exception exception)
			{
				tcs.TrySetException(exception);
			}
			return tcs.Task;
		}

		public static void SendConstraint(GameObject go1, GameObject go2, ConstraintMode mode, Vector3 point1, Vector3 point2, Vector3 normal1, Vector3 normal2, Vector3 pose1, Quaternion rot1, Vector3 pose2, Quaternion rot2)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			if (!InRoom || !Hosting || (Object)(object)go1 == (Object)null || (Object)(object)go2 == (Object)null)
			{
				return;
			}
			try
			{
				EntityIDList<NetworkEntity> registeredEntities = NetworkEntityManager.IDManager.RegisteredEntities;
				MessageRelay.RelayModule<ConstraintCreateMessage, ConstraintCreateData>(new ConstraintCreateData
				{
					SmallID = PlayerIDManager.LocalSmallID,
					ConstrainerID = null,
					Mode = mode,
					Tracker1 = new GameObjectReference(go1),
					Tracker2 = new GameObjectReference(go2),
					Tracker1Transform = new SerializedTransform(pose1, rot1),
					Tracker2Transform = new SerializedTransform(pose2, rot2),
					Point1 = point1,
					Point2 = point2,
					Normal1 = normal1,
					Normal2 = normal2,
					Point1Id = registeredEntities.AllocateNewID(),
					Point2Id = registeredEntities.AllocateNewID()
				}, CommonMessageRoutes.ReliableToClients);
			}
			catch (Exception ex)
			{
				Core current = Core.Current;
				if (current != null)
				{
					((MelonBase)current).LoggerInstance.Warning("Fusion constraint sync failed: " + ex.Message);
				}
			}
		}
	}
	public class SceneSaveConfig
	{
		public HashSet<string> BlacklistedLevelBarcodes { get; set; } = new HashSet<string>(StringComparer.Ordinal);


		public bool DefaultBlacklistSeeded { get; set; }

		public bool ModEnabled { get; set; } = true;


		public bool SavePlayerLocation { get; set; } = true;


		public bool SavePlayerLocationDefaultSeeded { get; set; }

		public string LastLevelBarcode { get; set; }

		public string LastLevelName { get; set; }
	}
	public class SceneSaveFile
	{
		public string InitialSaveVersion { get; set; }

		public string SupportedVersion { get; set; }

		public string LevelBarcode { get; set; }

		public string LevelName { get; set; }

		public DateTime SavedAtUtc { get; set; }

		public PlayerPoseRecord PlayerPose { get; set; }

		public PlayerAmmoRecord PlayerAmmo { get; set; }

		public PlayerInventoryRecord PlayerInventory { get; set; }

		public List<SavedObject> Objects { get; set; } = new List<SavedObject>();


		public List<ConstraintRecord> Constraints { get; set; } = new List<ConstraintRecord>();


		public List<SceneLogicRecord> SceneLogic { get; set; } = new List<SceneLogicRecord>();


		public List<string> DeletedSaveIds { get; set; } = new List<string>();

	}
	public class SceneSaveManifest
	{
		public string InitialSaveVersion { get; set; }

		public string SupportedVersion { get; set; }

		public string LevelBarcode { get; set; }

		public string LevelName { get; set; }

		public DateTime SavedAtUtc { get; set; }

		public PlayerPoseRecord PlayerPose { get; set; }

		public PlayerAmmoRecord PlayerAmmo { get; set; }

		public PlayerInventoryRecord PlayerInventory { get; set; }
	}
	public class PlayerPoseRecord
	{
		public Vec3 Position { get; set; }

		public Vec3 Forward { get; set; }

		public bool HasRotation { get; set; }

		public Vec3 Rotation { get; set; }
	}
	public class PlayerAmmoRecord
	{
		public int LightAmmo { get; set; }

		public int MediumAmmo { get; set; }

		public int HeavyAmmo { get; set; }
	}
	public class PlayerInventoryRecord
	{
		public List<PlayerInventoryItemRecord> Items { get; set; } = new List<PlayerInventoryItemRecord>();

	}
	public class PlayerInventoryItemRecord
	{
		public string SlotName { get; set; }

		public string Barcode { get; set; }
	}
	public class SavedObject
	{
		public string SaveId { get; set; }

		public string SceneSpawnerId { get; set; }

		public bool FromSceneCrateSpawner { get; set; }

		public string Barcode { get; set; }

		public string Name { get; set; }

		public Vec3 Position { get; set; }

		public Vec3 Rotation { get; set; }

		public Vec3 Scale { get; set; }

		public bool HasAIBrain { get; set; }

		public HealthRecord Health { get; set; }

		public DestructibleRecord Destructible { get; set; }

		public List<TransformRecord> Transforms { get; set; } = new List<TransformRecord>();

	}
	public class TransformRecord
	{
		public string Path { get; set; }

		public string SiblingPath { get; set; }

		public Vec3 LocalPosition { get; set; }

		public Vec3 LocalRotation { get; set; }

		public Vec3 LocalScale { get; set; }

		public bool HasWorldPose { get; set; }

		public Vec3 WorldPosition { get; set; }

		public Vec3 WorldRotation { get; set; }

		public bool ActiveSelf { get; set; } = true;


		public List<ComponentToggleRecord> ComponentToggles { get; set; } = new List<ComponentToggleRecord>();


		public List<ComponentBoolRecord> ComponentBools { get; set; } = new List<ComponentBoolRecord>();


		public List<ComponentFloatRecord> ComponentFloats { get; set; } = new List<ComponentFloatRecord>();


		public RigidbodyRecord Rigidbody { get; set; }
	}
	public class ComponentToggleRecord
	{
		public string TypeName { get; set; }

		public int TypeSlot { get; set; }

		public bool Enabled { get; set; }
	}
	public class ComponentBoolRecord
	{
		public string TypeName { get; set; }

		public int TypeSlot { get; set; }

		public string Name { get; set; }

		public bool Value { get; set; }
	}
	public class ComponentFloatRecord
	{
		public string TypeName { get; set; }

		public int TypeSlot { get; set; }

		public string Name { get; set; }

		public float Value { get; set; }
	}
	public class RigidbodyRecord
	{
		public bool IsKinematic { get; set; }

		public bool UseGravity { get; set; }

		public Vec3 Velocity { get; set; }

		public Vec3 AngularVelocity { get; set; }
	}
	public class ConstraintRecord
	{
		public string Mode { get; set; }

		public int FirstObjectIndex { get; set; }

		public string FirstPath { get; set; }

		public string FirstSiblingPath { get; set; }

		public int SecondObjectIndex { get; set; }

		public string SecondPath { get; set; }

		public string SecondSiblingPath { get; set; }

		public Vec3 FirstPoint { get; set; }

		public Vec3 SecondPoint { get; set; }

		public Vec3 FirstNormal { get; set; }

		public Vec3 SecondNormal { get; set; }

		public bool HasFirstTargetPose { get; set; }

		public Vec3 FirstTargetPosition { get; set; }

		public Vec3 FirstTargetRotation { get; set; }

		public bool HasSecondTargetPose { get; set; }

		public Vec3 SecondTargetPosition { get; set; }

		public Vec3 SecondTargetRotation { get; set; }
	}
	public class HealthRecord
	{
		public float? CurrentHealth { get; set; }

		public float? MaxHealth { get; set; }

		public bool? IsDead { get; set; }

		public float? AppliedDamage { get; set; }
	}
	public class DestructibleRecord
	{
		public float Health { get; set; }

		public float MaxHealth { get; set; }

		public bool IsDead { get; set; }
	}
	public struct Vec3
	{
		public float X { get; set; }

		public float Y { get; set; }

		public float Z { get; set; }

		public static Vec3 From(Vector3 vector)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			Vec3 result = default(Vec3);
			result.X = R(vector.x);
			result.Y = R(vector.y);
			result.Z = R(vector.z);
			return result;
		}

		public Vector3 ToUnity()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(X, Y, Z);
		}

		private static float R(float value)
		{
			return MathF.Round(value, 3);
		}
	}
	internal struct ConstraintState
	{
		public Vector3 PointStart;

		public Vector3 PointEnd;

		public Vector3 NormalStart;

		public Vector3 NormalEnd;
	}
	internal enum SceneSaveBarcode
	{
		CONSTRAINER
	}
	internal static class Barcodes
	{
		private const string ConstrainerBarcode = "c1534c5a-3813-49d6-a98c-f595436f6e73";

		public static string Get(SceneSaveBarcode barcode)
		{
			if (barcode == SceneSaveBarcode.CONSTRAINER)
			{
				return "c1534c5a-3813-49d6-a98c-f595436f6e73";
			}
			throw new ArgumentOutOfRangeException("barcode", barcode, null);
		}

		public static Spawnable Make(string barcode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_0018: Expected O, but got Unknown
			Spawnable val = new Spawnable
			{
				crateRef = new SpawnableCrateReference(barcode)
			};
			AssetSpawner.Register(val);
			return val;
		}
	}
	internal static class Utilities
	{
		public static Nullable<T> Nil<T>() where T : new()
		{
			return new Nullable<T>(default(T))
			{
				hasValue = false
			};
		}
	}
	internal sealed class UnityObjectComparer<T> : IEqualityComparer<T> where T : Object
	{
		public static IEqualityComparer<T> Instance { get; } = new UnityObjectComparer<T>();


		public bool Equals(T x, T y)
		{
			bool flag = (Object)(object)x == (Object)null;
			bool flag2 = (Object)(object)y == (Object)null;
			if (flag || flag2)
			{
				return flag && flag2;
			}
			return (Object)(object)x == (Object)(object)y;
		}

		public int GetHashCode(T obj)
		{
			if (!((Object)(object)obj == (Object)null))
			{
				return ((Object)(object)obj).GetHashCode();
			}
			return 0;
		}
	}
	public class SceneLogicRecord
	{
		public string SceneName { get; set; }

		public string TransformPath { get; set; }

		public string TypeName { get; set; }

		public int TypeSlot { get; set; }

		public bool? BehaviourEnabled { get; set; }

		public LogicLatestRecord Latest { get; set; }

		public List<ComponentBoolRecord> Bools { get; set; } = new List<ComponentBoolRecord>();


		public List<ComponentFloatRecord> Floats { get; set; } = new List<ComponentFloatRecord>();


		public List<ComponentIntRecord> Ints { get; set; } = new List<ComponentIntRecord>();


		public List<ComponentStringRecord> Strings { get; set; } = new List<ComponentStringRecord>();


		public List<ComponentVectorRecord> Vectors { get; set; } = new List<ComponentVectorRecord>();

	}
	public class LogicLatestRecord
	{
		public string Kind { get; set; }

		public bool BoolValue { get; set; }

		public int IntValue { get; set; }

		public float FloatValue { get; set; }

		public string StringValue { get; set; }

		public Vec3 VectorValue { get; set; }
	}
	public class ComponentIntRecord
	{
		public string Name { get; set; }

		public int Value { get; set; }
	}
	public class ComponentStringRecord
	{
		public string Name { get; set; }

		public string Value { get; set; }
	}
	public class ComponentVectorRecord
	{
		public string Name { get; set; }

		public Vec3 Value { get; set; }
	}
	internal static class SpawnBits
	{
		private const int maxRemembered = 1024;

		private static readonly List<(string Barcode, Poolee Poolee)> lastPoolees = new List<(string, Poolee)>(1024);

		private static bool _initialized;

		public static void Init(Harmony harmony)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			if (!_initialized)
			{
				_initialized = true;
				MethodInfo methodInfo = AccessTools.Method(typeof(Poolee), "OnEnable", (Type[])null, (Type[])null);
				MethodInfo methodInfo2 = AccessTools.Method(typeof(SpawnBits), "OnPooleeEnabled", (Type[])null, (Type[])null);
				if (methodInfo != null && methodInfo2 != null)
				{
					harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
		}

		public static Task<Poolee> SpawnAsync(string barcode, Vector3 position, Quaternion rotation, Vector3 scale)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			TaskCompletionSource<Poolee> tcs = new TaskCompletionSource<Poolee>();
			try
			{
				UniTask<Poolee> val = AssetSpawner.SpawnAsync(Barcodes.Make(barcode), position, rotation, Utilities.Nil<Vector3>(), (Transform)null, false, Utilities.Nil<int>(), (Action<GameObject>)null, (Action<GameObject>)null, (Action<GameObject>)null);
				Awaiter<Poolee> awaiter = val.GetAwaiter();
				awaiter.OnCompleted(Action.op_Implicit((Action)delegate
				{
					//IL_0016: Unknown result type (might be due to invalid IL or missing references)
					//IL_001c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0037: Unknown result type (might be due to invalid IL or missing references)
					try
					{
						Poolee val2 = awaiter.GetResult();
						if (val2 == null)
						{
							val2 = FindRecentSpawn(barcode, position, rotation);
						}
						if ((Object)(object)val2 != (Object)null)
						{
							((Component)val2).transform.localScale = scale;
						}
						tcs.TrySetResult(val2);
					}
					catch (Exception exception2)
					{
						tcs.TrySetException(exception2);
					}
				}));
			}
			catch (Exception exception)
			{
				tcs.TrySetException(exception);
			}
			return tcs.Task;
		}

		public static void Clear()
		{
			lastPoolees.Clear();
		}

		private static void OnPooleeEnabled(Poolee __instance)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			SpawnableCrate spawnableCrate = __instance.SpawnableCrate;
			if (!(((spawnableCrate != null) ? ((Scannable)spawnableCrate).Barcode : null) == (Barcode)null))
			{
				lastPoolees.Add((((Scannable)__instance.SpawnableCrate).Barcode.ID, __instance));
				if (lastPoolees.Count > 1024)
				{
					lastPoolees.RemoveAt(0);
				}
			}
		}

		private static Poolee FindRecentSpawn(string barcode, Vector3 position, Quaternion rotation)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			for (int num = lastPoolees.Count - 1; num >= 0; num--)
			{
				var (text, val) = lastPoolees[num];
				if (!((Object)(object)val == (Object)null) && !((Il2CppObjectBase)val).WasCollected && !(text != barcode) && ((Component)val).transform.position == position && ((Component)val).transform.rotation == rotation)
				{
					lastPoolees.RemoveAt(num);
					return val;
				}
			}
			Poolee result = null;
			float num2 = float.PositiveInfinity;
			int num3 = -1;
			for (int num4 = lastPoolees.Count - 1; num4 >= 0; num4--)
			{
				var (text2, val2) = lastPoolees[num4];
				if (!((Object)(object)val2 == (Object)null) && !((Il2CppObjectBase)val2).WasCollected && !(text2 != barcode))
				{
					float num5 = Vector3.Distance(((Component)val2).transform.position, position);
					if (num5 < num2)
					{
						result = val2;
						num2 = num5;
						num3 = num4;
					}
				}
			}
			if (num3 >= 0)
			{
				lastPoolees.RemoveAt(num3);
			}
			return result;
		}
	}
	internal static class CrateSpawnerAwakeBlocker
	{
		private static bool _initialized;

		public static void Init(Harmony harmony)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			if (!_initialized)
			{
				_initialized = true;
				MethodInfo methodInfo = AccessTools.Method(typeof(CrateSpawner), "Awake", (Type[])null, (Type[])null);
				MethodInfo methodInfo2 = AccessTools.Method(typeof(CrateSpawnerAwakeBlocker), "BeforeAwake", (Type[])null, (Type[])null);
				if (methodInfo != null && methodInfo2 != null)
				{
					harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
		}

		private static bool BeforeAwake(CrateSpawner __instance)
		{
			try
			{
				Core current = Core.Current;
				return current == null || !current.ShouldBlockCrateSpawnerAwake(__instance);
			}
			catch
			{
				return true;
			}
		}
	}
	internal static class PooleeHooks
	{
		private static bool _initialized;

		public static void Init(Harmony harmony)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Expected O, but got Unknown
			if (!_initialized)
			{
				_initialized = true;
				MethodInfo methodInfo = AccessTools.Method(typeof(CrateSpawner), "OnPooleeSpawn", (Type[])null, (Type[])null);
				MethodInfo methodInfo2 = AccessTools.Method(typeof(PooleeHooks), "OnCrateSpawnerPooleeSpawn", (Type[])null, (Type[])null);
				if (methodInfo != null && methodInfo2 != null)
				{
					harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				MethodInfo methodInfo3 = AccessTools.Method(typeof(Poolee), "OnDespawnEvent", (Type[])null, (Type[])null);
				MethodInfo methodInfo4 = AccessTools.Method(typeof(PooleeHooks), "OnPooleeDespawnEvent", (Type[])null, (Type[])null);
				if (methodInfo3 != null && methodInfo4 != null)
				{
					harmony.Patch((MethodBase)methodInfo3, (HarmonyMethod)null, new HarmonyMethod(methodInfo4), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				MethodInfo methodInfo5 = AccessTools.Method(typeof(Poolee), "OnEnable", (Type[])null, (Type[])null);
				MethodInfo methodInfo6 = AccessTools.Method(typeof(PooleeHooks), "OnPooleeEnabled", (Type[])null, (Type[])null);
				if (methodInfo5 != null && methodInfo6 != null)
				{
					harmony.Patch((MethodBase)methodInfo5, (HarmonyMethod)null, new HarmonyMethod(methodInfo6), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
		}

		private static void OnCrateSpawnerPooleeSpawn(CrateSpawner __instance, GameObject __0)
		{
			Core.Current?.RememberSpawnerPoolee(__instance, __0);
		}

		private static void OnPooleeDespawnEvent(Poolee __instance)
		{
			Core.Current?.PooleeWentAway(__instance);
		}

		private static void OnPooleeEnabled(Poolee __instance)
		{
			Core.Current?.PooleeWokeUp(__instance);
		}
	}
	internal struct NpcRuntimeState
	{
		public bool IsDead;

		public float DamageTaken;
	}
	internal static class NpcBits
	{
		private static readonly Dictionary<IntPtr, NpcRuntimeState> healthBits = new Dictionary<IntPtr, NpcRuntimeState>();

		private static readonly Dictionary<IntPtr, NpcRuntimeState> brainBits = new Dictionary<IntPtr, NpcRuntimeState>();

		private static bool _initialized;

		public static void Init(Harmony harmony)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			if (!_initialized)
			{
				_initialized = true;
				MethodInfo methodInfo = AccessTools.Method(typeof(SubBehaviourHealth), "TakeDamage", (Type[])null, (Type[])null);
				MethodInfo methodInfo2 = AccessTools.Method(typeof(NpcBits), "OnSubBehaviourHealthTakeDamage", (Type[])null, (Type[])null);
				if (methodInfo != null && methodInfo2 != null)
				{
					harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				MethodInfo methodInfo3 = AccessTools.Method(typeof(AIBrain), "OnDeath", (Type[])null, (Type[])null);
				MethodInfo methodInfo4 = AccessTools.Method(typeof(NpcBits), "OnAIBrainDeath", (Type[])null, (Type[])null);
				if (methodInfo3 != null && methodInfo4 != null)
				{
					harmony.Patch((MethodBase)methodInfo3, (HarmonyMethod)null, new HarmonyMethod(methodInfo4), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
		}

		public static NpcRuntimeState GetState(AIBrain brain, SubBehaviourHealth health)
		{
			NpcRuntimeState target = default(NpcRuntimeState);
			if (health != null && healthBits.TryGetValue(((Il2CppObjectBase)health).Pointer, out var value))
			{
				Merge(ref target, value);
			}
			if ((Object)(object)brain != (Object)null && brainBits.TryGetValue(((Il2CppObjectBase)brain).Pointer, out var value2))
			{
				Merge(ref target, value2);
			}
			return target;
		}

		public static void Clear()
		{
			healthBits.Clear();
			brainBits.Clear();
		}

		private static void OnSubBehaviourHealthTakeDamage(SubBehaviourHealth __instance, int m, Attack attack)
		{
			if (__instance != null)
			{
				float num = 0f;
				try
				{
					num = attack.damage;
				}
				catch
				{
				}
				if (num <= 0f)
				{
					num = Mathf.Max(0f, (float)m);
				}
				if (!(num <= 0f))
				{
					Record(healthBits, ((Il2CppObjectBase)__instance).Pointer, isDead: false, num);
					Core.Current?.SceneGotTouched();
				}
			}
		}

		private static void OnAIBrainDeath(AIBrain __instance)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			Record(brainBits, ((Il2CppObjectBase)__instance).Pointer, isDead: true, 0f);
			Core.Current?.SceneGotTouched();
			try
			{
				BehaviourBaseNav behaviour = __instance.behaviour;
				SubBehaviourHealth val = ((behaviour != null) ? behaviour.health : null);
				if (val != null)
				{
					Record(healthBits, ((Il2CppObjectBase)val).Pointer, isDead: true, 0f);
				}
			}
			catch
			{
			}
		}

		private static void Record(Dictionary<IntPtr, NpcRuntimeState> bag, IntPtr key, bool isDead, float damage)
		{
			if (!(key == IntPtr.Zero))
			{
				bag.TryGetValue(key, out var value);
				value.IsDead |= isDead;
				value.DamageTaken += damage;
				bag[key] = value;
			}
		}

		private static void Merge(ref NpcRuntimeState target, NpcRuntimeState source)
		{
			target.IsDead |= source.IsDead;
			target.DamageTaken = Mathf.Max(target.DamageTaken, source.DamageTaken);
		}
	}
	internal static class JointBits
	{
		private static readonly Dictionary<ConstraintTracker, ConstraintState> jointStates = new Dictionary<ConstraintTracker, ConstraintState>(UnityObjectComparer<ConstraintTracker>.Instance);

		private static readonly Dictionary<ConstraintTracker, ConstraintMode> jointModes = new Dictionary<ConstraintTracker, ConstraintMode>(UnityObjectComparer<ConstraintTracker>.Instance);

		private static bool _initialized;

		public static void Init(Harmony harmony)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			if (_initialized)
			{
				return;
			}
			_initialized = true;
			MethodInfo methodInfo = AccessTools.Method(typeof(Constrainer), "PrimaryButtonUp", (Type[])null, (Type[])null);
			if (methodInfo != null)
			{
				MethodInfo methodInfo2 = AccessTools.Method(typeof(JointBits), "CheckConstrainerForJoint", (Type[])null, (Type[])null);
				if (methodInfo2 != null)
				{
					harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
		}

		private static void CheckConstrainerForJoint(Constrainer __instance)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: 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_00e4: 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_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: 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_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)__instance == (Object)null || (int)__instance.mode == 6)
				{
					return;
				}
				MarrowBody mb = __instance._mb1;
				if ((Object)(object)((mb != null) ? mb._rigidbody : null) == (Object)null)
				{
					MarrowBody mb2 = __instance._mb2;
					if ((Object)(object)((mb2 != null) ? mb2._rigidbody : null) == (Object)null)
					{
						return;
					}
				}
				if ((Object)(object)__instance._mb1 == (Object)(object)__instance._mb2)
				{
					return;
				}
				GameObject gO = __instance._gO1;
				ConstraintTracker val = ((gO == null) ? null : ((IEnumerable<ConstraintTracker>)gO.GetComponents<ConstraintTracker>())?.LastOrDefault());
				if (val == null)
				{
					GameObject gO2 = __instance._gO2;
					val = ((gO2 == null) ? null : ((IEnumerable<ConstraintTracker>)gO2.GetComponents<ConstraintTracker>())?.LastOrDefault());
				}
				if (val == null)
				{
					val = FindMatchingTracker(__instance);
				}
				if (!((Object)(object)val == (Object)null))
				{
					if (!val.isHost)
					{
						val = val.otherTracker;
					}
					Vector3 val2 = __instance._point1;
					Vector3 val3 = __instance._point2;
					Vector3 val4 = __instance._normal1;
					Vector3 val5 = __instance._normal2;
					if (TrackerLooksReversed(val, __instance))
					{
						Vector3 val6 = val3;
						val3 = val2;
						val2 = val6;
						Vector3 val7 = val5;
						val5 = val4;
						val4 = val7;
					}
					jointStates[val] = new ConstraintState
					{
						PointStart = val2,
						PointEnd = val3,
						NormalStart = val4,
						NormalEnd = val5
					};
					jointModes[val] = __instance.mode;
					if ((Object)(object)val.otherTracker != (Object)null)
					{
						jointStates[val.otherTracker] = jointStates[val];
						jointModes[val.otherTracker] = __instance.mode;
					}
					Core.Current?.SceneGotTouched();
				}
			}
			catch
			{
			}
		}

		private static bool TrackerLooksReversed(ConstraintTracker tracker, Constrainer constrainer)
		{
			if (!((Object)(object)tracker == (Object)null) && !((Object)(object)tracker.attachPoint == (Object)null))
			{
				ConstraintTracker otherTracker = tracker.otherTracker;
				if (!((Object)(object)((otherTracker != null) ? otherTracker.attachPoint : null) == (Object)null) && !((Object)(object)constrainer == (Object)null))
				{
					Transform trackerTransform = NormalizeAttachPoint(tracker.attachPoint);
					Transform trackerTransform2 = NormalizeAttachPoint(tracker.otherTracker.attachPoint);
					GameObject gO = constrainer._gO1;
					Transform target = ((gO != null) ? gO.transform : null);
					GameObject gO2 = constrainer._gO2;
					Transform target2 = ((gO2 != null) ? gO2.transform : null);
					if (MatchesEndpoint(trackerTransform, target2) && MatchesEndpoint(trackerTransform2, target))
					{
						return true;
					}
					if (!MatchesEndpoint(trackerTransform, target))
					{
						return MatchesEndpoint(trackerTransform, target2);
					}
					return false;
				}
			}
			return false;
		}

		private static ConstraintTracker FindMatchingTracker(Constrainer constrainer)
		{
			if ((Object)(object)constrainer == (Object)null || (Object)(object)constrainer._gO1 == (Object)null || (Object)(object)constrainer._gO2 == (Object)null)
			{
				return null;
			}
			Transform transform = constrainer._gO1.transform;
			Transform transform2 = constrainer._gO2.transform;
			ConstraintTracker result = null;
			foreach (ConstraintTracker item in Object.FindObjectsOfType<ConstraintTracker>(true))
			{
				ConstraintTracker val = item;
				if ((Object)(object)val == (Object)null || ((Il2CppObjectBase)val).WasCollected)
				{
					continue;
				}
				if (!val.isHost)
				{
					val = val.otherTracker;
				}
				if ((Object)(object)val == (Object)null || ((Il2CppObjectBase)val).WasCollected || (Object)(object)val.attachPoint == (Object)null)
				{
					continue;
				}
				ConstraintTracker otherTracker = val.otherTracker;
				if (!((Object)(object)((otherTracker != null) ? otherTracker.attachPoint : null) == (Object)null))
				{
					Transform trackerTransform = NormalizeAttachPoint(val.attachPoint);
					Transform trackerTransform2 = NormalizeAttachPoint(val.otherTracker.attachPoint);
					if ((MatchesEndpoint(trackerTransform, transform) && MatchesEndpoint(trackerTransform2, transform2)) || (MatchesEndpoint(trackerTransform, transform2) && MatchesEndpoint(trackerTransform2, transform)))
					{
						result = val;
					}
				}
			}
			return result;
		}

		private static Transform NormalizeAttachPoint(Transform transform)
		{
			if ((Object)(object)transform != (Object)null && ((Object)transform).name.StartsWith("jPt", StringComparison.Ordinal) && (Object)(object)transform.parent != (Object)null)
			{
				return transform.parent;
			}
			return transform;
		}

		private static bool MatchesEndpoint(Transform trackerTransform, Transform target)
		{
			if ((Object)(object)trackerTransform == (Object)null || (Object)(object)target == (Object)null)
			{
				return false;
			}
			if (!((Object)(object)trackerTransform == (Object)(object)target) && !((Object)(object)((Component)trackerTransform).gameObject == (Object)(object)((Component)target).gameObject) && !trackerTransform.IsChildOf(target))
			{
				return target.IsChildOf(trackerTransform);
			}
			return true;
		}

		public static bool TryGetStateWhenSpawned(ConstraintTracker tracker, out ConstraintState state)
		{
			return jointStates.TryGetValue(tracker, out state);
		}

		public static ConstraintMode GetModeWhenSpawned(ConstraintTracker tracker, ConstraintMode fallback)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!jointModes.TryGetValue(tracker, out var value))
			{
				return fallback;
			}
			return value;
		}

		public static void Clear()
		{
			jointStates.Clear();
			jointModes.Clear();
		}
	}
	internal static class LevelHooks
	{
		private static bool _initialized;

		public static void Init(Harmony harmony)
		{
			if (!_initialized)
			{
				_initialized = true;
				MethodInfo methodInfo = AccessTools.Method(typeof(LevelHooks), "BeforeLoad", (Type[])null, (Type[])null);
				if (!(methodInfo == null))
				{
					Patch(harmony, AccessTools.Method(typeof(SceneStreamer), "Reload", (Type[])null, (Type[])null), methodInfo);
					Patch(harmony, AccessTools.Method(typeof(SceneStreamer), "Load", new Type[2]
					{
						typeof(Barcode),
						typeof(Barcode)
					}, (Type[])null), methodInfo);
					Patch(harmony, AccessTools.Method(typeof(SceneStreamer), "Load", new Type[2]
					{
						typeof(LevelCrateReference),
						typeof(LevelCrateReference)
					}, (Type[])null), methodInfo);
				}
			}
		}

		private static void Patch(Harmony harmony, MethodInfo original, MethodInfo prefix)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			if (!(original == null))
			{
				harmony.Patch((MethodBase)original, new HarmonyMethod(prefix), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		private static void BeforeLoad()
		{
			try
			{
				Core.Current?.SaveBeforeSceneStreamerLoad("scene streamer load");
			}
			catch
			{
			}
		}
	}
	internal static class HolodeckBits
	{
		private static readonly Dictionary<IntPtr, int> mats = new Dictionary<IntPtr, int>();

		private static readonly Dictionary<IntPtr, bool> doors = new Dictionary<IntPtr, bool>();

		private static bool ready;

		public static void Init(Harmony harmony)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			if (!ready)
			{
				ready = true;
				MethodInfo methodInfo = AccessTools.Method(typeof(GameControl_Holodeck), "SELECTMATERIAL", (Type[])null, (Type[])null);
				MethodInfo methodInfo2 = AccessTools.Method(typeof(HolodeckBits), "AfterSelect", (Type[])null, (Type[])null);
				if (methodInfo != null && methodInfo2 != null)
				{
					harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				MethodInfo methodInfo3 = AccessTools.Method(typeof(GameControl_Holodeck), "TOGGLEDOOR", (Type[])null, (Type[])null);
				MethodInfo methodInfo4 = AccessTools.Method(typeof(HolodeckBits), "AfterDoor", (Type[])null, (Type[])null);
				if (methodInfo3 != null && methodInfo4 != null)
				{
					harmony.Patch((MethodBase)methodInfo3, (HarmonyMethod)null, new HarmonyMethod(methodInfo4), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
		}

		public static void Clear()
		{
			mats.Clear();
			doors.Clear();
		}

		public static bool TryMat(GameControl_Holodeck deck, out int value)
		{
			value = 0;
			if ((Object)(object)deck != (Object)null)
			{
				return mats.TryGetValue(((Il2CppObjectBase)deck).Pointer, out value);
			}
			return false;
		}

		public static bool TryDoor(GameControl_Holodeck deck, out bool value)
		{
			value = false;
			if ((Object)(object)deck != (Object)null)
			{
				return doors.TryGetValue(((Il2CppObjectBase)deck).Pointer, out value);
			}
			return false;
		}

		private static void AfterSelect(GameControl_Holodeck __instance, int i)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				mats[((Il2CppObjectBase)__instance).Pointer] = i;
			}
		}

		private static void AfterDoor(GameControl_Holodeck __instance)
		{
			if (!((Object)(object)((__instance != null) ? __instance.doorHide : null) == (Object)null))
			{
				doors[((Il2CppObjectBase)__instance).Pointer] = __instance.doorHide.activeSelf;
			}
		}
	}
}