using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
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.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using EasyTextEffects.Editor.MyBoxCopy.Extensions;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using UnityEngine;
using UnityEngine.Networking;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[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("EasyTextEffects")]
[assembly: IgnoresAccessChecksTo("Facepunch Transport for Netcode for GameObjects")]
[assembly: IgnoresAccessChecksTo("Facepunch.Steamworks.Win64")]
[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: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("baer1")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (c) baer1 2025")]
[assembly: AssemblyDescription("A collection of useful modding utilities for Lethal Company")]
[assembly: AssemblyFileVersion("0.1.4.0")]
[assembly: AssemblyInformationalVersion("0.1.4+14c2ea79ed58e16b0499ad613f6db182b2c14c3e")]
[assembly: AssemblyProduct("LethalModUtils")]
[assembly: AssemblyTitle("baer1.LethalModUtils")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/baerchen201/LethalModUtils.git")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.4.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.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;
		}
	}
}
namespace LethalModUtils
{
	public static class Audio
	{
		public class UnknownTypeError : Exception
		{
			public UnknownTypeError(string fileExtension)
				: base("Unrecognized audio file type: " + fileExtension)
			{
			}
		}

		public class RequestError : Exception
		{
			public RequestError(string errorMessage)
				: base("WebRequest error: " + errorMessage)
			{
			}
		}

		public class ClipError : Exception
		{
			public ClipError(AudioDataLoadState? state)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				object obj;
				if (!state.HasValue)
				{
					obj = null;
				}
				else
				{
					AudioDataLoadState valueOrDefault = state.GetValueOrDefault();
					obj = ((object)(AudioDataLoadState)(ref valueOrDefault)).ToString();
				}
				if (obj == null)
				{
					obj = "null";
				}
				base..ctor("Clip load error: " + (string?)obj);
			}
		}

		public class AudioPlayer
		{
			public enum PlayerState
			{
				Playing,
				Paused,
				Finished
			}

			private class _MonoBehaviour : MonoBehaviour
			{
			}

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

				private object <>2__current;

				public AudioPlayer <>4__this;

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

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

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

				[DebuggerHidden]
				void IDisposable.Dispose()
				{
					int num = <>1__state;
					if (num == -3 || num == 2)
					{
						try
						{
						}
						finally
						{
							<>m__Finally1();
						}
					}
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					try
					{
						int num = <>1__state;
						AudioPlayer audioPlayer = <>4__this;
						switch (num)
						{
						default:
							return false;
						case 0:
							<>1__state = -1;
							<>2__current = null;
							<>1__state = 1;
							return true;
						case 1:
							<>1__state = -1;
							<>1__state = -3;
							break;
						case 2:
							<>1__state = -3;
							break;
						}
						if (!audioPlayer.finished && Object.op_Implicit((Object)(object)audioPlayer.AudioSource) && Object.op_Implicit((Object)(object)audioPlayer.GameObject))
						{
							audioPlayer.MainLoop?.Invoke(audioPlayer);
							<>2__current = null;
							<>1__state = 2;
							return true;
						}
						<>m__Finally1();
						return false;
					}
					catch
					{
						//try-fault
						((IDisposable)this).Dispose();
						throw;
					}
				}

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

				private void <>m__Finally1()
				{
					<>1__state = -1;
					AudioPlayer audioPlayer = <>4__this;
					audioPlayer.Cancel();
				}

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

			internal readonly AudioSource AudioSource;

			internal readonly GameObject GameObject;

			private readonly Action<AudioPlayer>? MainLoop;

			private bool finished;

			public PlayerState State
			{
				get
				{
					if (!finished)
					{
						if (!AudioSource.isPlaying)
						{
							return PlayerState.Paused;
						}
						return PlayerState.Playing;
					}
					return PlayerState.Finished;
				}
			}

			public bool Muted
			{
				get
				{
					return AudioSource.mute;
				}
				set
				{
					AudioSource.mute = value;
				}
			}

			public bool BypassEffects
			{
				get
				{
					return AudioSource.bypassEffects;
				}
				set
				{
					AudioSource.bypassEffects = value;
				}
			}

			public bool BypassListenerEffects
			{
				get
				{
					return AudioSource.bypassListenerEffects;
				}
				set
				{
					AudioSource.bypassListenerEffects = value;
				}
			}

			public bool BypassReverbZones
			{
				get
				{
					return AudioSource.bypassReverbZones;
				}
				set
				{
					AudioSource.bypassReverbZones = value;
				}
			}

			public bool Loop
			{
				get
				{
					return AudioSource.loop;
				}
				set
				{
					AudioSource.loop = value;
				}
			}

			public int Priority
			{
				get
				{
					return AudioSource.priority;
				}
				set
				{
					AudioSource.priority = value;
				}
			}

			public float Volume
			{
				get
				{
					return AudioSource.volume;
				}
				set
				{
					AudioSource.volume = value;
				}
			}

			public float Pitch
			{
				get
				{
					return AudioSource.pitch;
				}
				set
				{
					AudioSource.pitch = value;
				}
			}

			public float DopplerLevel
			{
				get
				{
					return AudioSource.dopplerLevel;
				}
				set
				{
					AudioSource.dopplerLevel = value;
				}
			}

			public float MaxDistance => AudioSource.maxDistance;

			public float MinDistance => AudioSource.minDistance;

			public AudioRolloffMode RolloffMode => AudioSource.rolloffMode;

			public AnimationCurve RolloffCurve => AudioSource.GetCustomCurve((AudioSourceCurveType)0);

			public AudioSource _audioSource => AudioSource;

			private AudioPlayer()
			{
				throw new InvalidOperationException();
			}

			internal AudioPlayer(AudioClip audioClip, Action<AudioPlayer>? mainLoop)
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Expected O, but got Unknown
				LethalModUtils.Logger.LogDebug((object)$">> AudioPlayer({audioClip}, {mainLoop.str()})");
				MainLoop = mainLoop;
				GameObject = new GameObject();
				AudioSource = GameObject.AddComponent<AudioSource>();
				Object.DontDestroyOnLoad((Object)(object)GameObject);
				((Object)GameObject).hideFlags = (HideFlags)61;
				AudioSource.clip = audioClip;
				finished = false;
				((MonoBehaviour)GameObject.AddComponent<_MonoBehaviour>()).StartCoroutine(this.mainLoop());
			}

			public void SetRange(float? maxDistance, float? minDistance = null)
			{
				AudioSource.spatialBlend = 1f;
				if (maxDistance.HasValue)
				{
					AudioSource.maxDistance = maxDistance.Value;
				}
				if (minDistance.HasValue)
				{
					AudioSource.minDistance = minDistance.Value;
				}
			}

			public void SetRange()
			{
				AudioSource.spatialBlend = 0f;
			}

			public void SetRolloff(bool linear = true)
			{
				AudioSource.rolloffMode = (AudioRolloffMode)(linear ? 1 : 0);
			}

			public void SetRolloff(AnimationCurve curve)
			{
				AudioSource.SetCustomCurve((AudioSourceCurveType)0, curve);
				AudioSource.rolloffMode = (AudioRolloffMode)2;
			}

			public void Cancel()
			{
				LethalModUtils.Logger.LogDebug((object)$">> AudioPlayer.Cancel() State:{State} AudioSource:{AudioSource.str()} GameObject:{GameObject.str()}");
				if (Object.op_Implicit((Object)(object)AudioSource))
				{
					Object.Destroy((Object)(object)AudioSource);
				}
				if (Object.op_Implicit((Object)(object)GameObject))
				{
					Object.Destroy((Object)(object)GameObject);
				}
				finished = true;
			}

			public void Pause()
			{
				AudioSource audioSource = AudioSource;
				if (audioSource != null)
				{
					audioSource.Pause();
				}
			}

			public void Stop()
			{
				AudioSource audioSource = AudioSource;
				if (audioSource != null)
				{
					audioSource.Stop();
				}
			}

			public void Resume()
			{
				AudioSource audioSource = AudioSource;
				if (audioSource != null)
				{
					audioSource.Play();
				}
			}

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

