using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Dawn;
using Dawn.Interfaces;
using Dawn.Internal;
using Dawn.Utils;
using DunGen;
using DunGen.Adapters;
using DunGen.Graph;
using DunGenPlus;
using GameNetcodeStuff;
using GoodItemScan;
using HarmonyLib;
using IL;
using IL.GameNetcodeStuff;
using LethalConfig.AutoConfig;
using LethalConfig.ConfigItems;
using LethalLevelLoader;
using LethalLib.Modules;
using LethalQuantities.Objects;
using LethalQuantities.Patches;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using MrovLib.Events;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using On;
using On.BepInEx.Configuration;
using On.DunGen;
using On.TMPro;
using On.Unity.Netcode;
using PathfindingLib.API.SmartPathfinding;
using Steamworks;
using TMPro;
using TerminalFormatter.Nodes;
using Unity.Netcode;
using Unity.Netcode.Components;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Audio;
using UnityEngine.Events;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.Pool;
using UnityEngine.Rendering.HighDefinition;
using UnityEngine.SceneManagement;
using UnityEngine.Serialization;
using UnityEngine.UI;
using WeatherRegistry;
using com.github.teamxiaolan.dawnlib.NetcodePatcher;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("com.github.teamxiaolan.dawnlib.dusk")]
[assembly: IgnoresAccessChecksTo("AmazingAssets.TerrainToMesh")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp-firstpass")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("ClientNetworkTransform")]
[assembly: IgnoresAccessChecksTo("com.olegknyazev.softmask")]
[assembly: IgnoresAccessChecksTo("DissonanceVoip")]
[assembly: IgnoresAccessChecksTo("DunGen")]
[assembly: IgnoresAccessChecksTo("DunGen.Integration.ASPP")]
[assembly: IgnoresAccessChecksTo("DunGen.Integration.UnityNav")]
[assembly: IgnoresAccessChecksTo("DunGenPlus")]
[assembly: IgnoresAccessChecksTo("EasyTextEffects")]
[assembly: IgnoresAccessChecksTo("Facepunch Transport for Netcode for GameObjects")]
[assembly: IgnoresAccessChecksTo("Facepunch.Steamworks.Win64")]
[assembly: IgnoresAccessChecksTo("GoodItemScan")]
[assembly: IgnoresAccessChecksTo("LethalConfig")]
[assembly: IgnoresAccessChecksTo("LethalLevelLoader")]
[assembly: IgnoresAccessChecksTo("LethalLib")]
[assembly: IgnoresAccessChecksTo("LethalQuantities")]
[assembly: IgnoresAccessChecksTo("MMHOOK_Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("MMHOOK_BepInEx")]
[assembly: IgnoresAccessChecksTo("MMHOOK_BepInEx.Preloader")]
[assembly: IgnoresAccessChecksTo("MMHOOK_DunGen")]
[assembly: IgnoresAccessChecksTo("MMHOOK_Unity.Netcode.Runtime")]
[assembly: IgnoresAccessChecksTo("MMHOOK_Unity.TextMeshPro")]
[assembly: IgnoresAccessChecksTo("MMHOOK_UnityEngine.CoreModule")]
[assembly: IgnoresAccessChecksTo("MrovLib")]
[assembly: IgnoresAccessChecksTo("StarlancerAI")]
[assembly: IgnoresAccessChecksTo("Unity.AI.Navigation")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging.DocCodeExamples")]
[assembly: IgnoresAccessChecksTo("Unity.Burst")]
[assembly: IgnoresAccessChecksTo("Unity.Burst.Unsafe")]
[assembly: IgnoresAccessChecksTo("Unity.Collections")]
[assembly: IgnoresAccessChecksTo("Unity.Collections.LowLevel.ILSupport")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem.ForUI")]
[assembly: IgnoresAccessChecksTo("Unity.Jobs")]
[assembly: IgnoresAccessChecksTo("Unity.Mathematics")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.Common")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.MetricTypes")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStats")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Component")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Implementation")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsReporting")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkProfiler.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkSolutionInterface")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Networking.Transport")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Csg")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.KdTree")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Poly2Tri")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Stl")]
[assembly: IgnoresAccessChecksTo("Unity.Profiling.Core")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.ShaderLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Config.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.ShaderGraph.ShaderGraphLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Authentication")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Analytics")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Device")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Networking")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Registration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Scheduler")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Telemetry")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Threading")]
[assembly: IgnoresAccessChecksTo("Unity.Services.QoS")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Relay")]
[assembly: IgnoresAccessChecksTo("Unity.TextMeshPro")]
[assembly: IgnoresAccessChecksTo("Unity.Timeline")]
[assembly: IgnoresAccessChecksTo("Unity.VisualEffectGraph.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.XR.CoreUtils")]
[assembly: IgnoresAccessChecksTo("Unity.XR.Management")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR.Features.ConformanceAutomation")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR.Features.MetaQuestSupport")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR.Features.MockRuntime")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR.Features.OculusQuestSupport")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR.Features.RuntimeDebugger")]
[assembly: IgnoresAccessChecksTo("UnityEngine.ARModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.NVIDIAModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.SpatialTracking")]
[assembly: IgnoresAccessChecksTo("UnityEngine.UI")]
[assembly: IgnoresAccessChecksTo("UnityEngine.XR.LegacyInputHelpers")]
[assembly: IgnoresAccessChecksTo("WeatherRegistry")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("XuXiaolan,loaforc")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("A modern API for Lethal Company content and all sizes of mods.")]
[assembly: AssemblyFileVersion("0.9.12.0")]
[assembly: AssemblyInformationalVersion("0.9.12+f11bddf4b9fdcd9f76adee794e9e867ff12f8841")]
[assembly: AssemblyProduct("DawnLib")]
[assembly: AssemblyTitle("com.github.teamxiaolan.dawnlib")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.9.12.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
[CompilerGenerated]
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Length;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => _items.Length;

	T IReadOnlyList<T>.this[int index] => _items[index];

	int ICollection<T>.Count => _items.Length;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlyArray(T[] items)
	{
		_items = items;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return ((IEnumerable)_items).GetEnumerator();
	}

	void ICollection.CopyTo(Array array, int index)
	{
		((ICollection)_items).CopyTo(array, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return ((IList)_items).Contains(value);
	}

	int IList.IndexOf(object value)
	{
		return ((IList)_items).IndexOf(value);
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return ((IEnumerable<T>)_items).GetEnumerator();
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return ((ICollection<T>)_items).Contains(item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		((ICollection<T>)_items).CopyTo(array, arrayIndex);
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return ((IList<T>)_items).IndexOf(item);
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlySingleElementList<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	private sealed class Enumerator : IDisposable, IEnumerator, IEnumerator<T>
	{
		object IEnumerator.Current => _item;

		T IEnumerator<T>.Current => _item;

		public Enumerator(T item)
		{
			_item = item;
		}

		bool IEnumerator.MoveNext()
		{
			if (!_moveNextCalled)
			{
				return _moveNextCalled = true;
			}
			return false;
		}

		void IEnumerator.Reset()
		{
			_moveNextCalled = false;
		}

		void IDisposable.Dispose()
		{
		}
	}

	int ICollection.Count => 1;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => 1;

	T IReadOnlyList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
	}

	int ICollection<T>.Count => 1;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlySingleElementList(T item)
	{
		_item = item;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return new Enumerator(_item);
	}

	void ICollection.CopyTo(Array array, int index)
	{
		array.SetValue(_item, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return EqualityComparer<T>.Default.Equals(_item, (T)value);
	}

	int IList.IndexOf(object value)
	{
		if (!EqualityComparer<T>.Default.Equals(_item, (T)value))
		{
			return -1;
		}
		return 0;
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return new Enumerator(_item);
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return EqualityComparer<T>.Default.Equals(_item, item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		array[arrayIndex] = _item;
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		if (!EqualityComparer<T>.Default.Equals(_item, item))
		{
			return -1;
		}
		return 0;
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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;
		}
	}
}
public sealed class Vector3Converter : JsonConverter<Vector3>
{
	public override void WriteJson(JsonWriter writer, Vector3 value, JsonSerializer serializer)
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		writer.WriteStartObject();
		writer.WritePropertyName("x");
		writer.WriteValue(value.x);
		writer.WritePropertyName("y");
		writer.WriteValue(value.y);
		writer.WritePropertyName("z");
		writer.WriteValue(value.z);
		writer.WriteEndObject();
	}

	public override Vector3 ReadJson(JsonReader reader, Type objectType, Vector3 existingValue, bool hasExistingValue, JsonSerializer serializer)
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Invalid comparison between Unknown and I4
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_009c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Invalid comparison between Unknown and I4
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Invalid comparison between Unknown and I4
		float num = 0f;
		float num2 = 0f;
		float num3 = 0f;
		if ((int)reader.TokenType != 1)
		{
			throw new JsonSerializationException("Expected StartObject for Vector3");
		}
		while (reader.Read() && (int)reader.TokenType != 13)
		{
			if ((int)reader.TokenType == 4)
			{
				string text = (string)reader.Value;
				reader.Read();
				switch (text)
				{
				case "x":
					num = Convert.ToSingle(reader.Value);
					break;
				case "y":
					num2 = Convert.ToSingle(reader.Value);
					break;
				case "z":
					num3 = Convert.ToSingle(reader.Value);
					break;
				}
			}
		}
		return new Vector3(num, num2, num3);
	}
}
public class DawnMapObjectNamespacedKeyContainer : MonoBehaviour
{
	[field: SerializeField]
	public NamespacedKey Value { get; internal set; }

	public DawnMapObjectInfo GetDawnMapObjectInfo()
	{
		return LethalContent.MapObjects[Value.AsTyped<DawnMapObjectInfo>()];
	}
}
public class DawnStoryLogNamespacedKeyContainer : MonoBehaviour
{
	[field: SerializeField]
	public NamespacedKey Value { get; internal set; }
}
namespace Dawn
{
	public abstract class BaseInfoBuilder
	{
		internal abstract void SoloAddTags(IEnumerable<NamespacedKey> newTags);
	}
	public abstract class BaseInfoBuilder<TInfo, T, TBuilder> : BaseInfoBuilder where TInfo : INamespaced<TInfo> where TBuilder : BaseInfoBuilder<TInfo, T, TBuilder>
	{
		protected HashSet<NamespacedKey> tags = new HashSet<NamespacedKey>();

		protected IDataContainer? customData;

		protected NamespacedKey<TInfo> key { get; private set; }

		protected T value { get; private set; }

		internal BaseInfoBuilder(NamespacedKey<TInfo> key, T value)
		{
			this.key = key;
			this.value = value;
		}

		public TBuilder AddTag(NamespacedKey tag)
		{
			tags.Add(tag);
			return (TBuilder)this;
		}

		public TBuilder AddTags(IEnumerable<NamespacedKey> newTags)
		{
			foreach (NamespacedKey newTag in newTags)
			{
				AddTag(newTag);
			}
			return (TBuilder)this;
		}

		internal override void SoloAddTags(IEnumerable<NamespacedKey> newTags)
		{
			AddTags(newTags);
		}

		public TBuilder EditCustomData(Action<IDataContainer> callback)
		{
			if (customData == null)
			{
				customData = new DataContainer();
			}
			callback(customData);
			return (TBuilder)this;
		}

		internal abstract TInfo Build();
	}
	[JsonObject(/*Could not decode attribute arguments.*/)]
	public class DataContainer : IDataContainer
	{
		private class NoOpDisposable : IDisposable
		{
			public void Dispose()
			{
			}
		}

		[JsonProperty]
		protected Dictionary<NamespacedKey, object> dictionary = new Dictionary<NamespacedKey, object>();

		public IEnumerable<NamespacedKey> Keys => dictionary.Keys;

		public int Count => dictionary.Count;

		public bool Has(NamespacedKey key)
		{
			return dictionary.ContainsKey(key);
		}

		public bool TryGet<T>(NamespacedKey key, [NotNullWhen(true)] out T? value)
		{
			if (dictionary.TryGetValue(key, out object value2))
			{
				JToken val = (JToken)((value2 is JToken) ? value2 : null);
				if (val != null)
				{
					value = val.ToObject<T>();
					return true;
				}
				if (value2 is T val2)
				{
					value = val2;
					return true;
				}
				if (typeof(T) == typeof(int) && value2 is long num)
				{
					value = (T)(object)(int)num;
					return true;
				}
				if (typeof(T) == typeof(long) && value2 is int num2)
				{
					value = (T)(object)(long)num2;
					return true;
				}
				throw new InvalidCastException($"type of '{key}' is {value2.GetType().Name} which can not be {typeof(T).Name}");
			}
			value = default(T);
			return false;
		}

		public T GetOrSetDefault<T>(NamespacedKey key, T defaultValue)
		{
			if (TryGet<T>(key, out T value))
			{
				return value;
			}
			Set(key, defaultValue);
			return defaultValue;
		}

		public T GetOrCreateDefault<T>(NamespacedKey key) where T : new()
		{
			if (TryGet<T>(key, out T value))
			{
				return value;
			}
			value = new T();
			Set(key, value);
			return value;
		}

		public virtual void Set<T>(NamespacedKey key, T value)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			dictionary[key] = value;
		}

		public virtual void Remove(NamespacedKey key)
		{
			dictionary.Remove(key);
		}

		public virtual void Clear()
		{
			dictionary.Clear();
		}

		public virtual void MarkDirty()
		{
		}

		public virtual IDisposable CreateEditContext()
		{
			return new NoOpDisposable();
		}

		public bool Has<T>(NamespacedKey key)
		{
			if (dictionary.ContainsKey(key))
			{
				return dictionary[key] is T;
			}
			return false;
		}
	}
	public class FrozenEmptyDataContainer : IDataContainer
	{
		public static FrozenEmptyDataContainer Instance { get; private set; } = new FrozenEmptyDataContainer();


		public IEnumerable<NamespacedKey> Keys { get; } = Array.Empty<NamespacedKey>();


		public int Count => 0;

		private FrozenEmptyDataContainer()
		{
		}

		public bool TryGet<T>(NamespacedKey key, [NotNullWhen(true)] out T? value)
		{
			value = default(T);
			return false;
		}

		public T GetOrSetDefault<T>(NamespacedKey key, T defaultValue)
		{
			throw new RegistryFrozenException();
		}

		public T GetOrCreateDefault<T>(NamespacedKey key) where T : new()
		{
			throw new RegistryFrozenException();
		}

		public void Set<T>(NamespacedKey key, T value)
		{
			throw new RegistryFrozenException();
		}

		public void Remove(NamespacedKey key)
		{
			throw new RegistryFrozenException();
		}

		public void Clear()
		{
			throw new RegistryFrozenException();
		}

		public void MarkDirty()
		{
			throw new RegistryFrozenException();
		}

		public IDisposable CreateEditContext()
		{
			throw new RegistryFrozenException();
		}

		public bool Has<T>(NamespacedKey key)
		{
			throw new NotImplementedException();
		}
	}
	public interface IDataContainer
	{
		IEnumerable<NamespacedKey> Keys { get; }

		int Count { get; }

		bool Has<T>(NamespacedKey key);

		bool TryGet<T>(NamespacedKey key, [NotNullWhen(true)] out T? value);

		T GetOrSetDefault<T>(NamespacedKey key, T defaultValue);

		T GetOrCreateDefault<T>(NamespacedKey key) where T : new();

		void Set<T>(NamespacedKey key, T value);

		void Remove(NamespacedKey key);

		void Clear();

		void MarkDirty();

		IDisposable CreateEditContext();
	}
	public interface INamespaced
	{
		NamespacedKey Key { get; }
	}
	public interface INamespaced<T> : INamespaced where T : INamespaced<T>
	{
		NamespacedKey<T> TypedKey { get; }
	}
	public class JSONTagDefinition
	{
		public string Tag;

		public string[] Values;
	}
	[Serializable]
	public class NamespacedKey : INetworkSerializable
	{
		private static readonly Regex NamespacedKeyRegex = new Regex("[?!.\\n\\t\"`\\[\\]'-]");

		private static readonly Dictionary<string, NamespacedKey> CanonicalByFull = new Dictionary<string, NamespacedKey>(StringComparer.Ordinal);

		private static readonly Dictionary<string, NamespacedKey> CanonicalByKey = new Dictionary<string, NamespacedKey>(StringComparer.Ordinal);

		private static readonly Dictionary<string, List<NamespacedKey>> SmartPlaceholdersByKey = new Dictionary<string, List<NamespacedKey>>(StringComparer.Ordinal);

		private static readonly Dictionary<char, string> NumberWords = new Dictionary<char, string>
		{
			{ '0', "Zero" },
			{ '1', "One" },
			{ '2', "Two" },
			{ '3', "Three" },
			{ '4', "Four" },
			{ '5', "Five" },
			{ '6', "Six" },
			{ '7', "Seven" },
			{ '8', "Eight" },
			{ '9', "Nine" }
		};

		public const char Separator = ':';

		public const string VanillaNamespace = "lethal_company";

		public const string SmartMatchingNamespace = "smart_matching";

		[SerializeField]
		private string _namespace;

		[SerializeField]
		private string _key;

		public string Namespace => _namespace;

		public string Key => _key;

		public ulong NetworkID => ComputeStableHash64(ToString());

		private static void PromoteSmartPlaceholders(string key, string newNamespace)
		{
			if (!SmartPlaceholdersByKey.TryGetValue(key, out List<NamespacedKey> value) || value.Count == 0)
			{
				return;
			}
			foreach (NamespacedKey item in value)
			{
				if (item._namespace == "smart_matching")
				{
					Debuggers.NamespacedKeys?.Log($"Promoting placeholder {item} to {newNamespace}");
					item._namespace = newNamespace;
				}
			}
		}

		internal static string NormalizeStringForNamespacedKey(string input, bool CSharpName)
		{
			if (string.IsNullOrWhiteSpace(input))
			{
				return string.Empty;
			}
			string text = NamespacedKeyRegex.Replace(input, string.Empty);
			StringBuilder stringBuilder = new StringBuilder(text.Length);
			bool flag = false;
			string text2 = text;
			foreach (char c in text2)
			{
				if (flag || (!char.IsDigit(c) && c != ' '))
				{
					flag = true;
					stringBuilder.Append(c);
				}
			}
			StringBuilder stringBuilder2 = new StringBuilder(stringBuilder.Length);
			string text3 = stringBuilder.ToString();
			foreach (char c2 in text3)
			{
				if (NumberWords.TryGetValue(c2, out string value))
				{
					stringBuilder2.Append(value);
				}
				else
				{
					stringBuilder2.Append(c2);
				}
			}
			string text4 = stringBuilder2.ToString();
			if (CSharpName)
			{
				text4 = text4.Replace(" ", string.Empty);
				text4 = text4.Replace("_", string.Empty);
				return text4.ToCapitalized();
			}
			return text4.ToLowerInvariant().Replace(" ", "_");
		}

		private static string BuildFullKey(string @namespace, string key)
		{
			return $"{@namespace}{':'}{key}";
		}

		private static bool ShouldReplaceCandidate(NamespacedKey existing, NamespacedKey candidate)
		{
			if (existing.Namespace == "smart_matching" && candidate.Namespace != "smart_matching")
			{
				return true;
			}
			if (candidate.Namespace == "lethal_company" && existing.Namespace != "lethal_company")
			{
				return true;
			}
			return false;
		}

		private static void Register(NamespacedKey key)
		{
			string key2 = BuildFullKey(key.Namespace, key.Key);
			CanonicalByFull.TryAdd(key2, key);
			NamespacedKey value2;
			if (key.Namespace == "smart_matching")
			{
				if (!SmartPlaceholdersByKey.TryGetValue(key.Key, out List<NamespacedKey> value))
				{
					value = new List<NamespacedKey>();
					SmartPlaceholdersByKey[key.Key] = value;
				}
				value.Add(key);
				if (!CanonicalByKey.ContainsKey(key.Key))
				{
					CanonicalByKey[key.Key] = key;
				}
			}
			else if (CanonicalByKey.TryGetValue(key.Key, out value2))
			{
				if (ShouldReplaceCandidate(value2, key))
				{
					CanonicalByKey[key.Key] = key;
					PromoteSmartPlaceholders(key.Key, key.Namespace);
				}
			}
			else
			{
				CanonicalByKey[key.Key] = key;
				PromoteSmartPlaceholders(key.Key, key.Namespace);
			}
		}

		private static bool TrySmartResolveByKey(string normalizedKey, [NotNullWhen(true)] out NamespacedKey? match)
		{
			match = null;
			if (CanonicalByKey.TryGetValue(normalizedKey, out NamespacedKey value))
			{
				match = value;
				return true;
			}
			return false;
		}

		protected NamespacedKey(string @namespace, string key)
		{
			_namespace = NormalizeStringForNamespacedKey(@namespace, CSharpName: false);
			_key = NormalizeStringForNamespacedKey(key, CSharpName: false);
			Register(this);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public NamespacedKey()
		{
		}

		public static NamespacedKey From(string @namespace, string key)
		{
			return new NamespacedKey(@namespace, key);
		}

		public static NamespacedKey Vanilla(string key)
		{
			return From("lethal_company", key);
		}

		public static NamespacedKey Parse(string input)
		{
			if (string.IsNullOrWhiteSpace(input))
			{
				throw new ArgumentException("Input cannot be null or empty.", "input");
			}
			string[] array = input.Split(':');
			if (array.Length != 2 || string.IsNullOrWhiteSpace(array[0]) || string.IsNullOrWhiteSpace(array[1]))
			{
				throw new FormatException($"Invalid namespaced key '{input}'. Expected 'namespace{':'}key'.");
			}
			return From(array[0], array[1]);
		}

		public static bool TryParse(string input, [NotNullWhen(true)] out NamespacedKey? result)
		{
			result = null;
			if (string.IsNullOrWhiteSpace(input))
			{
				return false;
			}
			string[] array = input.Split(':');
			if (array.Length != 2 || string.IsNullOrWhiteSpace(array[0]) || string.IsNullOrWhiteSpace(array[1]))
			{
				return false;
			}
			result = From(array[0], array[1]);
			return true;
		}

		public static NamespacedKey ForceParse(string input)
		{
			return ForceParse(input, useSmartMatching: false);
		}

		public static NamespacedKey ForceParse(string input, bool useSmartMatching)
		{
			if (string.IsNullOrWhiteSpace(input))
			{
				throw new ArgumentException("Input cannot be null or empty.", "input");
			}
			string[] array = input.Split(':');
			if (array.Length == 2)
			{
				return From(array[0], array[1]);
			}
			string input2 = array[0];
			string text = NormalizeStringForNamespacedKey(input2, CSharpName: false);
			if (useSmartMatching)
			{
				if (TrySmartResolveByKey(text, out NamespacedKey match))
				{
					return match;
				}
				return From("smart_matching", text);
			}
			return From("lethal_company", text);
		}

		public override string ToString()
		{
			return BuildFullKey(Namespace, Key);
		}

		public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
		{
			serializer.SerializeValue(ref _namespace, false);
			serializer.SerializeValue(ref _key, false);
		}

		public override bool Equals(object? obj)
		{
			if (this == obj)
			{
				return true;
			}
			if (!(obj is NamespacedKey namespacedKey))
			{
				return false;
			}
			if (string.Equals(Namespace, namespacedKey.Namespace, StringComparison.Ordinal))
			{
				return string.Equals(Key, namespacedKey.Key, StringComparison.Ordinal);
			}
			return false;
		}

		private static ulong ComputeStableHash64(string value)
		{
			ulong num = 14695981039346656037uL;
			byte[] bytes = Encoding.UTF8.GetBytes(value);
			byte[] array = bytes;
			foreach (byte b in array)
			{
				num ^= b;
				num *= 1099511628211L;
			}
			return num;
		}

		public override int GetHashCode()
		{
			int num = 13;
			num = num * 17 + (Namespace?.GetHashCode() ?? 0);
			return num * 17 + (Key?.GetHashCode() ?? 0);
		}

		public NamespacedKey<T> AsTyped<T>() where T : INamespaced
		{
			return NamespacedKey<T>.From(Namespace, Key);
		}

		public bool IsVanilla()
		{
			return Namespace == "lethal_company";
		}

		public bool IsModded()
		{
			return !IsVanilla();
		}
	}
	[Serializable]
	public class NamespacedKey<T> : NamespacedKey where T : INamespaced
	{
		protected NamespacedKey(string @namespace, string key)
			: base(@namespace, key)
		{
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public NamespacedKey()
		{
		}

		public new static NamespacedKey<T> From(string @namespace, string key)
		{
			return new NamespacedKey<T>(@namespace, key);
		}

		public new static NamespacedKey<T> Vanilla(string key)
		{
			return From("lethal_company", key);
		}

		public new static NamespacedKey<T> Parse(string input)
		{
			if (string.IsNullOrWhiteSpace(input))
			{
				throw new ArgumentException("Input cannot be null or empty.", "input");
			}
			string[] array = input.Split(':');
			if (array.Length != 2 || string.IsNullOrWhiteSpace(array[0]) || string.IsNullOrWhiteSpace(array[1]))
			{
				throw new FormatException($"Invalid namespaced key '{input}'. Expected 'namespace{':'}key'.");
			}
			return From(array[0], array[1]);
		}
	}
	public class NamespacedKeyConverter : JsonConverter
	{
		public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
		{
			if (value is NamespacedKey namespacedKey)
			{
				writer.WriteValue(namespacedKey.ToString());
			}
			else
			{
				writer.WriteNull();
			}
		}

		public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			if ((int)reader.TokenType == 11)
			{
				return null;
			}
			string text = reader.Value?.ToString();
			if (text == null)
			{
				return null;
			}
			NamespacedKey namespacedKey = NamespacedKey.ForceParse(text);
			if (objectType == typeof(NamespacedKey))
			{
				return namespacedKey;
			}
			if (objectType.IsGenericType && objectType.GetGenericTypeDefinition() == typeof(NamespacedKey<>))
			{
				MethodInfo method = typeof(NamespacedKey).GetMethod("AsTyped");
				MethodInfo methodInfo = method.MakeGenericMethod(objectType.GetGenericArguments()[0]);
				return methodInfo.Invoke(namespacedKey, null);
			}
			throw new JsonSerializationException($"Cannot deserialize {objectType}");
		}

		public override bool CanConvert(Type objectType)
		{
			if (objectType == typeof(NamespacedKey))
			{
				return true;
			}
			if (objectType.IsGenericType && objectType.GetGenericTypeDefinition() == typeof(NamespacedKey<>))
			{
				return true;
			}
			return false;
		}
	}
	public class NamespacedKeyDictionaryConverter : JsonConverter
	{
		public override bool CanConvert(Type objectType)
		{
			if (objectType.IsGenericType && objectType.GetGenericTypeDefinition() == typeof(Dictionary<, >))
			{
				return objectType.GetGenericArguments()[0] == typeof(NamespacedKey);
			}
			return false;
		}

		public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
		{
			writer.WriteStartObject();
			IDictionary dictionary = (IDictionary)value;
			List<object> list = new List<object>();
			foreach (object key in dictionary.Keys)
			{
				list.Add(key);
			}
			foreach (object item in list)
			{
				NamespacedKey namespacedKey = (NamespacedKey)item;
				object obj = dictionary[item];
				writer.WritePropertyName(namespacedKey.ToString());
				serializer.Serialize(writer, obj);
			}
			writer.WriteEndObject();
		}

		public override object ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
		{
			Type type = objectType.GetGenericArguments()[1];
			Type type2 = typeof(Dictionary<, >).MakeGenericType(typeof(NamespacedKey), type);
			IDictionary dictionary = (IDictionary)Activator.CreateInstance(type2);
			JObject val = JObject.Load(reader);
			foreach (JProperty item in val.Properties())
			{
				NamespacedKey key = NamespacedKey.ForceParse(item.Name);
				object value = item.Value.ToObject(type, serializer);
				dictionary[key] = value;
			}
			return dictionary;
		}
	}
	public class PersistentDataContainer : DataContainer
	{
		public class EditContext : IDisposable
		{
			private PersistentDataContainer _container;

			private bool _prevAutoSave;

			public EditContext(PersistentDataContainer container)
			{
				_container = container;
				_prevAutoSave = _container.AutoSave;
				_container.AutoSave = false;
			}

			public void Dispose()
			{
				_container.AutoSave = _prevAutoSave;
				_container.MarkDirty();
			}
		}

		private string _filePath;

		private readonly SemaphoreSlim _saveLock = new SemaphoreSlim(1, 1);

		public bool AutoSave { get; private set; } = true;


		internal static List<PersistentDataContainer> HasCorruptedData { get; private set; } = new List<PersistentDataContainer>();


		public string FileName => Path.GetFileName(_filePath);

		public PersistentDataContainer(string filePath)
		{
			Debuggers.PersistentDataContainer?.Log("new PersistentDataContainer: " + Path.GetFileName(filePath));
			_filePath = filePath;
			if (!File.Exists(filePath))
			{
				return;
			}
			Debuggers.PersistentDataContainer?.Log("loading existing file");
			try
			{
				dictionary = JsonConvert.DeserializeObject<Dictionary<NamespacedKey, object>>(File.ReadAllText(_filePath), DawnLib.JSONSettings);
			}
			catch (Exception arg)
			{
				DawnPlugin.Logger.LogFatal((object)$"Exception when loading from persistent data container ({Path.GetFileName(_filePath)}):\n{arg}");
				HasCorruptedData.Add(this);
				return;
			}
			if (dictionary == null)
			{
				DawnPlugin.Logger.LogFatal((object)("Failure when loading from persistent data container (" + Path.GetFileName(_filePath) + "), file likely corrupted, please delete."));
				HasCorruptedData.Add(this);
				return;
			}
			foreach (object value in dictionary.Values)
			{
				if (value is ChildPersistentDataContainer childPersistentDataContainer)
				{
					Debuggers.PersistentDataContainer?.Log(string.Format("updated parent for a loaded persistent data container. count = {0}: {1}", childPersistentDataContainer.Count, string.Join(", ", childPersistentDataContainer.Keys.Select((NamespacedKey it) => it.ToString()))));
					childPersistentDataContainer.Internal_SetParent(this);
				}
			}
			Debuggers.PersistentDataContainer?.Log($"loaded {dictionary.Count} entries.");
		}

		public override void Set<T>(NamespacedKey key, T value)
		{
			if (value is IDataContainer && !(value is ChildPersistentDataContainer))
			{
				throw new NotSupportedException($"{key} is a {value.GetType().Name}, which is not supported by persistent data container. Only ChildPersistentDataContainer is supported.");
			}
			if ((object)value is ChildPersistentDataContainer childPersistentDataContainer && childPersistentDataContainer.Parent != this)
			{
				throw new NotSupportedException($"{key} is a child persistent data container being added to '{FileName}' when it belongs to '{childPersistentDataContainer.Parent.FileName}'.");
			}
			base.Set(key, value);
			if (AutoSave)
			{
				Task.Run((Func<Task?>)SaveAsync);
			}
		}

		public override void Clear()
		{
			base.Clear();
			if (AutoSave)
			{
				MarkDirty();
			}
		}

		public override void Remove(NamespacedKey key)
		{
			base.Remove(key);
			if (AutoSave)
			{
				MarkDirty();
			}
		}

		[Obsolete("Use CreateEditContext()")]
		public IDisposable LargeEdit()
		{
			return CreateEditContext();
		}

		public override IDisposable CreateEditContext()
		{
			return new EditContext(this);
		}

		public override void MarkDirty()
		{
			Task.Run((Func<Task?>)SaveAsync);
		}

		private async Task SaveAsync()
		{
			Debuggers.PersistentDataContainer?.Log("saving (" + Path.GetFileName(_filePath) + ")");
			await _saveLock.WaitAsync().ConfigureAwait(continueOnCapturedContext: false);
			try
			{
				FileStream stream = new FileStream(_filePath, FileMode.Create, FileAccess.Write, FileShare.None, 4096, useAsync: true);
				try
				{
					StreamWriter writer = new StreamWriter(stream, Encoding.UTF8);
					try
					{
						string value = JsonConvert.SerializeObject((object)dictionary, DawnLib.JSONSettings);
						await writer.WriteAsync(value).ConfigureAwait(continueOnCapturedContext: false);
						await writer.FlushAsync().ConfigureAwait(continueOnCapturedContext: false);
						await stream.FlushAsync().ConfigureAwait(continueOnCapturedContext: false);
						Debuggers.PersistentDataContainer?.Log("saved (" + Path.GetFileName(_filePath) + ")");
					}
					finally
					{
						if (writer != null)
						{
							await writer.DisposeAsync();
						}
					}
				}
				finally
				{
					if (stream != null)
					{
						await stream.DisposeAsync();
					}
				}
			}
			catch (Exception arg)
			{
				DawnPlugin.Logger.LogError((object)$"Error happened while trying to save PersistentDataContainer ({Path.GetFileName(_filePath)}):\n{arg}");
			}
			finally
			{
				_saveLock.Release();
			}
		}

		internal void DeleteFile()
		{
			File.Delete(_filePath);
		}
	}
	public class ChildPersistentDataContainer : DataContainer
	{
		public PersistentDataContainer Parent { get; private set; }

		internal ChildPersistentDataContainer()
		{
		}

		public ChildPersistentDataContainer(PersistentDataContainer parent)
		{
			Parent = parent;
		}

		public override void MarkDirty()
		{
			if (Parent.AutoSave)
			{
				Parent.MarkDirty();
			}
		}

		public override IDisposable CreateEditContext()
		{
			return Parent.CreateEditContext();
		}

		internal void Internal_SetParent(PersistentDataContainer parent)
		{
			Parent = parent;
		}
	}
	public abstract class DawnBaseInfo<T> : INamespaced<T>, INamespaced, ITaggable, IRegistryEvents where T : DawnBaseInfo<T>
	{
		private HashSet<NamespacedKey> _tags;

		private IDataContainer? _customData;

		public IDataContainer CustomData
		{
			get
			{
				if (_customData == null)
				{
					_customData = new DataContainer();
				}
				return _customData;
			}
		}

		public NamespacedKey Key => TypedKey;

		public NamespacedKey<T> TypedKey { get; }

		protected DawnBaseInfo(NamespacedKey<T> key, HashSet<NamespacedKey> tags, IDataContainer? customData)
		{
			TypedKey = key;
			_tags = tags;
			_customData = customData;
		}

		public bool HasTag(NamespacedKey tag)
		{
			return _tags.Contains(tag);
		}

		public IEnumerable<NamespacedKey> AllTags()
		{
			return _tags;
		}

		internal void Internal_AddTag(NamespacedKey tag)
		{
			Debuggers.Tags?.Log($"Internal_AddTag: {tag} !!!");
			_tags.Add(tag);
		}

		public void OnFrozen()
		{
			if (_customData == null)
			{
				_customData = FrozenEmptyDataContainer.Instance;
			}
		}

		public bool ShouldSkipIgnoreOverride()
		{
			if (!Key.IsVanilla() && !HasTag(DawnLibTags.IsExternal))
			{
				return HasTag(Tags.Unimplemented);
			}
			return true;
		}

		public bool ShouldSkipRespectOverride()
		{
			if (ShouldSkipIgnoreOverride())
			{
				return !HasTag(DawnLibTags.LunarConfig);
			}
			return false;
		}
	}
	public class DawnInfoContainer<T> : MonoBehaviour where T : DawnBaseInfo<T>
	{
		public T Value { get; internal set; }
	}
	public static class DawnLib
	{
		public const string PLUGIN_GUID = "com.github.teamxiaolan.dawnlib";

		internal static readonly JsonSerializerSettings JSONSettings = new JsonSerializerSettings
		{
			ReferenceLoopHandling = (ReferenceLoopHandling)1,
			PreserveReferencesHandling = (PreserveReferencesHandling)0,
			TypeNameHandling = (TypeNameHandling)3,
			Formatting = (Formatting)1,
			Converters = new List<JsonConverter>(3)
			{
				(JsonConverter)(object)new NamespacedKeyConverter(),
				(JsonConverter)(object)new NamespacedKeyDictionaryConverter(),
				(JsonConverter)(object)new Vector3Converter()
			}
		};

		private static PersistentDataContainer? _profileContainer;

		public static PersistentDataContainer? GetCurrentSave()
		{
			return NetworkSingleton<DawnNetworker>.Instance?.SaveContainer;
		}

		public static PersistentDataContainer? GetCurrentContract()
		{
			return NetworkSingleton<DawnNetworker>.Instance?.ContractContainer;
		}

		public static PersistentDataContainer GetCurrentInstallSave()
		{
			if (_profileContainer == null)
			{
				_profileContainer = new PersistentDataContainer(Path.Combine(Paths.BepInExRootPath, "DawnLib.dawndata"));
			}
			return _profileContainer;
		}

		public static void RegisterNetworkPrefab(GameObject prefab)
		{
			if (!Object.op_Implicit((Object)(object)prefab))
			{
				throw new ArgumentNullException("prefab");
			}
			MiscFixesPatch.networkPrefabsToAdd.Add(prefab);
		}

		public static void RegisterNetworkScene(string scenePath)
		{
			DawnNetworkSceneManager.AddScenePath(scenePath);
		}

		public static void FixMixerGroups(GameObject prefab)
		{
			if (!Object.op_Implicit((Object)(object)prefab))
			{
				throw new ArgumentNullException("prefab");
			}
			MiscFixesPatch.soundPrefabsToFix.Add(prefab);
		}

		public static void FixDoorwaySockets(GameObject prefab)
		{
			if (!Object.op_Implicit((Object)(object)prefab))
			{
				throw new ArgumentNullException("prefab");
			}
			MiscFixesPatch.tilesToFixSockets.Add(prefab);
		}

		public static DawnTerminalCommandInfo DefineTerminalCommand(NamespacedKey<DawnTerminalCommandInfo> key, TerminalCommandBasicInformation commandBasicInformation, Action<TerminalCommandInfoBuilder> callback)
		{
			TerminalCommandInfoBuilder terminalCommandInfoBuilder = new TerminalCommandInfoBuilder(key, commandBasicInformation);
			callback(terminalCommandInfoBuilder);
			DawnTerminalCommandInfo dawnTerminalCommandInfo = terminalCommandInfoBuilder.Build();
			LethalContent.TerminalCommands.Register(dawnTerminalCommandInfo);
			return dawnTerminalCommandInfo;
		}

		public static DawnSurfaceInfo DefineSurface(NamespacedKey<DawnSurfaceInfo> key, FootstepSurface surface, Action<SurfaceInfoBuilder> callback)
		{
			SurfaceInfoBuilder surfaceInfoBuilder = new SurfaceInfoBuilder(key, surface);
			callback(surfaceInfoBuilder);
			DawnSurfaceInfo dawnSurfaceInfo = surfaceInfoBuilder.Build();
			surface.SetDawnInfo(dawnSurfaceInfo);
			LethalContent.Surfaces.Register(dawnSurfaceInfo);
			return dawnSurfaceInfo;
		}

		public static DawnStoryLogInfo DefineStoryLog(NamespacedKey<DawnStoryLogInfo> key, GameObject storyLogGameObject, Action<StoryLogInfoBuilder> callback)
		{
			StoryLogInfoBuilder storyLogInfoBuilder = new StoryLogInfoBuilder(key, storyLogGameObject);
			callback(storyLogInfoBuilder);
			DawnStoryLogInfo dawnStoryLogInfo = storyLogInfoBuilder.Build();
			DawnStoryLogNamespacedKeyContainer dawnStoryLogNamespacedKeyContainer = storyLogGameObject.AddComponent<DawnStoryLogNamespacedKeyContainer>();
			dawnStoryLogNamespacedKeyContainer.Value = dawnStoryLogInfo.TypedKey;
			LethalContent.StoryLogs.Register(dawnStoryLogInfo);
			return dawnStoryLogInfo;
		}

		public static DawnDungeonInfo DefineDungeon(NamespacedKey<DawnDungeonInfo> key, string flowName, Action<DungeonFlowInfoBuilder> callback)
		{
			DungeonFlow val = ScriptableObject.CreateInstance<DungeonFlow>();
			((Object)val).name = flowName;
			DungeonFlowInfoBuilder dungeonFlowInfoBuilder = new DungeonFlowInfoBuilder(key, val);
			callback(dungeonFlowInfoBuilder);
			DawnDungeonInfo dawnDungeonInfo = dungeonFlowInfoBuilder.Build();
			val.SetDawnInfo(dawnDungeonInfo);
			LethalContent.Dungeons.Register(dawnDungeonInfo);
			return dawnDungeonInfo;
		}

		public static DawnTileSetInfo DefineTileSet(NamespacedKey<DawnTileSetInfo> key, TileSet tileSet, Action<TilesetInfoBuilder> callback)
		{
			TilesetInfoBuilder tilesetInfoBuilder = new TilesetInfoBuilder(key, tileSet);
			callback(tilesetInfoBuilder);
			DawnTileSetInfo dawnTileSetInfo = tilesetInfoBuilder.Build();
			tileSet.SetDawnInfo(dawnTileSetInfo);
			LethalContent.TileSets.Register(dawnTileSetInfo);
			return dawnTileSetInfo;
		}

		public static DawnMapObjectInfo DefineMapObject(NamespacedKey<DawnMapObjectInfo> key, GameObject mapObject, Action<MapObjectInfoBuilder> callback)
		{
			MapObjectInfoBuilder mapObjectInfoBuilder = new MapObjectInfoBuilder(key, mapObject);
			callback(mapObjectInfoBuilder);
			DawnMapObjectInfo dawnMapObjectInfo = mapObjectInfoBuilder.Build();
			DawnMapObjectNamespacedKeyContainer dawnMapObjectNamespacedKeyContainer = mapObject.AddComponent<DawnMapObjectNamespacedKeyContainer>();
			dawnMapObjectNamespacedKeyContainer.Value = dawnMapObjectInfo.Key;
			if (dawnMapObjectInfo.InsideInfo != null)
			{
				dawnMapObjectInfo.InsideInfo.IndoorMapHazardType.SetDawnInfo(dawnMapObjectInfo);
			}
			if (dawnMapObjectInfo.OutsideInfo != null)
			{
				dawnMapObjectInfo.OutsideInfo.SpawnableOutsideObject.SetDawnInfo(dawnMapObjectInfo);
			}
			LethalContent.MapObjects.Register(dawnMapObjectInfo);
			return dawnMapObjectInfo;
		}

		public static DawnUnlockableItemInfo DefineUnlockable(NamespacedKey<DawnUnlockableItemInfo> key, UnlockableItem unlockableItem, Action<UnlockableInfoBuilder> callback)
		{
			UnlockableInfoBuilder unlockableInfoBuilder = new UnlockableInfoBuilder(key, unlockableItem);
			callback(unlockableInfoBuilder);
			DawnUnlockableItemInfo dawnUnlockableItemInfo = unlockableInfoBuilder.Build();
			unlockableItem.SetDawnInfo(dawnUnlockableItemInfo);
			LethalContent.Unlockables.Register(dawnUnlockableItemInfo);
			return dawnUnlockableItemInfo;
		}

		public static DawnItemInfo DefineItem(NamespacedKey<DawnItemInfo> key, Item item, Action<ItemInfoBuilder> callback)
		{
			ItemInfoBuilder itemInfoBuilder = new ItemInfoBuilder(key, item);
			callback(itemInfoBuilder);
			DawnItemInfo dawnItemInfo = itemInfoBuilder.Build();
			item.SetDawnInfo(dawnItemInfo);
			LethalContent.Items.Register(dawnItemInfo);
			return dawnItemInfo;
		}

		public static DawnEnemyInfo DefineEnemy(NamespacedKey<DawnEnemyInfo> key, EnemyType enemy, Action<EnemyInfoBuilder> callback)
		{
			EnemyInfoBuilder enemyInfoBuilder = new EnemyInfoBuilder(key, enemy);
			callback(enemyInfoBuilder);
			DawnEnemyInfo dawnEnemyInfo = enemyInfoBuilder.Build();
			enemy.SetDawnInfo(dawnEnemyInfo);
			LethalContent.Enemies.Register(dawnEnemyInfo);
			return dawnEnemyInfo;
		}

		public static DawnMoonInfo DefineMoon(NamespacedKey<DawnMoonInfo> key, SelectableLevel level, Action<MoonInfoBuilder> callback)
		{
			MoonInfoBuilder moonInfoBuilder = new MoonInfoBuilder(key, level);
			callback(moonInfoBuilder);
			DawnMoonInfo dawnMoonInfo = moonInfoBuilder.Build();
			level.SetDawnInfo(dawnMoonInfo);
			LethalContent.Moons.Register(dawnMoonInfo);
			return dawnMoonInfo;
		}

		public static void ApplyTag(JSONTagDefinition definition)
		{
			JSONTagDefinition definition2 = definition;
			NamespacedKey namespacedKey2 = NamespacedKey.Parse(definition2.Tag);
			ListenToRegistry<DawnMoonInfo>(LethalContent.Moons, namespacedKey2);
			ListenToRegistry<DawnMapObjectInfo>(LethalContent.MapObjects, namespacedKey2);
			ListenToRegistry<DawnEnemyInfo>(LethalContent.Enemies, namespacedKey2);
			ListenToRegistry<DawnItemInfo>(LethalContent.Items, namespacedKey2);
			ListenToRegistry<DawnWeatherEffectInfo>(LethalContent.Weathers, namespacedKey2);
			ListenToRegistry<DawnDungeonInfo>(LethalContent.Dungeons, namespacedKey2);
			ListenToRegistry<DawnUnlockableItemInfo>(LethalContent.Unlockables, namespacedKey2);
			Debuggers.Tags?.Log($"Scheduled applying tag: {namespacedKey2}");
			void ListenToRegistry<T>(TaggedRegistry<T> registry, NamespacedKey namespacedKey) where T : notnull, DawnBaseInfo<T>
			{
				TaggedRegistry<T> registry2 = registry;
				NamespacedKey namespacedKey3 = namespacedKey;
				registry2.OnFreeze += delegate
				{
					string[] values = definition2.Values;
					foreach (string input in values)
					{
						if (registry2.TryGetValue(NamespacedKey.Parse(input), out var value))
						{
							value.Internal_AddTag(namespacedKey3);
						}
					}
				};
			}
		}

		public static void ApplyAllTagsInFolder(string path)
		{
			string[] files = Directory.GetFiles(path, "*.tag.json", SearchOption.AllDirectories);
			foreach (string path2 in files)
			{
				JSONTagDefinition definition = JsonConvert.DeserializeObject<JSONTagDefinition>(File.ReadAllText(path2));
				ApplyTag(definition);
			}
		}
	}
	public class DawnNamespacedKeyContainer<T> : MonoBehaviour where T : NamespacedKey
	{
		public T Value { get; internal set; }
	}
	[HarmonyPatch]
	internal static class DungeonRegistrationHandler
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Awake <0>__RegisterDawnDungeons;

			public static hook_OnClientDisconnect <1>__StartOfRoundOnClientDisconnect;

			public static Action<Action<RandomMapObject>, RandomMapObject> <2>__FixRandomMapObjects;

			public static Action <3>__AddDawnDungeonsToMoons;

			public static Action <4>__CollectNonDawnDungeons;

			public static hook_SetPlanetsWeather <5>__UpdateAllDungeonWeights;

			public static hook_EndOfGame <6>__UnloadDungeonBundleForAllPlayers;

			public static hook_Awake <7>__DeleteLLLTranspilerAndEnsureDelayedDungeon;

			public static Manipulator <8>__MakeExtraScrapGenerationMoreModular;

			public static Action <9>__CleanDawnDungeonReferences;

			public static hook_TeleportPlayer <10>__HandleStingerAudio;

			public static Manipulator <11>__DelayDungeonGeneration;

			public static Func<IEnumerator> <12>__LoadDungeonBundle;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_GenerateNewFloor <>9__0_0;

			public static hook_Start <>9__0_1;

			public static hook_Generate <>9__0_2;

			public static Func<Instruction, bool> <>9__3_0;

			public static Func<Instruction, bool> <>9__3_1;

			public static Func<Instruction, bool> <>9__3_2;

			public static Func<Instruction, bool> <>9__3_3;

			public static Func<Instruction, bool> <>9__3_4;

			public static Func<Instruction, bool> <>9__3_5;

			public static Func<Instruction, bool> <>9__3_6;

			public static Func<Instruction, bool> <>9__3_7;

			public static Func<Instruction, bool> <>9__11_0;

			public static Func<Instruction, bool> <>9__11_1;

			public static Func<Instruction, bool> <>9__11_2;

			public static Func<bool> <>9__13_0;

			public static Func<EntranceTeleport, bool> <>9__15_0;

			public static Func<GlobalPropSettings, bool> <>9__15_1;

			public static Func<IndoorMapType, DungeonFlow> <>9__18_0;

			public static Func<bool> <>9__20_0;

			internal void <Init>b__0_0(orig_GenerateNewFloor orig, RoundManager self)
			{
				UpdateDungeonWeightOnLevel(self.currentLevel);
				orig.Invoke(self);
			}

			internal void <Init>b__0_1(orig_Start orig, RuntimeDungeon self)
			{
				self.GenerateOnStart = false;
				orig.Invoke(self);
			}

			internal void <Init>b__0_2(orig_Generate orig, RuntimeDungeon self)
			{
				AdjustFireExits(self.Generator.DungeonFlow);
				TryInjectTileSets(self.Generator.DungeonFlow);
				orig.Invoke(self);
			}

			internal bool <MakeExtraScrapGenerationMoreModular>b__3_0(Instruction instr)
			{
				return ILPatternMatchingExt.MatchLdarg(instr, 0);
			}

			internal bool <MakeExtraScrapGenerationMoreModular>b__3_1(Instruction instr)
			{
				return ILPatternMatchingExt.MatchLdfld<RoundManager>(instr, "currentDungeonType");
			}

			internal bool <MakeExtraScrapGenerationMoreModular>b__3_2(Instruction instr)
			{
				return ILPatternMatchingExt.MatchLdcI4(instr, 4);
			}

			internal bool <MakeExtraScrapGenerationMoreModular>b__3_3(Instruction instr)
			{
				ILLabel val = default(ILLabel);
				return ILPatternMatchingExt.MatchBneUn(instr, ref val);
			}

			internal bool <MakeExtraScrapGenerationMoreModular>b__3_4(Instruction instr)
			{
				return ILPatternMatchingExt.MatchLdloc(instr, 1);
			}

			internal bool <MakeExtraScrapGenerationMoreModular>b__3_5(Instruction instr)
			{
				return ILPatternMatchingExt.MatchLdcI4(instr, 6);
			}

			internal bool <MakeExtraScrapGenerationMoreModular>b__3_6(Instruction instr)
			{
				return ILPatternMatchingExt.MatchAdd(instr);
			}

			internal bool <MakeExtraScrapGenerationMoreModular>b__3_7(Instruction instr)
			{
				return ILPatternMatchingExt.MatchStloc(instr, 1);
			}

			internal bool <DelayDungeonGeneration>b__11_0(Instruction i)
			{
				return ILPatternMatchingExt.MatchLdarg(i, 0);
			}

			internal bool <DelayDungeonGeneration>b__11_1(Instruction i)
			{
				return ILPatternMatchingExt.MatchLdfld<RoundManager>(i, "dungeonGenerator");
			}

			internal bool <DelayDungeonGeneration>b__11_2(Instruction i)
			{
				return ILPatternMatchingExt.MatchCallvirt<RuntimeDungeon>(i, "Generate");
			}

			internal bool <LoadDungeonBundle>b__13_0()
			{
				return NetworkSingleton<DawnDungeonNetworker>.Instance.allPlayersDone;
			}

			internal bool <AdjustFireExits>b__15_0(EntranceTeleport e)
			{
				return e.entranceId != 0;
			}

			internal bool <AdjustFireExits>b__15_1(GlobalPropSettings p)
			{
				return p.ID == DawnDungeonInfo.FireExitGlobalPropID;
			}

			internal DungeonFlow <AddDawnDungeonsToMoons>b__18_0(IndoorMapType t)
			{
				return t.dungeonFlow;
			}

			internal bool <CollectNonDawnDungeons>b__20_0()
			{
				return true;
			}
		}

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

			private object <>2__current;

			private DawnDungeonInfo <dungeonInfo>5__2;

			private IEnumerator <waitForLoad>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Expected O, but got Unknown
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<dungeonInfo>5__2 = RoundManager.Instance.dungeonGenerator.Generator.DungeonFlow.GetDawnInfo();
					if (!<dungeonInfo>5__2.ShouldSkipIgnoreOverride())
					{
						NetworkSingleton<DawnDungeonNetworker>.Instance.QueueDungeonBundleLoading(<dungeonInfo>5__2.Key);
						<waitForLoad>5__3 = (IEnumerator)new WaitUntil((Func<bool>)(() => NetworkSingleton<DawnDungeonNetworker>.Instance.allPlayersDone));
						goto IL_00b0;
					}
					goto IL_00c4;
				case 1:
					<>1__state = -1;
					goto IL_00b0;
				case 2:
					{
						<>1__state = -1;
						if (LethalLevelLoaderCompat.Enabled && <dungeonInfo>5__2.ShouldSkipRespectOverride())
						{
							LethalLevelLoaderCompat.LetLLLHandleGeneration();
						}
						else
						{
							BoundedRange boundedRange = <dungeonInfo>5__2.DungeonClampRange;
							if (<dungeonInfo>5__2.DungeonClampRange.Min == 0f && <dungeonInfo>5__2.DungeonClampRange.Max == 0f)
							{
								boundedRange = new BoundedRange(0f, 999f);
							}
							RoundManager.Instance.dungeonGenerator.Generator.LengthMultiplier = Mathf.Clamp(RoundManager.Instance.dungeonGenerator.Generator.LengthMultiplier, boundedRange.Min, boundedRange.Max);
							RoundManager.Instance.dungeonGenerator.Generate();
						}
						return false;
					}
					IL_00b0:
					if (<waitForLoad>5__3.MoveNext())
					{
						<>2__current = <waitForLoad>5__3.Current;
						<>1__state = 1;
						return true;
					}
					<waitForLoad>5__3 = null;
					goto IL_00c4;
					IL_00c4:
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>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 <UnloadDungeonBundleForAllPlayers>d__12 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public orig_EndOfGame orig;

			public StartOfRound self;

			public int bodiesInsured;

			public int connectedPlayersOnServer;

			public int scrapCollected;

			private IEnumerator <origIEnumerator>5__2;

			private IEnumerator <unloadIEnumerator>5__3;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((Object)(object)NetworkSingleton<DawnDungeonNetworker>.Instance != (Object)null)
					{
						<unloadIEnumerator>5__3 = NetworkSingleton<DawnDungeonNetworker>.Instance.UnloadExisting();
						goto IL_0062;
					}
					if (!DawnConfig.VanillaCompatibility.Value)
					{
						DawnPlugin.Logger.LogError((object)"DawnDungeonNetworker is null, but VanillaCompatibility is false! This is a bug!");
					}
					goto IL_00ad;
				case 1:
					<>1__state = -1;
					goto IL_0062;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_0062:
					if (<unloadIEnumerator>5__3.MoveNext())
					{
						<>2__current = <unloadIEnumerator>5__3.Current;
						<>1__state = 1;
						return true;
					}
					NetworkSingleton<DawnDungeonNetworker>.Instance.PlayerSetBundleStateServerRpc(GameNetworkManager.Instance.localPlayerController, DawnMoonNetworker.BundleState.Done);
					<unloadIEnumerator>5__3 = null;
					goto IL_00ad;
					IL_00ad:
					<origIEnumerator>5__2 = orig.Invoke(self, bodiesInsured, connectedPlayersOnServer, scrapCollected);
					break;
				}
				if (<origIEnumerator>5__2.MoveNext())
				{
					<>2__current = <origIEnumerator>5__2.Current;
					<>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();
			}
		}

		private static readonly NamespacedKey StingerPlayedKey = NamespacedKey.From("dawn_lib", "played_stinger_once_before");

		private static bool _alreadyPatched = false;

		private static readonly Dictionary<string, string> _internalToHumanDungeonNames = new Dictionary<string, string>
		{
			{ "LevelOne", "Facility" },
			{ "LevelTwo", "Mansion" },
			{ "LevelThree", "Mineshaft" }
		};

		internal static void Init()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//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_0026: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			//IL_0047: 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_0052: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected O, but got Unknown
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Expected O, but got Unknown
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Expected O, but got Unknown
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Expected O, but got Unknown
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Expected O, but got Unknown
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Expected O, but got Unknown
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Expected O, but got Unknown
			//IL_0219: 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)
			//IL_0224: Expected O, but got Unknown
			DetourContext val = new DetourContext(int.MaxValue);
			try
			{
				object obj = <>O.<0>__RegisterDawnDungeons;
				if (obj == null)
				{
					hook_Awake val2 = RegisterDawnDungeons;
					<>O.<0>__RegisterDawnDungeons = val2;
					obj = (object)val2;
				}
				StartOfRound.Awake += (hook_Awake)obj;
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
			object obj2 = <>O.<1>__StartOfRoundOnClientDisconnect;
			if (obj2 == null)
			{
				hook_OnClientDisconnect val3 = StartOfRoundOnClientDisconnect;
				<>O.<1>__StartOfRoundOnClientDisconnect = val3;
				obj2 = (object)val3;
			}
			StartOfRound.OnClientDisconnect += (hook_OnClientDisconnect)obj2;
			DetourContext val4 = new DetourContext(200);
			try
			{
				DawnPlugin.Hooks.Add(new Hook((MethodBase)AccessTools.DeclaredMethod(typeof(RandomMapObject), "Awake", (Type[])null, (Type[])null), (Delegate)new Action<Action<RandomMapObject>, RandomMapObject>(FixRandomMapObjects)));
			}
			finally
			{
				((IDisposable)val4)?.Dispose();
			}
			LethalContent.Moons.OnFreeze += AddDawnDungeonsToMoons;
			LethalContent.Moons.OnFreeze += CollectNonDawnDungeons;
			object obj3 = <>O.<5>__UpdateAllDungeonWeights;
			if (obj3 == null)
			{
				hook_SetPlanetsWeather val5 = UpdateAllDungeonWeights;
				<>O.<5>__UpdateAllDungeonWeights = val5;
				obj3 = (object)val5;
			}
			StartOfRound.SetPlanetsWeather += (hook_SetPlanetsWeather)obj3;
			object obj4 = <>O.<6>__UnloadDungeonBundleForAllPlayers;
			if (obj4 == null)
			{
				hook_EndOfGame val6 = UnloadDungeonBundleForAllPlayers;
				<>O.<6>__UnloadDungeonBundleForAllPlayers = val6;
				obj4 = (object)val6;
			}
			StartOfRound.EndOfGame += (hook_EndOfGame)obj4;
			object obj5 = <>O.<7>__DeleteLLLTranspilerAndEnsureDelayedDungeon;
			if (obj5 == null)
			{
				hook_Awake val7 = DeleteLLLTranspilerAndEnsureDelayedDungeon;
				<>O.<7>__DeleteLLLTranspilerAndEnsureDelayedDungeon = val7;
				obj5 = (object)val7;
			}
			MenuManager.Awake += (hook_Awake)obj5;
			object obj6 = <>O.<8>__MakeExtraScrapGenerationMoreModular;
			if (obj6 == null)
			{
				Manipulator val8 = MakeExtraScrapGenerationMoreModular;
				<>O.<8>__MakeExtraScrapGenerationMoreModular = val8;
				obj6 = (object)val8;
			}
			RoundManager.SpawnScrapInLevel += (Manipulator)obj6;
			object obj7 = <>c.<>9__0_0;
			if (obj7 == null)
			{
				hook_GenerateNewFloor val9 = delegate(orig_GenerateNewFloor orig, RoundManager self)
				{
					UpdateDungeonWeightOnLevel(self.currentLevel);
					orig.Invoke(self);
				};
				<>c.<>9__0_0 = val9;
				obj7 = (object)val9;
			}
			RoundManager.GenerateNewFloor += (hook_GenerateNewFloor)obj7;
			LethalContent.Dungeons.BeforeFreeze += CleanDawnDungeonReferences;
			object obj8 = <>O.<10>__HandleStingerAudio;
			if (obj8 == null)
			{
				hook_TeleportPlayer val10 = HandleStingerAudio;
				<>O.<10>__HandleStingerAudio = val10;
				obj8 = (object)val10;
			}
			EntranceTeleport.TeleportPlayer += (hook_TeleportPlayer)obj8;
			object obj9 = <>c.<>9__0_1;
			if (obj9 == null)
			{
				hook_Start val11 = delegate(orig_Start orig, RuntimeDungeon self)
				{
					self.GenerateOnStart = false;
					orig.Invoke(self);
				};
				<>c.<>9__0_1 = val11;
				obj9 = (object)val11;
			}
			RuntimeDungeon.Start += (hook_Start)obj9;
			object obj10 = <>c.<>9__0_2;
			if (obj10 == null)
			{
				hook_Generate val12 = delegate(orig_Generate orig, RuntimeDungeon self)
				{
					AdjustFireExits(self.Generator.DungeonFlow);
					TryInjectTileSets(self.Generator.DungeonFlow);
					orig.Invoke(self);
				};
				<>c.<>9__0_2 = val12;
				obj10 = (object)val12;
			}
			RuntimeDungeon.Generate += (hook_Generate)obj10;
		}

		[HarmonyPatch(typeof(RoundManager), "GenerateNewLevelClientRpc")]
		[HarmonyPrefix]
		[HarmonyPriority(100)]
		internal static void GenerateNewLevelClientRpc_Prefix(RoundManager __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if ((int)((NetworkBehaviour)__instance).__rpc_exec_stage == 0)
			{
				RestoreRuntimeDungeon();
			}
		}

		private static void RestoreRuntimeDungeon()
		{
			//IL_0058: 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)
			GameObject val = GameObject.FindGameObjectWithTag("DungeonGenerator");
			RuntimeDungeon val2 = default(RuntimeDungeon);
			if (!val.TryGetComponent<RuntimeDungeon>(ref val2))
			{
				RuntimeDungeon val3 = val.AddComponent<RuntimeDungeon>();
				UnityNavMeshAdapter val4 = ((Component)val3).gameObject.AddComponent<UnityNavMeshAdapter>();
				Transform child = ((Component)val3).transform.GetParent().GetChild(1);
				if (!((Object)(object)child == (Object)null))
				{
					val3.Root = ((Component)child).gameObject;
					val4.BakeMode = (RuntimeNavMeshBakeMode)3;
					val4.LayerMask = LayerMask.op_Implicit(LayerMask.GetMask(new string[4] { "Default", "Room", "Colliders", "NavigationSurface" }));
					DungeonGenerator generator = val3.Generator;
					generator.AllowTilePooling = true;
					generator.GenerateAsynchronously = true;
				}
			}
		}

		private static void MakeExtraScrapGenerationMoreModular(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_013f: 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_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			ILLabel val2 = default(ILLabel);
			if (!val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[8]
			{
				(Instruction instr) => ILPatternMatchingExt.MatchLdarg(instr, 0),
				(Instruction instr) => ILPatternMatchingExt.MatchLdfld<RoundManager>(instr, "currentDungeonType"),
				(Instruction instr) => ILPatternMatchingExt.MatchLdcI4(instr, 4),
				(Instruction instr) => ILPatternMatchingExt.MatchBneUn(instr, ref val2),
				(Instruction instr) => ILPatternMatchingExt.MatchLdloc(instr, 1),
				(Instruction instr) => ILPatternMatchingExt.MatchLdcI4(instr, 6),
				(Instruction instr) => ILPatternMatchingExt.MatchAdd(instr),
				(Instruction instr) => ILPatternMatchingExt.MatchStloc(instr, 1)
			}))
			{
				DawnPlugin.Logger.LogWarning((object)"Failed to find IL for RoundManager.SpawnScrapInLevel (MakeExtraScrapGenerationMoreModular).");
				return;
			}
			val.RemoveRange(8);
			val.Emit(OpCodes.Ldloc_1);
			val.Emit(OpCodes.Call, (MethodBase)AccessTools.DeclaredMethod(typeof(DungeonRegistrationHandler), "GetExtraScrapForCurrentlyLoadedInterior", (Type[])null, (Type[])null));
			val.Emit(OpCodes.Add);
			val.Emit(OpCodes.Stloc_1);
		}

		private static int GetExtraScrapForCurrentlyLoadedInterior()
		{
			return (RoundManager.Instance.dungeonGenerator?.Generator?.DungeonFlow?.GetDawnInfo())?.ExtraScrapGeneration ?? 0;
		}

		private static void HandleStingerAudio(orig_TeleportPlayer orig, EntranceTeleport self)
		{
			if (!self.checkedForFirstTime)
			{
				self.checkedForFirstTime = true;
				DawnDungeonInfo dawnDungeonInfo = RoundManager.Instance.dungeonGenerator?.Generator?.DungeonFlow.GetDawnInfo();
				if (dawnDungeonInfo == null || (Object)(object)dawnDungeonInfo.StingerDetail.FirstTimeAudio == (Object)null)
				{
					orig.Invoke(self);
					return;
				}
				if (!dawnDungeonInfo.StingerDetail.AllowStingerToPlay.Provide())
				{
					orig.Invoke(self);
					return;
				}
				if (!dawnDungeonInfo.CustomData.TryGet<bool>(StingerPlayedKey, out var value))
				{
					DawnPlugin.Logger.LogError((object)$"Failed to get {StingerPlayedKey} from dungeon: {dawnDungeonInfo.Key}.");
					orig.Invoke(self);
					return;
				}
				if (value && !dawnDungeonInfo.StingerDetail.PlaysMoreThanOnce)
				{
					orig.Invoke(self);
					return;
				}
				float num = Random.Range(0f, 100f);
				if (num > dawnDungeonInfo.StingerDetail.PlayChance)
				{
					orig.Invoke(self);
					return;
				}
				Debuggers.Dungeons?.Log($"Playing dungeon stinger for dungeon {dawnDungeonInfo.Key}, alreadyPlayed: {value} (Chance Roll: {num} <= {dawnDungeonInfo.StingerDetail.PlayChance})");
				dawnDungeonInfo.CustomData.Set(StingerPlayedKey, value: true);
				((MonoBehaviour)self).StartCoroutine(self.playMusicOnDelay());
			}
			orig.Invoke(self);
		}

		private static void FixRandomMapObjects(Action<RandomMapObject> orig, RandomMapObject self)
		{
			foreach (DawnMapObjectInfo value in LethalContent.MapObjects.Values)
			{
				for (int i = 0; i < self.spawnablePrefabs.Count; i++)
				{
					if (!((Object)(object)self.spawnablePrefabs[i] == (Object)null))
					{
						GameObject mapObjectPrefab = value.GetMapObjectPrefab();
						if (!((Object)(object)mapObjectPrefab == (Object)null) && ((Object)self.spawnablePrefabs[i]).name.Equals(((Object)mapObjectPrefab).name, StringComparison.OrdinalIgnoreCase))
						{
							self.spawnablePrefabs[i] = mapObjectPrefab;
							break;
						}
					}
				}
			}
			orig.Invoke(self);
		}

		private static void DeleteLLLTranspilerAndEnsureDelayedDungeon(orig_Awake orig, MenuManager self)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			orig.Invoke(self);
			if (!_alreadyPatched)
			{
				if (LethalLevelLoaderCompat.Enabled)
				{
					DawnPlugin.Logger.LogDebug((object)"Removing LethalLevelLoader dungeon generation transpiler.");
					LethalLevelLoaderCompat.TryRemoveLLLDungeonTranspiler();
					LethalLevelLoaderCompat.ScrewWithLLLDynamicDungeonRarity();
				}
				object obj = <>O.<11>__DelayDungeonGeneration;
				if (obj == null)
				{
					Manipulator val = DelayDungeonGeneration;
					<>O.<11>__DelayDungeonGeneration = val;
					obj = (object)val;
				}
				RoundManager.GenerateNewFloor += (Manipulator)obj;
				_alreadyPatched = true;
			}
		}

		private static void CleanDawnDungeonReferences()
		{
			foreach (DawnDungeonInfo value in LethalContent.Dungeons.Values)
			{
				if (!value.ShouldSkipIgnoreOverride())
				{
					List<DungeonArchetype> list = value.DungeonFlow.GetUsedArchetypes().Distinct().ToList();
					List<TileSet> list2 = value.DungeonFlow.GetUsedTileSets().Distinct().ToList();
					value.DungeonFlow.Nodes.Clear();
					value.DungeonFlow.Lines.Clear();
					for (int num = list.Count - 1; num >= 0; num--)
					{
						Object.Destroy((Object)(object)list[num]);
					}
					for (int num2 = list2.Count - 1; num2 >= 0; num2--)
					{
						Object.Destroy((Object)(object)list2[num2]);
					}
				}
			}
		}

		private static void DelayDungeonGeneration(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0085: 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_00e8: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[3]
			{
				(Instruction i) => ILPatternMatchingExt.MatchLdarg(i, 0),
				(Instruction i) => ILPatternMatchingExt.MatchLdfld<RoundManager>(i, "dungeonGenerator"),
				(Instruction i) => ILPatternMatchingExt.MatchCallvirt<RuntimeDungeon>(i, "Generate")
			}))
			{
				val.RemoveRange(3);
				val.Emit(OpCodes.Ldarg_0);
				val.EmitDelegate<Func<IEnumerator>>((Func<IEnumerator>)LoadDungeonBundle);
				MethodInfo method = typeof(MonoBehaviour).GetMethod("StartCoroutine", new Type[1] { typeof(IEnumerator) });
				val.Emit(OpCodes.Callvirt, (MethodBase)method);
				val.Emit(OpCodes.Pop);
			}
			else
			{
				DawnPlugin.Logger.LogError((object)"Failed to apply DawnLib dungeon generation delay patch!");
				DawnPlugin.Logger.LogError((object)"IL code:");
				DawnPlugin.Logger.LogError((object)((object)il).ToString());
			}
		}

		[IteratorStateMachine(typeof(<UnloadDungeonBundleForAllPlayers>d__12))]
		private static IEnumerator UnloadDungeonBundleForAllPlayers(orig_EndOfGame orig, StartOfRound self, int bodiesInsured, int connectedPlayersOnServer, int scrapCollected)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UnloadDungeonBundleForAllPlayers>d__12(0)
			{
				orig = orig,
				self = self,
				bodiesInsured = bodiesInsured,
				connectedPlayersOnServer = connectedPlayersOnServer,
				scrapCollected = scrapCollected
			};
		}

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

		private static void StartOfRoundOnClientDisconnect(orig_OnClientDisconnect orig, StartOfRound self, ulong clientid)
		{
			orig.Invoke(self, clientid);
			if (((NetworkBehaviour)self).IsServer && self.inShipPhase)
			{
				NetworkSingleton<DawnDungeonNetworker>.Instance?.HostRebroadcastQueue();
			}
		}

		private static void AdjustFireExits(DungeonFlow dungeonFlow)
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			EntranceTeleport[] array = (from e in Object.FindObjectsByType<EntranceTeleport>((FindObjectsInactive)0, (FindObjectsSortMode)0)
				where e.entranceId != 0
				select e).ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				EntranceTeleport val = array[i];
				val.entranceId = i + 1;
			}
			foreach (GlobalPropSettings item in dungeonFlow.GlobalProps.Where((GlobalPropSettings p) => p.ID == DawnDungeonInfo.FireExitGlobalPropID))
			{
				item.Count = new IntRange(array.Length, array.Length);
			}
		}

		private static void UpdateAllDungeonWeights(orig_SetPlanetsWeather orig, StartOfRound self, int connectedPlayersOnServer)
		{
			orig.Invoke(self, connectedPlayersOnServer);
			UpdateDungeonWeightOnLevel(self.currentLevel);
		}

		internal static void UpdateDungeonWeightOnLevel(SelectableLevel level)
		{
			if (!LethalContent.Weathers.IsFrozen || !LethalContent.Dungeons.IsFrozen || (Object)(object)StartOfRound.Instance == (Object)null || (WeatherRegistryCompat.Enabled && !WeatherRegistryCompat.IsWeatherManagerReady()))
			{
				return;
			}
			IntWithRarity[] dungeonFlowTypes = level.dungeonFlowTypes;
			foreach (IntWithRarity val in dungeonFlowTypes)
			{
				DawnDungeonInfo dawnInfo = RoundManagerRefs.Instance.dungeonFlowTypes[val.id].dungeonFlow.GetDawnInfo();
				if (!dawnInfo.ShouldSkipRespectOverride())
				{
					SpawnWeightContext ctx = new SpawnWeightContext(level.GetDawnInfo(), null, TimeOfDayRefs.GetCurrentWeatherEffect(level)?.GetDawnInfo()).WithExtra(SpawnWeightExtraKeys.RoutingPriceKey, level.GetDawnInfo().DawnPurchaseInfo.Cost.Provide());
					int valueOrDefault = (dawnInfo.Weights?.GetFor(in ctx)).GetValueOrDefault();
					val.rarity = valueOrDefault.Clamp0();
				}
			}
		}

		private static void AddDawnDungeonsToMoons()
		{
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			foreach (DawnMoonInfo value in LethalContent.Moons.Values)
			{
				List<IntWithRarity> list = value.Level.dungeonFlowTypes.ToList();
				foreach (DawnDungeonInfo value2 in LethalContent.Dungeons.Values)
				{
					if (!value2.ShouldSkipIgnoreOverride())
					{
						int num = Array.IndexOf(RoundManagerRefs.Instance.dungeonFlowTypes.Select((IndoorMapType t) => t.dungeonFlow).ToArray(), value2.DungeonFlow);
						IntWithRarity item = new IntWithRarity(num, 0, (LevelAmbienceLibrary)null);
						list.Add(item);
					}
				}
				value.Level.dungeonFlowTypes = list.ToArray();
			}
		}

		private static void RegisterDawnDungeons(orig_Awake orig, StartOfRound self)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			List<IndoorMapType> list = RoundManagerRefs.Instance.dungeonFlowTypes.ToList();
			foreach (DawnDungeonInfo value in LethalContent.Dungeons.Values)
			{
				if (!value.ShouldSkipIgnoreOverride())
				{
					IndoorMapType item = new IndoorMapType(value.DungeonFlow, value.MapTileSize, value.StingerDetail.FirstTimeAudio);
					list.Add(item);
				}
			}
			RoundManagerRefs.Instance.dungeonFlowTypes = list.ToArray();
			orig.Invoke(self);
		}

		private static void CollectNonDawnDungeons()
		{
			Dictionary<string, WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>> dictionary = new Dictionary<string, WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>();
			foreach (DawnMoonInfo value3 in LethalContent.Moons.Values)
			{
				SelectableLevel level = value3.Level;
				List<IntWithRarity> list = level.dungeonFlowTypes.ToList();
				if (LethalLevelLoaderCompat.Enabled)
				{
					list.AddRange(LethalLevelLoaderCompat.GetCustomDungeonsWithRarities(level));
				}
				foreach (IntWithRarity item in list)
				{
					DungeonFlow dungeonFlow = RoundManagerRefs.Instance.dungeonFlowTypes[item.id].dungeonFlow;
					if (!dictionary.TryGetValue(((Object)dungeonFlow).name, out var value))
					{
						value = new WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>();
						dictionary[((Object)dungeonFlow).name] = value;
					}
					Debuggers.Dungeons?.Log($"Grabbing weight {item.rarity} to {((Object)dungeonFlow).name} on level {level.PlanetName}");
					value.AddWeight(value3.TypedKey, item.rarity);
				}
			}
			IndoorMapType[] dungeonFlowTypes = RoundManagerRefs.Instance.dungeonFlowTypes;
			foreach (IndoorMapType val in dungeonFlowTypes)
			{
				if (val == null || (Object)(object)val.dungeonFlow == (Object)null || val.dungeonFlow.HasDawnInfo())
				{
					continue;
				}
				string name = FormatFlowName(val.dungeonFlow);
				NamespacedKey<DawnDungeonInfo> namespacedKey = DungeonKeys.GetByReflection(name);
				BoundedRange dungeonClampRange = new BoundedRange(0f, 999f);
				if (namespacedKey == null && LethalLevelLoaderCompat.Enabled && LethalLevelLoaderCompat.TryGetExtendedDungeonModName(val.dungeonFlow, out string modName))
				{
					namespacedKey = NamespacedKey<DawnDungeonInfo>.From(modName, ((Object)val.dungeonFlow).name);
					dungeonClampRange = LethalLevelLoaderCompat.GetDungeonClamp(val.dungeonFlow);
				}
				else if (namespacedKey == null)
				{
					namespacedKey = NamespacedKey<DawnDungeonInfo>.From("unknown_modded", ((Object)val.dungeonFlow).name);
				}
				if (LethalContent.Dungeons.ContainsKey(namespacedKey))
				{
					Debuggers.Dungeons?.Log($"LethalContent.Dungeons already contains {namespacedKey}");
					val.dungeonFlow.SetDawnInfo(LethalContent.Dungeons[namespacedKey]);
					continue;
				}
				HashSet<NamespacedKey> tags = new HashSet<NamespacedKey> { DawnLibTags.IsExternal };
				CollectLLLTags(val.dungeonFlow, tags);
				dictionary.TryGetValue(((Object)val.dungeonFlow).name, out var value2);
				if (value2 == null)
				{
					value2 = new WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>();
				}
				PersistentDataContainer persistentDataContainer = new PersistentDataContainer(Path.Combine(PersistentDataHandler.RootPath, "dungeon_" + namespacedKey.Namespace + "_" + namespacedKey.Key));
				if (!persistentDataContainer.Has(StingerPlayedKey))
				{
					persistentDataContainer.Set(StingerPlayedKey, value: false);
				}
				DawnStingerDetail stingerDetail = new DawnStingerDetail(val.firstTimeAudio, playsMoreThanOnce: false, 100f, new FuncProvider<bool>(() => true));
				int extraScrapGeneration = 0;
				if (namespacedKey == DungeonKeys.MineshaftFlow)
				{
					extraScrapGeneration = 6;
				}
				DawnDungeonInfo dawnDungeonInfo = new DawnDungeonInfo(namespacedKey, tags, val.dungeonFlow, value2.Build(), val.MapTileSize, stingerDetail, string.Empty, dungeonClampRange, extraScrapGeneration, persistentDataContainer);
				val.dungeonFlow.SetDawnInfo(dawnDungeonInfo);
				LethalContent.Dungeons.Register(dawnDungeonInfo);
			}
			CollectArchetypesAndTileSets();
			LethalContent.Dungeons.Freeze();
		}

		private static void CollectArchetypesAndTileSets()
		{
			foreach (DawnDungeonInfo value in LethalContent.Dungeons.Values)
			{
				DungeonArchetype[] usedArchetypes = value.DungeonFlow.GetUsedArchetypes();
				foreach (DungeonArchetype val in usedArchetypes)
				{
					Debuggers.Dungeons?.Log("dungeonArchetype.name: " + ((Object)val).name);
					NamespacedKey<DawnArchetypeInfo> namespacedKey;
					if (value.Key.IsVanilla())
					{
						string text = FormatArchetypeName(val);
						namespacedKey = DungeonArchetypeKeys.GetByReflection(text);
						if (namespacedKey == null)
						{
							DawnPlugin.Logger.LogWarning((object)$"archetype: '{((Object)val).name}' (part of {value.Key}) is vanilla, but DawnLib couldn't get a corresponding NamespacedKey, archetype has formatted name: {text}!");
							continue;
						}
					}
					else
					{
						namespacedKey = NamespacedKey<DawnArchetypeInfo>.From(value.Key.Namespace, ((Object)val).name);
					}
					if (LethalContent.Archetypes.ContainsKey(namespacedKey))
					{
						Debuggers.Dungeons?.Log($"LethalContent.Archetypes already contains {namespacedKey}");
						val.SetDawnInfo(LethalContent.Archetypes[namespacedKey]);
						continue;
					}
					HashSet<NamespacedKey> hashSet = new HashSet<NamespacedKey>();
					if (value.HasTag(DawnLibTags.IsExternal))
					{
						hashSet.Add(DawnLibTags.IsExternal);
					}
					DawnArchetypeInfo dawnArchetypeInfo = new DawnArchetypeInfo(namespacedKey, hashSet, val, null);
					val.SetDawnInfo(dawnArchetypeInfo);
					dawnArchetypeInfo.ParentInfo = value;
					LethalContent.Archetypes.Register(dawnArchetypeInfo);
					List<TileSet> tileSets = val.TileSets;
					List<TileSet> branchCapTileSets = val.BranchCapTileSets;
					List<TileSet> list = new List<TileSet>(tileSets.Count + branchCapTileSets.Count);
					list.AddRange(tileSets);
					list.AddRange(branchCapTileSets);
					List<TileSet> list2 = list;
					foreach (TileSet item in list2)
					{
						Debuggers.Dungeons?.Log("tileSet.name: " + ((Object)item).name);
						NamespacedKey<DawnTileSetInfo> namespacedKey2;
						if (value.Key.IsVanilla())
						{
							string text2 = FormatTileSetName(item);
							namespacedKey2 = DungeonTileSetKeys.GetByReflection(text2);
							if (namespacedKey2 == null)
							{
								DawnPlugin.Logger.LogWarning((object)$"tileset: '{((Object)item).name}' (part of {namespacedKey}) is vanilla, but DawnLib couldn't get a corresponding NamespacedKey, tileset has formatted name: {text2}!");
								continue;
							}
						}
						else
						{
							namespacedKey2 = NamespacedKey<DawnTileSetInfo>.From(value.Key.Namespace, ((Object)item).name);
						}
						if (LethalContent.TileSets.ContainsKey(namespacedKey2))
						{
							Debuggers.Dungeons?.Log($"LethalContent.TileSets already contains {namespacedKey2}");
							item.SetDawnInfo(LethalContent.TileSets[namespacedKey2]);
							continue;
						}
						HashSet<NamespacedKey> hashSet2 = new HashSet<NamespacedKey>();
						if (value.HasTag(DawnLibTags.IsExternal))
						{
							hashSet2.Add(DawnLibTags.IsExternal);
						}
						DawnTileSetInfo dawnTileSetInfo = new DawnTileSetInfo(namespacedKey2, hashSet2, ConstantPredicate.True, item, val.BranchCapTileSets.Contains(item), val.TileSets.Contains(item), null);
						dawnArchetypeInfo.AddTileSet(dawnTileSetInfo);
						item.SetDawnInfo(dawnTileSetInfo);
						LethalContent.TileSets.Register(dawnTileSetInfo);
					}
				}
			}
			LethalContent.Archetypes.Freeze();
			LethalContent.TileSets.Freeze();
		}

		private static string FormatTileSetName(TileSet tileSet)
		{
			string input = NamespacedKey.NormalizeStringForNamespacedKey(((Object)tileSet).name, CSharpName: true);
			return ReplaceInternalLevelNames(input).Replace("Tiles", string.Empty);
		}

		private static string FormatArchetypeName(DungeonArchetype dungeonArchetype)
		{
			string input = NamespacedKey.NormalizeStringForNamespacedKey(((Object)dungeonArchetype).name, CSharpName: true);
			return ReplaceInternalLevelNames(input).Replace("Archetype", string.Empty);
		}

		private static string FormatFlowName(DungeonFlow dungeonFlow)
		{
			string input = NamespacedKey.NormalizeStringForNamespacedKey(((Object)dungeonFlow).name, CSharpName: true);
			return ReplaceInternalLevelNames(input);
		}

		private static string ReplaceInternalLevelNames(string input)
		{
			foreach (KeyValuePair<string, string> internalToHumanDungeonName in _internalToHumanDungeonNames)
			{
				internalToHumanDungeonName.Deconstruct(out var key, out var value);
				string oldValue = key;
				string newValue = value;
				input = input.Replace(oldValue, newValue);
			}
			return input;
		}

		private static void CollectLLLTags(DungeonFlow dungeonFlow, HashSet<NamespacedKey> tags)
		{
			if (LethalLevelLoaderCompat.Enabled && LethalLevelLoaderCompat.TryGetAllTagsWithModNames(dungeonFlow, out List<(string, string)> allTagsWithModNames))
			{
				tags.AddToList(allTagsWithModNames, Debuggers.Dungeons, ((Object)dungeonFlow).name);
			}
		}

		private static void TryInjectTileSets(DungeonFlow dungeonFlow)
		{
			DungeonArchetype[] usedArchetypes = dungeonFlow.GetUsedArchetypes();
			foreach (DungeonArchetype val in usedArchetypes)
			{
				if ((Object)(object)val == (Object)null)
				{
					Debuggers.Dungeons?.Log("Archetype is null in dungeonflow: " + ((Object)dungeonFlow).name);
					continue;
				}
				Debuggers.Dungeons?.Log("Injecting tile sets for " + ((Object)val).name);
				foreach (DawnTileSetInfo tileSet in val.GetDawnInfo().TileSets)
				{
					if (tileSet.ShouldSkipIgnoreOverride())
					{
						continue;
					}
					val.BranchCapTileSets.Remove(tileSet.TileSet);
					val.TileSets.Remove(tileSet.TileSet);
					if (tileSet.InjectionPredicate.Evaluate())
					{
						if (tileSet.IsBranchCap)
						{
							val.BranchCapTileSets.Add(tileSet.TileSet);
						}
						if (tileSet.IsRegular)
						{
							val.TileSets.Add(tileSet.TileSet);
						}
					}
				}
			}
		}
	}
	public class DawnArchetypeInfo : DawnBaseInfo<DawnArchetypeInfo>
	{
		private List<DawnTileSetInfo> _tileSets = new List<DawnTileSetInfo>();

		public DungeonArchetype DungeonArchetype { get; }

		public IReadOnlyList<DawnTileSetInfo> TileSets => _tileSets.AsReadOnly();

		public DawnDungeonInfo ParentInfo { get; internal set; }

		internal DawnArchetypeInfo(NamespacedKey<DawnArchetypeInfo> key, HashSet<NamespacedKey> tags, DungeonArchetype archetype, IDataContainer? customData)
			: base(key, tags, customData)
		{
			DungeonArchetype = archetype;
		}

		public void AddTileSet(DawnTileSetInfo info)
		{
			if (LethalContent.Dungeons.IsFrozen)
			{
				throw new RegistryFrozenException();
			}
			_tileSets.Add(info);
		}
	}
	public class DawnDungeonInfo : DawnBaseInfo<DawnDungeonInfo>
	{
		internal List<DoorwaySocket> sockets = new List<DoorwaySocket>();

		internal List<Doorway> doorways = new List<Doorway>();

		internal List<SpawnSyncedObject> spawnSyncedObjects = new List<SpawnSyncedObject>();

		internal List<Tile> tiles = new List<Tile>();

		public static int FireExitGlobalPropID = 1231;

		public DungeonFlow DungeonFlow { get; }

		public string AssetBundlePath { get; }

		public ProviderTable<int?, DawnMoonInfo, SpawnWeightContext> Weights { get; private set; }

		public float MapTileSize { get; private set; }

		public DawnStingerDetail StingerDetail { get; private set; }

		public BoundedRange DungeonClampRange { get; private set; }

		public int ExtraScrapGeneration { get; private set; }

		public IReadOnlyList<Tile> Tiles => tiles.AsReadOnly();

		public IReadOnlyList<Doorway> Doorways => doorways.AsReadOnly();

		public IReadOnlyList<SpawnSyncedObject> SpawnSyncedObjects => spawnSyncedObjects.AsReadOnly();

		public IReadOnlyList<DoorwaySocket> Sockets => sockets.AsReadOnly();

		internal DawnDungeonInfo(NamespacedKey<DawnDungeonInfo> key, HashSet<NamespacedKey> tags, DungeonFlow dungeonFlow, ProviderTable<int?, DawnMoonInfo, SpawnWeightContext> weights, float mapTileSize, DawnStingerDetail stingerDetail, string assetBundlePath, BoundedRange dungeonClampRange, int extraScrapGeneration, IDataContainer? customData)
			: base(key, tags, customData)
		{
			DungeonFlow = dungeonFlow;
			Weights = weights;
			MapTileSize = mapTileSize;
			StingerDetail = stingerDetail;
			AssetBundlePath = assetBundlePath;
			DungeonClampRange = dungeonClampRange;
			ExtraScrapGeneration = extraScrapGeneration;
			if (!ShouldSkipIgnoreOverride())
			{
				return;
			}
			sockets = new List<DoorwaySocket>();
			List<TileSet> list = new List<TileSet>();
			TileSet[] usedTileSets = DungeonFlow.GetUsedTileSets();
			foreach (TileSet val in usedTileSets)
			{
				if ((Object)(object)val == (Object)null)
				{
					DawnPlugin.Logger.LogWarning((object)("TileSet is null in dungeonflow: " + ((Object)DungeonFlow).name));
				}
				else if (!list.Contains(val))
				{
					list.Add(val);
				}
			}
			foreach (TileInjectionRule tileInjectionRule in DungeonFlow.TileInjectionRules)
			{
				if ((Object)(object)tileInjectionRule.TileSet == (Object)null)
				{
					DawnPlugin.Logger.LogWarning((object)"TileSet is null in a tileInjectionRule");
				}
				else if (!list.Contains(tileInjectionRule.TileSet))
				{
					list.Add(tileInjectionRule.TileSet);
				}
			}
			foreach (TileSet item in list)
			{
				foreach (GameObjectChance weight in item.TileWeights.Weights)
				{
					if ((Object)(object)weight.Value == (Object)null)
					{
						DawnPlugin.Logger.LogWarning((object)("GameObject is null in tileSet: " + ((Object)item).name));
						continue;
					}
					Tile[] componentsInChildren = weight.Value.GetComponentsInChildren<Tile>();
					foreach (Tile val2 in componentsInChildren)
					{
						if ((Object)(object)val2 == (Object)null)
						{
							DawnPlugin.Logger.LogWarning((object)("Tile is null in tileSet: " + ((Object)item).name));
						}
						else if (!tiles.Contains(val2))
						{
							tiles.Add(val2);
						}
					}
				}
			}
			doorways = new List<Doorway>();
			spawnSyncedObjects = new List<SpawnSyncedObject>();
			foreach (Tile tile in Tiles)
			{
				Doorway[] componentsInChildren2 = ((Component)tile).gameObject.GetComponentsInChildren<Doorway>();
				foreach (Doorway val3 in componentsInChildren2)
				{
					if (!Doorways.Contains(val3))
					{
						doorways.Add(val3);
					}
					if (!Sockets.Contains(val3.socket))
					{
						if ((Object)(object)val3.socket == (Object)null)
						{
							DawnPlugin.Logger.LogWarning((object)("DungeonFlow: " + ((Object)DungeonFlow).name + " has a null socket in doorway: " + ((Object)val3).name + " from Tile: " + ((Object)tile).name));
							continue;
						}
						sockets.Add(val3.socket);
					}
					foreach (GameObjectWeight connectorPrefabWeight in val3.ConnectorPrefabWeights)
					{
						SpawnSyncedObject[] componentsInChildren3 = connectorPrefabWeight.GameObject.GetComponentsInChildren<SpawnSyncedObject>();
						foreach (SpawnSyncedObject val4 in componentsInChildren3)
						{
							if (!SpawnSyncedObjects.Contains(val4))
							{
								spawnSyncedObjects.Add(val4);
							}
						}
					}
					foreach (GameObjectWeight blockerPrefabWeight in val3.BlockerPrefabWeights)
					{
						SpawnSyncedObject[] componentsInChildren4 = blockerPrefabWeight.GameObject.GetComponentsInChildren<SpawnSyncedObject>();
						foreach (SpawnSyncedObject val5 in componentsInChildren4)
						{
							if (!SpawnSyncedObjects.Contains(val5))
							{
								spawnSyncedObjects.Add(val5);
							}
						}
					}
				}
				SpawnSyncedObject[] componentsInChildren5 = ((Component)tile).gameObject.GetComponentsInChildren<SpawnSyncedObject>();
				foreach (SpawnSyncedObject val6 in componentsInChildren5)
				{
					if (!SpawnSyncedObjects.Contains(val6))
					{
						spawnSyncedObjects.Add(val6);
					}
				}
			}
		}
	}
	public class DawnStingerDetail
	{
		public AudioClip? FirstTimeAudio { get; private set; }

		public bool PlaysMoreThanOnce { get; private set; }

		public float PlayChance { get; private set; }

		public FuncProvider<bool> AllowStingerToPlay { get; private set; }

		public DawnStingerDetail(AudioClip? firstTimeAudio, bool playsMoreThanOnce, float playChance, FuncProvider<bool> allowStingerToPlay)
		{
			FirstTimeAudio = firstTimeAudio;
			PlaysMoreThanOnce = playsMoreThanOnce;
			PlayChance = playChance;
			AllowStingerToPlay = allowStingerToPlay;
			base..ctor();
		}
	}
	public class DawnTileSetInfo : DawnBaseInfo<DawnTileSetInfo>
	{
		public TileSet TileSet { get; }

		public bool IsBranchCap { get; }

		public bool IsRegular { get; }

		public IPredicate InjectionPredicate { get; }

		internal DawnTileSetInfo(NamespacedKey<DawnTileSetInfo> key, HashSet<NamespacedKey> tags, IPredicate injectionRule, TileSet tileSet, bool isBranchCap, bool isRegular, IDataContainer? customData)
			: base(key, tags, customData)
		{
			TileSet = tileSet;
			IsBranchCap = isBranchCap;
			IsRegular = isRegular;
			InjectionPredicate = injectionRule;
		}
	}
	public static class DungeonArchetypeExtensions
	{
		public static DawnArchetypeInfo GetDawnInfo(this DungeonArchetype archetype)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return (DawnArchetypeInfo)((IDawnObject)archetype).DawnInfo;
		}

		internal static bool HasDawnInfo(this DungeonArchetype archetype)
		{
			return archetype.GetDawnInfo() != null;
		}

		internal static void SetDawnInfo(this DungeonArchetype archetype, DawnArchetypeInfo archetypeInfo)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			((IDawnObject)archetype).DawnInfo = archetypeInfo;
		}
	}
	public static class DungeonFlowExtensions
	{
		public static DawnDungeonInfo GetDawnInfo(this DungeonFlow dungeonFlow)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return (DawnDungeonInfo)((IDawnObject)dungeonFlow).DawnInfo;
		}

		public static bool TryGetDawnInfo(this DungeonFlow dungeonFlow, [NotNullWhen(true)] out DawnDungeonInfo? dungeonInfo)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			dungeonInfo = (DawnDungeonInfo)((IDawnObject)dungeonFlow).DawnInfo;
			return dungeonInfo != null;
		}

		internal static bool HasDawnInfo(this DungeonFlow dungeonFlow)
		{
			return dungeonFlow.GetDawnInfo() != null;
		}

		internal static void SetDawnInfo(this DungeonFlow dungeonFlow, DawnDungeonInfo dungeonInfo)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			((IDawnObject)dungeonFlow).DawnInfo = dungeonInfo;
		}
	}
	public class DungeonFlowInfoBuilder : BaseInfoBuilder<DawnDungeonInfo, DungeonFlow, DungeonFlowInfoBuilder>
	{
		private float _mapTileSize;

		private AudioClip? _firstTimeAudio;

		private ProviderTable<int?, DawnMoonInfo, SpawnWeightContext> _weights;

		private string _assetBundlePath = string.Empty;

		private BoundedRange _dungeonRangeClamp = new BoundedRange(0f, 999f);

		private bool _stingerPlaysMoreThanOnce;

		private float _stingerPlayChance = 100f;

		private FuncProvider<bool> _allowStingerToPlay = new FuncProvider<bool>(() => true);

		private int _extraScrapGeneration;

		internal DungeonFlowInfoBuilder(NamespacedKey<DawnDungeonInfo> key, DungeonFlow value)
			: base(key, value)
		{
		}

		public DungeonFlowInfoBuilder SetArchetypeTileSetMapping(string archetypeName, IEnumerable<string> tileSetNames)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			GraphLine val = new GraphLine(base.value);
			base.value.Lines.Add(val);
			TileSet[] array = base.value.GetUsedTileSets() ?? Array.Empty<TileSet>();
			Dictionary<string, TileSet> dictionary = new Dictionary<string, TileSet>(StringComparer.Ordinal);
			TileSet[] array2 = array;
			foreach (TileSet val2 in array2)
			{
				if (!dictionary.ContainsKey(((Object)val2).name))
				{
					dictionary.Add(((Object)val2).name, val2);
				}
			}
			List<TileSet> list = new List<TileSet>();
			foreach (string tileSetName in tileSetNames)
			{
				string name = tileSetName.Trim();
				if (!dictionary.TryGetValue(name, out var val3))
				{
					val3 = ScriptableObject.CreateInstance<TileSet>();
					((Object)val3).name = name;
					dictionary.Add(name, val3);
				}
				if (!list.Contains(val3))
				{
					list.Add(val3);
				}
			}
			DungeonArchetype val4 = null;
			DungeonArchetype[] usedArchetypes = base.value.GetUsedArchetypes();
			if (usedArchetypes != null)
			{
				DungeonArchetype[] array3 = usedArchetypes;
				foreach (DungeonArchetype val5 in array3)
				{
					if (!((Object)(object)val5