			public override string ToString()
			{
				return $"{GetType().Name} {{ State:{State}, Volume:{Volume}, Muted:{Muted}, MainLoop:{MainLoop.str()} }}";
			}
		}

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

			private object <>2__current;

			public Uri path;

			public TaskCompletionSource<AudioClip> task;

			private UnityWebRequest <webRequest>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f9: Invalid comparison between Unknown and I4
				//IL_014d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0152: Unknown result type (might be due to invalid IL or missing references)
				//IL_0154: Unknown result type (might be due to invalid IL or missing references)
				//IL_0157: Invalid comparison between Unknown and I4
				//IL_0175: Unknown result type (might be due to invalid IL or missing references)
				AudioClip content;
				bool flag;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					string text = Path.GetExtension(path.AbsolutePath).ToLower();
					AudioType audioType = GetAudioType(text);
					LethalModUtils.Logger.LogDebug((object)$">> Audio.LoadEnumerator({path}, {task}) audioType:{audioType}");
					if ((int)audioType == 0)
					{
						UnknownTypeError unknownTypeError = new UnknownTypeError(text);
						LethalModUtils.Logger.LogWarning((object)$"Error loading {path}: {unknownTypeError.Message}");
						task.SetException(unknownTypeError);
						return false;
					}
					<webRequest>5__2 = UnityWebRequestMultimedia.GetAudioClip(path, audioType);
					((DownloadHandlerAudioClip)<webRequest>5__2.downloadHandler).streamAudio = !LethalModUtils.Instance.PreloadAudio;
					<>2__current = <webRequest>5__2.SendWebRequest();
					<>1__state = 1;
					return true;
				}
				case 1:
					{
						<>1__state = -1;
						if ((int)<webRequest>5__2.result != 1)
						{
							RequestError requestError = new RequestError(<webRequest>5__2.error);
							LethalModUtils.Logger.LogWarning((object)$"Error loading {path}: {requestError.Message}");
							task.SetException(requestError);
							return false;
						}
						content = DownloadHandlerAudioClip.GetContent(<webRequest>5__2);
						if (content != null)
						{
							AudioDataLoadState loadState = content.loadState;
							if ((int)loadState == 2)
							{
								flag = false;
								goto IL_0161;
							}
						}
						flag = true;
						goto IL_0161;
					}
					IL_0161:
					if (flag)
					{
						ClipError clipError = new ClipError((content != null) ? new AudioDataLoadState?(content.loadState) : null);
						LethalModUtils.Logger.LogWarning((object)$"Error loading {path}: {clipError.Message}");
						task.SetException(clipError);
						return false;
					}
					LethalModUtils.Logger.LogInfo((object)$"Loaded {path}");
					task.SetResult(content);
					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 AudioType GetAudioType(string ext)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			return (AudioType)(ext.ToLower() switch
			{
				".ogg" => 14, 
				".mp3" => 13, 
				".wav" => 20, 
				".m4a" => 1, 
				".aiff" => 2, 
				_ => 0, 
			});
		}

		public static AudioClip Load(Uri path, TimeSpan? timeout = null)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Invalid comparison between Unknown and I4
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Invalid comparison between Unknown and I4
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			string text = Path.GetExtension(path.AbsolutePath).ToLower();
			AudioType audioType = GetAudioType(text);
			LethalModUtils.Logger.LogDebug((object)$">> Audio.Load({path}, {timeout.str()}) audioType:{audioType}");
			if ((int)audioType == 0)
			{
				UnknownTypeError unknownTypeError = new UnknownTypeError(text);
				LethalModUtils.Logger.LogWarning((object)$"Error loading {path}: {unknownTypeError.Message}");
				throw unknownTypeError;
			}
			UnityWebRequest audioClip = UnityWebRequestMultimedia.GetAudioClip(path, audioType);
			((DownloadHandlerAudioClip)audioClip.downloadHandler).streamAudio = !LethalModUtils.Instance.PreloadAudio;
			audioClip.SendWebRequest();
			if (timeout.HasValue)
			{
				Task task = Task.Delay(timeout.Value);
				while (!audioClip.isDone && !task.IsCompleted)
				{
				}
				if (!audioClip.isDone)
				{
					TimeoutException ex = new TimeoutException();
					LethalModUtils.Logger.LogWarning((object)$"Error loading {path}: {ex.Message}");
					throw ex;
				}
			}
			else
			{
				while (!audioClip.isDone)
				{
				}
			}
			if ((int)audioClip.result != 1)
			{
				RequestError requestError = new RequestError(audioClip.error);
				LethalModUtils.Logger.LogWarning((object)$"Error loading {path}: {requestError.Message}");
				throw requestError;
			}
			AudioClip content = DownloadHandlerAudioClip.GetContent(audioClip);
			bool flag;
			if (content != null)
			{
				AudioDataLoadState loadState = content.loadState;
				if ((int)loadState == 2)
				{
					flag = false;
					goto IL_0146;
				}
			}
			flag = true;
			goto IL_0146;
			IL_0146:
			if (flag)
			{
				ClipError clipError = new ClipError((content != null) ? new AudioDataLoadState?(content.loadState) : null);
				LethalModUtils.Logger.LogWarning((object)$"Error loading {path}: {clipError.Message}");
				throw clipError;
			}
			LethalModUtils.Logger.LogInfo((object)$"Loaded {path}");
			return content;
		}

		public static AudioClip? TryLoad(Uri path, TimeSpan? timeout = null)
		{
			LethalModUtils.Logger.LogDebug((object)$">> Audio.TryLoad({path}, {timeout.str()})");
			try
			{
				return Load(path, timeout);
			}
			catch (Exception arg)
			{
				LethalModUtils.Logger.LogDebug((object)$"<< Audio.TryLoad null ({arg})");
			}
			return null;
		}

		public static AudioClip Load(Uri path, out UnityWebRequest webRequest, TimeSpan? timeout = null)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Invalid comparison between Unknown and I4
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Invalid comparison between Unknown and I4
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			string text = Path.GetExtension(path.AbsolutePath).ToLower();
			AudioType audioType = GetAudioType(text);
			LethalModUtils.Logger.LogDebug((object)$">> Audio.Load({path}, {timeout.str()}) audioType:{audioType}");
			if ((int)audioType == 0)
			{
				UnknownTypeError unknownTypeError = new UnknownTypeError(text);
				LethalModUtils.Logger.LogWarning((object)$"Error loading {path}: {unknownTypeError.Message}");
				throw unknownTypeError;
			}
			webRequest = UnityWebRequestMultimedia.GetAudioClip(path, audioType);
			((DownloadHandlerAudioClip)webRequest.downloadHandler).streamAudio = !LethalModUtils.Instance.PreloadAudio;
			webRequest.SendWebRequest();
			if (timeout.HasValue)
			{
				Task task = Task.Delay(timeout.Value);
				while (!webRequest.isDone && !task.IsCompleted)
				{
				}
				if (!webRequest.isDone)
				{
					TimeoutException ex = new TimeoutException();
					LethalModUtils.Logger.LogWarning((object)$"Error loading {path}: {ex.Message}");
					throw ex;
				}
			}
			else
			{
				while (!webRequest.isDone)
				{
				}
			}
			if ((int)webRequest.result != 1)
			{
				RequestError requestError = new RequestError(webRequest.error);
				LethalModUtils.Logger.LogWarning((object)$"Error loading {path}: {requestError.Message}");
				throw requestError;
			}
			AudioClip content = DownloadHandlerAudioClip.GetContent(webRequest);
			bool flag;
			if (content != null)
			{
				AudioDataLoadState loadState = content.loadState;
				if ((int)loadState == 2)
				{
					flag = false;
					goto IL_014c;
				}
			}
			flag = true;
			goto IL_014c;
			IL_014c:
			if (flag)
			{
				ClipError clipError = new ClipError((content != null) ? new AudioDataLoadState?(content.loadState) : null);
				LethalModUtils.Logger.LogWarning((object)$"Error loading {path}: {clipError.Message}");
				throw clipError;
			}
			LethalModUtils.Logger.LogInfo((object)$"Loaded {path}");
			return content;
		}

		public static AudioClip? TryLoad(Uri path, out UnityWebRequest? webRequest, TimeSpan? timeout = null)
		{
			webRequest = null;
			LethalModUtils.Logger.LogDebug((object)$">> Audio.TryLoad({path}, {timeout.str()})");
			try
			{
				return Load(path, out webRequest, timeout);
			}
			catch (Exception arg)
			{
				LethalModUtils.Logger.LogDebug((object)$"<< Audio.TryLoad null ({arg})");
			}
			return null;
		}

		public static Task<AudioClip> LoadAsync(Uri path, TimeSpan? timeout = null)
		{
			LethalModUtils.Logger.LogDebug((object)$">> Audio.LoadAsync({path}, {timeout.str()})");
			TaskCompletionSource<AudioClip> taskCompletionSource = new TaskCompletionSource<AudioClip>();
			((MonoBehaviour)LethalModUtils.Instance).StartCoroutine(LoadEnumerator(path, taskCompletionSource));
			if (timeout.HasValue)
			{
				Task task = Task.Delay(timeout.Value);
				if (Task.WhenAny(new Task[2] { taskCompletionSource.Task, task }) == task)
				{
					TimeoutException ex = new TimeoutException();
					LethalModUtils.Logger.LogWarning((object)$"Error loading {path}: {ex.Message}");
					throw ex;
				}
			}
			return taskCompletionSource.Task;
		}

		[IteratorStateMachine(typeof(<LoadEnumerator>d__9))]
		private static IEnumerator LoadEnumerator(Uri path, TaskCompletionSource<AudioClip> task)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadEnumerator>d__9(0)
			{
				path = path,
				task = task
			};
		}

		public static async Task<AudioClip?> TryLoadAsync(Uri path, TimeSpan? timeout = null)
		{
			LethalModUtils.Logger.LogDebug((object)$">> Audio.TryLoadAsync({path}, {timeout.str()})");
			try
			{
				return await LoadAsync(path, timeout);
			}
			catch (Exception arg)
			{
				LethalModUtils.Logger.LogDebug((object)$"<< Audio.TryLoadAsync null ({arg})");
			}
			return null;
		}

		public static AudioPlayer Play(this AudioClip audioClip, Action<AudioPlayer>? mainLoop = null)
		{
			AudioPlayer audioPlayer = new AudioPlayer(audioClip, mainLoop);
			audioPlayer.Resume();
			return audioPlayer;
		}

		public static AudioPlayer CreatePlayer(this AudioClip audioClip, Action<AudioPlayer>? mainLoop = null)
		{
			return new AudioPlayer(audioClip, mainLoop);
		}

		public static AudioPlayer PlayAt(this AudioClip audioClip, Vector3 position, Action<AudioPlayer>? mainLoop = null)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			AudioPlayer audioPlayer = new AudioPlayer(audioClip, mainLoop);
			audioPlayer.GameObject.transform.position = position;
			audioPlayer.Resume();
			return audioPlayer;
		}

		public static AudioPlayer PlayAt(this AudioClip audioClip, Transform parent, Action<AudioPlayer>? mainLoop = null)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			AudioPlayer audioPlayer = new AudioPlayer(audioClip, mainLoop);
			audioPlayer.GameObject.transform.parent = parent;
			audioPlayer.GameObject.transform.localPosition = Vector3.zero;
			audioPlayer.Resume();
			return audioPlayer;
		}

		public static AudioPlayer PlayAt(this AudioClip audioClip, Transform parent, Vector3 offset, Action<AudioPlayer>? mainLoop = null)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			AudioPlayer audioPlayer = new AudioPlayer(audioClip, mainLoop);
			audioPlayer.GameObject.transform.parent = parent;
			audioPlayer.GameObject.transform.localPosition = offset;
			audioPlayer.Resume();
			return audioPlayer;
		}

		public static AudioPlayer PlayAt(this AudioClip audioClip, Vector3 position, Transform parent, Action<AudioPlayer>? mainLoop = null)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			AudioPlayer audioPlayer = new AudioPlayer(audioClip, mainLoop);
			audioPlayer.GameObject.transform.position = position;
			audioPlayer.GameObject.transform.parent = parent;
			audioPlayer.Resume();
			return audioPlayer;
		}

		public static AudioPlayer CreatePlayerAt(this AudioClip audioClip, Vector3 position, Action<AudioPlayer>? mainLoop = null)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			AudioPlayer audioPlayer = new AudioPlayer(audioClip, mainLoop);
			audioPlayer.GameObject.transform.position = position;
			return audioPlayer;
		}

		public static AudioPlayer CreatePlayerAt(this AudioClip audioClip, Transform parent, Action<AudioPlayer>? mainLoop = null)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			AudioPlayer audioPlayer = new AudioPlayer(audioClip, mainLoop);
			audioPlayer.GameObject.transform.parent = parent;
			audioPlayer.GameObject.transform.localPosition = Vector3.zero;
			return audioPlayer;
		}

		public static AudioPlayer CreatePlayerAt(this AudioClip audioClip, Transform parent, Vector3 offset, Action<AudioPlayer>? mainLoop = null)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			AudioPlayer audioPlayer = new AudioPlayer(audioClip, mainLoop);
			audioPlayer.GameObject.transform.parent = parent;
			audioPlayer.GameObject.transform.localPosition = offset;
			return audioPlayer;
		}

		public static AudioPlayer CreatePlayerAt(this AudioClip audioClip, Vector3 position, Transform parent, Action<AudioPlayer>? mainLoop = null)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			AudioPlayer audioPlayer = new AudioPlayer(audioClip, mainLoop);
			audioPlayer.GameObject.transform.position = position;
			audioPlayer.GameObject.transform.parent = parent;
			return audioPlayer;
		}
	}
	public static class CodeMatcherExtensions
	{
		private static string MatchesToString(params CodeMatch[] matches)
		{
			return string.Join(';', matches.Select((CodeMatch i) => ((object)i).ToString()));
		}

		internal static CodeMatcher MatchForward(this CodeMatcher codeMatcher, params CodeMatch[] matches)
		{
			int pos = Math.Clamp(codeMatcher.Pos, 0, codeMatcher.Length - 1);
			if (codeMatcher.MatchForward(true, matches).IsInvalid)
			{
				int _pos = -1;
				LethalModUtils.Logger.LogError((object)string.Format("Start position: {0}\n{1}", pos, string.Join('\n', from i in codeMatcher.Instructions()
					select string.Format("{0} #{1,2} {2}{3}{4}", (++_pos > pos) ? "=" : ((_pos == pos) ? "v" : " "), _pos, i.opcode, (i.operand == null) ? string.Empty : (" " + i.operand), (i.labels.Count <= 0) ? string.Empty : (" " + string.Join(" ", i.labels.Select((Label l) => $"[{l}]")))))));
				throw new InvalidOperationException("MatchForward failed: " + MatchesToString(matches));
			}
			return codeMatcher;
		}

		internal static CodeMatcher MatchBack(this CodeMatcher codeMatcher, params CodeMatch[] matches)
		{
			int pos = Math.Clamp(codeMatcher.Pos, 0, codeMatcher.Length - 1);
			if (codeMatcher.MatchBack(true, matches).IsInvalid)
			{
				int _pos = -1;
				LethalModUtils.Logger.LogError((object)string.Format("Start position: {0}\n{1}", pos, string.Join('\n', from i in codeMatcher.Instructions()
					select string.Format("{0} #{1,2} {2}{3}{4}", (++_pos < pos) ? "=" : ((_pos == pos) ? "^" : " "), _pos, i.opcode, (i.operand == null) ? string.Empty : (" " + i.operand), (i.labels.Count <= 0) ? string.Empty : (" " + string.Join(" ", i.labels.Select((Label l) => $"[{l}]")))))));
				throw new InvalidOperationException("MatchBack failed: " + MatchesToString(matches));
			}
			return codeMatcher;
		}

		[Obsolete]
		internal static CodeMatcher LogDebug(this CodeMatcher codeMatcher)
		{
			CodeMatcher codeMatcher2 = codeMatcher;
			int pos = 0;
			LethalModUtils.Logger.LogDebug((object)string.Format("Current position: {0}\n{1}", codeMatcher2.Pos, string.Join('\n', from i in codeMatcher2.Instructions()
				select string.Format("{0} #{1,2} {2}{3}{4}", (++pos == codeMatcher2.Pos) ? ">" : " ", pos, i.opcode, (i.operand == null) ? string.Empty : (" " + i.operand), (i.labels.Count <= 0) ? string.Empty : (" " + string.Join(" ", i.labels.Select((Label l) => $"[{l}]")))))));
			return codeMatcher2;
		}
	}
	public static class Crc32
	{
		private static readonly uint[] table = new uint[256]
		{
			0u, 1996959894u, 3993919788u, 2567524794u, 124634137u, 1886057615u, 3915621685u, 2657392035u, 249268274u, 2044508324u,
			3772115230u, 2547177864u, 162941995u, 2125561021u, 3887607047u, 2428444049u, 498536548u, 1789927666u, 4089016648u, 2227061214u,
			450548861u, 1843258603u, 4107580753u, 2211677639u, 325883990u, 1684777152u, 4251122042u, 2321926636u, 335633487u, 1661365465u,
			4195302755u, 2366115317u, 997073096u, 1281953886u, 3579855332u, 2724688242u, 1006888145u, 1258607687u, 3524101629u, 2768942443u,
			901097722u, 1119000684u, 3686517206u, 2898065728u, 853044451u, 1172266101u, 3705015759u, 2882616665u, 651767980u, 1373503546u,
			3369554304u, 3218104598u, 565507253u, 1454621731u, 3485111705u, 3099436303u, 671266974u, 1594198024u, 3322730930u, 2970347812u,
			795835527u, 1483230225u, 3244367275u, 3060149565u, 1994146192u, 31158534u, 2563907772u, 4023717930u, 1907459465u, 112637215u,
			2680153253u, 3904427059u, 2013776290u, 251722036u, 2517215374u, 3775830040u, 2137656763u, 141376813u, 2439277719u, 3865271297u,
			1802195444u, 476864866u, 2238001368u, 4066508878u, 1812370925u, 453092731u, 2181625025u, 4111451223u, 1706088902u, 314042704u,
			2344532202u, 4240017532u, 1658658271u, 366619977u, 2362670323u, 4224994405u, 1303535960u, 984961486u, 2747007092u, 3569037538u,
			1256170817u, 1037604311u, 2765210733u, 3554079995u, 1131014506u, 879679996u, 2909243462u, 3663771856u, 1141124467u, 855842277u,
			2852801631u, 3708648649u, 1342533948u, 654459306u, 3188396048u, 3373015174u, 1466479909u, 544179635u, 3110523913u, 3462522015u,
			1591671054u, 702138776u, 2966460450u, 3352799412u, 1504918807u, 783551873u, 3082640443u, 3233442989u, 3988292384u, 2596254646u,
			62317068u, 1957810842u, 3939845945u, 2647816111u, 81470997u, 1943803523u, 3814918930u, 2489596804u, 225274430u, 2053790376u,
			3826175755u, 2466906013u, 167816743u, 2097651377u, 4027552580u, 2265490386u, 503444072u, 1762050814u, 4150417245u, 2154129355u,
			426522225u, 1852507879u, 4275313526u, 2312317920u, 282753626u, 1742555852u, 4189708143u, 2394877945u, 397917763u, 1622183637u,
			3604390888u, 2714866558u, 953729732u, 1340076626u, 3518719985u, 2797360999u, 1068828381u, 1219638859u, 3624741850u, 2936675148u,
			906185462u, 1090812512u, 3747672003u, 2825379669u, 829329135u, 1181335161u, 3412177804u, 3160834842u, 628085408u, 1382605366u,
			3423369109u, 3138078467u, 570562233u, 1426400815u, 3317316542u, 2998733608u, 733239954u, 1555261956u, 3268935591u, 3050360625u,
			752459403u, 1541320221u, 2607071920u, 3965973030u, 1969922972u, 40735498u, 2617837225u, 3943577151u, 1913087877u, 83908371u,
			2512341634u, 3803740692u, 2075208622u, 213261112u, 2463272603u, 3855990285u, 2094854071u, 198958881u, 2262029012u, 4057260610u,
			1759359992u, 534414190u, 2176718541u, 4139329115u, 1873836001u, 414664567u, 2282248934u, 4279200368u, 1711684554u, 285281116u,
			2405801727u, 4167216745u, 1634467795u, 376229701u, 2685067896u, 3608007406u, 1308918612u, 956543938u, 2808555105u, 3495958263u,
			1231636301u, 1047427035u, 2932959818u, 3654703836u, 1088359270u, 936918000u, 2847714899u, 3736837829u, 1202900863u, 817233897u,
			3183342108u, 3401237130u, 1404277552u, 615818150u, 3134207493u, 3453421203u, 1423857449u, 601450431u, 3009837614u, 3294710456u,
			1567103746u, 711928724u, 3020668471u, 3272380065u, 1510334235u, 755167117u
		};

		public static uint Calculate(byte[] bytes)
		{
			return bytes.Aggregate(uint.MaxValue, (uint current, byte b) => (current >> 8) ^ table[(current ^ b) & 0xFF]) ^ 0xFFFFFFFFu;
		}
	}
	internal static class ObjectExtensions
	{
		internal static string str(this object? obj)
		{
			if (obj != null)
			{
				return obj.ToString();
			}
			return "null";
		}
	}
	public static class FS
	{
		public enum ProcessFilter
		{
			All,
			None,
			DirectoriesOnly,
			FilesOnly
		}

		public static int IterateDirectories(DirectoryInfo root, Func<FileInfo, bool> callback, Func<DirectoryInfo, ProcessFilter>? filter = null)
		{
			Func<FileInfo, bool> callback2 = callback;
			Func<DirectoryInfo, ProcessFilter> filter2 = filter;
			LethalModUtils.Logger.LogDebug((object)$">> IterateDirectories(root: {root}, callback: {callback2}, filter: {filter2})");
			if (!root.Exists)
			{
				return 0;
			}
			ProcessFilter processFilter = filter2?.Invoke(root) ?? ProcessFilter.All;
			int num = 0;
			if ((processFilter == ProcessFilter.All || processFilter == ProcessFilter.DirectoriesOnly) ? true : false)
			{
				num += ((IEnumerable<DirectoryInfo>)root.GetDirectories()).Sum((Func<DirectoryInfo, int>)RecurseWithParameters);
			}
			if ((processFilter == ProcessFilter.All || processFilter == ProcessFilter.FilesOnly) ? true : false)
			{
				num += root.GetFiles().Count(callback2);
			}
			return num;
			int RecurseWithParameters(DirectoryInfo _root)
			{
				return IterateDirectories(_root, callback2, filter2);
			}
		}

		public static void IterateDirectories(DirectoryInfo root, Action<FileInfo> callback, Func<DirectoryInfo, ProcessFilter>? filter = null)
		{
			Action<FileInfo> callback2 = callback;
			Func<DirectoryInfo, ProcessFilter> filter2 = filter;
			LethalModUtils.Logger.LogDebug((object)$">> IterateDirectories(root: {root}, callback: {callback2}, filter: {filter2})");
			if (root.Exists)
			{
				ProcessFilter processFilter = filter2?.Invoke(root) ?? ProcessFilter.All;
				if ((processFilter == ProcessFilter.All || processFilter == ProcessFilter.DirectoriesOnly) ? true : false)
				{
					MyCollections.ForEach<DirectoryInfo>((IEnumerable<DirectoryInfo>)root.GetDirectories(), (Action<DirectoryInfo>)RecurseWithParameters);
				}
				if ((processFilter == ProcessFilter.All || processFilter == ProcessFilter.FilesOnly) ? true : false)
				{
					MyCollections.ForEach<FileInfo>((IEnumerable<FileInfo>)root.GetFiles(), callback2);
				}
			}
			void RecurseWithParameters(DirectoryInfo _root)
			{
				IterateDirectories(_root, callback2, filter2);
			}
		}
	}
	public class Image
	{
		public class RequestError : Exception
		{
			public RequestError(string errorMessage)
				: base("WebRequest error: " + errorMessage)
			{
			}
		}

		public class TextureError : Exception
		{
			public TextureError()
				: base("Texture is null")
			{
			}
		}

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

			private object <>2__current;

			public Uri path;

			public TaskCompletionSource<Texture2D> task;

			private UnityWebRequest <webRequest>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Invalid comparison between Unknown and I4
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					LethalModUtils.Logger.LogDebug((object)$">> Image.LoadEnumerator({path}, {task})");
					<webRequest>5__2 = UnityWebRequestTexture.GetTexture(path);
					<>2__current = <webRequest>5__2.SendWebRequest();
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					if ((int)<webRequest>5__2.result != 1)
					{
						RequestError requestError = new RequestError(<webRequest>5__2.error);
						LethalModUtils.Logger.LogWarning((object)$"Error loading {path}: {requestError.Message}");
						task.SetException(requestError);
						return false;
					}
					Texture2D content = DownloadHandlerTexture.GetContent(<webRequest>5__2);
					if (content == null)
					{
						TextureError textureError = new TextureError();
						LethalModUtils.Logger.LogWarning((object)$"Error loading {path}: {textureError.Message}");
						task.SetException(textureError);
						return false;
					}
					LethalModUtils.Logger.LogInfo((object)$"Loaded {path}");
					task.SetResult(content);
					return false;
				}
				}
			}

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

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

		public static Task<Texture2D> LoadAsync(Uri path, TimeSpan? timeout = null)
		{
			LethalModUtils.Logger.LogDebug((object)$">> Image.LoadAsync({path}, {timeout.str()})");
			TaskCompletionSource<Texture2D> taskCompletionSource = new TaskCompletionSource<Texture2D>();
			((MonoBehaviour)LethalModUtils.Instance).StartCoroutine(LoadEnumerator(path, taskCompletionSource));
			if (timeout.HasValue)
			{
				Task task = Task.Delay(timeout.Value);
				if (Task.WhenAny(new Task[2] { taskCompletionSource.Task, task }) == task)
				{
					TimeoutException ex = new TimeoutException();
					LethalModUtils.Logger.LogWarning((object)$"Error loading {path}: {ex.Message}");
					throw ex;
				}
			}
			return taskCompletionSource.Task;
		}

		[IteratorStateMachine(typeof(<LoadEnumerator>d__3))]
		private static IEnumerator LoadEnumerator(Uri path, TaskCompletionSource<Texture2D> task)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadEnumerator>d__3(0)
			{
				path = path,
				task = task
			};
		}

		public static async Task<Texture2D?> TryLoadAsync(Uri path, TimeSpan? timeout = null)
		{
			LethalModUtils.Logger.LogDebug((object)$">> Image.TryLoadAsync({path}, {timeout.str()})");
			try
			{
				return await LoadAsync(path, timeout);
			}
			catch (Exception arg)
			{
				LethalModUtils.Logger.LogDebug((object)$"<< Image.TryLoadAsync null ({arg})");
			}
			return null;
		}

		public static Sprite Texture2DToSprite(Texture2D texture, bool centered = true)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			return Sprite.Create(texture, new Rect(0f, 0f, (float)((Texture)texture).width, (float)((Texture)texture).height), (Vector2)(centered ? new Vector2(0.5f, 0.5f) : Vector2.zero));
		}
	}
	public static class Texture2DExtensions
	{
		public static Sprite ToSprite(this Texture2D texture, bool centered = true)
		{
			return Image.Texture2DToSprite(texture, centered);
		}
	}
	[BepInPlugin("baer1.LethalModUtils", "LethalModUtils", "0.1.4")]
	public class LethalModUtils : BaseUnityPlugin
	{
		internal ConfigEntry<bool> exportStaticData;

		private ConfigEntry<bool> preloadAudio;

		public static LethalModUtils Instance { get; private set; }

		internal static ManualLogSource Logger { get; private set; }

		internal static Harmony? Harmony { get; set; }

		public bool PreloadAudio { get; private set; }

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			InitConfig();
			Patch();
			Logger.LogInfo((object)"baer1.LethalModUtils v0.1.4 has loaded!");
			void InitConfig()
			{
				exportStaticData = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ExportStaticData", false, "Set to true to export static game data to file on next opportunity");
				exportStaticData.SettingChanged += delegate
				{
					if (exportStaticData.Value && Object.op_Implicit((Object)(object)StartOfRound.Instance))
					{
						ExportStaticData(StartOfRound.Instance);
					}
				};
				preloadAudio = ((BaseUnityPlugin)this).Config.Bind<bool>("Audio", "PreloadAudio", true, "Whether to pre-load audio into RAM");
				PreloadAudio = preloadAudio.Value;
			}
			static void Patch()
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Expected O, but got Unknown
				if (Harmony == null)
				{
					Harmony = new Harmony("baer1.LethalModUtils");
				}
				Logger.LogDebug((object)"Patching...");
				Harmony.PatchAll();
				Logger.LogDebug((object)"Finished patching!");
			}
		}

		public void ExportStaticData(StartOfRound __instance)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			Logger.LogInfo((object)"Requested static data export...");
			exportStaticData.Value = false;
			try
			{
				using FileStream fileStream = File.Open(Path.Combine(Environment.CurrentDirectory, "StaticData.json"), FileMode.Create, FileAccess.Write);
				using StreamWriter streamWriter = new StreamWriter(fileStream, Encoding.UTF8);
				JsonTextWriter val = new JsonTextWriter((TextWriter)streamWriter);
				try
				{
					StaticData.ImportUtil.Import(GameNetworkManager.Instance?.gameVersionNum ?? (-1), __instance.allItemsList, __instance.levels).Serialize((JsonWriter)(object)val);
					((JsonWriter)val).Flush();
					streamWriter.Flush();
					fileStream.Flush();
					Logger.LogInfo((object)$"Exported static data to {Path.GetFullPath(fileStream.Name)} ({fileStream.Position} bytes)");
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
			}
			catch (Exception ex)
			{
				Debug.LogException(ex);
			}
		}
	}
	public struct StaticData
	{
		public static class ImportUtil
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public static Keyframe ToUnity(AnimationCurve.Keyframe keyframe)
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				return new Keyframe(keyframe.time, keyframe.value, keyframe.inTangent, keyframe.outTangent, keyframe.inWeight, keyframe.outWeight);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public static AnimationCurve.Keyframe Import(Keyframe keyframe)
			{
				AnimationCurve.Keyframe result = default(AnimationCurve.Keyframe);
				result.time = ((Keyframe)(ref keyframe)).time;
				result.value = ((Keyframe)(ref keyframe)).value;
				result.inTangent = ((Keyframe)(ref keyframe)).inTangent;
				result.outTangent = ((Keyframe)(ref keyframe)).outTangent;
				result.inWeight = ((Keyframe)(ref keyframe)).inWeight;
				result.outWeight = ((Keyframe)(ref keyframe)).outWeight;
				return result;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public static AnimationCurve ToUnity(AnimationCurve animationCurve)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Expected O, but got Unknown
				return new AnimationCurve(animationCurve.keys.Select(ToUnity).ToArray());
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public static AnimationCurve Import(AnimationCurve animationCurve)
			{
				AnimationCurve result = default(AnimationCurve);
				result.keys = animationCurve.keys.Select(Import).ToArray();
				return result;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public static Color ToUnity(Color color)
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				return new Color(color.r, color.g, color.b, color.a);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public static Color Import(Color color)
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				Color result = default(Color);
				result.r = color.r;
				result.g = color.g;
				result.b = color.b;
				result.a = color.a;
				return result;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public static Vector3 ToUnity(Vector3 vector3)
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				return new Vector3(vector3.x, vector3.y, vector3.z);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public static Vector3 Import(Vector3 vector3)
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				Vector3 result = default(Vector3);
				result.x = vector3.x;
				result.y = vector3.y;
				result.z = vector3.z;
				return result;
			}

			public static ItemType Import(Item item)
			{
				//IL_0303: Unknown result type (might be due to invalid IL or missing references)
				//IL_0315: Unknown result type (might be due to invalid IL or missing references)
				//IL_0327: Unknown result type (might be due to invalid IL or missing references)
				if (!Object.op_Implicit((Object)(object)item))
				{
					return default(ItemType);
				}
				ItemType result = default(ItemType);
				result.Id = item.itemId;
				result.Name = item.itemName;
				result.LockedInDemo = item.lockedInDemo;
				result.PrefabName = ((object)item.spawnPrefab)?.ToString() ?? string.Empty;
				result.ItemIcon = ((object)item.itemIcon)?.ToString() ?? string.Empty;
				result.SpawnPositionTypes = item.spawnPositionTypes?.Select((ItemGroup i) => i.itemSpawnTypeName).ToArray() ?? Array.Empty<string>();
				result.TwoHanded = item.twoHanded;
				result.TwoHandedAnimation = item.twoHandedAnimation;
				result.DisableHandsOnWall = item.disableHandsOnWall;
				result.CanBeGrabbedBeforeGameStart = item.canBeGrabbedBeforeGameStart;
				result.DisallowUtilitySlot = item.disallowUtilitySlot;
				result.Weight = item.weight;
				result.IsTrigger = item.itemIsTrigger;
				result.HoldButtonUse = item.holdButtonUse;
				result.SpawnsOnGround = item.itemSpawnsOnGround;
				result.IsConductive = item.isConductiveMetal;
				result.IsScrap = item.isScrap;
				result.Value = item.creditsWorth;
				result.MaxValue = item.maxValue;
				result.MinValue = item.minValue;
				result.MaxSalePercentage = item.highestSalePercentage;
				result.UsesBattery = item.requiresBattery;
				result.BatteryUsage = item.batteryUsage;
				result.AutomaticallySetUsingPower = item.automaticallySetUsingPower;
				result.GrabAnimation = item.grabAnim;
				result.GrabAnimationTime = item.grabAnimationTime;
				result.UseAnimation = item.useAnim;
				result.PocketAnimation = item.pocketAnim;
				result.ThrowAnimation = item.throwAnim;
				result.GrabSFX = ((object)item.grabSFX)?.ToString() ?? string.Empty;
				result.DropSFX = ((object)item.dropSFX)?.ToString() ?? string.Empty;
				result.PocketSFX = ((object)item.pocketSFX)?.ToString() ?? string.Empty;
				result.ThrowSFX = ((object)item.throwSFX)?.ToString() ?? string.Empty;
				result.SyncGrabFunction = item.syncGrabFunction;
				result.SyncUseFunction = item.syncUseFunction;
				result.SyncDiscardFunction = item.syncDiscardFunction;
				result.SyncInteractLRFunction = item.syncInteractLRFunction;
				result.SaveItemVariable = item.saveItemVariable;
				result.IsWeapon = item.isDefensiveWeapon;
				result.ToolTips = item.toolTips;
				result.VerticalOffset = item.verticalOffset;
				result.FloorYOffset = item.floorYOffset;
				result.DropAheadOfPlayer = item.allowDroppingAheadOfPlayer;
				result.RestingRotation = Import(item.restingRotation);
				result.RotationOffset = Import(item.rotationOffset);
				result.PositionOffset = Import(item.positionOffset);
				result.MeshOffset = item.meshOffset;
				result.MeshVariants = toSArr(item.meshVariants);
				result.MaterialVariants = toSArr(item.materialVariants);
				result.ClinkAudios = toSArr(item.clinkAudios);
				result.UsableInSpecialAnimations = false;
				result.CanBeInspected = false;
				result._imported_from = item;
				return result;
			}

			public static EnemyType.Animation Import(MiscAnimation miscAnimation)
			{
				EnemyType.Animation result = default(EnemyType.Animation);
				result.Name = miscAnimation.AnimString;
				result.AudioClip = ((object)miscAnimation.AnimVoiceclip)?.ToString() ?? string.Empty;
				result.Length = miscAnimation.AnimLength;
				result.Priority = miscAnimation.priority;
				return result;
			}

			public static EnemyType Import(EnemyType enemyType)
			{
				//IL_019b: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a5: Expected I4, but got Unknown
				//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b2: Expected I4, but got Unknown
				//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bf: Expected I4, but got Unknown
				if (!Object.op_Implicit((Object)(object)enemyType))
				{
					return default(EnemyType);
				}
				EnemyType result = default(EnemyType);
				result.Name = enemyType.enemyName;
				result.PrefabName = ((object)enemyType.enemyPrefab)?.ToString() ?? string.Empty;
				result.ProbabilityCurve = Import(enemyType.probabilityCurve);
				result.Disabled = enemyType.spawningDisabled;
				result.SpawnFromWeeds = enemyType.spawnFromWeeds;
				result.SpawnFalloff = Import(enemyType.numberSpawnedFalloff);
				result.UseSpawnFalloff = enemyType.useNumberSpawnedFalloff;
				result.SpawnInGroups = enemyType.spawnInGroupsOf;
				result.RequireNestObject = enemyType.requireNestObjectsToSpawn;
				result.PowerLevel = enemyType.PowerLevel;
				result.DiversityPowerLevel = enemyType.DiversityPowerLevel;
				result.MaxCount = enemyType.MaxCount;
				result.IsOutsideEnemy = enemyType.isOutsideEnemy;
				result.IsDaytimeEnemy = enemyType.isDaytimeEnemy;
				result.IncreasedChanceInterior = enemyType.increasedChanceInterior;
				result.NormalizedTimeInDayToLeave = enemyType.normalizedTimeInDayToLeave;
				result.StunTimeMultiplier = enemyType.stunTimeMultiplier;
				result.DoorSpeedMultiplier = enemyType.doorSpeedMultiplier;
				result.StunGameDifficultyMultiplier = enemyType.stunGameDifficultyMultiplier;
				result.CanBeStunned = enemyType.canBeStunned;
				result.CanDie = enemyType.canDie;
				result.CanBeDestroyed = enemyType.canBeDestroyed;
				result.DestroyOnDeath = enemyType.destroyOnDeath;
				result.CanSeeThroughFog = enemyType.canSeeThroughFog;
				result.DisableAnimatorWhenFar = enemyType.disableAnimatorWhenFar;
				result.PushPlayerForce = enemyType.pushPlayerForce;
				result.PushPlayerDistance = enemyType.pushPlayerDistance;
				result.SizeLimit = (int)enemyType.SizeLimit;
				result.EnemySize = (int)enemyType.EnemySize;
				result.WaterType = (int)enemyType.WaterType;
				result.TimeToPlayAudio = enemyType.timeToPlayAudio;
				result.LoudnessMultiplier = enemyType.loudnessMultiplier;
				result.OverrideVentSFX = ((object)enemyType.overrideVentSFX)?.ToString() ?? string.Empty;
				result.NestPrefabName = ((object)enemyType.nestSpawnPrefab)?.ToString() ?? string.Empty;
				result.NestPrefabWidth = enemyType.nestSpawnPrefabWidth;
				result.NestDistanceFromShip = enemyType.nestDistanceFromShip;
				result.UseMinEnemyThresholdForNest = enemyType.useMinEnemyThresholdForNest;
				result.MinEnemiesToSpawnNest = enemyType.minEnemiesToSpawnNest;
				result.HitBodySFX = ((object)enemyType.hitBodySFX)?.ToString() ?? string.Empty;
				result.HitEnemyVoiceSFX = ((object)enemyType.hitEnemyVoiceSFX)?.ToString() ?? string.Empty;
				result.DeathSFX = ((object)enemyType.deathSFX)?.ToString() ?? string.Empty;
				result.StunSFX = ((object)enemyType.stunSFX)?.ToString() ?? string.Empty;
				result.MiscAudioClips = toSArr(enemyType.audioClips);
				result.MiscAnimations = enemyType.miscAnimations?.Select(Import).ToArray() ?? Array.Empty<EnemyType.Animation>();
				result._imported_from = enemyType;
				return result;
			}

			public static Level.WeatherWithVariables Import(RandomWeatherWithVariables randomWeatherWithVariables)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Expected I4, but got Unknown
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				Level.WeatherWithVariables result = default(Level.WeatherWithVariables);
				result.Weather = (int)randomWeatherWithVariables.weatherType;
				result.Variable1 = randomWeatherWithVariables.weatherVariable;
				result.Variable2 = randomWeatherWithVariables.weatherVariable2;
				result.Color = Import(randomWeatherWithVariables.weatherVariableColor);
				return result;
			}

			public static Level.LevelAmbience.WeightedAudioClip Import(RandomAudioClip randomAudioClip)
			{
				Level.LevelAmbience.WeightedAudioClip result = default(Level.LevelAmbience.WeightedAudioClip);
				result.AudioClip = ((object)randomAudioClip.audioClip)?.ToString() ?? string.Empty;
				result.Rarity = randomAudioClip.chance;
				return result;
			}

			public static Level.LevelAmbience Import(LevelAmbienceLibrary levelAmbienceLibrary)
			{
				if (!Object.op_Implicit((Object)(object)levelAmbienceLibrary))
				{
					return default(Level.LevelAmbience);
				}
				Level.LevelAmbience result = default(Level.LevelAmbience);
				result.insanityMusicAudios = toSArr(levelAmbienceLibrary.insanityMusicAudios);
				result.insideAmbience = toSArr(levelAmbienceLibrary.insideAmbience);
				result.insideAmbienceInsanity = toWArr(levelAmbienceLibrary.insideAmbienceInsanity);
				result.shipAmbience = toSArr(levelAmbienceLibrary.shipAmbience);
				result.shipAmbienceInsanity = toWArr(levelAmbienceLibrary.shipAmbienceInsanity);
				result.outsideAmbience = toSArr(levelAmbienceLibrary.outsideAmbience);
				result.outsideAmbienceInsanity = toWArr(levelAmbienceLibrary.outsideAmbienceInsanity);
				return result;
				static Level.LevelAmbience.WeightedAudioClip[] toWArr(IEnumerable<RandomAudioClip>? enumerable)
				{
					return enumerable?.Select(Import).ToArray() ?? Array.Empty<Level.LevelAmbience.WeightedAudioClip>();
				}
			}

			public static Level.Interior Import(IntWithRarity intWithRarity)
			{
				Level.Interior result = default(Level.Interior);
				result.Id = intWithRarity.id;
				result.Rarity = intWithRarity.rarity;
				result.OverridesLevelAmbience = Object.op_Implicit((Object)(object)intWithRarity.overrideLevelAmbience);
				result.LevelAmbience = Import(intWithRarity.overrideLevelAmbience);
				return result;
			}

			public static Level.InsideHazard.HazardType Import(IndoorMapHazardType indoorMapHazardType)
			{
				if (!Object.op_Implicit((Object)(object)indoorMapHazardType))
				{
					return default(Level.InsideHazard.HazardType);
				}
				Level.InsideHazard.HazardType result = default(Level.InsideHazard.HazardType);
				result.PrefabName = ((object)indoorMapHazardType.prefabToSpawn)?.ToString() ?? string.Empty;
				result.SpawnFacingAwayFromWall = indoorMapHazardType.spawnFacingAwayFromWall;
				result.SpawnFacingWall = indoorMapHazardType.spawnFacingWall;
				result.SpawnWithBackToWall = indoorMapHazardType.spawnWithBackToWall;
				result.SpawnWithBackFlushAgainstWall = indoorMapHazardType.spawnWithBackFlushAgainstWall;
				result.RequireDistanceBetweenSpawns = indoorMapHazardType.requireDistanceBetweenSpawns;
				result.DisallowSpawningNearEntrances = indoorMapHazardType.disallowSpawningNearEntrances;
				result.SpawnInMineshaft = indoorMapHazardType.allowInMineshaft;
				return result;
			}

			public static Level.InsideHazard Import(IndoorMapHazard indoorMapHazard)
			{
				Level.InsideHazard result = default(Level.InsideHazard);
				result.Hazard = Import(indoorMapHazard.hazardType);
				result.SpawnAmount = Import(indoorMapHazard.numberToSpawn);
				return result;
			}

			public static Level.OutsideHazard.HazardType Import(SpawnableOutsideObject spawnableOutsideObject)
			{
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				if (!Object.op_Implicit((Object)(object)spawnableOutsideObject))
				{
					return default(Level.OutsideHazard.HazardType);
				}
				Level.OutsideHazard.HazardType result = default(Level.OutsideHazard.HazardType);
				result.PrefabName = ((object)spawnableOutsideObject.prefabToSpawn)?.ToString() ?? string.Empty;
				result.SpawnFacingAwayFromWall = spawnableOutsideObject.spawnFacingAwayFromWall;
				result.ObjectWidth = spawnableOutsideObject.objectWidth;
				result.DestroyTrees = spawnableOutsideObject.destroyTrees;
				result.SpawnableFloorTags = spawnableOutsideObject.spawnableFloorTags;
				result.RotationOffset = Import(spawnableOutsideObject.rotationOffset);
				return result;
			}

			public static Level.OutsideHazard Import(SpawnableOutsideObjectWithRarity spawnableOutsideObjectWithRarity)
			{
				Level.OutsideHazard result = default(Level.OutsideHazard);
				result.Hazard = Import(spawnableOutsideObjectWithRarity.spawnableObject);
				result.SpawnAmount = Import(spawnableOutsideObjectWithRarity.randomAmount);
				return result;
			}

			public static StaticData Import(int gameVersion, AllItemsList allItemsList, SelectableLevel[] selectableLevels)
			{
				//IL_014b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0155: Expected I4, but got Unknown
				List<ItemType> ItemTable = new List<ItemType>();
				List<EnemyType> EnemyTable = new List<EnemyType>();
				List<Level> list = new List<Level>();
				if (Object.op_Implicit((Object)(object)allItemsList))
				{
					foreach (Item items in allItemsList.itemsList)
					{
						GetOrImportItemType(items);
					}
				}
				foreach (SelectableLevel val in selectableLevels)
				{
					list.Add(new Level
					{
						Name = val.PlanetName,
						SceneName = val.sceneName,
						LockedForDemo = val.lockedForDemo,
						SpawnEnemiesAndScrap = val.spawnEnemiesAndScrap,
						LevelDescription = val.LevelDescription,
						RiskLevel = val.riskLevel,
						LandingTime = val.timeToArrive,
						VideoPreview = (((object)val.videoReel)?.ToString() ?? string.Empty),
						LevelIcon = val.levelIconString,
						HasTime = val.planetHasTime,
						OffsetFromGlobalTime = val.OffsetFromGlobalTime,
						DaySpeedMultiplier = val.DaySpeedMultiplier,
						HasStaticWeather = val.overrideWeather,
						StaticWeather = (int)val.overrideWeatherType,
						Weathers = val.randomWeathers.Select(Import).ToArray(),
						InteriorSizeMultiplier = val.factorySizeMultiplier,
						Interiors = val.dungeonFlowTypes.Select(Import).ToArray(),
						HasAmbienceClips = Object.op_Implicit((Object)(object)val.levelAmbienceClips),
						AmbienceClips = Import(val.levelAmbienceClips),
						SpawnableInsideObjects = val.indoorMapHazards.Select(Import).ToArray(),
						SpawnableOutsideObjects = val.spawnableOutsideObjects.Select(Import).ToArray(),
						CanSpawnMold = val.canSpawnMold,
						MoldSpreadIterations = val.moldSpreadIterations,
						MoldStartPosition = val.moldStartPosition,
						MoldType = val.moldType,
						SpawnableScrap = val.spawnableScrap.Select(delegate(SpawnableItemWithRarity i)
						{
							Level.SpawnableItem result3 = default(Level.SpawnableItem);
							result3.ItemIndex = GetOrImportItemType(i.spawnableItem);
							result3.Rarity = i.rarity;
							return result3;
						}).ToArray(),
						MinScrap = val.minScrap,
						MaxScrap = val.maxScrap,
						MinTotalScrapValue = val.minTotalScrapValue,
						MaxTotalScrapValue = val.maxTotalScrapValue,
						MaxEnemyPowerCount = val.maxEnemyPowerCount,
						MaxOutsideEnemyPowerCount = val.maxOutsideEnemyPowerCount,
						MaxDaytimeEnemyPowerCount = val.maxDaytimeEnemyPowerCount,
						MaxInsideDiversityPowerCount = val.maxInsideDiversityPowerCount,
						MaxOutsideDiversityPowerCount = val.maxOutsideDiversityPowerCount,
						InsideEnemies = toEArr(val.Enemies),
						SpecialEnemyRarity = new Level.OverrideSpawnableEnemy
						{
							EnemyIndex = GetOrImportEnemyType(val.specialEnemyRarity.overrideEnemy),
							Chance = val.specialEnemyRarity.percentageChance
						},
						OutsideEnemies = toEArr(val.OutsideEnemies),
						DaytimeEnemies = toEArr(val.DaytimeEnemies),
						InsideEnemySpawnChanceThroughoutDay = Import(val.enemySpawnChanceThroughoutDay),
						OutsideEnemySpawnChanceThroughoutDay = Import(val.outsideEnemySpawnChanceThroughDay),
						DaytimeEnemySpawnChanceThroughoutDay = Import(val.daytimeEnemySpawnChanceThroughDay),
						EnemySpawnProbabilityRange = val.spawnProbabilityRange,
						DaytimeEnemySpawnProbabilityRange = val.daytimeEnemiesProbabilityRange,
						SnowFootprints = val.levelIncludesSnowFootprints
					});
				}
				StaticData result = default(StaticData);
				result.GameVersion = gameVersion;
				result.ModVersion = "0.1.4";
				result.ImportTime = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
				result.NavSizeLimitValues = enumToDict<NavSizeLimit>();
				result.EnemySizeValues = enumToDict<EnemySize>();
				result.EnemyWaterTypeValues = enumToDict<EnemyWaterType>();
				result.LevelWeatherTypeValues = enumToDict<LevelWeatherType>();
				result.ItemTable = ItemTable.ToArray();
				result.EnemyTable = EnemyTable.ToArray();
				result.Levels = list.ToArray();
				return result;
				int GetOrImportEnemyType(EnemyType gEnemyType)
				{
					//IL_0027: Unknown result type (might be due to invalid IL or missing references)
					//IL_0031: Expected O, but got Unknown
					int num = 0;
					foreach (EnemyType item in EnemyTable)
					{
						if (item._imported_from != null && (Object)(object)gEnemyType == (Object)(EnemyType)item._imported_from)
						{
							return num;
						}
						num++;
					}
					EnemyTable.Add(Import(gEnemyType));
					return num;
				}
				int GetOrImportItemType(Item item)
				{
					//IL_0027: Unknown result type (might be due to invalid IL or missing references)
					//IL_0031: Expected O, but got Unknown
					int num2 = 0;
					foreach (ItemType item2 in ItemTable)
					{
						if (item2._imported_from != null && (Object)(object)item == (Object)(Item)item2._imported_from)
						{
							return num2;
						}
						num2++;
					}
					ItemTable.Add(Import(item));
					return num2;
				}
				static Dictionary<int, string> enumToDict<T>() where T : struct, Enum
				{
					return ((int[])Enum.GetValues(typeof(T))).ToDictionary((int v) => v, (int v) => Enum.GetName(typeof(T), v));
				}
				[MethodImpl(MethodImplOptions.AggressiveInlining)]
				Level.SpawnableEnemy[] toEArr(IEnumerable<SpawnableEnemyWithRarity>? enumerable)
				{
					return enumerable?.Select(delegate(SpawnableEnemyWithRarity i)
					{
						Level.SpawnableEnemy result2 = default(Level.SpawnableEnemy);
						result2.EnemyIndex = GetOrImportEnemyType(i.enemyType);
						result2.Rarity = i.rarity;
						return result2;
					}).ToArray() ?? Array.Empty<Level.SpawnableEnemy>();
				}
			}
		}

		public struct AnimationCurve
		{
			public struct Keyframe
			{
				public float time;

				public float value;

				public float inTangent;

				public float outTangent;

				public float inWeight;

				public float outWeight;
			}

			public Keyframe[] keys;
		}

		public struct Color
		{
			public float r;

			public float g;

			public float b;

			public float a;
		}

		public struct Vector3
		{
			public float x;

			public float y;

			public float z;
		}

		public struct ItemType
		{
			public int Id;

			public string Name;

			public bool LockedInDemo;

			public string PrefabName;

			public string ItemIcon;

			public string[] SpawnPositionTypes;

			public bool TwoHanded;

			public bool TwoHandedAnimation;

			public bool DisableHandsOnWall;

			public bool CanBeGrabbedBeforeGameStart;

			public bool DisallowUtilitySlot;

			public float Weight;

			public bool IsTrigger;

			public bool HoldButtonUse;

			public bool SpawnsOnGround;

			public bool IsConductive;

			public bool IsScrap;

			public int Value;

			public int MaxValue;

			public int MinValue;

			public int MaxSalePercentage;

			public bool UsesBattery;

			public float BatteryUsage;

			public bool AutomaticallySetUsingPower;

			public string GrabAnimation;

			public float GrabAnimationTime;

			public string UseAnimation;

			public string PocketAnimation;

			public string ThrowAnimation;

			public string GrabSFX;

			public string DropSFX;

			public string PocketSFX;

			public string ThrowSFX;

			public bool SyncGrabFunction;

			public bool SyncUseFunction;

			public bool SyncDiscardFunction;

			public bool SyncInteractLRFunction;

			public bool SaveItemVariable;

			public bool IsWeapon;

			public string[] ToolTips;

			public float VerticalOffset;

			public int FloorYOffset;

			public bool DropAheadOfPlayer;

			public Vector3 RestingRotation;

			public Vector3 RotationOffset;

			public Vector3 PositionOffset;

			public bool MeshOffset;

			public string[] MeshVariants;

			public string[] MaterialVariants;

			public string[] ClinkAudios;

			public bool UsableInSpecialAnimations;

			public bool CanBeInspected;

			[JsonIgnore]
			internal object? _imported_from;
		}

		public struct EnemyType
		{
			public struct Animation
			{
				public string Name;

				public string AudioClip;

				public float Length;

				public int Priority;
			}

			public string Name;

			public string PrefabName;

			public AnimationCurve ProbabilityCurve;

			public bool Disabled;

			public bool SpawnFromWeeds;

			public AnimationCurve SpawnFalloff;

			public bool UseSpawnFalloff;

			public int SpawnInGroups;

			public bool RequireNestObject;

			public float PowerLevel;

			public int DiversityPowerLevel;

			public int MaxCount;

			public bool IsOutsideEnemy;

			public bool IsDaytimeEnemy;

			public int IncreasedChanceInterior;

			public float NormalizedTimeInDayToLeave;

			public float StunTimeMultiplier;

			public float DoorSpeedMultiplier;

			public float StunGameDifficultyMultiplier;

			public bool CanBeStunned;

			public bool CanDie;

			public bool CanBeDestroyed;

			public bool DestroyOnDeath;

			public bool CanSeeThroughFog;

			public bool DisableAnimatorWhenFar;

			public float PushPlayerForce;

			public float PushPlayerDistance;

			public int SizeLimit;

			public int EnemySize;

			public int WaterType;

			public float TimeToPlayAudio;

			public float LoudnessMultiplier;

			public string OverrideVentSFX;

			public string NestPrefabName;

			public float NestPrefabWidth;

			public float NestDistanceFromShip;

			public bool UseMinEnemyThresholdForNest;

			public int MinEnemiesToSpawnNest;

			public string HitBodySFX;

			public string HitEnemyVoiceSFX;

			public string DeathSFX;

			public string StunSFX;

			public string[] MiscAudioClips;

			public Animation[] MiscAnimations;

			[JsonIgnore]
			internal object? _imported_from;
		}

		public struct Level
		{
			public struct WeatherWithVariables
			{
				public int Weather;

				public int Variable1;

				public int Variable2;

				public Color Color;
			}

			public struct LevelAmbience
			{
				public struct WeightedAudioClip
				{
					public string AudioClip;

					public int Rarity;
				}

				public string[] insanityMusicAudios;

				public string[] insideAmbience;

				public WeightedAudioClip[] insideAmbienceInsanity;

				public string[] shipAmbience;

				public WeightedAudioClip[] shipAmbienceInsanity;

				public string[] outsideAmbience;

				public WeightedAudioClip[] outsideAmbienceInsanity;
			}

			public struct Interior
			{
				public int Id;

				public int Rarity;

				public bool OverridesLevelAmbience;

				public LevelAmbience LevelAmbience;
			}

			public struct InsideHazard
			{
				public struct HazardType
				{
					public string PrefabName;

					public bool SpawnFacingAwayFromWall;

					public bool SpawnFacingWall;

					public bool SpawnWithBackToWall;

					public bool SpawnWithBackFlushAgainstWall;

					public bool RequireDistanceBetweenSpawns;

					public bool DisallowSpawningNearEntrances;

					public bool SpawnInMineshaft;
				}

				public HazardType Hazard;

				public AnimationCurve SpawnAmount;
			}

			public struct OutsideHazard
			{
				public struct HazardType
				{
					public string PrefabName;

					public bool SpawnFacingAwayFromWall;

					public int ObjectWidth;

					public bool DestroyTrees;

					public string[] SpawnableFloorTags;

					public Vector3 RotationOffset;
				}

				public HazardType Hazard;

				public AnimationCurve SpawnAmount;
			}

			public struct SpawnableItem
			{
				public int ItemIndex;

				public int Rarity;
			}

			public struct SpawnableEnemy
			{
				public int EnemyIndex;

				public int Rarity;
			}

			public struct OverrideSpawnableEnemy
			{
				public int EnemyIndex;

				public float Chance;
			}

			public string Name;

			public string SceneName;

			public bool LockedForDemo;

			public bool SpawnEnemiesAndScrap;

			public string LevelDescription;

			public string RiskLevel;

			public float LandingTime;

			public string VideoPreview;

			public string LevelIcon;

			public bool HasTime;

			public float OffsetFromGlobalTime;

			public float DaySpeedMultiplier;

			public bool HasStaticWeather;

			public int StaticWeather;

			public WeatherWithVariables[] Weathers;

			public float InteriorSizeMultiplier;

			public Interior[] Interiors;

			public bool HasAmbienceClips;

			public LevelAmbience AmbienceClips;

			public InsideHazard[] SpawnableInsideObjects;

			public OutsideHazard[] SpawnableOutsideObjects;

			public bool CanSpawnMold;

			public int MoldSpreadIterations;

			public int MoldStartPosition;

			public int MoldType;

			public SpawnableItem[] SpawnableScrap;

			public int MinScrap;

			public int MaxScrap;

			public int MinTotalScrapValue;

			public int MaxTotalScrapValue;

			public int MaxEnemyPowerCount;

			public int MaxOutsideEnemyPowerCount;

			public int MaxDaytimeEnemyPowerCount;

			public int MaxInsideDiversityPowerCount;

			public int MaxOutsideDiversityPowerCount;

			public SpawnableEnemy[] InsideEnemies;

			public OverrideSpawnableEnemy SpecialEnemyRarity;

			public SpawnableEnemy[] OutsideEnemies;

			public SpawnableEnemy[] DaytimeEnemies;

			public AnimationCurve InsideEnemySpawnChanceThroughoutDay;

			public AnimationCurve OutsideEnemySpawnChanceThroughoutDay;

			public AnimationCurve DaytimeEnemySpawnChanceThroughoutDay;

			public float EnemySpawnProbabilityRange;

			public float DaytimeEnemySpawnProbabilityRange;

			public bool SnowFootprints;
		}

		public int GameVersion;

		public string ModVersion;

		public long ImportTime;

		public Dictionary<int, string> NavSizeLimitValues;

		public Dictionary<int, string> EnemySizeValues;

		public Dictionary<int, string> EnemyWaterTypeValues;

		public Dictionary<int, string> LevelWeatherTypeValues;

		public ItemType[] ItemTable;

		public EnemyType[] EnemyTable;

		public Level[] Levels;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static string[] toSArr<T>(IEnumerable<T>? enumerable)
		{
			return enumerable?.Select(delegate(T i)
			{
				object obj = i?.ToString();
				if (obj == null)
				{
					obj = string.Empty;
				}
				return (string)obj;
			}).ToArray() ?? Array.Empty<string>();
		}

		public static StaticData Deserialize(JsonReader reader)
		{
			return JsonSerializer.Create().Deserialize<StaticData>(reader);
		}

		public void Serialize(JsonWriter writer)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Expected O, but got Unknown
			JsonSerializer.Create(new JsonSerializerSettings()).Serialize(writer, (object)this);
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "Awake")]
	internal static class StartOfRound_Awake
	{
		private static void Postfix(ref StartOfRound __instance)
		{
			try
			{
				if (LethalModUtils.Instance.exportStaticData.Value)
				{
					LethalModUtils.Instance.ExportStaticData(__instance);
				}
			}
			catch (Exception ex)
			{
				Debug.LogException(ex);
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "baer1.LethalModUtils";

		public const string PLUGIN_NAME = "LethalModUtils";

		public const string PLUGIN_VERSION = "0.1.4";
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}